change the type property

modules/heat/HeatLayer.js

     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('heat')
+  }
+
   /**
    *
    * @private

modules/layer/Layer.js

     this._layerEvent.on(LayerEventType.ADD, this._onAdd, this)
     this._layerEvent.on(LayerEventType.REMOVE, this._onRemove, this)
     this._state = undefined
-    this.type = undefined
   }
 
   get layerId() {

modules/layer/LayerGroup.js

     this._layerGroupEvent = new LayerGroupEvent()
     this._layerGroupEvent.on(LayerGroupEventType.ADD, this._onAdd, this)
     this._layerGroupEvent.on(LayerGroupEventType.REMOVE, this._onRemove, this)
-    this.type = Layer.getLayerType('layer_group')
     this._state = State.INITIALIZED
   }
 
     return this._id
   }
 
+  get type() {
+    return Layer.getLayerType('layer_group')
+  }
+
   set show(show) {
     this._show = show
     Object.keys(this._cache).forEach(key => {

modules/layer/type/ClusterLayer.js

       this
     )
     this._delegate.clustering.pixelRange = this._options.pixelRange
-    this.type = Layer.getLayerType('cluster')
+
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('cluster')
+  }
+
   set enableCluster(enableCluster) {
     this._delegate.clustering.enabled = enableCluster
     return this

modules/layer/type/CzmlLayer.js

   constructor(id, url = '', options = {}) {
     super(id)
     this._delegate = Cesium.CzmlDataSource.load(url, options)
-    this.type = Layer.getLayerType('czml')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('czml')
+  }
+
   set show(show) {
     this._show = show
     this._delegate &&

modules/layer/type/DynamicLayer.js

   constructor(id) {
     super(id)
     this._delegate = new Cesium.CustomDataSource(id)
-    this.type = Layer.getLayerType('dynamic')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('dynamic')
+  }
+
   /**
    * Clears all entities
    * @returns {DynamicLayer}

modules/layer/type/FeatureGridLayer.js

   count: 10,
   maximumLevel: 21,
   dataProperty: '',
-  callback: record => {
+  callback: () => {
     return null
   }
 }
     this._rectangle = this._tilingScheme.rectangle
     this._credit = undefined
     this._token = undefined
-    this.type = Layer.getLayerType('feature_grid')
     for (let i = 0; i < this.maximumLevel; i++) {
       this._levelLayers[String(i)] = new VectorLayer(id + '-grid-' + i)
     }
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('feature_grid')
+  }
+
   get url() {
     return this._url
   }

modules/layer/type/GeoJsonLayer.js

     }
     super(id)
     this._delegate = Cesium.GeoJsonDataSource.load(url, options)
-    this.type = Layer.getLayerType('geojson')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('geojson')
+  }
+
   set show(show) {
     this._show = show
     this._delegate &&

modules/layer/type/HtmlLayer.js

     this._delegate = DomUtil.create('div', 'html-layer', undefined)
     this._delegate.setAttribute('id', this._id)
     this._renderRemoveCallback = undefined
-    this.type = Layer.getLayerType('html')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('html')
+  }
+
   set show(show) {
     this._show = show
     this._delegate.style.visibility = this._show ? 'visible' : 'hidden'

modules/layer/type/KmlLayer.js

     }
     super(id)
     this._delegate = Cesium.KmlDataSource.load(url, options)
-    this.type = Layer.getLayerType('kml')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('kml')
+  }
+
   set show(show) {
     this._show = show
     this._delegate &&

modules/layer/type/LabelLayer.js

     this._dataSource = Cesium.GeoJsonDataSource.load(url)
     this._delegate = new Cesium.CustomDataSource(id)
     this._initLabel()
-    this.type = Layer.registerType('label')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('label')
+  }
+
   _createLabel(entity) {
     if (entity.position && entity.name) {
       return Label.fromEntity(entity)

modules/layer/type/PrimitiveLayer.js

 import State from '@dc-modules/state/State'
 import Layer from '../Layer'
 
+/**
+ * PrimitiveLayer is used to add primitve
+ */
 class PrimitiveLayer extends Layer {
   constructor(id) {
     super(id)
     this._labels = this._delegate.add(new Cesium.LabelCollection())
     this._billboards = this._delegate.add(new Cesium.BillboardCollection())
     this._polylines = this._delegate.add(new Cesium.PolylineCollection())
-    this.type = Layer.getLayerType('primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('primitive')
+  }
+
   get points() {
     return this._points
   }

modules/layer/type/TilesetLayer.js

   constructor(id) {
     super(id)
     this._delegate = new Cesium.PrimitiveCollection()
-    this.type = Layer.getLayerType('tileset')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('tileset')
+  }
+
   /**
    * Clear all tileset
    * @returns {TilesetLayer}

modules/layer/type/TopoJsonLayer.js

 
 import State from '@dc-modules/state/State'
 import GeoJsonLayer from './GeoJsonLayer'
+import Layer from '../Layer'
 
 class TopoJsonLayer extends GeoJsonLayer {
   constructor(id, url, options = {}) {
       throw new Error('TopoJsonLayer：the url invalid')
     }
     super(id, url, options)
-    this.type = GeoJsonLayer.getLayerType('topojson')
     this._state = State.INITIALIZED
   }
+
+  get type() {
+    return Layer.getLayerType('topojson')
+  }
 }
 
 GeoJsonLayer.registerType('topojson')

modules/layer/type/VectorLayer.js

   constructor(id) {
     super(id)
     this._delegate = new Cesium.CustomDataSource(id)
-    this.type = Layer.getLayerType('vector')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('vector')
+  }
+
   /**
    * Clears all entities
    * @returns {VectorLayer}

modules/mapv/MapvLayer.js

 import { mapv } from '@dc-modules/namespace'
 import State from '@dc-modules/state/State'
 import { Layer } from '@dc-modules/layer'
+import Overlay from '../overlay/Overlay'
 
 class MapvLayer extends Layer {
   constructor(id, option = {}) {
     this._option = option
     this._dataSet = undefined
     this._delegate = undefined
-    this.type = Layer.getLayerType('mapv')
+    this._state = State.INITIALIZED
+  }
+
+  get type() {
+    return Overlay.getOverlayType('mapv')
   }
 
   set show(show) {

modules/overlay/Overlay.js

     this._allowDrillPicking = false
     this._contextMenu = []
     this._overlayEvent = new OverlayEvent()
-    this.type = undefined
     this.on(OverlayEventType.ADD, this._onAdd, this)
     this.on(OverlayEventType.REMOVE, this._onRemove, this)
   }
       this._layer.delegate.entities.add(this._delegate)
     } else if (this._layer?.delegate?.add && this._delegate) {
       // for Primitive
-      if (this.type === 'point_primitive' && this._layer.points) {
+      if (this.type && this.type === 'point_primitive' && this._layer.points) {
         this._delegate = this._layer.points.add(this._delegate)
       } else if (
-        this.type === 'billboard_primitive' &&
+        this.type.indexOf('billboard_primitive') >= 0 &&
         this._layer.billboards
       ) {
         this._delegate = this._layer.billboards.add(this._delegate)
       } else if (this.type === 'polyline_primitive' && this._layer.polylines) {
         this._delegate = this._layer.polylines.add(this._delegate)
-      } else if (this.type === 'label_primitive' && this._layer.labels) {
+      } else if (
+        this.type.indexOf('label_primitive') >= 0 &&
+        this._layer.labels
+      ) {
         this._delegate = this._layer.labels.add(this._delegate)
       } else {
         this._layer.delegate.add(this._delegate)
       if (this.type === 'point_primitive' && this._layer.points) {
         this._layer.points.remove(this._delegate)
       } else if (
-        this.type === 'billboard_primitive' &&
+        this.type.indexOf('billboard_primitive') >= 0 &&
         this._layer.billboards
       ) {
         this._layer.billboards.remove(this._delegate)
       } else if (this.type === 'polyline_primitive' && this._layer.polylines) {
         this._layer.polylines.remove(this._delegate)
-      } else if (this.type === 'label_primitive' && this._layer.labels) {
+      } else if (
+        this.type.indexOf('label_primitive') >= 0 &&
+        this._layer.labels
+      ) {
         this._layer.labels.remove(this._delegate)
       } else {
         this._layer.delegate.remove(this._delegate)

modules/overlay/custom/CustomBillboard.js

     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('custom_billboard')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(
       ...style,
       semiMajorAxis: radius,
       semiMinorAxis: radius,
-      stRotation: new Cesium.CallbackProperty(time => {
+      stRotation: new Cesium.CallbackProperty(() => {
         stRotation += amount
         if (stRotation >= 360 || stRotation <= -360) {
           stRotation = 0

modules/overlay/custom/CustomLabel.js

     this._delegate = new Cesium.Entity({ label: {} })
     this._position = Parse.parsePosition(position)
     this._text = text
-    this.type = Overlay.getOverlayType('custom_label')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('custom_label')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(
       ...style,
       semiMajorAxis: radius,
       semiMinorAxis: radius,
-      stRotation: new Cesium.CallbackProperty(time => {
+      stRotation: new Cesium.CallbackProperty(() => {
         stRotation += amount
         if (stRotation >= 360 || stRotation <= -360) {
           stRotation = 0

modules/overlay/dynamic/DynamicBillboard.js

     this._posistion = Parse.parsePosition(position)
     this._icon = icon
     this._delegate = new Cesium.Entity({ billboard: {} })
-    this.type = Overlay.getOverlayType('dynamic_billboard')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('dynamic_billboard')
+  }
+
   set icon(icon) {
     this._icon = icon
     this._delegate.billboard.image = this._icon

modules/overlay/dynamic/DynamicModel.js

     this._posistion = Parse.parsePosition(position)
     this._modelUrl = modelUrl
     this._delegate = new Cesium.Entity({ model: {} })
-    this.type = Overlay.getOverlayType('dynamic_model')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('dynamic_model')
+  }
+
   set modelUrl(modelUrl) {
     this._modelUrl = modelUrl
     this._delegate.model.uri = this._modelUrl

modules/overlay/html/DivIcon.js

       left: '0'
     })
     this.content = content
-    this.type = Overlay.getOverlayType('div_icon')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('div_icon')
+  }
+
   set show(show) {
     this._show = show
     this._delegate.style.visibility = this._show ? 'visible' : 'hidden'

modules/overlay/model/Model.js

     this._position = Parse.parsePosition(position)
     this._modelUrl = modelUrl
     this._rotateAmount = 0
-    this.type = Overlay.getOverlayType('model')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('model')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(
 
   set rotateAmount(amount) {
     this._rotateAmount = +amount
-    this._delegate.orientation = new Cesium.CallbackProperty(time => {
+    this._delegate.orientation = new Cesium.CallbackProperty(() => {
       this._position.heading += this._rotateAmount
       if (this._position.heading >= 360 || this._position.heading <= -360) {
         this._position.heading = 0

modules/overlay/model/Tileset.js

     this._tileVisibleCallback = undefined
     this._properties = undefined
     this._customShader = undefined
-    this.type = Overlay.getOverlayType('tileset')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('tileset')
+  }
+
   get readyPromise() {
     return this._delegate.readyPromise
   }

modules/overlay/plot/AttackArrow.js

     this.neckHeightFactor = 0.85
     this.neckWidthFactor = 0.15
     this.headTailFactor = 0.8
-    this.type = Overlay.getOverlayType('attack_arrow')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('attack_arrow')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()

modules/overlay/plot/DoubleArrow.js

     this.headWidthFactor = 0.3
     this.neckHeightFactor = 0.85
     this.neckWidthFactor = 0.15
-    this.type = Overlay.getOverlayType('double_arrow')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('double_arrow')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()

modules/overlay/plot/FineArrow.js

     this.headWidthFactor = 0.25
     this.headAngle = Math.PI / 8.5
     this.neckAngle = Math.PI / 13
-    this.type = Overlay.getOverlayType('fine_arrow')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('fine_arrow')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()

modules/overlay/plot/GatheringPlace.js

     this._positions = Parse.parsePositions(positions)
     this._delegate = new Cesium.Entity({ polygon: {} })
     this.t = 0.4
-    this.type = Overlay.getOverlayType('gathering_place')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('gathering_place')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()

modules/overlay/plot/TailedAttackArrow.js

     this.tailWidthFactor = 0.1
     this.headTailFactor = 0.8
     this.swallowTailFactor = 1
-    this.type = Overlay.getOverlayType('tailed_attack_arrow')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('tailed_attack_arrow')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()

modules/overlay/primitive/BillboardPrimitive.js

       width: 0,
       height: 0
     }
-    this.type = Overlay.getOverlayType('billboard_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('billboard_primitive')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/primitive/BounceBillboardPrimitive.js

 
 import { Cesium } from '@dc-modules/namespace'
 import State from '@dc-modules/state/State'
-import { Util } from '@dc-modules/utils'
 import Overlay from '../Overlay'
 import BillboardPrimitive from './BillboardPrimitive'
 
     super(position, icon)
     this._currentOffset = new Cesium.Cartesian2(0, 0)
     this._isUp = true
-    this.type = Overlay.getOverlayType('bounce_billboard_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('bounce_billboard_primitive')
+  }
+
   /**
    *
-   * @param layer
    * @private
    */
-  _onAdd(layer) {
-    if (!layer) {
+  _addedHook() {
+    if (!this._delegate || !this._layer) {
       return
     }
-    this._layer = layer
-    this._mountedHook && this._mountedHook()
-    if (this._layer?.delegate?.add && this._delegate) {
-      this._delegate = this._layer.billboards.add(this._delegate)
-      this._layer.delegate.add(this)
-    }
-    this._addedHook && this._addedHook()
-    this._state = State.ADDED
+    this._delegate.layerId = this._layer?.layerId
+    this._delegate.overlayId = this._id
+    this._layer.delegate.add(this)
   }
 
-  _onRemove() {
-    if (!this._layer || !this._delegate) {
+  /**
+   *
+   * @private
+   */
+  _removedHook() {
+    if (!this._layer) {
       return
     }
-    if (this._layer?.delegate?.remove) {
-      this._layer.billboards.remove(this._delegate)
-      this._layer.delegate.remove(this)
-    }
-    this._removedHook && this._removedHook()
-    this._state = State.REMOVED
+    this._layer.delegate.remove(this)
   }
 
   /**

modules/overlay/primitive/BounceLabelPrimitive.js

 
 import { Cesium } from '@dc-modules/namespace'
 import State from '@dc-modules/state/State'
-import { Util } from '@dc-modules/utils'
 import Overlay from '../Overlay'
 import LabelPrimitive from './LabelPrimitive'
 
     super(position, text)
     this._currentOffset = new Cesium.Cartesian2(0, 0)
     this._isUp = true
-    this.type = Overlay.getOverlayType('bounce_label_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('bounce_label_primitive')
+  }
+
   /**
    *
-   * @param layer
    * @private
    */
-  _onAdd(layer) {
-    if (!layer) {
+  _addedHook() {
+    if (!this._delegate || !this._layer) {
       return
     }
-    this._layer = layer
-    this._mountedHook && this._mountedHook()
-    if (this._layer?.delegate?.add && this._delegate) {
-      this._delegate = this._layer.labels.add(this._delegate)
-      this._layer.delegate.add(this)
-    }
-    this._addedHook && this._addedHook()
-    this._state = State.ADDED
+    this._delegate.layerId = this._layer?.layerId
+    this._delegate.overlayId = this._id
+    this._layer.delegate.add(this)
   }
 
-  _onRemove() {
-    if (!this._layer || !this._delegate) {
+  /**
+   *
+   * @private
+   */
+  _removedHook() {
+    if (!this._layer) {
       return
     }
-    if (this._layer?.delegate?.remove) {
-      this._layer.labels.remove(this._delegate)
-      this._layer.delegate.remove(this)
-    }
-    this._removedHook && this._removedHook()
-    this._state = State.REMOVED
+    this._layer.delegate.remove(this)
   }
 
   /**

modules/overlay/primitive/DiffuseWallPrimitive.js

     this._currentHeight = height || 0
     this._currentRadius = 10
     this._style = { ...DEF_STYLE }
-    this.type = Overlay.getOverlayType('diffuse_wall_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('diffuse_wall_primitive')
+  }
+
   set center(position) {
     this._center = Parse.parsePosition(position)
     return this

modules/overlay/primitive/ElecEllipsoidPrimitive.js

         geometry: {}
       })
     })
-    this.type = Overlay.getOverlayType('elec_ellipsoid_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('elec_ellipsoid_primitive')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.geometryInstances.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(

modules/overlay/primitive/FlowLinePrimitive.js

         geometry: {}
       })
     })
-    this.type = Overlay.getOverlayType('flow_line_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('flow_line_primitive')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.geometryInstances.geometry = new Cesium.PolylineGeometry({

modules/overlay/primitive/LabelPrimitive.js

       position: undefined,
       text: undefined
     }
-    this.type = Overlay.getOverlayType('label_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('label_primitive')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/primitive/ModelPrimitive.js

     this._position = Parse.parsePosition(position)
     this._modelUrl = modelUrl
     this._delegate = Cesium.Model.fromGltf({ url: modelUrl })
-    this.type = Overlay.getOverlayType('model_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('model_primitive')
+  }
+
   get readyPromise() {
     return this._delegate.readyPromise
   }

modules/overlay/primitive/PointPrimitive.js

   constructor(position) {
     super()
     this._position = Parse.parsePosition(position)
-    this.type = Overlay.getOverlayType('point_primitive')
+
     this._delegate = {
       position: undefined
     }
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('point_primitive')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/primitive/PolylinePrimitive.js

     this._delegate = {
       positions: []
     }
-    this.type = Overlay.getOverlayType('polyline_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('polyline_primitive')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.positions = Transform.transformWGS84ArrayToCartesianArray(

modules/overlay/primitive/ScanCirclePrimitive.js

         geometry: {}
       })
     })
-    this.type = Overlay.getOverlayType('scan_circle_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('scan_circle_primitive')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.geometryInstances.geometry = new Cesium.EllipseGeometry({

modules/overlay/primitive/TrailLinePrimitive.js

         geometry: {}
       })
     })
-    this.type = Overlay.getOverlayType('trail_line_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('trail_line_primitive')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.geometryInstances.geometry = new Cesium.PolylineGeometry({

modules/overlay/primitive/VideoPrimitive.js

       })
     })
     this._video = video
-    this.type = Overlay.getOverlayType('video_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('video_primitive')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.geometryInstances.geometry = Cesium.PolygonGeometry.fromPositions(

modules/overlay/primitive/WaterPrimitive.js

       }),
       asynchronous: true
     })
-    this.type = Overlay.getOverlayType('water_primitive')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('water_primitive')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.geometryInstances.geometry = Cesium.PolygonGeometry.fromPositions(

modules/overlay/vector/Billboard.js

     this._position = Parse.parsePosition(position)
     this._icon = icon
     this._size = [32, 32]
-    this.type = Overlay.getOverlayType('billboard')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('billboard')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Box.js

         }
       }
     })
-    this.type = Overlay.getOverlayType('box')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('box')
+  }
+
   /**
    *
    * @param position

modules/overlay/vector/Circle.js

     this._radius = +radius || 0
     this._rotateAmount = 0
     this._stRotation = 0
-    this.type = Overlay.getOverlayType('circle')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('circle')
+  }
+
   set center(center) {
     this._center = Parse.parsePosition(center)
     this._delegate.polygon.hierarchy = this._computeHierarchy()
 
   set rotateAmount(amount) {
     this._rotateAmount = +amount
-    this._delegate.polygon.stRotation = new Cesium.CallbackProperty(time => {
+    this._delegate.polygon.stRotation = new Cesium.CallbackProperty(() => {
       this._stRotation += this._rotateAmount
       if (this._stRotation >= 360 || this._stRotation <= -360) {
         this._stRotation = 0

modules/overlay/vector/Corridor.js

     super()
     this._positions = Parse.parsePositions(positions)
     this._delegate = new Cesium.Entity({ corridor: {} })
-    this.type = Overlay.getOverlayType('corridor')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('corridor')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.corridor.positions = Transform.transformWGS84ArrayToCartesianArray(

modules/overlay/vector/Cylinder.js

     this._topRadius = +topRadius || 0
     this._bottomRadius = +bottomRadius || 0
     this._delegate = new Cesium.Entity({ cylinder: {} })
-    this.type = Overlay.getOverlayType('cylinder')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('cylinder')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Ellipse.js

     this._semiMajorAxis = +semiMajorAxis || 0
     this._semiMinorAxis = +semiMinorAxis || 0
     this._delegate = new Cesium.Entity({ ellipse: {} })
-    this.type = Overlay.getOverlayType('ellipse')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('ellipse')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Ellipsoid.js

     this._position = Parse.parsePosition(position)
     this._radius = radius || { x: 10, y: 10, z: 10 }
     this._delegate = new Cesium.Entity({ ellipsoid: {} })
-    this.type = Overlay.getOverlayType('ellipsoid')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('ellipsoid')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Label.js

     this._delegate = new Cesium.Entity({ label: {} })
     this._position = Parse.parsePosition(position)
     this._text = text
-    this.type = Overlay.getOverlayType('label')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('label')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Plane.js

         plane: new Cesium.Plane(this._normal, this._distance)
       }
     })
-    this.type = Overlay.getOverlayType('plane')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('plane')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Point.js

     super()
     this._delegate = new Cesium.Entity({ point: {} })
     this._position = Parse.parsePosition(position)
-    this.type = Overlay.getOverlayType('point')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('point')
+  }
+
   set position(position) {
     this._position = Parse.parsePosition(position)
     this._delegate.position = Transform.transformWGS84ToCartesian(

modules/overlay/vector/Polygon.js

     this._delegate = new Cesium.Entity({ polygon: {} })
     this._positions = Parse.parsePositions(positions)
     this._holes = []
-    this.type = Overlay.getOverlayType('polygon')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('polygon')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._computeHierarchy()

modules/overlay/vector/Polyline.js

     super()
     this._positions = Parse.parsePositions(positions)
     this._delegate = new Cesium.Entity({ polyline: {} })
-    this.type = Overlay.getOverlayType('polyline')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('polyline')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polyline.positions = Transform.transformWGS84ArrayToCartesianArray(

modules/overlay/vector/PolylineVolume.js

     this._positions = Parse.parsePositions(positions)
     this._shape = shape || []
     this._delegate = new Cesium.Entity({ polylineVolume: {} })
-    this.type = Overlay.getOverlayType('polyline_volume')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('polyline_volume')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polylineVolume.positions = Transform.transformWGS84ArrayToCartesianArray(

modules/overlay/vector/Rectangle.js

     super()
     this._positions = Parse.parsePositions(positions)
     this._delegate = new Cesium.Entity({ rectangle: {} })
-    this.type = Overlay.getOverlayType('rectangle')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('rectangle')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.rectangle.coordinates = Cesium.Rectangle.fromCartesianArray(

modules/overlay/vector/Wall.js

     super()
     this._positions = Parse.parsePositions(positions)
     this._delegate = new Cesium.Entity({ wall: {} })
-    this.type = Overlay.getOverlayType('wall')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Overlay.getOverlayType('wall')
+  }
+
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.wall.positions = Transform.transformWGS84ArrayToCartesianArray(

modules/weather/type/Cloud.js

     this._delegate = undefined
     this._rotateAmount = 0
     this._enable = false
-    this.type = 'cloud'
     this._heading = 0
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return 'cloud'
+  }
+
   set enable(enable) {
     if (!this._viewer.scene.mode === Cesium.SceneMode.SCENE3D) {
       return this

modules/weather/type/Fog.js

     this._enable = false
     this._fogByDistance = { near: 10, nearValue: 0, far: 2000, farValue: 1.0 }
     this._color = new Cesium.Color(0, 0, 0, 1)
-    this.type = 'fog'
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return 'fog'
+  }
+
   set enable(enable) {
     this._enable = enable
     if (enable && this._viewer && !this._delegate) {

modules/weather/type/Rain.js

     this._delegate = undefined
     this._enable = false
     this._speed = 10.0
-    this.type = 'rain'
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return 'rain'
+  }
+
   set enable(enable) {
     this._enable = enable
     if (enable && this._viewer && !this._delegate) {

modules/weather/type/Snow.js

     this._delegate = undefined
     this._enable = false
     this._speed = 10.0
-    this.type = 'snow'
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return 'snow'
+  }
+
   set enable(enable) {
     this._enable = enable
     if (enable && this._viewer && !this._delegate) {

modules/widget/Widget.js

     this._enable = false
     this._wrapper = undefined
     this._ready = false
-    this.type = undefined
   }
 
   set enable(enable) {

modules/widget/type/Compass.js

     this._rotateFrame = undefined
     this._mouseMoveHandle = undefined
     this._mouseUpHandle = undefined
-    this.type = Widget.getWidgetType('compass')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('compass')
+  }
+
   /**
    *
    * @private
     }
   }
 
-  _handleDoubleClick(event) {
+  _handleDoubleClick() {
     let scene = this._viewer.scene
     let camera = scene.camera
     let sscc = scene.screenSpaceCameraController
     this._updateAngleAndOpacity(vector, this._compassRectangle.width)
   }
 
-  _orbitTickFunction(e) {
+  _orbitTickFunction() {
     let scene = this._viewer.scene
     let camera = this._viewer.camera
     let timestamp = Cesium.getTimestamp()

modules/widget/type/ContextMenu.js

     this._defaultMenu = [
       {
         label: '飞到默认位置',
-        callback: e => {
+        callback: () => {
           this._viewer.camera.flyHome(1.5)
         },
         context: this
       },
       {
         label: '取消飞行',
-        callback: e => {
+        callback: () => {
           this._viewer.camera.cancelFlight()
         },
         context: this
       }
     ]
     this._overlayMenu = []
-    this.type = Widget.getWidgetType('contextmenu')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('contextmenu')
+  }
+
   set DEFAULT_MENU(menus) {
     this._defaultMenu = menus
     return this

modules/widget/type/DistanceLegend.js

     this._labelEl = undefined
     this._scaleBarEl = undefined
     this._lastUpdate = Cesium.getTimestamp()
-    this.type = Widget.getWidgetType('distance_legend')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('distance_legend')
+  }
+
   /**
    *
    * @private

modules/widget/type/HawkeyeMap.js

     this._wrapper.setAttribute('id', Util.uuid())
     this._baseLayers = []
     this._map = undefined
-    this.type = Widget.getWidgetType('hawkeye_map')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('hawkeye_map')
+  }
+
   get baseLayers() {
     return this._baseLayers
   }

modules/widget/type/LoadingMask.js

   constructor() {
     super()
     this._wrapper = DomUtil.create('div', 'dc-loading-mask')
-    this.type = Widget.getWidgetType('loading_mask')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('loading_mask')
+  }
+
   /**
    *
    * @private

modules/widget/type/LocationBar.js

     this._wrapper = DomUtil.create('div', 'dc-location-bar')
     this._mouseEl = undefined
     this._cameraEl = undefined
-    this.type = Widget.getWidgetType('location_bar')
     this._state = State.INITIALIZED
     this._lastMouseUpdate = Cesium.getTimestamp()
     this._lastCameraUpdate = Cesium.getTimestamp()
   }
 
+  get type() {
+    return Widget.getWidgetType('location_bar')
+  }
+
   /**
    *
    * @private

modules/widget/type/MapSplit.js

     this._wrapper = DomUtil.create('div', 'dc-slider')
     this._baseLayer = undefined
     this._moveActive = false
-    this.type = Widget.getWidgetType('map_split')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('map_split')
+  }
+
   /**
    *
    * @private

modules/widget/type/MapSwitch.js

     this._wrapper = DomUtil.create('div', 'dc-map-switch')
     this._config = undefined
     this._cache = []
-    this.type = Widget.getWidgetType('map_switch')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('map_switch')
+  }
+
   /**
    * Override the superclass function
    * @private

modules/widget/type/Popup.js

     this._wrapper = DomUtil.create('div', 'dc-popup')
     this._config = { customClass: '' }
     this._position = undefined
-    this.type = Widget.getWidgetType('popup')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('popup')
+  }
+
   set config(config) {
     this._config = config
     config.customClass && this._setCustomClass()

modules/widget/type/Tooltip.js

     super()
     this._wrapper = DomUtil.create('div', 'dc-tool-tip')
     this._ready = true
-    this.type = Widget.getWidgetType('tooltip')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('tooltip')
+  }
+
   /**
    *
    * @private

modules/widget/type/ZoomController.js

     this._zoomInEl = undefined
     this._zoomOutEl = undefined
     this._refreshEl = undefined
-    this.type = Widget.getWidgetType('zoom_controller')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Widget.getWidgetType('zoom_controller')
+  }
+
   /**
    *
    * @param scene
     this._wrapper.appendChild(this._refreshEl)
     this._wrapper.appendChild(this._zoomOutEl)
     let self = this
-    this._zoomInEl.onclick = e => {
+    this._zoomInEl.onclick = () => {
       self._zoomIn()
     }
-    this._refreshEl.onclick = e => {
+    this._refreshEl.onclick = () => {
       self._refresh()
     }
-    this._zoomOutEl.onclick = e => {
+    this._zoomOutEl.onclick = () => {
       self._zoomOut()
     }
     this._ready = true

modules/wind/WindLayer.js

     }
     this._data = undefined
     this._canvas = document.createElement('canvas')
-    this.type = Layer.getLayerType('wind')
     this._state = State.INITIALIZED
   }
 
+  get type() {
+    return Layer.getLayerType('wind')
+  }
+
   set show(show) {
     this._show = show
     this._canvas.style.visibility = show ? 'visible' : 'hidden'