update dependencies

.eslintrc

     "no-trailing-spaces": 0,
     "no-mixed-spaces-and-tabs": 0,
     "space-before-function-paren": [0, "always"],
-    "no-multiple-empty-lines": 0
+    "no-multiple-empty-lines": 0,
+    "no-prototype-builtins": 0,
+    "no-loss-of-precision":0
   }
 }

README.md

+# DC-SDK
+
 <p>
 <img src="https://img.shields.io/github/actions/workflow/status/dvgis/dc-sdk/build.yml"/>
 <img src="https://img.shields.io/badge/license-Apache%202-blue"/>

gulpfile.js

 import { babel } from '@rollup/plugin-babel'
 import startServer from './server.js'
 import { uglify } from 'rollup-plugin-uglify'
+import inlineImage from 'esbuild-plugin-inline-image'
+import { glsl } from 'esbuild-plugin-glsl'
 
 const obfuscatorConfig = {
   compact: true, //压缩代码
   sourcemap: false,
   write: true,
   logLevel: 'info',
+  plugins: [
+    inlineImage({
+      limit: -1,
+    }),
+    glsl(),
+  ],
 }
 
 const packageJson = fse.readJsonSync('./package.json')
 
 async function buildNamespace(options) {
   const bundle = await rollup({
-    input: 'src/namespace.js',
+    input: 'src/namespace/libs.js',
     plugins: [
       commonjs(),
       resolve({ preferBuiltins: true }),
 
   const exportNamespace = `
         export const __namespace = {
-            Cesium: exports.Cesium,
-            turf:  exports.turf
+            Cesium: exports.Cesium
         }
      `
 

package.json

     "@turf/turf": "^6.5.0",
     "chalk": "^5.2.0",
     "esbuild": "^0.17.18",
+    "esbuild-plugin-glsl": "^1.2.1",
+    "esbuild-plugin-inline-image": "^0.0.9",
     "eslint": "^8.40.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-import": "^2.27.5",

src/index.js

 /**
  @Author: Caven Chen
  **/
-import { registerLib } from './global-api/lib-utils.js'
+import { getLib, registerLib } from './global-api/lib-utils.js'
 
 export { registerLib, getLib } from './global-api/lib-utils.js'
 
 }
 
 export function ready(options = {}) {
-  if (options.baseUrl) {
-    this.config.baseUrl = options.baseUrl
+  if (options['baseUrl']) {
+    this.config.baseUrl = options['baseUrl']
   }
-  if (options.accessToken) {
-    this.config.accessToken = options.accessToken
+  if (options['accessToken']) {
+    this.config.accessToken = options['accessToken']
   }
-  const { Cesium, turf } = this['__namespace']
-  registerLib('Cesium', Cesium)
-  registerLib('turf', turf)
+
+  if (options['Cesium']) {
+    registerLib('Cesium', options['Cesium'])
+  } else {
+    registerLib('Cesium', this['__namespace']['Cesium'])
+  }
+
+  // if (options['echarts']) {
+  //   registerLib('echarts', options['echarts'])
+  // }
+
+  // if (options['turf']) {
+  //   registerLib('turf', options['turf'])
+  // }
+
   this['__cmdOut'] && this['__cmdOut']()
+
   return new Promise((resolve, reject) => {
+    const Cesium = getLib('Cesium')
+    if (!Cesium) {
+      throw new Error('missing Cesium Lib')
+    }
+    this.config.baseUrl && Cesium.buildModuleUrl.setBaseUrl(this.config.baseUrl)
+    // register common modules
     const modules = require('./modules')
-    this.config.baseUrl &&
-      Cesium &&
-      Cesium.buildModuleUrl.setBaseUrl(this.config.baseUrl)
     Object.keys(modules).forEach((key) => {
       this[key] = modules[key]
     })
+
+    // register chart module
+    if (getLib('echarts')) {
+      const modules = require('./modules/chart')
+      Object.keys(modules).forEach((key) => {
+        this[key] = modules[key]
+      })
+    }
+
+    // register turf module
+    if (getLib('turf')) {
+      // todo
+    }
+
     resolve()
+  }).catch((e) => {
+    throw new Error(e.message)
   })
 }

src/modules/chart/ChartLayer.js

+/**
+ @author : Caven Chen
+ @date : 2023-05-23
+ */
+
+import { echarts } from '../../namespace'
+import { Layer } from '../layer'
+const { init } = echarts
+
+class ChartLayer extends Layer {
+  constructor(id, viewer) {
+    super(id)
+    this._viewer.canvas.setAttribute('tabIndex', '0')
+    this._chartEl = this._createChartElement()
+    this._chart = init(this._chartEl)
+    this._show = true
+    Object(this._chart.getZr()).viewer = viewer
+  }
+
+  get id() {
+    return this._id
+  }
+
+  set show(show) {
+    this._show = show
+    this._chartEl.style.visibility = show ? 'visible' : 'hidden'
+  }
+
+  get show() {
+    return this._show
+  }
+
+  /**
+   *
+   * @returns {HTMLDivElement}
+   * @private
+   */
+  _createChartElement() {
+    let canvas = this._viewer.scene.canvas
+    let el = document.createElement('div')
+    el.setAttribute('id', this._id)
+    el.style.cssText = `position:absolute; top:0; left:0; width: ${canvas.clientWidth}px; height: ${canvas.clientHeight}px;pointer-events:none;`
+    this._viewer.container.appendChild(el)
+    return el
+  }
+
+  /**
+   *
+   * @param option
+   * @returns {ChartLayer}
+   */
+  setOption(option = {}) {
+    this._chart.setOption({ ...option, GLMap: {}, animation: false })
+    return this
+  }
+
+  /**
+   *
+   * @returns {ChartLayer}
+   */
+  clear() {
+    this._chart.clear()
+    return this
+  }
+
+  /**
+   *
+   * @returns {ChartLayer}
+   */
+  resize() {
+    this._chart.resize()
+    return this
+  }
+}
+
+export default ChartLayer

src/modules/chart/GLMapCoordSys.js

+/**
+ @author : Caven Chen
+ @date : 2023-05-23
+ */
+
+import { echarts, Cesium } from '../../namespace'
+const { Cartesian3, Ellipsoid, Math: CesiumMath } = Cesium
+const { graphic, matrix } = echarts
+
+class GLMapCoordSys {
+  constructor(api) {
+    this._api = api
+    this._viewer = Object(api.getZr()).viewer
+    this._mapOffset = [0, 0]
+    this.dimensions = ['lng', 'lat']
+  }
+
+  getViewer() {
+    return this._viewer
+  }
+
+  setMapOffset(mapOffset) {
+    this._mapOffset = mapOffset
+    return this
+  }
+
+  dataToPoint(data) {
+    let result = []
+    let cartesian3 = Cartesian3.fromDegrees(data[0], data[1])
+    if (!cartesian3) {
+      return result
+    }
+    let up = Ellipsoid.WGS84.geodeticSurfaceNormal(cartesian3, new Cartesian3())
+    let cd = this._viewer.camera.direction
+    if (Cartesian3.dot(up, cd) >= 0) {
+      return result
+    }
+    let coords = this._viewer.scene.cartesianToCanvasCoordinates(cartesian3)
+    if (!coords) {
+      return result
+    }
+    return [coords.x - this._mapOffset[0], coords.y - this._mapOffset[1]]
+  }
+
+  pointToData(point) {
+    let ellipsoid = this._viewer.scene.globe.ellipsoid
+    let cartesian3 = new Cartesian3(
+      point[0] + this._mapOffset[0],
+      point[1] + this._mapOffset[1],
+      0
+    )
+    let cartographic = ellipsoid.cartesianToCartographic(cartesian3)
+    return [
+      CesiumMath.toDegrees(cartographic.longitude),
+      CesiumMath.toDegrees(cartographic.latitude),
+    ]
+  }
+
+  getViewRect() {
+    let api = this._api
+    return new graphic.BoundingRect(0, 0, api.getWidth(), api.getHeight())
+  }
+
+  getRoamTransform() {
+    return matrix.create()
+  }
+
+  static create(ecModel, api) {
+    let coordinateSys = undefined
+    ecModel.eachComponent('GLMap', function (model) {
+      coordinateSys = new GLMapCoordSys(api)
+      coordinateSys.setMapOffset(model['__mapOffset'] || [0, 0])
+      model.coordinateSystem = coordinateSys
+    })
+    ecModel.eachSeries(function (model) {
+      'GLMap' === model.get('coordinateSystem') &&
+        (model.coordinateSystem = coordinateSys)
+    })
+  }
+}
+
+GLMapCoordSys.dimensions = ['lng', 'lat']
+
+export default GLMapCoordSys

src/modules/chart/GLMapModel.js

+/**
+ @author : Caven Chen
+ @date : 2023-05-23
+ */
+
+import { echarts } from '../../namespace'
+
+const { extendComponentModel } = echarts
+
+extendComponentModel({
+  type: 'GLMap',
+  getViewer() {
+    return Object(this.getZr()).viewer
+  },
+  defaultOption: {
+    roam: false,
+  },
+})

src/modules/chart/GLMapView.js

+/**
+  @Author: Caven Chen
+**/
+
+import { echarts } from '../../namespace'
+
+const { extendComponentView } = echarts
+
+extendComponentView({
+  type: 'GLMap',
+  init: function (ecModel, api) {
+    this.api = api
+    let viewer = api.getZr().viewer
+    viewer.scene.postRender.addEventListener(this.moveHandler, this)
+  },
+  moveHandler: function (t, e) {
+    this.api.dispatchAction({
+      type: 'GLMapRoam',
+    })
+  },
+  render: function (t, e, i) {},
+  dispose: function (t) {
+    let viewer = this.api.getZr().viewer
+    viewer.scene.postRender.removeEventListener(this.moveHandler, this)
+  },
+})

src/modules/chart/index.js

+/**
+  @Author: Caven Chen
+**/
+
+import { echarts } from '../../namespace'
+
+import './GLMapModel'
+import './GLMapView'
+import GLMapCoordSys from './GLMapCoordSys'
+import ChartLayer from './ChartLayer.js'
+
+const { registerAction, registerCoordinateSystem } = echarts
+
+registerCoordinateSystem('GLMap', GLMapCoordSys)
+registerAction(
+  {
+    type: 'GLMapRoam',
+    event: 'GLMapRoam',
+    update: 'updateLayout',
+  },
+  function (payload, ecModel) {}
+)
+
+export { ChartLayer }

src/modules/exts/BaseLayerPicker.js

 /**
- @author : Caven Chen
- @date : 2023-05-09
- */
+ @Author: Caven Chen
+ **/
 
 import { Cesium } from '../../namespace/index.js'
-const { DeveloperError, EllipsoidTerrainProvider } = Cesium
+
+const { EllipsoidTerrainProvider } = Cesium
 
 class BaseLayerPicker {
   constructor(options) {
     if (!options.globe) {
-      throw new DeveloperError('globe is required')
+      throw new Error('globe is required')
     }
     this._globe = options.globe
-    this._imageryProviders = []
+    this._imageryLayers = []
     this._terrainProviders = []
-    this._selectedImagery = undefined
+    this._selectedImageryLayer = undefined
     this._selectedTerrain = undefined
+    this._count = 0
   }
 
-  set selectedImagery(imagery) {
-    if (!imagery || !imagery.providers) {
-      new DeveloperError('imagery format error')
+  set selectedImageryLayer(imageryLayer) {
+    if (!imageryLayer || !imageryLayer.layers) {
+      new Error('imagery format error')
     }
-    const imageryLayers = this._globe.imageryLayers
-    if (!this._selectedImagery) {
-      for (let i = imagery.providers.length - 1; i >= 0; i--) {
-        imageryLayers.addImageryProvider(imagery.providers[i], 0)
+    let imageryLayers = this._globe.imageryLayers
+    if (!this._selectedImageryLayer) {
+      for (let i = imageryLayer.layers.length - 1; i >= 0; i--) {
+        imageryLayers.add(imageryLayer.layers[i], 0)
       }
     } else if (
-      this._selectedImagery &&
-      imagery.id !== this._selectedImagery.id
+      this._selectedImageryLayer &&
+      imageryLayer.id !== this._selectedImageryLayer.id
     ) {
       imageryLayers.removeAll()
-      for (let i = imagery.providers.length - 1; i >= 0; i--) {
-        imageryLayers.addImageryProvider(imagery.providers[i], 0)
+      for (let i = imageryLayer.layers.length - 1; i >= 0; i--) {
+        imageryLayers.addImageryProvider(imageryLayer.layers[i], 0)
       }
     }
-    this._selectedImagery = imagery
+    this._selectedImageryLayer = imageryLayer
   }
 
-  get selectedImagery() {
-    return this._selectedImagery
+  get selectedImageryLayer() {
+    return this._selectedImageryLayer
   }
 
-  set selectedTerrain(terrian) {
-    if (this.selectedImagery !== terrian) {
+  set selectedTerrain(terrain) {
+    if (this.selectedTerrain !== terrain) {
       this._globe.depthTestAgainstTerrain = !(
-        terrian instanceof EllipsoidTerrainProvider
+        terrain instanceof EllipsoidTerrainProvider
       )
-      this._globe.terrainProvider = terrian
-      this._selectedTerrain = terrian
+      this._globe.terrainProvider = terrain
+      this._selectedTerrain = terrain
     }
   }
 
 
   /**
    *
-   * @param provider
+   * @param imageryLayer
    * @returns {BaseLayerPicker}
    */
-  addImageryProvider(provider) {
-    let providers = []
-    let len = this._imageryProviders.length + 1
-    if (Array.isArray(provider)) {
-      providers = provider.slice(0)
+  addImageryLayer(imageryLayer) {
+    let imageryLayers = []
+    if (Array.isArray(imageryLayer)) {
+      imageryLayers = imageryLayer.slice(0)
     } else {
-      providers = [provider]
+      imageryLayers = [imageryLayer]
     }
-    this._imageryProviders.push({
-      id: `dc-imagery-${len}`,
-      providers,
+    this._count++
+    this._imageryLayers.push({
+      id: `dc-imagery-${this._count}`,
+      layers: imageryLayers,
     })
     return this
   }
    * @param index
    * @returns {BaseLayerPicker}
    */
-  changeImagery(index) {
-    if (index > this._imageryProviders.length - 1) {
-      new DeveloperError('index error ')
-      return this
+  changeImageryLayer(index) {
+    if (index > this._imageryLayers.length - 1) {
+      throw new Error('index error')
     }
-    this.selectedImagery = this._imageryProviders[index]
+    this.selectedImageryLayer = this._imageryLayers[index]
     return this
   }
 
    */
   changeTerrain(index) {
     if (index > this._terrainProviders.length - 1) {
-      new DeveloperError('index error ')
-      return this
+      throw new Error('index error')
     }
     this.selectedTerrain = this._terrainProviders[index]
+    return this
   }
 }
 

src/modules/exts/Viewer.js

 /**
  @author : Caven Chen
- @date : 2023-05-07
+ @date : 2023-05-23
  */
-import { Cesium } from '../../namespace'
+import { Cesium } from '../../namespace/index.js'
+
 const {
   BoundingSphere,
   BoundingSphereState,
 }
 
 /**
+ * @typedef {object} Viewer.ConstructorOptions
+ *
+ * Initialization options for the Viewer constructor
  *
- * @param container
- * @param options
+ * @property {ImageryProvider|false} [imageryProvider=createWorldImagery()] The imagery provider to use.  This value is only valid if `baseLayerPicker` is set to false. Deprecated.
+ * @property {ImageryLayer|false} [baseLayer=ImageryLayer.fromWorldImagery()] The bottommost imagery layer applied to the globe. If set to <code>false</code>, no imagery provider will be added. This value is only valid if `baseLayerPicker` is set to false.
+ * @property {TerrainProvider} [terrainProvider=new EllipsoidTerrainProvider()] The terrain provider to use
+ * @property {Terrain} [terrain] A terrain object which handles asynchronous terrain provider. Can only specify if options.terrainProvider is undefined.
+ * @property {SkyBox|false} [skyBox] The skybox used to render the stars.  When <code>undefined</code>, the default stars are used. If set to <code>false</code>, no skyBox, Sun, or Moon will be added.
+ * @property {SkyAtmosphere|false} [skyAtmosphere] Blue sky, and the glow around the Earth's limb.  Set to <code>false</code> to turn it off.
+ * @property {Element|string} [fullscreenElement=document.body] The element or id to be placed into fullscreen mode when the full screen button is pressed.
+ * @property {boolean} [useDefaultRenderLoop=true] True if this widget should control the render loop, false otherwise.
+ * @property {number} [targetFrameRate] The target frame rate when using the default render loop.
+ * @property {boolean} [showRenderLoopErrors=true] If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
+ * @property {boolean} [useBrowserRecommendedResolution=true] If true, render at the browser's recommended resolution and ignore <code>window.devicePixelRatio</code>.
+ * @property {boolean} [automaticallyTrackDataSourceClocks=true] If true, this widget will automatically track the clock settings of newly added DataSources, updating if the DataSource's clock changes.  Set this to false if you want to configure the clock independently.
+ * @property {ContextOptions} [contextOptions] Context and WebGL creation properties passed to {@link Scene}.
+ * @property {SceneMode} [sceneMode=SceneMode.SCENE3D] The initial scene mode.
+ * @property {MapProjection} [mapProjection=new GeographicProjection()] The map projection to use in 2D and Columbus View modes.
+ * @property {Globe|false} [globe=new Globe(mapProjection.ellipsoid)] The globe to use in the scene.  If set to <code>false</code>, no globe will be added.
+ * @property {boolean} [orderIndependentTranslucency=true] If true and the configuration supports it, use order independent translucency.
+ * @property {Element|string} [creditContainer] The DOM element or ID that will contain the {@link CreditDisplay}.  If not specified, the credits are added to the bottom of the widget itself.
+ * @property {Element|string} [creditViewport] The DOM element or ID that will contain the credit pop up created by the {@link CreditDisplay}.  If not specified, it will appear over the widget itself.
+ * @property {DataSourceCollection} [dataSources=new DataSourceCollection()] The collection of data sources visualized by the widget.  If this parameter is provided,
+ *                               the instance is assumed to be owned by the caller and will not be destroyed when the viewer is destroyed.
+ * @property {boolean} [shadows=false] Determines if shadows are cast by light sources.
+ * @property {ShadowMode} [terrainShadows=ShadowMode.RECEIVE_ONLY] Determines if the terrain casts or receives shadows from light sources.
+ * @property {MapMode2D} [mapMode2D=MapMode2D.INFINITE_SCROLL] Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
+ * @property {boolean} [projectionPicker=false] If set to true, the ProjectionPicker widget will be created.
+ * @property {boolean} [blurActiveElementOnCanvasFocus=true] If true, the active element will blur when the viewer's canvas is clicked. Setting this to false is useful for cases when the canvas is clicked only for retrieving position or an entity data without actually meaning to set the canvas to be the active element.
+ * @property {boolean} [requestRenderMode=false] If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling reduces the CPU/GPU usage of your application and uses less battery on mobile, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
+ * @property {number} [maximumRenderTimeChange=0.0] If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
+ * @property {number} [depthPlaneEllipsoidOffset=0.0] Adjust the DepthPlane to address rendering artefacts below ellipsoid zero elevation.
+ * @property {number} [msaaSamples=1] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
+ */
+
+/**
+ * A base widget for building applications.  It composites all of the standard Cesium widgets into one reusable package.
+ * The widget can always be extended by using mixins, which add functionality useful for a variety of applications.
+ *
+ * @alias Viewer
  * @constructor
+ *
+ * @param {Element|string} container The DOM element or ID that will contain the widget.
+ * @param {Viewer.ConstructorOptions} [options] Object describing initialization options
+ *
+ * @exception {DeveloperError} Element with id "container" does not exist in the document.
+ * @exception {DeveloperError} options.selectedImageryProviderViewModel is not available when not using the BaseLayerPicker widget, specify options.baseLayer instead.
+ * @exception {DeveloperError} options.selectedTerrainProviderViewModel is not available when not using the BaseLayerPicker widget, specify options.terrainProvider instead.
+ *
+ * @see Animation
+ * @see BaseLayerPicker
+ * @see CesiumWidget
+ * @see FullscreenButton
+ * @see HomeButton
+ * @see SceneModePicker
+ * @see Timeline
+ * @see viewerDragDropMixin
+ *
+ * @demo {@link https://sandcastle.cesium.com/index.html?src=Hello%20World.html|Cesium Sandcastle Hello World Demo}
+ *
+ * @example
+ * // Initialize the viewer widget with several custom options and mixins.
+ * try {
+ *   const viewer = new Cesium.Viewer("cesiumContainer", {
+ *     // Start in Columbus Viewer
+ *     sceneMode: Cesium.SceneMode.COLUMBUS_VIEW,
+ *     // Use Cesium World Terrain
+ *     terrain: Cesium.Terrain.fromWorldTerrain(),
+ *     // Use OpenStreetMaps
+ *     baseLayer: new Cesium.ImageryLayer(OpenStreetMapImageryProvider({
+ *       url: "https://a.tile.openstreetmap.org/"
+ *     })),
+ *     skyBox: new Cesium.SkyBox({
+ *       sources: {
+ *         positiveX: "stars/TychoSkymapII.t3_08192x04096_80_px.jpg",
+ *         negativeX: "stars/TychoSkymapII.t3_08192x04096_80_mx.jpg",
+ *         positiveY: "stars/TychoSkymapII.t3_08192x04096_80_py.jpg",
+ *         negativeY: "stars/TychoSkymapII.t3_08192x04096_80_my.jpg",
+ *         positiveZ: "stars/TychoSkymapII.t3_08192x04096_80_pz.jpg",
+ *         negativeZ: "stars/TychoSkymapII.t3_08192x04096_80_mz.jpg"
+ *       }
+ *     }),
+ *     // Show Columbus View map with Web Mercator projection
+ *     mapProjection: new Cesium.WebMercatorProjection()
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ *
+ * // Add basic drag and drop functionality
+ * viewer.extend(Cesium.viewerDragDropMixin);
+ *
+ * // Show a pop-up alert if we encounter an error when processing a dropped file
+ * viewer.dropError.addEventListener(function(dropHandler, name, error) {
+ *   console.log(error);
+ *   window.alert(error);
+ * });
  */
 function Viewer(container, options) {
   //>>includeStart('debug', pragmas.debug);
   container = getElement(container)
   options = defaultValue(options, defaultValue.EMPTY_OBJECT)
 
-  //>>includeEnd('debug')
   const viewerContainer = document.createElement('div')
-  viewerContainer.className = 'dc-viewer'
-  container.appendChild(viewerContainer)
-
-  // Cesium widget container
-  const cesiumWidgetContainer = document.createElement('div')
-  cesiumWidgetContainer.className = 'dc-viewer-widget-container'
-  viewerContainer.appendChild(cesiumWidgetContainer)
 
-  // Bottom container
   const bottomContainer = document.createElement('div')
-  bottomContainer.className = 'dc-viewer-bottom'
 
   const scene3DOnly = defaultValue(options.scene3DOnly, false)
 
   }
 
   // Cesium widget
-  const cesiumWidget = new CesiumWidget(cesiumWidgetContainer, {
+  const cesiumWidget = new CesiumWidget(container, {
     baseLayer: false,
     clock: clock,
     skyBox: options.skyBox,
     targetFrameRate: options.targetFrameRate,
     showRenderLoopErrors: options.showRenderLoopErrors,
     useBrowserRecommendedResolution: options.useBrowserRecommendedResolution,
-    creditContainer: defined(options.creditContainer)
-      ? options.creditContainer
-      : bottomContainer,
-    creditViewport: options.creditViewport,
     scene3DOnly: scene3DOnly,
     shadows: options.shadows,
     terrainShadows: options.terrainShadows,
     msaaSamples: options.msaaSamples,
   })
 
-  cesiumWidget.container.firstChild.className = 'dc-widget'
   cesiumWidget.scene.backgroundColor = Color.TRANSPARENT
-  cesiumWidget.scene.screenSpaceCameraController.maximumZoomDistance = 40489014.0
-
-  let childrens = cesiumWidget.creditViewport.children
 
-  for (let i = 0; i < childrens.length; i++) {
-    if (!(childrens[i] instanceof HTMLCanvasElement)) {
-      cesiumWidget.creditViewport.removeChild(childrens[i])
-    }
+  while (
+    cesiumWidget.creditViewport.hasChildNodes() &&
+    !(cesiumWidget.creditViewport.lastChild instanceof HTMLCanvasElement)
+  ) {
+    cesiumWidget.creditViewport.removeChild(
+      cesiumWidget.creditViewport.lastChild
+    )
   }
 
+  cesiumWidget.creditViewport.className = 'dc-viewer-canvas'
+
   let dataSourceCollection = options.dataSources
   let destroyDataSourceCollection = false
   if (!defined(dataSourceCollection)) {
 
   // Main Toolbar
   const toolbar = document.createElement('div')
-  toolbar.className = 'dc-viewer-toolbar'
+
   //Assign all properties to this instance.  No "this" assignments should
   //take place above this line.
   this._dataSourceChangedListeners = {}
 Object.defineProperties(Viewer.prototype, {
   /**
    * Gets the parent container.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Element}
    * @readonly
    */
   /**
    * Gets the DOM element for the area at the bottom of the window containing the
    * {@link CreditDisplay} and potentially other things.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Element}
    * @readonly
    */
 
   /**
    * Gets the CesiumWidget.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {CesiumWidget}
    * @readonly
    */
 
   /**
    * Gets the display used for {@link DataSource} visualization.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {DataSourceDisplay}
    * @readonly
    */
   /**
    * Gets the collection of entities not tied to a particular data source.
    * This is a shortcut to [dataSourceDisplay.defaultDataSource.entities]{@link Viewer#dataSourceDisplay}.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {EntityCollection}
    * @readonly
    */
 
   /**
    * Gets the set of {@link DataSource} instances to be visualized.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {DataSourceCollection}
    * @readonly
    */
 
   /**
    * Gets the canvas.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {HTMLCanvasElement}
    * @readonly
    */
 
   /**
    * Gets the scene.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Scene}
    * @readonly
    */
 
   /**
    * Determines if shadows are cast by light sources.
-   * @memberof viewer.prototype
-   * @type {Boolean}
+   * @memberof Viewer.prototype
+   * @type {boolean}
    */
   shadows: {
     get: function () {
 
   /**
    * Determines if the terrain casts or shadows from light sources.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {ShadowMode}
    */
   terrainShadows: {
 
   /**
    * Get the scene's shadow map
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {ShadowMap}
    * @readonly
    */
 
   /**
    * Gets the collection of image layers that will be rendered on the globe.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
    * @type {ImageryLayerCollection}
    * @readonly
 
   /**
    * The terrain provider providing surface geometry for the globe.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
    * @type {TerrainProvider}
    */
 
   /**
    * Gets the camera.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
    * @type {Camera}
    * @readonly
 
   /**
    * Gets the post-process stages.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
    * @type {PostProcessStageCollection}
    * @readonly
 
   /**
    * Gets the clock.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Clock}
    * @readonly
    */
 
   /**
    * Gets the screen space event handler.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {ScreenSpaceEventHandler}
    * @readonly
    */
    * is true. If undefined, the browser's requestAnimationFrame implementation
    * determines the frame rate.  If defined, this value must be greater than 0.  A value higher
    * than the underlying requestAnimationFrame implementation will have no effect.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
-   * @type {Number}
+   * @type {number}
    */
   targetFrameRate: {
     get: function () {
    * <code>renderError</code> event will be raised and this property
    * will be set to false.  It must be set back to true to continue rendering
    * after the error.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
-   * @type {Boolean}
+   * @type {boolean}
    */
   useDefaultRenderLoop: {
     get: function () {
    * For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
    * will cause the scene to be rendered at 320x240 and then scaled up while setting
    * it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
-   * @type {Number}
+   * @type {number}
    * @default 1.0
    */
   resolutionScale: {
    * performance on less powerful devices that have high pixel density. When false, rendering
    * will be in device pixels. {@link Viewer#resolutionScale} will still take effect whether
    * this flag is true or false.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
-   * @type {Boolean}
+   * @type {boolean}
    * @default true
    */
   useBrowserRecommendedResolution: {
    * For example, if asynchronous primitives are being processed in the
    * background, the clock will not advance until the geometry is ready.
    *
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    *
-   * @type {Boolean}
+   * @type {boolean}
    */
   allowDataSourcesToSuspendAnimation: {
     get: function () {
 
   /**
    * Gets or sets the Entity instance currently being tracked by the camera.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Entity | undefined}
    */
   trackedEntity: {
    * If a user interactively picks a Cesium3DTilesFeature instance, then this property
    * will contain a transient Entity instance with a property named "feature" that is
    * the instance that was picked.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Entity | undefined}
    */
   selectedEntity: {
   },
   /**
    * Gets the event that is raised when the selected entity changes.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Event}
    * @readonly
    */
   },
   /**
    * Gets the event that is raised when the tracked entity changes.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {Event}
    * @readonly
    */
   },
   /**
    * Gets or sets the data source to track with the viewer's clock.
-   * @memberof viewer.prototype
+   * @memberof Viewer.prototype
    * @type {DataSource}
    */
   clockTrackedDataSource: {
 })
 
 /**
+ * Extends the base viewer functionality with the provided mixin.
+ * A mixin may add additional properties, functions, or other behavior
+ * to the provided viewer instance.
+ *
+ * @param {Viewer.ViewerMixin} mixin The Viewer mixin to add to this instance.
+ * @param {object} [options] The options object to be passed to the mixin function.
  *
- * @param mixin
- * @param options
+ * @see viewerDragDropMixin
  */
 Viewer.prototype.extend = function (mixin, options) {
   //>>includeStart('debug', pragmas.debug);
   }
   this._dataSourceRemoved(undefined, this._dataSourceDisplay.defaultDataSource)
 
-  this._container.removeChild(this._element)
-  this._element.removeChild(this._toolbar)
-
   this._eventHelper.removeAll()
 
   this._dataSourceDisplay = this._dataSourceDisplay.destroy()
  * target will be the range. The heading will be determined from the offset. If the heading cannot be
  * determined from the offset, the heading will be north.</p>
  *
- * @param {Entity|Entity[]|EntityCollection|DataSource|ImageryLayer|Cesium3DTileset|TimeDynamicPointCloud|Promise.<Entity|Entity[]|EntityCollection|DataSource|ImageryLayer|Cesium3DTileset|TimeDynamicPointCloud>} target The entity, array of entities, entity collection, data source, Cesium3DTileset, point cloud, or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
- * @param {Object} [options] Object with the following properties:
- * @param {Number} [options.duration=3.0] The duration of the flight in seconds.
- * @param {Number} [options.maximumHeight] The maximum height at the peak of the flight.
+ * @param {Entity|Entity[]|EntityCollection|DataSource|ImageryLayer|Cesium3DTileset|TimeDynamicPointCloud|Promise<Entity|Entity[]|EntityCollection|DataSource|ImageryLayer|Cesium3DTileset|TimeDynamicPointCloud|VoxelPrimitive>} target The entity, array of entities, entity collection, data source, Cesium3DTileset, point cloud, or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
+ * @param {object} [options] Object with the following properties:
+ * @param {number} [options.duration=3.0] The duration of the flight in seconds.
+ * @param {number} [options.maximumHeight] The maximum height at the peak of the flight.
  * @param {HeadingPitchRange} [options.offset] The offset from the target in the local east-north-up reference frame centered at the target.
- * @returns {Promise.<Boolean>} A Promise that resolves to true if the flight was successful or false if the target is not currently visualized in the scene or the flight was cancelled. //TODO: Cleanup entity mentions
+ * @returns {Promise<boolean>} A Promise that resolves to true if the flight was successful or false if the target is not currently visualized in the scene or the flight was cancelled. //TODO: Cleanup entity mentions
  */
 Viewer.prototype.flyTo = function (target, options) {
   return zoomToOrFly(this, target, options, true)
   updateZoomTarget(this)
   updateTrackedEntity(this)
 }
-
 function updateZoomTarget(viewer) {
   const target = viewer._zoomTarget
   if (!defined(target) || viewer.scene.mode === SceneMode.MORPHING) {

src/modules/material/type/circle.js

  * @Date: 2021-02-27 22:49:41
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 
 const CircleBlurMaterial = require('../shader/circle/CircleBlurMaterial.glsl')
 const CircleDiffuseMaterial = require('../shader/circle/CircleDiffuseMaterial.glsl')
     type: Cesium.Material.CircleBlurType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 3.0
+      speed: 3.0,
     },
-    source: CircleBlurMaterial
+    source: CircleBlurMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CircleDiffuseType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 3.0
+      speed: 3.0,
     },
-    source: CircleDiffuseMaterial
+    source: CircleDiffuseMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CircleFadeType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 3.0
+      speed: 3.0,
     },
-    source: CircleFadeMaterial
+    source: CircleFadeMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CirclePulseType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 12.0
+      speed: 12.0,
     },
-    source: CirclePulseMaterial
+    source: CirclePulseMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
   fabric: {
     type: Cesium.Material.CircleRingType,
     uniforms: {
-      color: new Cesium.Color(1.0, 0.0, 0.0, 0.7)
+      color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
     },
-    source: CircleRingMaterial
+    source: CircleRingMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CircleRotateType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      image: Cesium.Material.DefaultImageId
+      image: Cesium.Material.DefaultImageId,
     },
-    source: CircleRotateMaterial
+    source: CircleRotateMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CircleScanType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 1
+      speed: 1,
     },
-    source: CircleScanMaterial
+    source: CircleScanMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CircleSpiralType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 3.0
+      speed: 3.0,
     },
-    source: CircleSpiralMaterial
+    source: CircleSpiralMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
     type: Cesium.Material.CircleVaryType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 3.0
+      speed: 3.0,
     },
-    source: CircleVaryMaterial
+    source: CircleVaryMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
       speed: 3.0,
       count: 1,
-      gradient: 0.1
+      gradient: 0.1,
     },
-    source: CircleWaveMaterial
+    source: CircleWaveMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })

src/modules/material/type/cylinder.js

  * @Date: 2022-05-28 21:36:23
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 
 const CylinderFadeMaterial = require('../shader/cylinder/CylinderFadeMaterial.glsl')
 const CylinderParticlesMaterial = require('../shader/cylinder/CylinderParticlesMaterial.glsl')
   fabric: {
     type: Cesium.Material.CylinderFadeType,
     uniforms: {
-      color: new Cesium.Color(1.0, 0.0, 0.0, 0.7)
+      color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
     },
-    source: CylinderFadeMaterial
+    source: CylinderFadeMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })
 
 /**
       type: Cesium.Material.CylinderParticlesType,
       uniforms: {
         color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-        image: Cesium.Material.DefaultImageId
+        image: Cesium.Material.DefaultImageId,
       },
-      source: CylinderParticlesMaterial
+      source: CylinderParticlesMaterial,
     },
-    translucent: function(material) {
+    translucent: function (material) {
       return true
-    }
+    },
   }
 )

src/modules/material/type/ellipsoid.js

  * @Date: 2021-02-27 23:20:11
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 
 const EllipsoidElectricMaterial = require('../shader/ellipsoid/EllipsoidElectricMaterial.glsl')
 const EllipsoidTrailMaterial = require('../shader/ellipsoid/EllipsoidTrailMaterial.glsl')
       type: Cesium.Material.EllipsoidElectricType,
       uniforms: {
         color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-        speed: 1
+        speed: 1,
       },
-      source: EllipsoidElectricMaterial
+      source: EllipsoidElectricMaterial,
     },
-    translucent: function(material) {
+    translucent: function (material) {
       return true
-    }
+    },
   }
 )
 
     type: Cesium.Material.EllipsoidTrailType,
     uniforms: {
       color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-      speed: 3.0
+      speed: 3.0,
     },
-    source: EllipsoidTrailMaterial
+    source: EllipsoidTrailMaterial,
   },
-  translucent: function(material) {
+  translucent: function (material) {
     return true
-  }
+  },
 })

src/modules/math/area.js

  */
 
 import { Cesium } from '../../namespace'
-import { Transform } from '@dc-modules/transform'
+import { Transform } from '../transform'
 
 /**
  *

src/modules/math/bounds.js

   let minLat = 90
   let maxLng = -180
   let maxLat = -90
-  positions.forEach(item => {
+  positions.forEach((item) => {
     minLng = Math.min(minLng, item.lng || item.x)
     minLat = Math.min(minLat, item.lat || item.y)
     maxLng = Math.max(maxLng, item.lng || item.x)
     west: minLng,
     south: minLat,
     east: maxLng,
-    north: maxLat
+    north: maxLat,
   }
 }

src/modules/math/center.js

  * @Date: 2020-04-24 14:43:39
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
-import Position from '@dc-modules/position/Position'
+import { Cesium } from '../../namespace'
+import { Transform } from '../transform'
+import Position from '../position/Position'
 
 export default function center(positions) {
   if (positions && Array.isArray(positions)) {

src/modules/math/distance.js

  * @Date: 2020-03-31 20:58:06
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../namespace'
+import { Transform } from '../transform'
 
 export default function distance(positions) {
   let distance = 0

src/modules/math/heading.js

  * @Date: 2020-04-11 00:41:47
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
-import Parse from '@dc-modules/parse/Parse'
+import { Cesium } from '../../namespace'
+import { Transform } from '../transform'
+import Parse from '../parse/Parse'
 
 export default function heading(start, end) {
   let startPosition = start

src/modules/math/midCartesian.js

  * @Date: 2020-08-21 18:16:52
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../namespace'
 
 export default function midCartesian(start, end) {
   let c1 = Cesium.Ellipsoid.WGS84.cartesianToCartographic(start)

src/modules/math/midPosition.js

  * @Date: 2020-08-21 18:16:52
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
-import Parse from '@dc-modules/parse/Parse'
-import Position from '@dc-modules/position/Position'
+import { Cesium } from '../../namespace'
+import { Transform } from '../transform'
+import Parse from '../parse/Parse'
+import Position from '../position/Position'
 
 export default function midPosition(start, end) {
   let startPosition = Parse.parsePosition(start)

src/modules/measure/draw/DrawPolygon.js

           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }

src/modules/measure/draw/DrawPolyline.js

         ...this._style,
         positions: new Cesium.CallbackProperty(() => {
           return this._positions
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }

src/modules/measure/type/Angle.js

           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
   }
 
     new EditPolyline(delegate).start(
       {
         viewer: this._viewer,
-        layer: this._layer
+        layer: this._layer,
       },
       {
         ...this._options,
-        ...{ maxAnchorSize: this._maxAnchorSize }
+        ...{ maxAnchorSize: this._maxAnchorSize },
       }
     )
   }
           positions[1],
           new Cesium.Cartesian3()
         ),
-        positions[1]
+        positions[1],
       ]
 
       let hegiht = Math.abs(Cesium.Plane.getPointDistance(plane, positions[1]))
   start(measure, options) {
     this._startHook(measure, options)
     let helpLineMaterial = new Cesium.PolylineDashMaterialProperty({
-      color: Cesium.Color.GREENYELLOW
+      color: Cesium.Color.GREENYELLOW,
     })
     this._helpLine.polyline.material = helpLineMaterial
     this._helpLine.polyline.depthFailMaterial = helpLineMaterial
       depthFailMaterial:
         options.depthFailMaterial ||
         new Cesium.PolylineDashMaterialProperty({
-          color: Cesium.Color.YELLOW.withAlpha(0.6)
+          color: Cesium.Color.YELLOW.withAlpha(0.6),
         }),
       width: options.width || 2,
-      clampToGround: false
+      clampToGround: false,
     }).start(measure, {
       ...options,
-      ...{ maxAnchorSize: this._maxAnchorSize }
+      ...{ maxAnchorSize: this._maxAnchorSize },
     })
     return this
   }

src/modules/overlay/Overlay.js

  * @Date: 2020-01-03 12:18:17
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import { Util } from '@dc-modules/utils'
-import { OverlayEventType, OverlayEvent } from '@dc-modules/event'
+import { Cesium } from '../../namespace'
+import State from '../state/State'
+import { Util } from '../utils'
+import { OverlayEventType, OverlayEvent } from '../event'
 import OverlayType from './OverlayType'
 
 class Overlay {
     if (this._delegate instanceof Cesium.Entity) {
       this._delegate.label = {
         ...textStyle,
-        text: text
+        text: text,
       }
     }
     return this

src/modules/overlay/custom/CustomBillboard.js

  * @Author: Caven
  * @Date: 2020-02-12 21:44:24
  */
-
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class CustomBillboard extends Overlay {
   constructor(position, icon) {
     this._delegate.position = Transform.transformWGS84ToCartesian(
       this._position
     )
-    return this
   }
 
   get position() {
   set icon(icon) {
     this._icon = icon
     this._delegate.billboard.image = this._icon
-    return this
   }
 
   get icon() {
     this._size = size
     this._delegate.billboard.width = this._size[0] || 32
     this._delegate.billboard.height = this._size[1] || 32
-    return this
   }
 
   get size() {
   setLabel(text, textStyle) {
     this._delegate.label = {
       ...textStyle,
-      text: text
+      text: text,
     }
     return this
   }
         ...style,
         positions: Transform.transformWGS84ArrayToCartesianArray([
           position,
-          this._position
-        ])
+          this._position,
+        ]),
       }
     }
     return this
           stRotation = 0
         }
         return stRotation
-      }, false)
+      }, false),
     }
     return this
   }

src/modules/overlay/custom/CustomLabel.js

  * @Author: Caven
  * @Date: 2020-07-28 18:37:59
  */
-
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class CustomLabel extends Overlay {
   constructor(position, text) {
     this._delegate.position = Transform.transformWGS84ToCartesian(
       this._position
     )
-    return this
   }
 
   get position() {
   set text(text) {
     this._text = text
     this._delegate.label.text = this._text
-    return this
   }
 
   get text() {
         ...style,
         positions: Transform.transformWGS84ArrayToCartesianArray([
           position,
-          this._position
-        ])
+          this._position,
+        ]),
       }
     }
     return this
           stRotation = 0
         }
         return stRotation
-      }, false)
+      }, false),
     }
     return this
   }

src/modules/overlay/dynamic/DynamicBillboard.js

  * @Date: 2021-05-05 09:16:35
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
 import DynamicOverlay from './DynamicOverlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class DynamicBillboard extends DynamicOverlay {
   constructor(position, icon) {

src/modules/overlay/dynamic/DynamicModel.js

  * @Author: Caven
  * @Date: 2021-05-05 09:16:35
  */
-
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
 import DynamicOverlay from './DynamicOverlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class DynamicModel extends DynamicOverlay {
   constructor(position, modelUrl) {

src/modules/overlay/dynamic/DynamicOverlay.js

  * @Date: 2021-05-05 09:16:35
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
 
 class DynamicOverlay extends Overlay {
   constructor() {
       this._sampledPosition.removeSamples(
         new Cesium.TimeInterval({
           start: start,
-          stop: stop
+          stop: stop,
         })
       )
       this._cache.splice(0, this._cache.length - this._maxCacheSize)

src/modules/overlay/html/DivIcon.js

  * @Date: 2020-02-12 21:46:22
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { DomUtil, Util } from '@dc-modules/utils'
-import { MouseEventType } from '@dc-modules/event'
-import { isBetween } from '@dc-modules/math'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { isBetween } from '../../math'
+import { Util, DomUtil } from '../../utils'
+import { MouseEventType } from '../../event'
 
 class DivIcon extends Overlay {
   constructor(position, content) {
     Util.merge(this._delegate.style, {
       position: 'absolute',
       top: '0',
-      left: '0'
+      left: '0',
     })
     this.content = content
     this._state = State.INITIALIZED
   set show(show) {
     this._show = show
     this._delegate.style.visibility = this._show ? 'visible' : 'hidden'
-    return this
   }
 
   get show() {
 
   set position(position) {
     this._position = Parse.parsePosition(position)
-    return this
   }
 
   get position() {
       }
       this._delegate.appendChild(content)
     }
-    return this
   }
 
   get content() {
     let params = {
       layer: layer,
       overlay: this,
-      position: Transform.transformWGS84ToCartesian(this._position)
+      position: Transform.transformWGS84ToCartesian(this._position),
     }
 
     this._delegate.addEventListener('click', () => {
     divIcon = new DivIcon(position, content)
     if (entity.billboard) {
       divIcon.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return divIcon

src/modules/overlay/model/Model.js

  * @Date: 2020-01-06 20:03:25
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class Model extends Overlay {
   constructor(position, modelUrl) {
         )
       )
     }
-    return this
   }
 
   get position() {
   set modelUrl(modelUrl) {
     this._modelUrl = modelUrl
     this._delegate.model.uri = this._modelUrl
-    return this
   }
 
   get modelUrl() {
         )
       )
     }, false)
-    return this
   }
 
   get rotateAmount() {
     )
     let model = new Model(position, modelUrl)
     model.attr = {
-      ...entity.properties.getValue(now)
+      ...entity.properties.getValue(now),
     }
     return model
   }

src/modules/overlay/model/Tileset.js

  * @Date: 2020-01-07 20:51:56
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
 
 class Tileset extends Overlay {
   constructor(url, options = {}) {
     super()
     this._delegate = new Cesium.Cesium3DTileset({
       ...options,
-      url: url
+      url: url,
     })
     this._tileVisibleCallback = undefined
     this._properties = undefined
-    this._fragmentShader = undefined
-    this._replaceFS = false
     this._state = State.INITIALIZED
   }
 
    */
   _updateTile(tile) {
     let content = tile.content
-    let model = content._model
     // sets properties
     for (let i = 0; i < content.featuresLength; i++) {
       let feature = content.getFeature(i)
       if (this._properties && this._properties.length) {
-        this._properties.forEach(property => {
+        this._properties.forEach((property) => {
           if (
             feature.hasProperty(property['key']) &&
             feature.getProperty(property['key']) === property['keyValue']
    */
   setPosition(position) {
     position = Parse.parsePosition(position)
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       let modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
         Cesium.Cartesian3.fromDegrees(position.lng, position.lat, position.alt)
       )
    * @returns {Tileset}
    */
   setHeadingPitchRoll(heading, pitch, roll) {
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       let modelMatrix = tileset.root.transform
       let rotation = Cesium.Matrix4.fromRotationTranslation(
         Cesium.Matrix3.fromHeadingPitchRoll(
    * @returns {Tileset}
    */
   clampToGround() {
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       let center = Cesium.Cartographic.fromCartesian(
         tileset.boundingSphere.center
       )
    * @returns {Tileset}
    */
   setHeight(height, isAbsolute = false) {
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       let center = Cesium.Cartographic.fromCartesian(
         tileset.boundingSphere.center
       )
    * @returns {Tileset}
    */
   setScale(scale) {
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       let modelMatrix = tileset.root.transform
       if (scale > 0 && scale !== 1) {
         Cesium.Matrix4.multiplyByUniformScale(modelMatrix, scale, modelMatrix)
    * @return {Tileset}
    */
   setSplitDirection(splitDirection) {
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       tileset.splitDirection = splitDirection
     })
     return this
    * @return {Tileset}
    */
   setCustomShader(customShader) {
-    this.readyPromise.then(tileset => {
+    this.readyPromise.then((tileset) => {
       tileset.customShader = customShader
     })
     return this

src/modules/overlay/plot/AttackArrow.js

 /**
  * @Author: Caven
- * @Date: 2020-08-29 21:45:14
+ * @Date: 2020-08-29
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util, PlotUtil } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util, PlotUtil } from '../../utils'
 
 const HALF_PI = Math.PI / 2
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()
-    return this
   }
 
   get positions() {

src/modules/overlay/plot/DoubleArrow.js

  * @Date: 2020-08-29 22:15:47
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util, PlotUtil } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util, PlotUtil } from '../../utils'
 
 const HALF_PI = Math.PI / 2
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()
-    return this
   }
 
   get positions() {

src/modules/overlay/plot/FineArrow.js

  * @Date: 2020-08-29 22:38:10
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util, PlotUtil } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util, PlotUtil } from '../../utils'
 
 const HALF_PI = Math.PI / 2
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()
-    return this
   }
 
   get positions() {
           pnt2,
           headRight,
           neckRight,
-          tailRight
+          tailRight,
         ])
       )
     )

src/modules/overlay/plot/GatheringPlace.js

  * @Date: 2020-08-29 23:00:27
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util, PlotUtil } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util, PlotUtil } from '../../utils'
 
 const HALF_PI = Math.PI / 2
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()
-    return this
   }
 
   get positions() {

src/modules/overlay/plot/TailedAttackArrow.js

  * @Date: 2020-08-29 22:51:36
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { PlotUtil } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { PlotUtil } from '../../utils'
 import AttackArrow from './AttackArrow'
 
 class TailedAttackArrow extends AttackArrow {
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
     this._delegate.polygon.hierarchy = this._getHierarchy()
-    return this
   }
 
   get positions() {
         Parse.parsePositions(
           leftPnts.concat(headPnts, rightPnts.reverse(), [
             swallowTailPnt,
-            leftPnts[0]
+            leftPnts[0],
           ])
         )
       )

src/modules/overlay/primitive/BillboardPrimitive.js

  * @Date: 2021-06-03 21:06:17
  */
 
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
 import Overlay from '../Overlay'
+import Parse from '../../parse/Parse'
+import State from '../../state/State'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class BillboardPrimitive extends Overlay {
   constructor(position, icon) {
       position: undefined,
       image: undefined,
       width: 0,
-      height: 0
+      height: 0,
     }
     this._state = State.INITIALIZED
   }
     this._delegate.position = Transform.transformWGS84ToCartesian(
       this._position
     )
-    return this
   }
 
   get position() {
   set icon(icon) {
     this._icon = icon
     this._delegate.image = this._icon
-    return this
   }
 
   get icon() {
     this._size = size
     this._delegate.width = this._size[0] || 32
     this._delegate.height = this._size[1] || 32
-    return this
   }
 
   get size() {

src/modules/overlay/primitive/BounceBillboardPrimitive.js

  * @Date: 2021-06-03 21:06:17
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
 import BillboardPrimitive from './BillboardPrimitive'
 
 const DEF_STYLE = {
   maxOffsetY: 10,
-  offsetAmount: 0.1
+  offsetAmount: 0.1,
 }
 
 class BounceBillboardPrimitive extends BillboardPrimitive {

src/modules/overlay/primitive/BounceLabelPrimitive.js

  * @Date: 2021-06-03 21:06:17
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
 import LabelPrimitive from './LabelPrimitive'
 
 const DEF_STYLE = {
   maxOffsetY: 10,
-  offsetAmount: 0.1
+  offsetAmount: 0.1,
 }
 
 class BounceLabelPrimitive extends LabelPrimitive {

src/modules/overlay/primitive/CloudPrimitive.js

  * @Date: 2021-11-08 20:35:42
  */
 
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class CloudPrimitive extends Overlay {
   constructor(position) {
     this._position = Parse.parsePosition(position)
     this._delegate = {
       position: undefined,
-      scale: { x: 12, y: 8 }
+      scale: { x: 12, y: 8 },
     }
     this._state = State.INITIALIZED
   }
     this._delegate.position = Transform.transformWGS84ToCartesian(
       this._position
     )
-    return this
   }
 
   get position() {

src/modules/overlay/primitive/DiffuseWallPrimitive.js

  * @Date: 2021-06-04 20:38:39
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 const DEF_STYLE = {
   minRadius: 10,
   minHeight: 30,
   color: Cesium.Color.RED,
   slices: 128,
-  speed: 10
+  speed: 10,
 }
 
 class DiffuseWallPrimitive extends Overlay {
     let geometry = new Cesium.WallGeometry({
       positions: positions,
       minimumHeights: this._getHeights(positions.length, 0),
-      maximumHeights: this._getHeights(positions.length, this._currentHeight)
+      maximumHeights: this._getHeights(positions.length, this._currentHeight),
     })
 
     this._delegate = new Cesium.Primitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry
+        geometry,
       }),
       appearance: new Cesium.MaterialAppearance({
         material: Cesium.Material.fromType('WallDiffuse', {
-          color: this._style?.color
+          color: this._style?.color,
         }),
-        flat: true
+        flat: true,
       }),
-      asynchronous: false
+      asynchronous: false,
     })
     this._delegate.update(frameState)
   }

src/modules/overlay/primitive/ElecEllipsoidPrimitive.js

  * @Date: 2021-01-09 21:40:36
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class ElecEllipsoidPrimitive extends Overlay {
   constructor(position, radius) {
     this._radius = radius || { x: 10, y: 10, z: 10 }
     this._delegate = new Cesium.Primitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry: {}
-      })
+        geometry: {},
+      }),
     })
     this._state = State.INITIALIZED
   }
 
   set position(position) {
     this._position = Parse.parsePosition(position)
-    this._delegate.geometryInstances.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
-      Transform.transformWGS84ToCartesian(this._position)
-    )
-    return this
+    this._delegate.geometryInstances.modelMatrix =
+      Cesium.Transforms.eastNorthUpToFixedFrame(
+        Transform.transformWGS84ToCartesian(this._position)
+      )
   }
 
   get position() {
     this._radius = radius
     this._delegate.geometryInstances.geometry = new Cesium.EllipsoidGeometry({
       radii: this._radius,
-      maximumCone: Cesium.Math.PI_OVER_TWO
+      maximumCone: Cesium.Math.PI_OVER_TWO,
     })
-    return this
   }
 
   get radius() {
     this._delegate.appearance = new Cesium.MaterialAppearance({
       material: Cesium.Material.fromType('EllipsoidElectric', {
         color: this._style?.color || Cesium.Color.GREEN,
-        speed: this._style?.speed || 5
-      })
+        speed: this._style?.speed || 5,
+      }),
     })
   }
 

src/modules/overlay/primitive/FlowLinePrimitive.js

  * @Date: 2021-01-05 20:18:34
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class FlowLinePrimitive extends Overlay {
   constructor(positions, width = 1) {
     this._width = width
     this._delegate = new Cesium.Primitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry: {}
-      })
+        geometry: {},
+      }),
     })
     this._state = State.INITIALIZED
   }
     this._positions = Parse.parsePositions(positions)
     this._delegate.geometryInstances.geometry = new Cesium.PolylineGeometry({
       positions: Transform.transformWGS84ArrayToCartesianArray(this._positions),
-      width: this._width
+      width: this._width,
     })
-    return this
   }
 
   get positions() {
         color: this._style?.color || new Cesium.Color(1.0, 0.0, 0.0, 0.7),
         speed: this._style?.speed || 1,
         percent: this._style?.percent || 0.03,
-        gradient: this._style?.gradient || 0.1
-      })
+        gradient: this._style?.gradient || 0.1,
+      }),
     })
   }
 

src/modules/overlay/primitive/LabelPrimitive.js

  * @Date: 2021-06-03 22:28:49
  */
 
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class LabelPrimitive extends Overlay {
   constructor(position, text) {
     this._text = text
     this._delegate = {
       position: undefined,
-      text: undefined
+      text: undefined,
     }
     this._state = State.INITIALIZED
   }
     this._delegate.position = Transform.transformWGS84ToCartesian(
       this._position
     )
-    return this
   }
 
   get position() {
   set text(text) {
     this._text = text
     this._delegate.text = this._text
-    return this
   }
 
   get text() {

src/modules/overlay/primitive/LightCylinderPrimitive.js

  * @Date: 2022-05-28 10:25:24
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
-import { IMG_PARTICLES } from '@dc-modules/images/base64'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
+import { IMG_PARTICLES } from '../../images/base64'
 
 const DEF_STYLE = {
-  color: Cesium.Color.ORANGE
+  color: Cesium.Color.ORANGE,
 }
 
 class LightCylinderPrimitive extends Overlay {
   set center(position) {
     this._center = Parse.parsePosition(position)
     this._updatePrimitives()
-    return this
   }
 
   get center() {
   set length(length) {
     this._length = length
     this._updatePrimitives()
-    return this
   }
 
   get length() {
   set topRadius(topRadius) {
     this._topRadius = topRadius
     this._updatePrimitives()
-    return this
   }
 
   get topRadius() {
   set bottomRadius(bottomRadius) {
     this._bottomRadius = bottomRadius
     this._updatePrimitives()
-    return this
   }
 
   get bottomRadius() {
         semiMajorAxis: radius,
         semiMinorAxis: radius,
         rotation: 0,
-        granularity: 0.005
+        granularity: 0.005,
       },
       false,
       true
     let polygon = Cesium.PolygonGeometry.createGeometry(
       new Cesium.PolygonGeometry({
         polygonHierarchy: new Cesium.PolygonHierarchy(newpts),
-        perPositionHeight: true
+        perPositionHeight: true,
       })
     )
     polygon.indices = define_indices
     polygon.attributes.st.values = sts
     return new Cesium.GeometryInstance({
-      geometry: polygon
+      geometry: polygon,
     })
   }
 
           polygonHierarchy: new Cesium.PolygonHierarchy(
             this._computeEllipsePositions(this._center, this._bottomRadius * 2)
           ),
-          perPositionHeight: !isGroud
+          perPositionHeight: !isGroud,
         }),
-        asynchronous: false
-      })
+        asynchronous: false,
+      }),
     }
 
     // ring
 
     ring.appearance = new Cesium.EllipsoidSurfaceAppearance({
       material: Cesium.Material.fromType(Cesium.Material.CircleRingType, {
-        color: this._style.color
-      })
+        color: this._style.color,
+      }),
     })
 
     // circle
     circle.appearance = new Cesium.EllipsoidSurfaceAppearance({
       material: Cesium.Material.fromType(Cesium.Material.CircleRotateType, {
         color: this._style.color,
-        image: this._getCircleImage()
-      })
+        image: this._getCircleImage(),
+      }),
     })
 
     // cylinder
       ),
       appearance: new Cesium.EllipsoidSurfaceAppearance({
         material: Cesium.Material.fromType(Cesium.Material.CylinderFadeType, {
-          color: this._style.color
-        })
+          color: this._style.color,
+        }),
       }),
-      asynchronous: false
+      asynchronous: false,
     })
 
     if (isGroud) {
     }
 
     // particles
-    Cesium.Resource.fetchImage({ url: IMG_PARTICLES }).then(image => {
+    Cesium.Resource.fetchImage({ url: IMG_PARTICLES }).then((image) => {
       let particles = new Cesium.Primitive({
         geometryInstances: this._createCylinderInstance(
           topPositions,
             Cesium.Material.CylinderParticlesType,
             {
               color: this._style.color,
-              image: this._getParticlesImage(image)
+              image: this._getParticlesImage(image),
             }
-          )
+          ),
         }),
-        asynchronous: false
+        asynchronous: false,
       })
       this._delegate.add(particles)
     })

src/modules/overlay/primitive/ModelCollectionPrimitive.js

  * @Date: 2021-08-02 20:12:04
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class ModelCollectionPrimitive extends Overlay {
   constructor(positions, modelUrl) {
 
   set attrs(attrs) {
     this._attrs = attrs
-    return this
   }
 
   get attrs() {
       this._resetDelegate()
       this._layer.delegate.add(this._delegate)
     }
-    return this
   }
 
   set modelUrl(modelUrl) {
       this._resetDelegate()
       this._layer.delegate.add(this._delegate)
     }
-    return this
   }
 
   get modelUrl() {
   _resetDelegate() {
     this._delegate = new Cesium.ModelInstanceCollection({
       url: this._modelUrl,
-      instances: this._positions.map(item => {
+      instances: this._positions.map((item) => {
         let origin = Transform.transformWGS84ToCartesian(item)
         let modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(
           origin,
             modelMatrix
           )
         return {
-          modelMatrix
+          modelMatrix,
         }
       }),
-      ...this._style
+      ...this._style,
     })
     this._delegate.layerId = this._layer?.layerId
     this._delegate.overlayId = this._id

src/modules/overlay/primitive/ModelPrimitive.js

  * @Date: 2021-05-14 00:33:27
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class ModelPrimitive extends Overlay {
   constructor(position, modelUrl) {
         Cesium.Math.toRadians(this._position.roll)
       )
     )
-    return this
   }
 
   get position() {
     this._modelUrl = modelUrl
     this._delegate = Cesium.Model.fromGltf({ url: modelUrl })
     this.position = this._position
-    return this
   }
 
   get modelUrl() {

src/modules/overlay/primitive/PointPrimitive.js

  * @Date: 2021-06-03 20:51:25
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 const DEF_STYLE = {
   pixelSize: 8,
   outlineColor: Cesium.Color.BLUE,
-  outlineWidth: 2
+  outlineWidth: 2,
 }
 
 class PointPrimitive extends Overlay {
     this._position = Parse.parsePosition(position)
 
     this._delegate = {
-      position: undefined
+      position: undefined,
     }
     this._state = State.INITIALIZED
   }
     this._delegate.position = Transform.transformWGS84ToCartesian(
       this._position
     )
-    return this
   }
 
   get position() {

src/modules/overlay/primitive/PolylinePrimitive.js

  * @Date: 2021-06-03 21:16:27
  */
 
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
-import { center, distance } from '@dc-modules/math'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
+import { center, distance } from '../../math'
 
 class PolylinePrimitive extends Overlay {
   constructor(positions) {
     super()
     this._positions = Parse.parsePositions(positions)
     this._delegate = {
-      positions: []
+      positions: [],
     }
     this._state = State.INITIALIZED
   }
     this._delegate.positions = Transform.transformWGS84ArrayToCartesianArray(
       this._positions
     )
-    return this
   }
 
   get positions() {

src/modules/overlay/primitive/ScanCirclePrimitive.js

  * @Date: 2020-12-31 11:05:32
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class ScanCirclePrimitive extends Overlay {
   constructor(position, radius) {
     this._radius = radius
     this._delegate = new Cesium.GroundPrimitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry: {}
-      })
+        geometry: {},
+      }),
     })
     this._state = State.INITIALIZED
   }
     this._delegate.geometryInstances.geometry = new Cesium.EllipseGeometry({
       center: Transform.transformWGS84ToCartesian(this._position),
       semiMajorAxis: this._radius,
-      semiMinorAxis: this._radius
+      semiMinorAxis: this._radius,
     })
-    return this
   }
 
   get position() {
     this._radius = radius
     this._delegate.geometryInstances.geometry.semiMajorAxis = this._radius
     this._delegate.geometryInstances.geometry.semiMinorAxis = this._radius
-    return this
   }
 
   get radius() {
     this._delegate.appearance = new Cesium.MaterialAppearance({
       material: Cesium.Material.fromType('CircleScan', {
         color: this._style?.color || Cesium.Color.WHITE,
-        speed: this._style?.speed || 10
-      })
+        speed: this._style?.speed || 10,
+      }),
     })
   }
 

src/modules/overlay/primitive/TrailLinePrimitive.js

 /**
  * @Author: Caven
- * @Date: 2021-01-09 21:33:59
+ * @Date: 2021-01-09
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class TrailLinePrimitive extends Overlay {
   constructor(positions, width = 1) {
     this._width = width
     this._delegate = new Cesium.Primitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry: {}
-      })
+        geometry: {},
+      }),
     })
     this._state = State.INITIALIZED
   }
     this._positions = Parse.parsePositions(positions)
     this._delegate.geometryInstances.geometry = new Cesium.PolylineGeometry({
       positions: Transform.transformWGS84ArrayToCartesianArray(this._positions),
-      width: this._width
+      width: this._width,
     })
-    return this
   }
 
   get positions() {
     this._delegate.appearance = new Cesium.PolylineMaterialAppearance({
       material: Cesium.Material.fromType('PolylineTrail', {
         color: this._style?.color || new Cesium.Color(1.0, 0.0, 0.0, 0.7),
-        speed: this._style?.speed || 5
-      })
+        speed: this._style?.speed || 5,
+      }),
     })
   }
 

src/modules/overlay/primitive/VideoPrimitive.js

  * @Date: 2020-11-09 20:04:30
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class VideoPrimitive extends Overlay {
   constructor(positions, video) {
     this._positions = Parse.parsePositions(positions)
     this._delegate = new Cesium.GroundPrimitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry: {}
-      })
+        geometry: {},
+      }),
     })
     this._video = video
     this._state = State.INITIALIZED
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
-    this._delegate.geometryInstances.geometry = Cesium.PolygonGeometry.fromPositions(
-      {
+    this._delegate.geometryInstances.geometry =
+      Cesium.PolygonGeometry.fromPositions({
         positions: Transform.transformWGS84ArrayToCartesianArray(
           this._positions
         ),
         extrudedHeight: this._style?.extrudedHeight,
         closeTop: this._style?.closeTop,
         closeBottom: this._style?.closeBottom,
-        vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT
-      }
-    )
-    return this
+        vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
+      })
   }
 
   get positions() {
   set video(video) {
     this._video = video
     this._setAppearance()
-    return this
   }
 
   get video() {
   _setAppearance() {
     this._delegate.appearance = new Cesium.EllipsoidSurfaceAppearance({
       material: Cesium.Material.fromType('Image', {
-        image: this._video
-      })
+        image: this._video,
+      }),
     })
   }
 

src/modules/overlay/primitive/WaterPrimitive.js

  * @Date: 2020-10-11 18:24:37
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { Util } from '../../utils'
 
 class WaterPrimitive extends Overlay {
   constructor(positions, holes = []) {
     super()
     this._positions = Parse.parsePositions(positions)
-    this._holes = holes.map(item => Parse.parsePositions(item))
+    this._holes = holes.map((item) => Parse.parsePositions(item))
     this._delegate = new Cesium.GroundPrimitive({
       geometryInstances: new Cesium.GeometryInstance({
-        geometry: {}
+        geometry: {},
       }),
-      asynchronous: true
+      asynchronous: true,
     })
     this._state = State.INITIALIZED
   }
       polygonHierarchy: new Cesium.PolygonHierarchy(
         Transform.transformWGS84ArrayToCartesianArray(this._positions),
         this._holes.map(
-          item =>
+          (item) =>
             new Cesium.PolygonHierarchy(
               Transform.transformWGS84ArrayToCartesianArray(item)
             )
       extrudedHeight: this._style?.extrudedHeight,
       closeTop: this._style?.closeTop,
       closeBottom: this._style?.closeBottom,
-      vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT
+      vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
     })
-    return this
   }
 
   get positions() {
         frequency: this._style?.frequency || 1000.0,
         animationSpeed: this._style?.animationSpeed || 0.01,
         amplitude: this._style?.amplitude || 10,
-        specularIntensity: this._style?.specularIntensity || 0.5
-      })
+        specularIntensity: this._style?.specularIntensity || 0.5,
+      }),
     })
   }
 

src/modules/overlay/vector/Billboard.js

  * @Date: 2020-01-19 10:18:23
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Billboard extends Overlay {
   constructor(position, icon) {
     if (entity.billboard) {
       billboard = new Billboard(position, entity.billboard.image.getValue(now))
       billboard.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return billboard

src/modules/overlay/vector/Box.js

  * @Date: 2020-02-25 18:28:36
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Box extends Overlay {
   constructor(position, length, width, height) {
         dimensions: {
           x: +this._length,
           y: +this._width,
-          z: +this._height
-        }
-      }
+          z: +this._height,
+        },
+      },
     })
     this._state = State.INITIALIZED
   }

src/modules/overlay/vector/Circle.js

  * @Date: 2020-01-31 18:57:02
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Circle extends Overlay {
   constructor(center, radius) {
         semiMajorAxis: this._radius,
         semiMinorAxis: this._radius,
         rotation: 0,
-        granularity: 0.005
+        granularity: 0.005,
       },
       false,
       true
     this._delegate.position = Transform.transformWGS84ToCartesian(this._center)
     this._delegate.label = {
       ...textStyle,
-      text: text
+      text: text,
     }
     return this
   }

src/modules/overlay/vector/Corridor.js

  * @Date: 2020-04-11 18:58:17
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Corridor extends Overlay {
   constructor(positions) {
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
-    this._delegate.corridor.positions = Transform.transformWGS84ArrayToCartesianArray(
-      this._positions
-    )
+    this._delegate.corridor.positions =
+      Transform.transformWGS84ArrayToCartesianArray(this._positions)
     return this
   }
 
       )
       corridor = new Corridor(positions)
       corridor.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return corridor

src/modules/overlay/vector/Cylinder.js

  * @Date: 2020-04-14 18:10:00
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Cylinder extends Overlay {
   constructor(position, length, topRadius, bottomRadius) {

src/modules/overlay/vector/Ellipse.js

  * @Date: 2020-04-14 18:30:45
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Ellipse extends Overlay {
   constructor(position, semiMajorAxis, semiMinorAxis) {

src/modules/overlay/vector/Ellipsoid.js

  * @Date: 2020-04-14 18:20:23
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Ellipsoid extends Overlay {
   constructor(position, radius) {

src/modules/overlay/vector/Label.js

  * @Date: 2020-02-01 11:59:28
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Label extends Overlay {
   constructor(position, text) {
     if (entity.billboard) {
       label = new Label(position, entity.name)
       label.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return label

src/modules/overlay/vector/Plane.js

  * @Date: 2020-02-18 19:08:26
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Plane extends Overlay {
   constructor(position, width, height, plane = {}) {
       plane: {
         dimensions: {
           x: this._width,
-          y: this._height
+          y: this._height,
         },
-        plane: new Cesium.Plane(this._normal, this._distance)
-      }
+        plane: new Cesium.Plane(this._normal, this._distance),
+      },
     })
     this._state = State.INITIALIZED
   }

src/modules/overlay/vector/Point.js

  * @Date: 2020-01-06 15:03:25
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 const DEF_STYLE = {
   pixelSize: 8,
   outlineColor: Cesium.Color.BLUE,
-  outlineWidth: 2
+  outlineWidth: 2,
 }
 
 class Point extends Overlay {
     )
     point = new Point(position)
     point.attr = {
-      ...entity?.properties?.getValue(now)
+      ...entity?.properties?.getValue(now),
     }
     return point
   }

src/modules/overlay/vector/Polygon.js

  * @Date: 2020-01-09 09:10:37
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
-import { center, area } from '@dc-modules/math'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
+import { center, area } from '../../math'
 
 class Polygon extends Overlay {
   constructor(positions) {
 
   set holes(holes) {
     if (holes && holes.length) {
-      this._holes = holes.map(item => Parse.parsePositions(item))
+      this._holes = holes.map((item) => Parse.parsePositions(item))
       this._delegate.polygon.hierarchy = this._computeHierarchy()
     }
     return this
       this._positions
     )
     result.holes = this._holes.map(
-      item =>
+      (item) =>
         new Cesium.PolygonHierarchy(
           Transform.transformWGS84ArrayToCartesianArray(item)
         )
     this._delegate.position = Transform.transformWGS84ToCartesian(this.center)
     this._delegate.label = {
       text: text,
-      ...textStyle
+      ...textStyle,
     }
     return this
   }
       )
       polygon = new Polygon(positions)
       polygon.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return polygon

src/modules/overlay/vector/Polyline.js

  * @Date: 2020-01-06 15:03:25
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
-import { center, distance } from '@dc-modules/math'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
+import { center, distance } from '../../math'
 
 class Polyline extends Overlay {
   constructor(positions) {
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
-    this._delegate.polyline.positions = Transform.transformWGS84ArrayToCartesianArray(
-      this._positions
-    )
+    this._delegate.polyline.positions =
+      Transform.transformWGS84ArrayToCartesianArray(this._positions)
     return this
   }
 
     this._delegate.position = Transform.transformWGS84ToCartesian(this.center)
     this._delegate.label = {
       text: text,
-      ...textStyle
+      ...textStyle,
     }
     return this
   }
       )
       polyline = new Polyline(positions)
       polyline.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return polyline

src/modules/overlay/vector/PolylineVolume.js

  * @Date: 2020-04-14 20:10:34
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class PolylineVolume extends Overlay {
   constructor(positions, shape) {
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
-    this._delegate.polylineVolume.positions = Transform.transformWGS84ArrayToCartesianArray(
-      this._positions
-    )
+    this._delegate.polylineVolume.positions =
+      Transform.transformWGS84ArrayToCartesianArray(this._positions)
     return this
   }
 
       )
       polylineVolume = new PolylineVolume(positions, shape)
       polylineVolume.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return polylineVolume

src/modules/overlay/vector/Rectangle.js

  * @Date: 2020-04-14 20:46:23
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Overlay from '../Overlay'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 
 class Rectangle extends Overlay {
   constructor(positions) {
     )
     this._delegate.label = {
       ...textStyle,
-      text: text
+      text: text,
     }
     return this
   }

src/modules/overlay/vector/Wall.js

  * @Date: 2020-02-25 18:28:36
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import State from '@dc-modules/state/State'
-import Parse from '@dc-modules/parse/Parse'
-import { Util } from '@dc-modules/utils'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
+import State from '../../state/State'
+import Parse from '../../parse/Parse'
+import { Util } from '../../utils'
+import { Transform } from '../../transform'
 import Overlay from '../Overlay'
 
 class Wall extends Overlay {
 
   set positions(positions) {
     this._positions = Parse.parsePositions(positions)
-    this._delegate.wall.positions = Transform.transformWGS84ArrayToCartesianArray(
-      this._positions
-    )
+    this._delegate.wall.positions =
+      Transform.transformWGS84ArrayToCartesianArray(this._positions)
     return this
   }
 
       )
       wall = new Wall(positions)
       wall.attr = {
-        ...entity?.properties?.getValue(now)
+        ...entity?.properties?.getValue(now),
       }
     }
     return wall

src/modules/parse/Parse.js

  * @Author: Caven
  * @Date: 2020-03-22 00:10:25
  */
-
-import Position from '@dc-modules/position/Position'
+import Position from '../position/Position'
 
 class Parse {
   /**
       if (positions.indexOf('#') >= 0) {
         throw new Error('the positions invalid')
       }
-      positions = positions.split(';').filter(item => !!item)
+      positions = positions.split(';').filter((item) => !!item)
     }
-    return positions.map(item => {
+    return positions.map((item) => {
       if (typeof item === 'string') {
         return Position.fromString(item)
       } else if (Array.isArray(item)) {
   static parsePolylineCoordToArray(positions) {
     let result = []
     positions = this.parsePositions(positions)
-    positions.forEach(item => {
+    positions.forEach((item) => {
       result.push([item.lng, item.lat])
     })
     return result
   static parsePolygonCoordToArray(positions, loop = false) {
     let result = []
     positions = this.parsePositions(positions)
-    positions.forEach(item => {
+    positions.forEach((item) => {
       result.push([item.lng, item.lat])
     })
     if (loop && result.length > 0) {

src/modules/plot/Plot.js

  * @Date: 2020-08-29 19:26:06
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { OverlayType } from '@dc-modules/overlay'
+import { Cesium } from '../../namespace'
+import { OverlayType } from '../overlay'
 
 import DrawPoint from './draw/DrawPoint'
 import DrawPolyline from './draw/DrawPolyline'
       ...this._options,
       maxAnchorSize: maxAnchorSize,
       onDrawStop: callback,
-      clampToModel: clampToModel ?? this._options.clampToModel
+      clampToModel: clampToModel ?? this._options.clampToModel,
     })
     return this
   }
     this._currentWorker = this._createEditWorker(overlay)?.start(this, {
       ...this._options,
       onEditStop: callback,
-      clampToModel: clampToModel ?? this._options.clampToModel
+      clampToModel: clampToModel ?? this._options.clampToModel,
     })
     return this
   }

src/modules/plot/draw/Draw.js

  * @Author: Caven
  * @Date: 2020-01-31 19:45:32
  */
-
-import { PlotEventType } from '@dc-modules/event'
+import { PlotEventType } from '../../event'
 
 class Draw {
   constructor(style) {
    * Subclasses need to be overridden
    * @private
    */
-  _stopdHook() {}
+  _stoppedHook() {}
 
   /**
    *
     this._unbindEvent()
     this._viewer.drawTool.deactivate()
     this._delegate && this._layer.entities.remove(this._delegate)
-    this._stopdHook()
+    this._stoppedHook()
   }
 
   /**

src/modules/plot/draw/DrawAttackArrow.js

  * @Date: 2020-08-30 16:43:12
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { AttackArrow } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
 import Draw from './Draw'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { AttackArrow } from '../../overlay'
 import AttackArrowGraphics from '../graphics/AttackArrowGraphics'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawAttackArrow extends Draw {
     this._maxAnchorSize = 3
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
     this._graphics = new AttackArrowGraphics()
   }
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let attackArrow = null
     if (this._positions.length) {
       attackArrow = new AttackArrow(

src/modules/plot/draw/DrawBillboard.js

  * @Date: 2020-08-29 20:29:59
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { Billboard } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
 import Draw from './Draw'
-
-const IMG_CIRCLE_RED = require('@dc-modules/images/circle_red.png')
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { Billboard } from '../../overlay'
+import IMG_CIRCLE_RED from '../../images/circle_red.png'
 
 class DrawPoint extends Draw {
   constructor(style) {
     this._position = Cesium.Cartesian3.ZERO
     this._style = {
       image: IMG_CIRCLE_RED,
-      ...style
+      ...style,
     }
   }
 
         return this._position
       }, false),
       billboard: {
-        ...this._style
-      }
+        ...this._style,
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let billboard = null
     if (this._position) {
       billboard = new Billboard(

src/modules/plot/draw/DrawCircle.js

  * @Date: 2020-08-29 21:24:55
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { Circle } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { Circle } from '../../overlay'
 import Draw from './Draw'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawCircle extends Draw {
     this._radius = 0
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
   }
 
                 semiMajorAxis: this._radius,
                 semiMinorAxis: this._radius,
                 rotation: 0,
-                granularity: 0.005
+                granularity: 0.005,
               },
               false,
               true
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let circle = null
     if (this._positions.length) {
       circle = new Circle(
     this._positions.push(position)
     this.drawTool.fire(PlotEventType.CREATE_ANCHOR, {
       position,
-      isCenter: len === 1
+      isCenter: len === 1,
     })
     if (len >= this._maxAnchorSize) {
       this._positions.pop()

src/modules/plot/draw/DrawDoubleArrow.js

 /**
  * @Author: Caven
- * @Date: 2020-08-30 16:43:12
+ * @Date: 2020-08-30
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { DoubleArrow } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { DoubleArrow } from '../../overlay'
 import Draw from './Draw'
 import DoubleArrowGraphics from '../graphics/DoubleArrowGraphics'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawDoubleArrow extends Draw {
     this._maxAnchorSize = 4
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
     this._graphics = new DoubleArrowGraphics()
   }
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let doubleArrow = null
     if (this._positions.length) {
       doubleArrow = new DoubleArrow(

src/modules/plot/draw/DrawFineArrow.js

  * @Date: 2020-08-30 16:43:12
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
-import { PlotEventType } from '@dc-modules/event'
-import { FineArrow } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
 import Draw from './Draw'
+import { Transform } from '../../transform'
+import { PlotEventType } from '../../event'
+import { FineArrow } from '../../overlay'
+
 import FineArrowGraphics from '../graphics/FineArrowGraphics'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawFineArrow extends Draw {
     this._maxAnchorSize = 2
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
     this._graphics = new FineArrowGraphics()
   }
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let fineArrow = null
     if (this._positions.length) {
       fineArrow = new FineArrow(

src/modules/plot/draw/DrawGatheringPlace.js

  * @Date: 2020-08-30 17:22:21
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
-import { PlotEventType } from '@dc-modules/event'
-import { GatheringPlace } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
 import Draw from './Draw'
+import { Transform } from '../../transform'
+import { PlotEventType } from '../../event'
+import { GatheringPlace } from '../../overlay'
+
 import GatheringPlaceGraphics from '../graphics/GatheringPlaceGraphics'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawGatheringPlace extends Draw {
     this._maxAnchorSize = 3
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
     this._graphics = new GatheringPlaceGraphics()
   }
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let gatheringPlace = null
     if (this._positions.length) {
       gatheringPlace = new GatheringPlace(

src/modules/plot/draw/DrawPoint.js

  * @Date: 2020-01-31 16:25:29
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { Point } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { Point } from '../../overlay'
 import Draw from './Draw'
 
 const DEF_STYLE = {
   pixelSize: 10,
   outlineColor: Cesium.Color.BLUE,
-  outlineWidth: 5
+  outlineWidth: 5,
 }
 
 class DrawPoint extends Draw {
     this._position = Cesium.Cartesian3.ZERO
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
   }
 
         return this._position
       }, false),
       point: {
-        ...this._style
-      }
+        ...this._style,
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let point = null
     if (this._position) {
       point = new Point(

src/modules/plot/draw/DrawPolygon.js

  * @Date: 2020-08-29 20:55:14
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { Polygon } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { Polygon } from '../../overlay'
 import Draw from './Draw'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawPolygon extends Draw {
     super()
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
   }
 
         hierarchy: new Cesium.CallbackProperty(() => {
           if (this._positions.length > 2) {
             return new Cesium.PolygonHierarchy(
-              this._positions.map(item => item.clone())
+              this._positions.map((item) => item.clone())
             )
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let polygon = null
     if (this._positions.length) {
       polygon = new Polygon(

src/modules/plot/draw/DrawPolyline.js

  * @Date: 2020-08-29 20:54:37
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { Polyline } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { Polyline } from '../../overlay'
 import Draw from './Draw'
 
 const DEF_STYLE = {
   width: 3,
-  material: Cesium.Color.YELLOW.withAlpha(0.6)
+  material: Cesium.Color.YELLOW.withAlpha(0.6),
 }
 
 class DrawPolyline extends Draw {
     super()
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
   }
 
         ...this._style,
         positions: new Cesium.CallbackProperty(() => {
           return this._positions
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let polyline = null
     if (this._positions.length) {
       polyline = new Polyline(

src/modules/plot/draw/DrawRectangle.js

  * @Date: 2020-08-29 21:30:41
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { Rectangle } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
 import Draw from './Draw'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { Rectangle } from '../../overlay'
 
 const DEF_STYLE = {
-  material: Cesium.Color.YELLOW.withAlpha(0.6)
+  material: Cesium.Color.YELLOW.withAlpha(0.6),
 }
 
 class DrawRectangle extends Draw {
     this._maxAnchorSize = 2
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
   }
 
     this._delegate = new Cesium.Entity({
       rectangle: {
         ...this._style,
-        coordinates: new Cesium.CallbackProperty(time => {
+        coordinates: new Cesium.CallbackProperty((time) => {
           if (this._positions.length > 1) {
             return Cesium.Rectangle.fromCartesianArray(this._positions)
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let rectangle = null
     if (this._positions.length) {
       rectangle = new Rectangle(

src/modules/plot/draw/DrawTailedAttackArrow.js

  * @Date: 2020-08-30 16:43:12
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
-import { TailedAttackArrow } from '@dc-modules/overlay'
+import { Cesium } from '../../../namespace'
 import Draw from './Draw'
 import TailedAttackArrowGraphics from '../graphics/TailedAttackArrowGraphics'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
+import { TailedAttackArrow } from '../../overlay'
 
 const DEF_STYLE = {
   material: Cesium.Color.YELLOW.withAlpha(0.6),
-  fill: true
+  fill: true,
 }
 
 class DrawTailedAttackArrow extends Draw {
     this._maxAnchorSize = 3
     this._style = {
       ...DEF_STYLE,
-      ...style
+      ...style,
     }
     this._graphics = new TailedAttackArrowGraphics()
   }
           } else {
             return null
           }
-        }, false)
-      }
+        }, false),
+      },
     })
     this._layer.entities.add(this._delegate)
   }
    *
    * @private
    */
-  _stopdHook() {
+  _stoppedHook() {
     let tailedAttackArrow = null
     if (this._positions.length) {
       tailedAttackArrow = new TailedAttackArrow(

src/modules/plot/edit/Edit.js

  * @Date: 2020-08-30 23:50:53
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
 
 class Edit {
   constructor(overlay) {
     this._positions.forEach((item, index) => {
       this.editTool.fire(PlotEventType.CREATE_ANCHOR, {
         position: item,
-        index: index
+        index: index,
       })
     })
   }
   stop() {
     this.editTool.fire(PlotEventType.EDIT_STOP, {
       pickedAnchor: null,
-      position: null
+      position: null,
     })
     return this
   }

src/modules/plot/edit/EditAttackArrow.js

  * @Date: 2020-08-30 23:46:07
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
 import AttackArrowGraphics from '../graphics/AttackArrowGraphics'
 

src/modules/plot/edit/EditBillboard.js

  * @Date: 2020-08-30 22:04:36
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
+import { Transform } from '../../transform'
 
 class EditBillboard extends Edit {
   constructor(overlay) {

src/modules/plot/edit/EditCircle.js

  * @Date: 2020-08-31 10:54:38
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
+import { PlotEventType } from '../../event'
+import { Transform } from '../../transform'
 
 class EditCircle extends Edit {
   constructor(overlay) {
     this._center = Transform.transformWGS84ToCartesian(this._overlay.center)
     this._positions = [].concat([
       this._center,
-      this._computeCirclePoints(this._center, this._radius)[0]
+      this._computeCirclePoints(this._center, this._radius)[0],
     ])
-    this._delegate.polygon.hierarchy = new Cesium.CallbackProperty(time => {
+    this._delegate.polygon.hierarchy = new Cesium.CallbackProperty((time) => {
       if (this._positions.length > 1) {
         this._radius = Cesium.Cartesian3.distance(
           this._positions[0],
         semiMajorAxis: radius,
         semiMinorAxis: radius,
         rotation: 0,
-        granularity: 0.005
+        granularity: 0.005,
       },
       false,
       true
       this.editTool.fire(PlotEventType.CREATE_ANCHOR, {
         position: item,
         index: index,
-        isCenter: index % 2 === 0
+        isCenter: index % 2 === 0,
       })
     })
   }

src/modules/plot/edit/EditDoubleArrow.js

  * @Date: 2020-08-30 23:46:07
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
 import DoubleArrowGraphics from '../graphics/DoubleArrowGraphics'
 

src/modules/plot/edit/EditFineArrow.js

  * @Date: 2020-08-30 23:46:07
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
 import FineArrowGraphics from '../graphics/FineArrowGraphics'
 

src/modules/plot/edit/EditGatheringPlace.js

  * @Date: 2020-08-30 23:46:07
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
 import GatheringPlaceGraphics from '../graphics/GatheringPlaceGraphics'
 

src/modules/plot/edit/EditPoint.js

  * @Date: 2020-08-30 22:04:36
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
+import { Transform } from '../../transform'
 
 class EditPoint extends Edit {
   constructor(overlay) {

src/modules/plot/edit/EditPolygon.js

  * @Date: 2020-08-30 23:12:09
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { midCartesian } from '@dc-modules/math'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
+import { PlotEventType } from '../../event'
+import { midCartesian } from '../../math'
+import { Transform } from '../../transform'
 
 class EditPolygon extends Edit {
   constructor(overlay) {
    * @private
    */
   _mountedHook() {
-    this._delegate.polygon.hierarchy = new Cesium.CallbackProperty(time => {
+    this._delegate.polygon.hierarchy = new Cesium.CallbackProperty((time) => {
       if (this._positions.length > 2) {
         return new Cesium.PolygonHierarchy(
-          this._positions.map(item => item.clone())
+          this._positions.map((item) => item.clone())
         )
       } else {
         return null
       this.editTool.fire(PlotEventType.CREATE_ANCHOR, {
         position: item,
         index: index,
-        isMid: index % 2 !== 0
+        isMid: index % 2 !== 0,
       })
     })
   }
         this.editTool.fire(PlotEventType.CREATE_ANCHOR, {
           position: item,
           index: index,
-          isMid: index % 2 !== 0
+          isMid: index % 2 !== 0,
         })
       })
     }
       this._positions[nextMidAnchorIndex] = nextMidPosition
       this.editTool.fire(PlotEventType.UPDATE_ANCHOR, {
         index: preMidAnchorIndex,
-        position: preMidPosition
+        position: preMidPosition,
       })
       this.editTool.fire(PlotEventType.UPDATE_ANCHOR, {
         index: nextMidAnchorIndex,
-        position: nextMidPosition
+        position: nextMidPosition,
       })
     }
   }

src/modules/plot/edit/EditPolyline.js

  * @Date: 2020-08-30 22:39:34
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { PlotEventType } from '@dc-modules/event'
-import { midCartesian } from '@dc-modules/math'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
+import { PlotEventType } from '../../event'
+import { midCartesian } from '../../math'
+import { Transform } from '../../transform'
 
 class EditPolyline extends Edit {
   constructor(overlay) {
       this.editTool.fire(PlotEventType.CREATE_ANCHOR, {
         position: item,
         index: index,
-        isMid: index % 2 !== 0
+        isMid: index % 2 !== 0,
       })
     })
   }
         this.editTool.fire(PlotEventType.CREATE_ANCHOR, {
           position: item,
           index: index,
-          isMid: index % 2 !== 0
+          isMid: index % 2 !== 0,
         })
       })
     }
         this._positions[preMidAnchorIndex] = preMidPosition
         this.editTool.fire(PlotEventType.UPDATE_ANCHOR, {
           index: preMidAnchorIndex,
-          position: preMidPosition
+          position: preMidPosition,
         })
       }
 
         this._positions[nextMidAnchorIndex] = nextMidPosition
         this.editTool.fire(PlotEventType.UPDATE_ANCHOR, {
           index: nextMidAnchorIndex,
-          position: nextMidPosition
+          position: nextMidPosition,
         })
       }
     }

src/modules/plot/edit/EditRectangle.js

  * @Date: 2020-08-30 23:41:34
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import { Transform } from '@dc-modules/transform'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
 
 class EditRectangle extends Edit {
    * @private
    */
   _mountedHook() {
-    this._delegate.rectangle.coordinates = new Cesium.CallbackProperty(time => {
-      if (this._positions.length > 1) {
-        return Cesium.Rectangle.fromCartesianArray(this._positions)
-      } else {
-        return null
-      }
-    }, false)
+    this._delegate.rectangle.coordinates = new Cesium.CallbackProperty(
+      (time) => {
+        if (this._positions.length > 1) {
+          return Cesium.Rectangle.fromCartesianArray(this._positions)
+        } else {
+          return null
+        }
+      },
+      false
+    )
     this._layer.entities.add(this._delegate)
   }
 }

src/modules/plot/edit/EditTailedAttackArrow.js

  * @Date: 2020-08-30 23:46:07
  */
 
-import { Cesium } from '@dc-modules/namespace'
+import { Cesium } from '../../../namespace'
 import Edit from './Edit'
 import TailedAttackArrowGraphics from '../graphics/TailedAttackArrowGraphics'
 

src/modules/plot/graphics/AttackArrowGraphics.js

  * @Date: 2020-08-30 16:22:50
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import Parse from '@dc-modules/parse/Parse'
-import { Transform } from '@dc-modules/transform'
-import { PlotUtil } from '@dc-modules/utils'
+import { Cesium } from '../../../namespace'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { PlotUtil } from '../../utils'
 
 const HALF_PI = Math.PI / 2
 

src/modules/plot/graphics/DoubleArrowGraphics.js

  * @Date: 2020-08-30 16:27:29
  */
 
-import { Cesium } from '@dc-modules/namespace'
-import Parse from '@dc-modules/parse/Parse'
-import { Transform } from '@dc-modules/transform'
-import { PlotUtil } from '@dc-modules/utils'
+import { Cesium } from '../../../namespace'
+import Parse from '../../parse/Parse'
+import { Transform } from '../../transform'
+import { PlotUtil } from '../../utils'
 
 const HALF_PI = Math.PI / 2