完善覆盖物的属性设置

.eslintrc

   "plugins": ["prettier"],
   "extends": ["eslint:recommended", "plugin:prettier/recommended"],
   "globals": {
+    "__VERSION__": false,
+    "__TIME__": false,
+    "__AUTHOR__": false,
+    "__HOME_PAGE__": false,
+    "__REPOSITORY__": false,
     "DC": false,
-    "build": false,
     "Cesium": false
   },
   "rules": {

CHANGE.md

 
 > 1. 完善罗盘功能
 > 2. 修改框架包node下导入的方式
+> 3. 修改DivIcon显示和隐藏功能
+> 4. 完善覆盖物的属性设置
 
 ## 1.10.1
 

package.json

 {
   "name": "@dvgis/dc-sdk",
-  "version": "1.10.1",
+  "version": "1.10.2",
   "description": " The SDK is a secondary development based on the open source project Cesium, which optimizes some operations of Cesium and enables developers to quickly develop 3D applications through the framework.",
   "main": "index.js",
   "repository": "https://github.com/dvgis/dc-sdk.git",

src/log.js → src/LICENSE.js

 // eslint-disable-next-line no-console
 console.log(
   `%c \n DC-SDK \n  %c \n 用数字描绘世界之美  %c \n
-    版本:${build.version}
-    编译日期:${build.time}
+    版本:${__VERSION__}
+    编译日期:${__TIME__}
     Cesium版本：1.73
-    作者:${build.author}
-    主页: ${build.homepage}
-    github:${build.repository}
+    作者:${__AUTHOR__}
+    主页: ${__HOME_PAGE__}
+    github:${__REPOSITORY__}
     授权信息：授权-永久使用此软件当前版本。 \n
 
     版权声明:

src/base/global-api/mixin.js

  */
 
 const ignores = [
+  'version',
+  'author',
+  'home_page',
   'init',
   'ready',
   'use',
   'mixin',
   'Namespace',
-  'Initialized',
-  'Version',
-  'Author',
-  'GitHub',
-  'Home'
+  'Initialized'
 ]
 
 /**

src/base/index.js

 
 import { initMixin, initUse } from './global-api'
 
+// global namespace
 let DC = {
-  Author: build.author,
-  GitHub: build.repository,
-  Home: build.homepage,
-  Version: build.version,
+  version: __VERSION__,
+  author: __AUTHOR__,
+  home_page: __HOME_PAGE__,
   Namespace: {},
   Initialized: false
 }
 
+// init global api
 initMixin(DC)
 initUse(DC)
+require('../LICENSE')
 
+// load Cesium
 let cesiumLoaded = false
 DC.init = callback => {
   if (!cesiumLoaded) {
     new Promise((resolve, reject) => {
       let Cesium = require('cesium/Cesium')
       resolve(Cesium)
-    }).then(Cesium => {
-      DC.Namespace['Cesium'] = Cesium
-      cesiumLoaded = true
-      delete window.Cesium
-      callback && callback()
     })
+      .then(Cesium => {
+        DC.Namespace['Cesium'] = Cesium
+        cesiumLoaded = true
+        delete window.Cesium
+        callback && callback()
+      })
+      .catch(e => {})
   } else {
     callback && callback()
   }
 }
 
-require('../log')
-
 export default DC

src/core/Loader.Base.js

 import { Util, DomUtil, PlotUtil } from './utils'
 import { MouseEventType, SceneEventType, Event } from './event'
 import { LayerType, Layer } from './layer'
-import { Overlay, OverlayType } from './overlay'
+import { OverlayType, Overlay } from './overlay'
 import ImageryType from './imagery/ImageryType'
+import TerrainType from './terrain/TerrainType'
 import WidgetType from './widget/WidgetType'
 import State from './state/State'
 import Position from './position/Position'
   State,
   Event,
   ImageryType,
+  TerrainType,
   LayerType,
   OverlayType,
   MouseEventType,

src/core/event/EventType.js

 
 const { Cesium } = DC.Namespace
 
-const baseEventType = {
+const BaseEventType = {
   ADD: 'add',
   REMOVE: 'remove'
 }
   MOUSE_MOVE: Cesium.ScreenSpaceEventType.MOUSE_MOVE,
   WHEEL: Cesium.ScreenSpaceEventType.WHEEL,
   MOUSE_OVER: 'mouseover',
-  MOUSE_OUT: 'mouseout',
-  DRAG_START: 'dragStart',
-  DRAG_END: 'dragEnd',
-  EDIT_START: 'editStart',
-  EDIT_END: 'editEnd'
+  MOUSE_OUT: 'mouseout'
 }
 
 const ViewerEventType = {
   CLOCK_TICK: 'clockTick'
 }
 
-const LayerGroupEventType = {
-  ...baseEventType
-}
-
-const LayerEventType = {
-  ...baseEventType,
-  CLEAR: 'clear'
-}
-
-const EffectEventType = {
-  ...baseEventType
-}
-
 const OverlayEventType = {
-  ...baseEventType,
+  ...BaseEventType,
   CLICK: Cesium.ScreenSpaceEventType.LEFT_CLICK,
   RIGHT_CLICK: Cesium.ScreenSpaceEventType.RIGHT_CLICK,
   DB_CLICK: Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK,
   MOUSE_OVER: 'mouseover',
-  MOUSE_OUT: 'mouseout',
-  DRAG_START: 'dragStart',
-  DRAG_END: 'dragEnd',
-  EDIT_START: 'editStart',
-  EDIT_END: 'editEnd'
+  MOUSE_OUT: 'mouseout'
 }
 
+const LayerGroupEventType = BaseEventType
+
+const LayerEventType = BaseEventType
+
+const EffectEventType = BaseEventType
+
 export {
   MouseEventType,
   ViewerEventType,
   SceneEventType,
   LayerGroupEventType,
   LayerEventType,
-  EffectEventType,
-  OverlayEventType
+  OverlayEventType,
+  EffectEventType
 }

src/core/event/MouseEvent.js

 
     // for Entity
     if (target && target.id && target.id instanceof Cesium.Entity) {
-      layer = target.id.layer
+      layer = this._viewer
+        .getLayers()
+        .filter(item => item.layerId === target.id.layerId)[0]
       if (layer && layer.getOverlay) {
         overlay = layer.getOverlay(target.id.overlayId)
       }
 
     // for Cesium3DTileFeature
     if (target && target instanceof Cesium.Cesium3DTileFeature) {
-      layer = target.tileset.layer
+      layer = this._viewer
+        .getLayers()
+        .filter(item => item.layerId === target.tileset.layerId)[0]
       feature = target
       if (layer && layer.getOverlay) {
         overlay = layer.getOverlay(target.tileset.overlayId)

src/core/layer/GeoJsonLayer.js

  * @Date: 2020-01-13 10:13:53
  */
 
-import { Layer, VectorLayer } from './index'
-import { Billboard, Polyline, Polygon, Model } from '../overlay'
 import State from '../state/State'
+import Layer from './Layer'
+import VectorLayer from './VectorLayer'
+import { Billboard, Polyline, Polygon, Model } from '../overlay'
 
 const { Cesium } = DC.Namespace
 

src/core/layer/HtmlLayer.js

  */
 
 import { DomUtil } from '../utils'
-import Layer from './Layer'
 import State from '../state/State'
 import Transform from '../transform/Transform'
+import Layer from './Layer'
 
 const { Cesium } = DC.Namespace
 
    * @param viewer
    * @private
    */
-  _addHandler(viewer) {
+  _onAdd(viewer) {
     this._viewer = viewer
     this._viewer.dcContainer.appendChild(this._delegate)
     let scene = this._viewer.scene
       let cameraPosition = this._viewer.camera.positionWC
       this.eachOverlay(item => {
         if (item && item.position) {
+          item.show = this.show
           let position = Transform.transformWGS84ToCartesian(item.position)
           let windowCoord = Cesium.SceneTransforms.wgs84ToWindowCoordinates(
             scene,
    * @returns {boolean}
    * @private
    */
-  _removeHandler() {
+  _onRemove() {
     this._renderRemoveCallback && this._renderRemoveCallback()
     this._viewer.dcContainer.removeChild(this._delegate)
     this._state = State.REMOVED

src/core/layer/LabelLayer.js

  * @Date: 2020-03-30 17:14:00
  */
 
-import { Label } from '../overlay'
 import State from '../state/State'
+import { Label } from '../overlay'
 import Layer from './Layer'
 
 const { Cesium } = DC.Namespace
 
 class LabelLayer extends Layer {
-  constructor(id, url) {
-    if (!url) {
-      throw new Error('LabelLayer：the url invalid')
-    }
+  constructor(id, url = '') {
     super(id)
     this._dataSource = Cesium.GeoJsonDataSource.load(url)
     this._delegate = new Cesium.CustomDataSource(id)

src/core/layer/Layer.js

 
 class Layer {
   constructor(id) {
-    this._id = id || Util.uuid()
+    this._id = Util.uuid()
+    this._bid = id || Util.uuid()
     this._delegate = undefined
     this._viewer = undefined
     this._state = undefined
     this._show = true
     this._cache = {}
     this._attr = {}
-    this._style = {}
     this._layerEvent = new LayerEvent()
-    this._layerEvent.on(LayerEventType.ADD, this._addHandler, this)
-    this._layerEvent.on(LayerEventType.REMOVE, this._removeHandler, this)
+    this._layerEvent.on(LayerEventType.ADD, this._onAdd, this)
+    this._layerEvent.on(LayerEventType.REMOVE, this._onRemove, this)
     this._state = undefined
     this.type = undefined
   }
 
+  get layerId() {
+    return this._id
+  }
+
+  get id() {
+    return this._bid
+  }
+
+  get delegate() {
+    return this._delegate
+  }
+
   set show(show) {
     this._show = show
     this._delegate && (this._delegate.show = this._show)
     return this._attr
   }
 
-  get id() {
-    return this._id
-  }
-
-  get delegate() {
-    return this._delegate
-  }
-
   get state() {
     return this._state
   }
    * @param viewer
    * @private
    */
-  _addHandler(viewer) {
+  _onAdd(viewer) {
     this._viewer = viewer
     if (this._delegate instanceof Cesium.PrimitiveCollection) {
       this._viewer.scene.primitives.add(this._delegate)
    * @returns {boolean}
    * @private
    */
-  _removeHandler() {
+  _onRemove() {
     if (!this._delegate) {
       return false
     }

src/core/layer/LayerGroup.js

  * @Date: 2020-08-27 19:50:32
  */
 
-import Util from '../../core/utils/Util'
+import { Util } from '../../core/utils'
 import State from '../state/State'
-import Layer from './Layer'
 import { LayerGroupEventType, LayerGroupEvent } from '../event'
+import Layer from './Layer'
 
 class LayerGroup {
   constructor(id) {
     this._show = true
     this._viewer = undefined
     this._layerGroupEvent = new LayerGroupEvent()
-    this._layerGroupEvent.on(LayerGroupEventType.ADD, this._addHandler, this)
-    this._layerGroupEvent.on(
-      LayerGroupEventType.REMOVE,
-      this._removeHandler,
-      this
-    )
+    this._layerGroupEvent.on(LayerGroupEventType.ADD, this._onAdd, this)
+    this._layerGroupEvent.on(LayerGroupEventType.REMOVE, this._onRemove, this)
     this.type = Layer.getLayerType('layer-group')
     this._state = State.INITIALIZED
   }
    * @param viewer
    * @private
    */
-  _addHandler(viewer) {
+  _onAdd(viewer) {
     this._viewer = viewer
     Object.keys(this._cache).forEach(key => {
       this._viewer.addLayer(this._cache[key])
    *
    * @private
    */
-  _removeHandler() {
+  _onRemove() {
     Object.keys(this._cache).forEach(key => {
       this._viewer && this._viewer.remove(this._cache[key])
     })
   }
 
   /**
-   *
+   * Adds a layer
    * @param layer
    * @returns {LayerGroup}
    */
   }
 
   /**
-   *
+   * Removes a layer
    * @param layer
    * @returns {LayerGroup}
    */
   }
 
   /**
-   *
+   * Returns a layer by id
    * @param id
    * @returns {*|undefined}
    */
   }
 
   /**
-   *
+   * Returns all layers
    * @returns {[]}
    */
   getLayers() {
     return result
   }
 
+  /**
+   * Adds to the viewer
+   * @param viewer
+   * @returns {LayerGroup}
+   */
+  addTo(viewer) {
+    if (viewer && viewer.addLayerGroup) {
+      viewer.addLayerGroup(this)
+    }
+    return this
+  }
+
   /**
    *
    * @returns {LayerGroup}
    */
   remove() {
-    this._viewer && this._viewer.removeLayer(this)
+    this._viewer && this._viewer.removeLayerGroup(this)
     return this
   }
 }

src/core/overlay/Overlay.js

     this._attr = {}
     this._overlayEvent = new OverlayEvent()
     this.type = undefined
-    this.on(OverlayEventType.ADD, this._addHandler, this)
-    this.on(OverlayEventType.REMOVE, this._removeHandler, this)
+    this.on(OverlayEventType.ADD, this._onAdd, this)
+    this.on(OverlayEventType.REMOVE, this._onRemove, this)
   }
 
   get overlayId() {
     if (!this._delegate) {
       return false
     }
-    this._delegate.layer = this._layer
+    this._delegate.layerId = this._layer?.layerId
     this._delegate.overlayId = this._id
   }
 
    * @returns {boolean}
    * @private
    */
-  _addHandler(layer) {
+  _onAdd(layer) {
     if (!layer) {
       return false
     }
    * Remove handler
    * @private
    */
-  _removeHandler() {
+  _onRemove() {
     if (this._layer?.delegate?.entities) {
       this._layer.delegate.entities.remove(this._delegate)
       this._removedHook && this._removedHook()

src/core/overlay/base/Billboard.js

  */
 
 import { Util } from '../../utils'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/base/Circle.js

  */
 
 import { Util } from '../../utils'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/base/DivIcon.js

 
     let distanceDisplayCondition = this._style.distanceDisplayCondition
     if (distance && distanceDisplayCondition) {
-      this.show = isBetween(
-        distance,
-        distanceDisplayCondition.near,
-        distanceDisplayCondition.far
-      )
+      this.show =
+        this._show &&
+        isBetween(
+          distance,
+          distanceDisplayCondition.near,
+          distanceDisplayCondition.far
+        )
     }
     this._delegate.style.transform = `${translate3d} ${scale3d}`
   }
    * @returns {boolean}
    * @private
    */
-  _addHandler(layer) {
+  _onAdd(layer) {
     this._layer = layer
     this._layer.delegate.appendChild(this._delegate)
     this._delegate.addEventListener('click', () => {
    *
    * @private
    */
-  _removeHandler() {
+  _onRemove() {
     if (this._layer) {
       this._layer.delegate.removeChild(this._delegate)
       this._state = State.REMOVED

src/core/overlay/base/Label.js

  */
 
 import { Util } from '../../utils'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/base/Point.js

  */
 
 import { Util } from '../../utils'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/base/Polygon.js

 
 import { Util } from '../../utils'
 import { center, area } from '../../math'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/base/Polyline.js

 
 import { Util } from '../../utils'
 import { center, distance } from '../../math'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/index.js

-/*
+/**
  * @Author: Caven
- * @Date: 2020-01-06 15:04:15
- * @Last Modified by: Caven
- * @Last Modified time: 2020-06-04 22:01:23
+ * @Date: 2020-04-15 20:57:22
  */
+
 export { default as OverlayType } from './OverlayType'
 export { default as Overlay } from './Overlay'
 export { default as Billboard } from './base/Billboard'

src/core/overlay/model/Model.js

  */
 
 import { Util } from '../../utils'
+import State from '../../state/State'
 import Transform from '../../transform/Transform'
 import Parse from '../../parse/Parse'
-import State from '../../state/State'
 import Overlay from '../Overlay'
 
 const { Cesium } = DC.Namespace

src/core/overlay/model/Tileset.js

    * @param {*} layer
    * Overrides parent methods
    */
-  _addHandler(layer) {
+  _onAdd(layer) {
     if (!layer) {
       return false
     }
     this._layer = layer
     this._delegate.readyPromise.then(tileset => {
       this._layer.delegate.add(tileset)
-      tileset.layer = layer
+      tileset.layerId = layer?.layerId
       tileset.overlayId = this._id
       this._state = State.ADDED
     })
   /**
    * Overrides parent methods
    */
-  _removeHandler() {
+  _onRemove() {
     if (!this._layer) {
       return false
     }

src/core/position/Position.js

     return position
   }
 
+  /**
+   *
+   * @returns {*[]}
+   */
+  toArray() {
+    return [this.lng, this.lat, this.alt, this.heading, this.pitch, this.roll]
+  }
+
   /**
    *
    * @returns {string}
 
   /**
    *
-   * @param str
+   * @param arr
    * @returns {Position}
    */
-  static fromString(str) {
+  static fromArray(arr) {
     let position = new Position()
-    if (str && typeof str === 'string') {
-      let arr = str.split(',')
+    if (Array.isArray(arr)) {
       position.lng = arr[0] || 0
       position.lat = arr[1] || 0
       position.alt = arr[2] || 0
     return position
   }
 
+  /**
+   *
+   * @param str
+   * @returns {Position}
+   */
+  static fromString(str) {
+    let position = new Position()
+    if (str && typeof str === 'string') {
+      let arr = str.split(',')
+      position = this.fromArray(arr)
+    }
+    return position
+  }
+
   /**
    * Deserialize
    * @param valStr

src/core/state/State.js

   CLEARED: 'cleared',
   INSTALLED: 'installed',
   ENABLED: 'enabled',
-  DISABLED: 'disabled'
+  DISABLED: 'disabled',
+  PLAY: 'play',
+  PAUSE: 'pause',
+  RESTORE: 'restore'
 }
 
 export default State

src/core/terrain/TerrainFactory.js

  * @Date: 2020-01-21 15:54:56
  */
 
+import TerrainType from './TerrainType'
+
 const { Cesium } = DC.Namespace
 
 class TerrainFactory {
   static createVRTerrain(options) {
     return new Cesium.VRTheWorldTerrainProvider(options)
   }
+
+  /**
+   * Create Terrain
+   * @param type
+   * @param options
+   * @returns {any}
+   */
+  static createTerrain(type, options) {
+    let terrain = undefined
+    switch (type) {
+      case TerrainType.NONE:
+        terrain = this.createEllipsoidTerrain(options)
+        break
+      case TerrainType.XYZ:
+        terrain = this.createUrlTerrain(options)
+        break
+      case TerrainType.GOOGLE:
+        terrain = this.createGoogleTerrain(options)
+        break
+      case TerrainType.ARCGIS:
+        terrain = this.createArcgisTerrain(options)
+        break
+      case TerrainType.VR:
+        terrain = this.createVRTerrain(options)
+        break
+      default:
+        break
+    }
+    return terrain
+  }
 }
 
 export default TerrainFactory

src/core/terrain/TerrainType.js

+/**
+ * @Author: Caven
+ * @Date: 2020-05-10 08:15:36
+ */
+
+let TerrainType = {
+  NONE: 'none',
+  XYZ: 'xyz',
+  ARCGIS: 'arcgis',
+  GOOGLE: 'google',
+  VR: 'vr'
+}
+
+export default TerrainType

src/core/utils/Util.js

     return dest
   }
 
-  /**
-   *
-   * @function trim(str: String): String
-   * Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
-   * @param {*} str
-   *
-   */
-  static trim(str) {
-    return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '')
-  }
-
   /**
    * @function splitWords(str: String): String[]
    * Trims and splits the string on whitespace and returns the array of parts.
     return obj.options
   }
 
+  /**
+   *  @function formatNum(num: Number, digits?: Number): Number
+   *  Returns the number `num` rounded to `digits` decimals, or to 6 decimals by default.
+   * @param num
+   * @param digits
+   * @returns {number}
+   */
+  static formatNum(num, digits) {
+    let pow = Math.pow(10, digits === undefined ? 6 : digits)
+    return Math.round(num * pow) / pow
+  }
+
+  /**
+   * @function trim(str: String): String
+   * Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
+   * @param {*} str
+   */
+  static trim(str) {
+    return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '')
+  }
+
+  /**
+   *  Data URI string containing a base64-encoded empty GIF image.
+   * Used as a hack to free memory from unused images on WebKit-powered
+   * mobile devices (by setting image `src` to this string).
+   * @returns {string}
+   */
+  static emptyImageUrl() {
+    return (function() {
+      return 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
+    })()
+  }
+
   /**
    * @function checkPosition(position: Object): Boolean
    * Check position for validity
       position.hasOwnProperty('_alt')
     )
   }
-
-  /**
-   * Checks positions for validity
-   * @param positions
-   * @returns {Boolean}
-   */
-  static checkPositions(positions) {
-    return (
-      positions && (typeof positions === 'string' || Array.isArray(positions))
-    )
-  }
-
-  /**
-   * Checks viewer for validity
-   * @param viewer
-   * @returns {Boolean}
-   */
-  static checkViewer(viewer) {
-    return viewer && viewer.delegate && viewer.canvas
-  }
 }
 
 export default Util

src/thirdpart/index.js

   Cartesian2: Cesium.Cartesian2,
   Cartesian3: Cesium.Cartesian3,
   SceneMode: Cesium.SceneMode,
+  HeightReference: Cesium.HeightReference,
+  ClassificationType: Cesium.ClassificationType,
+  ShadowMode: Cesium.ShadowMode,
   TilesetStyle: Cesium.Cesium3DTileStyle,
   CallbackProperty: Cesium.CallbackProperty,
   JulianDate: Cesium.JulianDate,
-  ClassificationType: Cesium.ClassificationType,
   Color: Cesium.Color,
   ColorMaterialProperty: Cesium.ColorMaterialProperty,
   ImageMaterialProperty: Cesium.ImageMaterialProperty,

webpack.base.conf.js

     ...cesiumCopyPlugin,
     new webpack.DefinePlugin({
       CESIUM_BASE_URL: JSON.stringify('./libs/dc-sdk/resources/'),
-      'build.version': JSON.stringify(packageInfo.version),
-      'build.time': JSON.stringify(getTime()),
-      'build.author': JSON.stringify(packageInfo.author),
-      'build.repository': JSON.stringify(packageInfo.repository),
-      'build.homepage': JSON.stringify(packageInfo.homepage)
+      __VERSION__: JSON.stringify(packageInfo.version),
+      __TIME__: JSON.stringify(getTime()),
+      __AUTHOR__: JSON.stringify(packageInfo.author),
+      __REPOSITORY__: JSON.stringify(packageInfo.repository),
+      __HOME_PAGE__: JSON.stringify(packageInfo.homepage)
     })
   ]
   if (IS_PROD) {
     entry: {
       'dc.base': ['base']
     },
-    devtool: IS_PROD ? false : 'source-map',
+    devtool: IS_PROD ? false : 'cheap-module-eval-source-map',
     output: {
       filename: IS_PROD ? '[name].min.js' : '[name].js',
       path: path.resolve(__dirname, 'dist'),

webpack.config.js

     entry: {
       'dc.core': ['theme', 'entry']
     },
-    devtool: IS_PROD ? false : 'source-map',
+    devtool: IS_PROD ? false : 'cheap-module-eval-source-map',
     output: {
       filename: IS_PROD ? '[name].min.js' : '[name].js',
       path: path.resolve(__dirname, 'dist'),