mars3d-supermap 3.4.26 → 3.5.0

package/dist/mars3d-supermap.js

@@ -1,10 +1,10 @@
 /**
  * Mars3D平台插件,结合supermap超图库使用的功能插件  mars3d-supermap
  *
- * 版本信息：v3.4.26
- * 编译日期：2023-03-09 16:18:54
+ * 版本信息：v3.5.0
+ * 编译日期：2023-03-17 08:59:34
  * 版权所有：Copyright by 火星科技  http://mars3d.cn
- * 使用单位：免费公开版 ，2022-06-01
+ * 使用单位：免费公开版 ，2022-10-01
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, (window.mars3d || require('mars3d'))) :
@@ -34,14 +34,17 @@
 
   function ownKeys(object, enumerableOnly) {
     var keys = Object.keys(object);
+
     if (Object.getOwnPropertySymbols) {
       var symbols = Object.getOwnPropertySymbols(object);
       enumerableOnly && (symbols = symbols.filter(function (sym) {
         return Object.getOwnPropertyDescriptor(object, sym).enumerable;
       })), keys.push.apply(keys, symbols);
     }
+
     return keys;
   }
+
   function _objectSpread2(target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = null != arguments[i] ? arguments[i] : {};
@@ -51,13 +54,16 @@
         Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
       });
     }
+
     return target;
   }
+
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
+
   function _defineProperties(target, props) {
     for (var i = 0; i < props.length; i++) {
       var descriptor = props[i];
@@ -67,6 +73,7 @@
       Object.defineProperty(target, descriptor.key, descriptor);
     }
   }
+
   function _createClass(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties(Constructor, staticProps);
@@ -75,6 +82,7 @@
     });
     return Constructor;
   }
+
   function _defineProperty(obj, key, value) {
     if (key in obj) {
       Object.defineProperty(obj, key, {
@@ -86,12 +94,15 @@
     } else {
       obj[key] = value;
     }
+
     return obj;
   }
+
   function _inherits(subClass, superClass) {
     if (typeof superClass !== "function" && superClass !== null) {
       throw new TypeError("Super expression must either be null or a function");
     }
+
     subClass.prototype = Object.create(superClass && superClass.prototype, {
       constructor: {
         value: subClass,
@@ -104,23 +115,28 @@
     });
     if (superClass) _setPrototypeOf(subClass, superClass);
   }
+
   function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
       return o.__proto__ || Object.getPrototypeOf(o);
     };
     return _getPrototypeOf(o);
   }
+
   function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
       o.__proto__ = p;
       return o;
     };
+
     return _setPrototypeOf(o, p);
   }
+
   function _isNativeReflectConstruct() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
     if (typeof Proxy === "function") return true;
+
     try {
       Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
       return true;
@@ -128,115 +144,135 @@
       return false;
     }
   }
+
   function _assertThisInitialized(self) {
     if (self === void 0) {
       throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
+
     return self;
   }
+
   function _possibleConstructorReturn(self, call) {
     if (call && (typeof call === "object" || typeof call === "function")) {
       return call;
     } else if (call !== void 0) {
       throw new TypeError("Derived constructors may only return object or undefined");
     }
+
     return _assertThisInitialized(self);
   }
+
   function _createSuper(Derived) {
     var hasNativeReflectConstruct = _isNativeReflectConstruct();
+
     return function _createSuperInternal() {
       var Super = _getPrototypeOf(Derived),
-        result;
+          result;
+
       if (hasNativeReflectConstruct) {
         var NewTarget = _getPrototypeOf(this).constructor;
+
         result = Reflect.construct(Super, arguments, NewTarget);
       } else {
         result = Super.apply(this, arguments);
       }
+
       return _possibleConstructorReturn(this, result);
     };
   }
+
   function _superPropBase(object, property) {
     while (!Object.prototype.hasOwnProperty.call(object, property)) {
       object = _getPrototypeOf(object);
       if (object === null) break;
     }
+
     return object;
   }
+
   function _get() {
     if (typeof Reflect !== "undefined" && Reflect.get) {
-      _get = Reflect.get.bind();
+      _get = Reflect.get;
     } else {
       _get = function _get(target, property, receiver) {
         var base = _superPropBase(target, property);
+
         if (!base) return;
         var desc = Object.getOwnPropertyDescriptor(base, property);
+
         if (desc.get) {
           return desc.get.call(arguments.length < 3 ? target : receiver);
         }
+
         return desc.value;
       };
     }
+
     return _get.apply(this, arguments);
   }
 
   var Cesium$2 = mars3d__namespace.Cesium;
   var BaseLayer$1 = mars3d__namespace.layer.BaseLayer;
-
   /**
    * 超图S3M三维模型图层,
    * 【需要引入  mars3d-supermap 插件库】
    *
-   * @param {Object} [options] 参数对象，包括以下：
-   * @param {String} options.url supermap的S3M服务地址,示例："url": "http://www.supermapol.com/realspace/services/3D-Olympic/rest/realspace"
-   * @param {String} [options.layername] 指定图层名称,未指定时，打开iserver场景服务下所有图层
-   * @param {String} [options.sceneName] 工作空间中有多个场景，需要指定场景名称；设置为undefined，默认打开第一个
-   * @param {Object} [options.s3mOptions] [S3M支持的参数]{@link http://support.supermap.com.cn:8090/webgl/docs/Documentation/S3MTilesLayer.html?classFilter=S3MTilesLayer} ,示例： {"selectEnabled":false},
-   * @param {Object} [options.position] 模型新的中心点位置（移动模型）
-   * @param {Number} options.position.alt 获取或设置底部高程。（单位：米）
+   * @param {object} [options] 参数对象，包括以下：
+   * @param {string} options.url supermap的S3M服务地址,示例："url": "http://www.supermapol.com/realspace/services/3D-Olympic/rest/realspace"
+   * @param {string} [options.layername] 指定图层名称,未指定时，打开iserver场景服务下所有图层
+   * @param {string} [options.sceneName] 工作空间中有多个场景，需要指定场景名称；设置为undefined，默认打开第一个
+   * @param {object} [options.s3mOptions] [S3M支持的参数]{@link http://support.supermap.com.cn:8090/webgl/docs/Documentation/S3MTilesLayer.html?classFilter=S3MTilesLayer} ,示例： {"selectEnabled":false},
+   * @param {object} [options.position] 模型新的中心点位置（移动模型）
+   * @param {number} options.position.alt 获取或设置底部高程。（单位：米）
    *
-   * @param {String|Number} [options.id = createGuid()] 图层id标识
-   * @param {String|Number} [options.pid = -1] 图层父级的id，一般图层管理中使用
-   * @param {String} [options.name = ''] 图层名称
-   * @param {Boolean} [options.show = true] 图层是否显示
-   * @param {BaseClass|Boolean} [options.eventParent]  指定的事件冒泡对象，默认为map对象，false时不冒泡
-   * @param {Object} [options.center] 图层自定义定位视角 {@link Map#setCameraView}
-   * @param {Number} options.center.lng 经度值, 180 - 180
-   * @param {Number} options.center.lat 纬度值, -90 - 90
-   * @param {Number} [options.center.alt] 高度值
-   * @param {Number} [options.center.heading] 方向角度值，绕垂直于地心的轴旋转角度, 0至360
-   * @param {Number} [options.center.pitch] 俯仰角度值，绕纬度线旋转角度, -90至90
-   * @param {Number} [options.center.roll] 翻滚角度值，绕经度线旋转角度, -90至90
-   * @param {Boolean} [options.flyTo] 加载完成数据后是否自动飞行定位到数据所在的区域。
+   * @param {string|number} [options.id = createGuid()] 图层id标识
+   * @param {string|number} [options.pid = -1] 图层父级的id，一般图层管理中使用
+   * @param {string} [options.name = ''] 图层名称
+   * @param {boolean} [options.show = true] 图层是否显示
+   * @param {BaseClass|boolean} [options.eventParent]  指定的事件冒泡对象，默认为map对象，false时不冒泡
+   * @param {object} [options.center] 图层自定义定位视角 {@link Map#setCameraView}
+   * @param {number} options.center.lng 经度值, 180 - 180
+   * @param {number} options.center.lat 纬度值, -90 - 90
+   * @param {number} [options.center.alt] 高度值
+   * @param {number} [options.center.heading] 方向角度值，绕垂直于地心的轴旋转角度, 0至360
+   * @param {number} [options.center.pitch] 俯仰角度值，绕纬度线旋转角度, -90至90
+   * @param {number} [options.center.roll] 翻滚角度值，绕经度线旋转角度, -90至90
+   * @param {boolean} [options.flyTo] 加载完成数据后是否自动飞行定位到数据所在的区域。
    * @export
    * @class S3MLayer
    * @extends {BaseLayer}
    */
+
   var S3MLayer = /*#__PURE__*/function (_BaseLayer) {
     _inherits(S3MLayer, _BaseLayer);
+
     var _super = _createSuper(S3MLayer);
+
     function S3MLayer() {
       _classCallCheck(this, S3MLayer);
+
       return _super.apply(this, arguments);
     }
+
     _createClass(S3MLayer, [{
       key: "layer",
       get:
       /**
        * 模型对应的Cesium.S3MTilesLayer图层组
-       * @type {Object[]}
+       * @type {object[]}
        * @readonly
        * @see http://support.supermap.com.cn:8090/webgl/docs/Documentation/S3MTilesLayer.html
        */
       function get() {
         return this._layerArr;
       }
-
       /**
        * 设置S3M图层本身支持的参数
-       * @type {Object}
+       * @type {object}
        * @see [S3M支持的参数]{@link http://support.supermap.com.cn:8090/webgl/docs/Documentation/S3MTilesLayer.html?classFilter=S3MTilesLayer}
        */
+
     }, {
       key: "s3mOptions",
       get: function get() {
@@ -246,17 +282,21 @@
         for (var key in value) {
           var val = value[key];
           this.options.s3mOptions[key] = val;
+
           if (key === "transparentBackColor") {
             // 去黑边，与offset互斥，注意别配置offset
             val = Cesium$2.Color.fromCssColorString(val);
           } else if (key === "transparentBackColorTolerance") {
             val = Number(val);
           }
+
           for (var i = 0; i < this._layerArr.length; i++) {
             var layer = this._layerArr[i];
+
             if (layer == null) {
               continue;
             }
+
             layer[key] = val;
           }
         }
@@ -266,27 +306,31 @@
       value: function _showHook(show) {
         this.eachLayer(function (layer) {
           layer.visible = show; // 不同超图版本，有的是visible，有的是show
+
           layer.show = show;
         }, this);
       }
-
       /**
        * 对象添加到地图前创建一些对象的钩子方法，
        * 只会调用一次
        * @return {void}  无
        * @private
        */
+
     }, {
       key: "_mountedHook",
       value: function _mountedHook() {
         var _this = this;
+
         if (!this._map.scene.open) {
           throw new Error("请引入 超图版本Cesium库 或 超图S3M插件 ");
         }
-        var centerOld = this._map.getCameraView();
 
-        // 场景添加S3M图层服务
+        var centerOld = this._map.getCameraView(); // 场景添加S3M图层服务
+
+
         var promise;
+
         if (this.options.layername) {
           promise = this._map.scene.addS3MTilesLayerByScp(this.options.url, {
             name: this.options.layername,
@@ -298,24 +342,30 @@
             autoSetView: this.options.flyTo
           });
         }
+
         promise.then(function (smLayer) {
           if (Array.isArray(smLayer)) {
             _this._layerArr = smLayer;
           } else {
             _this._layerArr = [smLayer];
           }
+
           for (var i = 0; i < _this._layerArr.length; i++) {
             var layer = _this._layerArr[i];
+
             if (!layer) {
               continue;
             }
+
             try {
               _this._initModelItem(layer);
             } catch (e) {
               mars3d__namespace.Log.logError("s3m图层初始化出错", e);
             }
           }
+
           _this._showHook(_this.show);
+
           if (_this.options.flyTo) {
             _this.flyToByAnimationEnd();
           } else if (_this.options.flyTo === false) {
@@ -323,31 +373,33 @@
               duration: 0
             });
           }
+
           _this._readyPromise.resolve(_this);
+
           _this.fire(mars3d__namespace.EventType.load, {
             layers: _this._layerArr
           });
         }, function (error) {
           var _this$_readyPromise;
+
           if ((_this$_readyPromise = _this._readyPromise) !== null && _this$_readyPromise !== void 0 && _this$_readyPromise.reject) {
             _this._readyPromise.reject(error);
           }
-        });
-
-        // this._map.viewer.pickEvent.addEventListener(function (feature) {
+        }); // this._map.viewer.pickEvent.addEventListener(function (feature) {
         //   debugger;
         // });
-      }
+      } // 对单个s3m图层处理
 
-      // 对单个s3m图层处理
     }, {
       key: "_initModelItem",
       value: function _initModelItem(layer) {
         var _this$options, _this$options$positio;
+
         // 图层参数合并
         if (this.options.s3mOptions) {
           for (var key in this.options.s3mOptions) {
             var val = this.options.s3mOptions[key];
+
             if (key === "transparentBackColor") {
               layer[key] = Cesium$2.Color.fromCssColorString(val); // 去黑边
             } else if (key === "transparentBackColorTolerance") {
@@ -356,84 +408,87 @@
               layer[key] = val;
             }
           }
-        }
+        } // 选中颜色
+
 
-        // 选中颜色
         if (this.options.highlight) {
           layer.selectedColor = mars3d__namespace.Util.getColorByStyle(this.options.highlight);
-        }
+        } // 高度调整
+
 
-        // 高度调整
         if ((_this$options = this.options) !== null && _this$options !== void 0 && (_this$options$positio = _this$options.position) !== null && _this$options$positio !== void 0 && _this$options$positio.alt) {
           layer.style3D.altitudeMode = Cesium$2.HeightReference.NONE;
           layer.style3D.bottomAltitude = this.options.position.alt;
+
           if (layer.refresh) {
             layer.refresh(); // 设置风格后需刷新
           }
         }
       }
-
       /**
        * 对象添加到地图上的创建钩子方法，
        * 每次add时都会调用
        * @return {void}  无
        * @private
        */
+
     }, {
       key: "_addedHook",
       value: function _addedHook() {
         this._showHook(this.show);
       }
-
       /**
        * 对象从地图上移除的创建钩子方法，
        * 每次remove时都会调用
        * @return {void}  无
        * @private
        */
+
     }, {
       key: "_removedHook",
       value: function _removedHook() {
         this._showHook(false);
       }
-
       /**
        * 遍历每一个子图层并将其作为参数传递给回调函数
        *
        * @param {Function} method 回调方法
-       * @param {Object} [context] 侦听器的上下文(this关键字将指向的对象)。
+       * @param {object} [context] 侦听器的上下文(this关键字将指向的对象)。
        * @return {GroupLayer} 当前对象本身,可以链式调用
        */
+
     }, {
       key: "eachLayer",
       value: function eachLayer(method, context) {
         if (!this._layerArr) {
           return;
         }
+
         this._layerArr.forEach(function (layer) {
           method.call(context, layer);
         });
+
         return this;
       }
-
       /**
        * 设置透明度
-       * @param {Number} value 透明度
+       * @param {number} value 透明度
        * @return {void}  无
        */
+
     }, {
       key: "setOpacity",
       value: function setOpacity(value) {
         this.eachLayer(function (layer) {
           layer.style3D.fillForeColor.alpha = value;
         }, this);
-      }
+      } // 定位至数据区域
 
-      // 定位至数据区域
     }, {
       key: "flyTo",
       value: function flyTo() {
         var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
         if (this.options.center) {
           return this._map.setCameraView(this.options.center, options);
         } else if (this.options.extent) {
@@ -441,183 +496,195 @@
         }
       }
     }]);
+
     return S3MLayer;
   }(BaseLayer$1);
-  mars3d__namespace.layer.S3MLayer = S3MLayer;
+  mars3d__namespace.layer.S3MLayer = S3MLayer; // 注册下
 
-  // 注册下
   mars3d__namespace.LayerUtil.register("supermap_s3m", S3MLayer);
 
   var Cesium$1 = mars3d__namespace.Cesium;
   var BaseTileLayer = mars3d__namespace.layer.BaseTileLayer;
-
   /**
    * 超图影像瓦片服务图层,
    * 【需要引入  mars3d-supermap 插件库】
    *
-   * @param {Object} [options] 参数对象，包括以下：
-   * @param {String} options.url supermap的影像服务地址
-   * @param {String|String[]} [options.subdomains] URL模板中用于 {s} 占位符的子域。 如果此参数是单个字符串，则字符串中的每个字符都是一个子域。如果是 一个数组，数组中的每个元素都是一个子域。
-   * @param {String} [options.tileFormat] 影像图片格式，默认为png。
-   * @param {Boolean} [options.transparent=true] 设置请求的地图服务的参数是否为transparent。
-   * @param {String|Cesium.Color} [options.transparentBackColor] 设置影像透明色。
-   * @param {Number} [options.transparentBackColorTolerance] 去黑边,设置影像透明色容限，取值范围为0.0~1.0。0.0表示完全透明，1.0表示完全不透明。
-   * @param {String} [options.cacheKey] 影像的三维缓存密钥。
+   * @param {object} [options] 参数对象，包括以下：
+   * @param {string} options.url supermap的影像服务地址
+   * @param {string|string[]} [options.subdomains] URL模板中用于 {s} 占位符的子域。 如果此参数是单个字符串，则字符串中的每个字符都是一个子域。如果是 一个数组，数组中的每个元素都是一个子域。
+   * @param {string} [options.tileFormat] 影像图片格式，默认为png。
+   * @param {boolean} [options.transparent=true] 设置请求的地图服务的参数是否为transparent。
+   * @param {string|Cesium.Color} [options.transparentBackColor] 设置影像透明色。
+   * @param {number} [options.transparentBackColorTolerance] 去黑边,设置影像透明色容限，取值范围为0.0~1.0。0.0表示完全透明，1.0表示完全不透明。
+   * @param {string} [options.cacheKey] 影像的三维缓存密钥。
    *
-   * @param {Number} [options.minimumLevel=0] 瓦片所支持的最低层级，如果数据没有第0层，该参数必须配置,当地图小于该级别时，平台不去请求服务数据。
-   * @param {Number} [options.maximumLevel] 瓦片所支持的最大层级,大于该层级时会显示上一层拉伸后的瓦片，当地图大于该级别时，平台不去请求服务数据。
-   * @param {Number} [options.minimumTerrainLevel] 展示影像图层的最小地形细节级别，小于该级别时，平台不显示影像数据。
-   * @param {Number} [options.maximumTerrainLevel] 展示影像图层的最大地形细节级别，大于该级别时，平台不显示影像数据。
-   * @param {Object} [options.rectangle] 瓦片数据的矩形区域范围
-   * @param {Number} options.rectangle.xmin 最小经度值, -180 至 180
-   * @param {Number} options.rectangle.xmax 最大经度值, -180 至 180
-   * @param {Number} options.rectangle.ymin 最小纬度值, -90 至 90
-   * @param {Number} options.rectangle.ymax 最大纬度值, -90 至 90
-   * @param {Number[]} [options.bbox] bbox规范的瓦片数据的矩形区域范围,与rectangle二选一即可。
-   * @param {Number} [options.zIndex] 控制图层的叠加层次，默认按加载的顺序进行叠加，但也可以自定义叠加顺序，数字大的在上面(只对同类型图层间有效)。
+   * @param {number} [options.minimumLevel=0] 瓦片所支持的最低层级，如果数据没有第0层，该参数必须配置,当地图小于该级别时，平台不去请求服务数据。
+   * @param {number} [options.maximumLevel] 瓦片所支持的最大层级,大于该层级时会显示上一层拉伸后的瓦片，当地图大于该级别时，平台不去请求服务数据。
+   * @param {number} [options.minimumTerrainLevel] 展示影像图层的最小地形细节级别，小于该级别时，平台不显示影像数据。
+   * @param {number} [options.maximumTerrainLevel] 展示影像图层的最大地形细节级别，大于该级别时，平台不显示影像数据。
+   * @param {object} [options.rectangle] 瓦片数据的矩形区域范围
+   * @param {number} options.rectangle.xmin 最小经度值, -180 至 180
+   * @param {number} options.rectangle.xmax 最大经度值, -180 至 180
+   * @param {number} options.rectangle.ymin 最小纬度值, -90 至 90
+   * @param {number} options.rectangle.ymax 最大纬度值, -90 至 90
+   * @param {number[]} [options.bbox] bbox规范的瓦片数据的矩形区域范围,与rectangle二选一即可。
+   * @param {number} [options.zIndex] 控制图层的叠加层次，默认按加载的顺序进行叠加，但也可以自定义叠加顺序，数字大的在上面(只对同类型图层间有效)。
    * @param {CRS} [options.crs=CRS.EPSG:3857] 瓦片数据的坐标系信息，默认为墨卡托投影
    * @param {ChinaCRS} [options.chinaCRS] 标识瓦片的国内坐标系（用于自动纠偏或加偏），自动将瓦片转为map对应的chinaCRS类型坐标系。
    *
-   * @param {String} [options.proxy] 加载资源时要使用的代理服务url。
-   * @param {Object} [options.templateValues] 一个对象，用于替换Url中的模板值的键/值对
-   * @param {Object} [options.queryParameters] 一个对象，其中包含在检索资源时将发送的查询参数。比如：queryParameters: {'access_token': '123-435-456-000'},
-   * @param {Object} [options.headers] 一个对象，将发送的其他HTTP标头。比如：headers: { 'X-My-Header': 'valueOfHeader' },
-   * @param {Boolean} [options.enablePickFeatures=true] 如果为true，则 {@link UrlTemplateImageryProvider#pickFeatures} 请求 pickFeaturesUrl 并尝试解释响应中包含的功能。
+   * @param {string} [options.proxy] 加载资源时要使用的代理服务url。
+   * @param {object} [options.templateValues] 一个对象，用于替换Url中的模板值的键/值对
+   * @param {object} [options.queryParameters] 一个对象，其中包含在检索资源时将发送的查询参数。比如：queryParameters: {'access_token': '123-435-456-000'},
+   * @param {object} [options.headers] 一个对象，将发送的其他HTTP标头。比如：headers: { 'X-My-Header': 'valueOfHeader' },
+   * @param {boolean} [options.enablePickFeatures=true] 如果为true，则 {@link UrlTemplateImageryProvider#pickFeatures} 请求 pickFeaturesUrl 并尝试解释响应中包含的功能。
    *        如果为 false{@link UrlTemplateImageryProvider#pickFeatures} 会立即返回未定义（表示没有可拾取的内容） 功能）而无需与服务器通信。如果您知道数据，则将此属性设置为false 源不支持选择功能，或者您不希望该提供程序的功能可供选择。注意 可以通过修改 {@link UriTemplateImageryProvider#enablePickFeatures}来动态覆盖 属性。
    * @param {Cesium.GetFeatureInfoFormat[]} [options.getFeatureInfoFormats] 在某处获取功能信息的格式 调用 {@link UrlTemplateImageryProvider#pickFeatures} 的特定位置。如果这 参数未指定，功能选择已禁用。
    *
-   * @param {Number} [options.opacity = 1.0] 透明度，取值范围：0.0-1.0。
-   * @param {Number|Function} [options.alpha=1.0] 同opacity。
-   * @param {Number|Function} [options.nightAlpha=1.0] 当 enableLighting 为 true 时 ，在地球的夜晚区域的透明度，取值范围：0.0-1.0。
-   * @param {Number|Function} [options.dayAlpha=1.0]  当 enableLighting 为 true 时，在地球的白天区域的透明度，取值范围：0.0-1.0。
-   * @param {Number|Function} [options.brightness=1.0] 亮度
-   * @param {Number|Function} [options.contrast=1.0] 对比度。 1.0使用未修改的图像颜色，小于1.0会降低对比度，而大于1.0则会提高对比度。
-   * @param {Number|Function} [options.hue=0.0] 色调。 0.0 时未修改的图像颜色。
-   * @param {Number|Function} [options.saturation=1.0] 饱和度。 1.0使用未修改的图像颜色，小于1.0会降低饱和度，而大于1.0则会增加饱和度。
-   * @param {Number|Function} [options.gamma=1.0] 伽马校正值。 1.0使用未修改的图像颜色。
-   * @param {Number} [options.maximumAnisotropy=maximum supported] 使用的最大各向异性水平 用于纹理过滤。如果未指定此参数，则支持最大各向异性 将使用WebGL堆栈。较大的值可使影像在水平方向上看起来更好 视图。
+   * @param {number} [options.opacity = 1.0] 透明度，取值范围：0.0-1.0。
+   * @param {number|Function} [options.alpha=1.0] 同opacity。
+   * @param {number|Function} [options.nightAlpha=1.0] 当 enableLighting 为 true 时 ，在地球的夜晚区域的透明度，取值范围：0.0-1.0。
+   * @param {number|Function} [options.dayAlpha=1.0]  当 enableLighting 为 true 时，在地球的白天区域的透明度，取值范围：0.0-1.0。
+   * @param {number|Function} [options.brightness=1.0] 亮度
+   * @param {number|Function} [options.contrast=1.0] 对比度。 1.0使用未修改的图像颜色，小于1.0会降低对比度，而大于1.0则会提高对比度。
+   * @param {number|Function} [options.hue=0.0] 色调。 0.0 时未修改的图像颜色。
+   * @param {number|Function} [options.saturation=1.0] 饱和度。 1.0使用未修改的图像颜色，小于1.0会降低饱和度，而大于1.0则会增加饱和度。
+   * @param {number|Function} [options.gamma=1.0] 伽马校正值。 1.0使用未修改的图像颜色。
+   * @param {number} [options.maximumAnisotropy=maximum supported] 使用的最大各向异性水平 用于纹理过滤。如果未指定此参数，则支持最大各向异性 将使用WebGL堆栈。较大的值可使影像在水平方向上看起来更好 视图。
    * @param {Cesium.Rectangle} [options.cutoutRectangle] 制图矩形，用于裁剪此ImageryLayer的一部分。
    * @param {Cesium.Color} [options.colorToAlpha]  用作Alpha的颜色。
-   * @param {Number} [options.colorToAlphaThreshold=0.004] 颜色到Alpha的阈值。
-   * @param {Boolean} [options.hasAlphaChannel=true] 如果此图像提供者提供的图像为真 包括一个Alpha通道；否则为假。如果此属性为false，则为Alpha通道，如果 目前，将被忽略。如果此属性为true，则任何没有Alpha通道的图像都将 它们的alpha随处可见。当此属性为false时，内存使用情况 和纹理上传时间可能会减少。
-   * @param {Number} [options.tileWidth=256] 图像图块的像素宽度。
-   * @param {Number} [options.tileHeight=256] 图像图块的像素高度。
-   * @param {Object} [options.customTags] 允许替换网址模板中的自定义关键字。该对象必须具有字符串作为键，并且必须具有值。
+   * @param {number} [options.colorToAlphaThreshold=0.004] 颜色到Alpha的阈值。
+   * @param {boolean} [options.hasAlphaChannel=true] 如果此图像提供者提供的图像为真 包括一个Alpha通道；否则为假。如果此属性为false，则为Alpha通道，如果 目前，将被忽略。如果此属性为true，则任何没有Alpha通道的图像都将 它们的alpha随处可见。当此属性为false时，内存使用情况 和纹理上传时间可能会减少。
+   * @param {number} [options.tileWidth=256] 图像图块的像素宽度。
+   * @param {number} [options.tileHeight=256] 图像图块的像素高度。
+   * @param {object} [options.customTags] 允许替换网址模板中的自定义关键字。该对象必须具有字符串作为键，并且必须具有值。
    *
-   * @param {String|Number} [options.id = createGuid()] 图层id标识
-   * @param {String|Number} [options.pid = -1] 图层父级的id，一般图层管理中使用
-   * @param {String} [options.name = ''] 图层名称
-   * @param {Boolean} [options.show = true] 图层是否显示
-   * @param {BaseClass|Boolean} [options.eventParent]  指定的事件冒泡对象，默认为map对象，false时不冒泡
-   * @param {Object} [options.center] 图层自定义定位视角 {@link Map#setCameraView}
-   * @param {Number} options.center.lng 经度值, 180 - 180
-   * @param {Number} options.center.lat 纬度值, -90 - 90
-   * @param {Number} [options.center.alt] 高度值
-   * @param {Number} [options.center.heading] 方向角度值，绕垂直于地心的轴旋转角度, 0至360
-   * @param {Number} [options.center.pitch] 俯仰角度值，绕纬度线旋转角度, -90至90
-   * @param {Number} [options.center.roll] 翻滚角度值，绕经度线旋转角度, -90至90
-   * @param {Boolean} [options.flyTo] 加载完成数据后是否自动飞行定位到数据所在的区域。
+   * @param {string|number} [options.id = createGuid()] 图层id标识
+   * @param {string|number} [options.pid = -1] 图层父级的id，一般图层管理中使用
+   * @param {string} [options.name = ''] 图层名称
+   * @param {boolean} [options.show = true] 图层是否显示
+   * @param {BaseClass|boolean} [options.eventParent]  指定的事件冒泡对象，默认为map对象，false时不冒泡
+   * @param {object} [options.center] 图层自定义定位视角 {@link Map#setCameraView}
+   * @param {number} options.center.lng 经度值, 180 - 180
+   * @param {number} options.center.lat 纬度值, -90 - 90
+   * @param {number} [options.center.alt] 高度值
+   * @param {number} [options.center.heading] 方向角度值，绕垂直于地心的轴旋转角度, 0至360
+   * @param {number} [options.center.pitch] 俯仰角度值，绕纬度线旋转角度, -90至90
+   * @param {number} [options.center.roll] 翻滚角度值，绕经度线旋转角度, -90至90
+   * @param {boolean} [options.flyTo] 加载完成数据后是否自动飞行定位到数据所在的区域。
    * @export
    * @class SmImgLayer
    * @extends {BaseTileLayer}
    *
    * @see http://support.supermap.com.cn:8090/webgl/docs/Documentation/SuperMapImageryProvider.html?classFilter=SuperMapImageryProvider
    */
+
   var SmImgLayer = /*#__PURE__*/function (_BaseTileLayer) {
     _inherits(SmImgLayer, _BaseTileLayer);
+
     var _super = _createSuper(SmImgLayer);
+
     function SmImgLayer() {
       _classCallCheck(this, SmImgLayer);
+
       return _super.apply(this, arguments);
     }
+
     _createClass(SmImgLayer, [{
       key: "_createImageryProvider",
-      value:
-      // 构建ImageryProvider
+      value: // 构建ImageryProvider
       function _createImageryProvider(options) {
         return createImageryProvider(options);
-      }
+      } // 添加时
 
-      // 添加时
     }, {
       key: "_addedHook",
       value: function _addedHook() {
         _get(_getPrototypeOf(SmImgLayer.prototype), "_addedHook", this).call(this);
+
         if (Cesium$1.defined(this.options.transparentBackColor)) {
           this._imageryLayer.transparentBackColor = mars3d__namespace.Util.getCesiumColor(this.options.transparentBackColor);
           this._imageryLayer.transparentBackColorTolerance = this.options.transparentBackColorTolerance; // 去黑边
         }
       }
     }]);
+
     return SmImgLayer;
   }(BaseTileLayer);
+
   function createImageryProvider(options) {
     options = mars3d__namespace.LayerUtil.converOptions(options);
+
     if (options.url instanceof Cesium$1.Resource) {
       options.url = options.url.url;
     }
+
     if (Cesium$1.defined(options.transparentBackColor)) {
       delete options.transparentBackColor;
       delete options.transparentBackColorTolerance;
     }
+
     return new Cesium$1.SuperMapImageryProvider(options);
   }
-
   /**
    * 创建用于图层的 ImageryProvider对象
    *
-   * @param {Object} options Provider参数，同图层构造参数。
+   * @param {object} options Provider参数，同图层构造参数。
    * @return {Cesium.ImageryProvider} ImageryProvider类
    * @function
    */
+
+
   SmImgLayer.createImageryProvider = createImageryProvider;
-  mars3d__namespace.layer.SmImgLayer = SmImgLayer;
+  mars3d__namespace.layer.SmImgLayer = SmImgLayer; // 注册下
 
-  // 注册下
   var layerType = "supermap_img";
   mars3d__namespace.LayerUtil.register(layerType, SmImgLayer);
   mars3d__namespace.LayerUtil.registerImageryProvider(layerType, createImageryProvider);
 
   var Cesium = mars3d__namespace.Cesium;
   var BaseLayer = mars3d__namespace.layer.BaseLayer;
-
   /**
    * 超图MVT矢量瓦片图层,
    * 【需要引入  mars3d-supermap 插件库】
    *
-   * @param {Object} [options] 参数对象，包括以下：
-   * @param {String} options.url 适用于通过SuperMap桌面软件生成mvt数据,经iServer发布为rest风格的地图服务，只需提供服务地址。
-   * @param {String} options.layer 图层名称,适用于第三方发布的WMTS服务。
-   * @param {Number} [options.canvasWidth] 用来绘制矢量的纹理边长。默认是512，越大越精细，越小性能越高。
-   * @param {String} [options.format='mvt'] 适用于第三方发布的WMTS服务。
-   * @param {Object} [options.mapboxStyle] 使用的mapBox风格。
-   * @param {Object} [options.多个参数] 参考[supermap官方API]{@link http://support.supermap.com.cn:8090/webgl/docs/Documentation/Scene.html#addVectorTilesLayer}
+   * @param {object} [options] 参数对象，包括以下：
+   * @param {string} options.url 适用于通过SuperMap桌面软件生成mvt数据,经iServer发布为rest风格的地图服务，只需提供服务地址。
+   * @param {string} options.layer 图层名称,适用于第三方发布的WMTS服务。
+   * @param {number} [options.canvasWidth] 用来绘制矢量的纹理边长。默认是512，越大越精细，越小性能越高。
+   * @param {string} [options.format='mvt'] 适用于第三方发布的WMTS服务。
+   * @param {object} [options.mapboxStyle] 使用的mapBox风格。
+   * @param {object} [options.多个参数] 参考[supermap官方API]{@link http://support.supermap.com.cn:8090/webgl/docs/Documentation/Scene.html#addVectorTilesLayer}
    *
    *
-   * @param {String|Number} [options.id = createGuid()] 图层id标识
-   * @param {String|Number} [options.pid = -1] 图层父级的id，一般图层管理中使用
-   * @param {String} [options.name = ''] 图层名称
-   * @param {Boolean} [options.show = true] 图层是否显示
-   * @param {BaseClass|Boolean} [options.eventParent]  指定的事件冒泡对象，默认为map对象，false时不冒泡
-   * @param {Object} [options.center] 图层自定义定位视角 {@link Map#setCameraView}
-   * @param {Number} options.center.lng 经度值, 180 - 180
-   * @param {Number} options.center.lat 纬度值, -90 - 90
-   * @param {Number} [options.center.alt] 高度值
-   * @param {Number} [options.center.heading] 方向角度值，绕垂直于地心的轴旋转角度, 0至360
-   * @param {Number} [options.center.pitch] 俯仰角度值，绕纬度线旋转角度, -90至90
-   * @param {Number} [options.center.roll] 翻滚角度值，绕经度线旋转角度, -90至90
-   * @param {Boolean} [options.flyTo] 加载完成数据后是否自动飞行定位到数据所在的区域。
+   * @param {string|number} [options.id = createGuid()] 图层id标识
+   * @param {string|number} [options.pid = -1] 图层父级的id，一般图层管理中使用
+   * @param {string} [options.name = ''] 图层名称
+   * @param {boolean} [options.show = true] 图层是否显示
+   * @param {BaseClass|boolean} [options.eventParent]  指定的事件冒泡对象，默认为map对象，false时不冒泡
+   * @param {object} [options.center] 图层自定义定位视角 {@link Map#setCameraView}
+   * @param {number} options.center.lng 经度值, 180 - 180
+   * @param {number} options.center.lat 纬度值, -90 - 90
+   * @param {number} [options.center.alt] 高度值
+   * @param {number} [options.center.heading] 方向角度值，绕垂直于地心的轴旋转角度, 0至360
+   * @param {number} [options.center.pitch] 俯仰角度值，绕纬度线旋转角度, -90至90
+   * @param {number} [options.center.roll] 翻滚角度值，绕经度线旋转角度, -90至90
+   * @param {boolean} [options.flyTo] 加载完成数据后是否自动飞行定位到数据所在的区域。
    * @export
    * @class SmMvtLayer
    * @extends {BaseLayer}
    */
+
   var SmMvtLayer = /*#__PURE__*/function (_BaseLayer) {
     _inherits(SmMvtLayer, _BaseLayer);
+
     var _super = _createSuper(SmMvtLayer);
+
     function SmMvtLayer() {
       _classCallCheck(this, SmMvtLayer);
+
       return _super.apply(this, arguments);
     }
+
     _createClass(SmMvtLayer, [{
       key: "layer",
       get:
@@ -630,78 +697,81 @@
       function get() {
         return this._mvtLayer;
       }
-
       /**
        * 对象添加到地图前创建一些对象的钩子方法，
        * 只会调用一次
        * @return {void}  无
        * @private
        */
+
     }, {
       key: "_mountedHook",
       value: function _mountedHook() {
         var _this = this;
+
         // options参考API文档：http://support.supermap.com.cn:8090/webgl/docs/Documentation/Scene.html
         this._mvtLayer = this._map.scene.addVectorTilesMap(_objectSpread2({
           viewer: this._map.viewer,
           canvasWidth: 512
         }, this.options));
-        this._mvtLayer.readyPromise.then(function (data) {
-          // setPaintProperty(layerId, name, value, options)
+
+        this._mvtLayer.readyPromise.then(function (data) {// setPaintProperty(layerId, name, value, options)
           // for(var layerId in that.options.style){
           //     that._mvtLayer.setPaintProperty(layerId, "fill-color", "rgba(255,0,0,0.8)");
           // }
         });
+
         var scene = this._map.scene;
         var handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
         handler.setInputAction(function (event) {
           if (!_this.show) {
             return;
           }
-          var position = mars3d__namespace.PointUtil.getCurrentMousePosition(scene, event.position);
 
-          // 查询出相交图层的feature
-          var features = _this._mvtLayer.queryRenderedFeatures([position], {
-            // layers: [selectLayer.id]
-          });
+          var position = mars3d__namespace.PointUtil.getCurrentMousePosition(scene, event.position); // 查询出相交图层的feature
+
+          var features = _this._mvtLayer.queryRenderedFeatures([position], {// layers: [selectLayer.id]
+          }); // eslint-disable-next-line array-callback-return
+
 
-          // eslint-disable-next-line array-callback-return
           features.reduce(function (memo, result) {
             var attr = result.feature.properties;
+
             if (!attr) {
               // eslint-disable-next-line array-callback-return
               return;
             }
+
             var content = mars3d__namespace.Util.getPopupForConfig(_this.options, attr);
             var item = {
               data: attr,
               event: event
             };
+
             _this._map.openPopup(position, content, item);
           });
         }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
         this.handler = handler;
       }
-
       /**
        * 对象添加到地图上的创建钩子方法，
        * 每次add时都会调用
        * @return {void}  无
        * @private
        */
+
     }, {
       key: "_addedHook",
       value: function _addedHook() {
-        this._mvtLayer.show = true;
-        // this._mvtLayer.refresh();
+        this._mvtLayer.show = true; // this._mvtLayer.refresh();
       }
-
       /**
        * 对象从地图上移除的创建钩子方法，
        * 每次remove时都会调用
        * @return {void}  无
        * @private
        */
+
     }, {
       key: "_removedHook",
       value: function _removedHook() {
@@ -709,25 +779,25 @@
           this._mvtLayer.show = false;
         }
       }
-
       /**
        * 设置透明度
-       * @param {Number} value 透明度
+       * @param {number} value 透明度
        * @return {void}  无
        */
+
     }, {
       key: "setOpacity",
       value: function setOpacity(value) {
         if (this._mvtLayer) {
           this._mvtLayer.alpha = parseFloat(value);
         }
-      }
+      } // 定位至数据区域
 
-      // 定位至数据区域
     }, {
       key: "flyTo",
       value: function flyTo() {
         var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
         if (this.options.center) {
           return this._map.setCameraView(this.options.center, options);
         } else if (this.options.extent) {
@@ -737,14 +807,15 @@
             destination: this._mvtLayer.rectangle
           }));
         }
+
         return Promise.resolve(false);
       }
     }]);
+
     return SmMvtLayer;
   }(BaseLayer);
-  mars3d__namespace.layer.SmMvtLayer = SmMvtLayer;
+  mars3d__namespace.layer.SmMvtLayer = SmMvtLayer; // 注册下
 
-  // 注册下
   mars3d__namespace.LayerUtil.register("supermap_mvt", SmMvtLayer);
 
   exports.S3MLayer = S3MLayer;

package/package.json

@@ -1,14 +1,14 @@
 {
 	"name": "mars3d-supermap",
-	"version": "3.4.26",
+	"version": "3.5.0",
 	"description": "Mars3D平台插件,结合supermap超图库使用的功能插件",
 	"main": "dist/mars3d-supermap.js",
 	"files": [
 		"dist"
 	],
-	"dependencies": {},
+	"peerDependencies": {},
 	"devDependencies": {
-		"mars3d": "~3.4.26"
+		"mars3d": "~3.5.0"
 	},
 	"scripts": {
 		"lint": "eslint ./src/**/*.{js,ts} --fix"