add tileset event

src/modules/event/EventType.js

   POSITION_UPDATE: 'positionUpdate',
 }
 
+const ModelEventType = {}
+
+const TileSetEventType = {
+  INITIAL_TILES_LOADED: 'initialTilesLoaded',
+  ALL_TILES_LOADED: 'allTilesLoaded ',
+  LOAD_PROGRESS: 'loadProgress ',
+  TILE_FAILED: 'tileFailed ',
+  TILE_LOAD: 'tileLoad',
+  TILE_UNLOAD: 'tileUnload',
+  TILE_VISIBLE: 'tileVisible',
+}
+
 const LayerGroupEventType = BaseEventType
 
 const LayerEventType = {
   LayerGroupEventType,
   LayerEventType,
   OverlayEventType,
+  TileSetEventType,
   TrackEventType,
   PathEventType,
   PlotEventType,

src/modules/event/index.js

 export { default as LayerGroupEvent } from './type/LayerGroupEvent'
 export { default as LayerEvent } from './type/LayerEvent'
 export { default as OverlayEvent } from './type/OverlayEvent'
+export { default as TilesetEvent } from './type/TilesetEvent'
 
 /**
  * animation

src/modules/event/type/MouseEvent.js

       overlayId = target.primitive.overlayId
     }
 
-    // for Primitve
+    // for Primitive
     else if (target?.primitive) {
       overlayId = target.primitive.overlayId
     }
     if (!movement?.position) {
       return false
     }
-    let mouseInfo = this._getMouseInfo(movement.position)
-    this._raiseEvent(MouseEventType.CLICK, mouseInfo)
+    this._raiseEvent(
+      MouseEventType.CLICK,
+      this._getMouseInfo(movement.position)
+    )
   }
 
   /**
     if (!movement?.position) {
       return false
     }
-    let mouseInfo = this._getMouseInfo(movement.position)
-    this._raiseEvent(MouseEventType.DB_CLICK, mouseInfo)
+    this._raiseEvent(
+      MouseEventType.DB_CLICK,
+      this._getMouseInfo(movement.position)
+    )
   }
 
   /**
     if (!movement?.position) {
       return false
     }
-    let mouseInfo = this._getMouseInfo(movement.position)
-    this._raiseEvent(MouseEventType.RIGHT_CLICK, mouseInfo)
+    this._raiseEvent(
+      MouseEventType.RIGHT_CLICK,
+      this._getMouseInfo(movement.position)
+    )
   }
 
   /**
     if (!movement?.position) {
       return false
     }
-    let mouseInfo = this._getMouseInfo(movement.position)
-    this._raiseEvent(MouseEventType.LEFT_DOWN, mouseInfo)
+    this._raiseEvent(
+      MouseEventType.LEFT_DOWN,
+      this._getMouseInfo(movement.position)
+    )
   }
 
   /**
     if (!movement?.position) {
       return false
     }
-    let mouseInfo = this._getMouseInfo(movement.position)
-    this._raiseEvent(MouseEventType.RIGHT_DOWN, mouseInfo)
+    this._raiseEvent(
+      MouseEventType.RIGHT_DOWN,
+      this._getMouseInfo(movement.position)
+    )
   }
 
   /**

src/modules/event/type/TilesetEvent.js

+/**
+ * @Author : Caven Chen
+ */
+import { TileSetEventType } from '../EventType'
+import Event from '../Event'
+
+class TilesetEvent extends Event {
+  constructor(tileset) {
+    super(TileSetEventType)
+    this._tileset = tileset
+  }
+
+  /**
+   *
+   * @param type
+   * @param callback
+   * @param context
+   */
+  on(type, callback, context) {
+    this._tileset.then((tileset) => {
+      switch (type) {
+        case TileSetEventType.INITIAL_TILES_LOADED:
+          tileset.initialTilesLoaded.addEventListener(callback, context || this)
+          break
+        case TileSetEventType.ALL_TILES_LOADED:
+          tileset.allTilesLoaded.addEventListener(callback, context || this)
+          break
+        case TileSetEventType.LOAD_PROGRESS:
+          tileset.loadProgress.addEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_FAILED:
+          tileset.tileFailed.addEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_LOAD:
+          tileset.tileLoad.addEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_UNLOAD:
+          tileset.tileUnload.addEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_VISIBLE:
+          tileset.tileVisible.addEventListener(callback, context || this)
+          break
+        default:
+          break
+      }
+    })
+    return null
+  }
+
+  off(type, callback, context) {
+    this._tileset.then((tileset) => {
+      switch (type) {
+        case TileSetEventType.INITIAL_TILES_LOADED:
+          tileset.initialTilesLoaded.removeEventListener(
+            callback,
+            context || this
+          )
+          break
+        case TileSetEventType.ALL_TILES_LOADED:
+          tileset.allTilesLoaded.removeEventListener(callback, context || this)
+          break
+        case TileSetEventType.LOAD_PROGRESS:
+          tileset.loadProgress.removeEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_FAILED:
+          tileset.tileFailed.removeEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_LOAD:
+          tileset.tileLoad.removeEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_UNLOAD:
+          tileset.tileUnload.removeEventListener(callback, context || this)
+          break
+        case TileSetEventType.TILE_VISIBLE:
+          tileset.tileVisible.removeEventListener(callback, context || this)
+          break
+        default:
+          break
+      }
+    })
+    return true
+  }
+}
+
+export default TilesetEvent

src/modules/overlay/model/Tileset.js

 import Overlay from '../Overlay'
 import Parse from '../../parse/Parse'
 import State from '../../state/State'
+import { TilesetEvent } from '../../event'
 
 class Tileset extends Overlay {
   constructor(url, options = {}) {
     super()
     this._delegate = Cesium.Cesium3DTileset.fromUrl(url, options)
+    this._tilesetEvent = new TilesetEvent()
     this._tileVisibleCallback = undefined
     this._properties = undefined
     this._state = State.INITIALIZED
    */
   _bindVisibleEvent() {
     this._tileVisibleCallback && this._tileVisibleCallback()
-    this._tileVisibleCallback = this._delegate.tileVisible.addEventListener(
-      this._updateTile,
-      this
-    )
+    this._tileVisibleCallback = this._delegate.then((tileset) => {
+      tileset.tileVisible.addEventListener(this._updateTile, this)
+    })
   }
 
   /**
     }
     return this
   }
+
+  /**
+   * Subscribe event
+   * @param type
+   * @param callback
+   * @param context
+   * @returns {Overlay}
+   */
+  on(type, callback, context) {
+    this._overlayEvent.on(type, callback, context || this)
+    this._tilesetEvent.on(type, callback, context || this)
+    return this
+  }
+
+  /**
+   * Unsubscribe event
+   * @param type
+   * @param callback
+   * @param context
+   * @returns {Overlay}
+   */
+  off(type, callback, context) {
+    this._overlayEvent.off(type, callback, context || this)
+    this._tilesetEvent.off(type, callback, context || this)
+    return this
+  }
 }
 
 Overlay.registerType('tileset')