npm - @mapgis/webclient-mapboxgl-plugin - Versions diffs - 17.0.6 → 17.2.0 - Mend

@mapgis/webclient-mapboxgl-plugin 17.0.6 → 17.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/README.md +11 -35
package/dist/es5/webclient-common.min.js +15 -4
package/dist/es5/webclient-mapboxgl-plugin.min.js +1 -1
package/dist/webclient-mapboxgl-plugin-es6.min.js +1 -1
package/documention/MapViewMapboxgl.html +1233 -8
package/documention/Popup.html +3 -3
package/documention/Screenshot.html +0 -11
package/documention/SketchEditorMapboxgl.html +31 -2
package/documention/index.html +4 -4
package/documention/scripts/sideBar.js +16 -2
package/package.json +3 -4
package/documention/document_ArcGISVectorTileLayerView.js.html +0 -265
package/documention/document_EchartsLayerView.js.html +0 -246
package/documention/document_GraphicsLayerView.js.html +0 -314
package/documention/document_IGSFeatureLayerView.js.html +0 -218
package/documention/document_IGSMapImageLayerView.js.html +0 -240
package/documention/document_IGSTileLayerView.js.html +0 -236
package/documention/document_IGSVectorTileLayerView.js.html +0 -264
package/documention/document_MapVLayerView.js.html +0 -247
package/documention/document_WMSLayerView.js.html +0 -240
package/documention/document_WMTSLayerView.js.html +0 -234
package/documention/document_WebTileLayerView.js.html +0 -240
package/documention/document_support_FeatureRenderView.js.html +0 -682
package/documention/document_support_MapboxglGraphicsLayer.js.html +0 -1184
package/documention/document_support_SourceMetaData.js.html +0 -223
package/documention/document_support_Utils.js.html +0 -624
package/documention/document_support_mapbox_mapboxCustomUtil.js.html +0 -322
package/documention/sketchEditor_SketchEditorMapboxgl.js.html +0 -875
package/documention/util_ConvertRendererToStyleLayerUtil.js.html +0 -844
package/documention/util_MapboxglFeatureRender.js.html +0 -225
package/documention/util_MapboxglPlugin.js.html +0 -284
package/documention/view_MapViewMapboxgl.js.html +0 -1882
package/documention/view_utils_ArcGISVectorTileLayerUtil.js.html +0 -382
package/documention/view_utils_EchartsLayerUtil.js.html +0 -194
package/documention/view_utils_IGSMapImageUtil.js.html +0 -373
package/documention/view_utils_IGSTileLayerUtil.js.html +0 -285
package/documention/view_utils_IGSVectorTileLayerUtil.js.html +0 -379
package/documention/view_utils_MapVLayerUtil.js.html +0 -197
package/documention/view_utils_Popup.js.html +0 -525
package/documention/view_utils_Screenshot.js.html +0 -320
package/documention/view_utils_WMSLayerUtil.js.html +0 -337
package/documention/view_utils_WMTSLayerUtil.js.html +0 -331
package/documention/view_utils_WebTileLayerUtil.js.html +0 -284
package/documention/view_utils_echarts_EchartsLayerPlugin.js.html +0 -419
package/documention/view_utils_mapV_MapVLayerPlugin.js.html +0 -527
package/documention/view_utils_mapV_MapvBaseLayer.js.html +0 -477
package/documention/view_utils_support_rasterLayerUtil.js.html +0 -244
package/documention/view_utils_support_vectorLayerUtil.js.html +0 -503

package/documention/view_MapViewMapboxgl.js.html DELETED Viewed

@@ -1,1882 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Client for JavaScript view/MapViewMapboxgl.js</title>
-  <!--[if lt IE 9]>
-    <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
-  <![endif]-->
-  <link type="text/css" rel="stylesheet" href="styles/app.min.css">
-  <link type="text/css" rel="stylesheet" href="styles/iframe.css">
-  <link type="text/css" rel="stylesheet" href="">
-</head>
-<body class="layout small-header">
-    <div id="stickyNavbarOverlay"></div>
-<div class="top-nav">
-    <div class="inner">
-        <a id="hamburger" role="button" class="navbar-burger" aria-label="menu" aria-expanded="false">
-            <span aria-hidden="true"></span>
-            <span aria-hidden="true"></span>
-            <span aria-hidden="true"></span>
-        </a>
-        <div class="logo">
-                <h1> MapGIS Client for JavaScript API</h1>
-        </div>
-        <div class="menu">
-            <div class="navigation">
-                        <a
-                            class="link user-link "
-                            href="/static/modules/common/api/common-mapgis/index.html"
-                        >
-                            Common
-                        </a>
-                        <a
-                            class="link user-link "
-                            href="/static/modules/cesium/api/cesium-mapgis/index.html"
-                        >
-                            Cesium
-                        </a>
-                        <a
-                            class="link user-link "
-                            href="/static/modules/mapboxgl/api/mapboxgl-mapgis/index.html"
-                        >
-                            MapboxGL
-                        </a>
-                        <a
-                            class="link user-link "
-                            href="/static/modules/leaflet/api/leaflet-mapgis/index.html"
-                        >
-                            Leaflet
-                        </a>
-                        <a
-                            class="link user-link "
-                            href="/static/modules/openlayers/api/openLayers-mapgis/index.html"
-                        >
-                            OpenLayers
-                        </a>
-            </div>
-        </div>
-    </div>
-</div>
-    <div id="main">
-        <div
-            class="sidebar "
-            id="sidebarNav"
-        >
-            <div>
-                <span class="mapgis-api-document-span"><a href="index.html">API文档</a></span>
-            </div>
-                <div class="search-wrapper">
-                    <input id="search" type="text" placeholder="搜索文档..." class="input">
-                </div>
-            <nav>
-                    <div class="category"><div style="font-weight: bold;vertical-align: middle;padding: 0.4rem 0;" class="mapgis-menu-span"><img style="width: 20px;margin-right: 6px;vertical-align: middle;" src="./styles/m.png" alt="">undefined</div><ul class="mapgis-sidebar-menus"><li><img style="width: 20px;margin-right: 6px;vertical-align: middle;" src="./styles/c.png" alt=""><a href="Popup.html">Popup</a><span style="display: none;"><p>二维场景信息弹窗(leaflet引擎)
-参考示例：
-<a href='#MapView'>[初始化二维场景视图]</a>
-[ES6引入方式]：<br/>
-import { Popup } from '@mapgis/webclient-leaflet-plugin' <br/>
-自定义样式说明：<br/>
-zondy-popup__content 弹窗容器样式<br/>
-zondy-popup__tip 弹窗对话框箭头样式<br/>
-zondy-popup__header 弹窗头部样式<br/>
-zondy-popup__content 弹窗主体样式<br/>
-zondy-popup__footer 弹窗底部样式<br/></p></span></li></ul><div style="font-weight: bold;vertical-align: middle;padding: 0.4rem 0;" class="mapgis-menu-span"><img style="width: 20px;margin-right: 6px;vertical-align: middle;" src="./styles/m.png" alt="">undefined</div><ul class="mapgis-sidebar-menus"><li><img style="width: 20px;margin-right: 6px;vertical-align: middle;" src="./styles/c.png" alt=""><a href="Screenshot.html">Screenshot</a><span style="display: none;"><p>打印工具</p></span></li></ul><div style="font-weight: bold;vertical-align: middle;padding: 0.4rem 0;" class="mapgis-menu-span"><img style="width: 20px;margin-right: 6px;vertical-align: middle;" src="./styles/m.png" alt="">草图编辑模块</div><ul class="mapgis-sidebar-menus"><li><img style="width: 20px;margin-right: 6px;vertical-align: middle;" src="./styles/c.png" alt=""><a href="SketchEditorMapboxgl.html">SketchEditorMapboxgl</a><span style="display: none;"><p>二维场景草图编辑类<br/>
-<br>[ES5引入方式]：<br/>
-const { SketchEditorMapboxgl } = Zondy <br/>
-[ES6引入方式]：<br/>
-import { SketchEditorMapboxgl } from &quot;@mapgis/webclient-leaflet-plugin&quot; <br/></p></span></li></ul></div>
-            </nav>
-        </div>
-        <div class="core" id="main-content-wrapper">
-            <div class="content">
-                <header id="page-title" class="page-title">
-                    <span class="page-title-main">类名</span>
-                    <span class="page-title-sub">view/MapViewMapboxgl.js</span>
-                </header>
-    <section>
-        <article>
-            <pre class="prettyprint source linenums"><code>import {
-  Zondy,
-  defaultValue,
-  MapView,
-  Point,
-  Extent,
-  SpatialReference,
-  ViewEventType,
-  LayerType,
-  Projection,
-  Geometry,
-  isNull,
-  proj4,
-  TileInfoUtil,
-  toJSON,
-  Map,
-  getGUID
-} from '@mapgis/webclient-common'
-import mapboxgl from '@mapgis/mapbox-gl'
-import { getLayerView } from '../document/index'
-import MapViewUtil from './utils/MapViewUtil'
-import Popup from './utils/Popup'
-import Screenshot from './utils/Screenshot'
-import { mapboxCustomCRS } from '../document/support/mapbox/mapboxCustomUtil'
-class MapViewMapboxgl extends MapView {
-  constructor(options) {
-    super(options)
-    options = defaultValue(options, {})
-    this._options = options
-    /**
-     * 地图视图中心点
-     * @member {Point} MapView.prototype.center
-     */
-    // 统一center的类型
-    this._center = defaultValue(options.center, undefined)
-    if (
-      this._center &amp;&amp;
-      Array.isArray(this._center) &amp;&amp;
-      this._center.length > 1
-    ) {
-      this._center = new Point({
-        coordinates: [this._center[0], this._center[1]]
-      })
-    }
-    /**
-     * 地图视图可视范围
-     * @member {Extent} MapView.prototype.extent
-     */
-    this._extent = defaultValue(options.extent, undefined)
-    /**
-     * 地图视图宽度
-     * @readonly
-     * @member {Number} MapView.prototype.width
-     */
-    this.width = undefined
-    /**
-     * 地图视图高度
-     * @readonly
-     * @member {Number} MapView.prototype.height
-     */
-    this.height = undefined
-    /**
-     * 地图层级
-     * @member {Number} MapView.prototype.zoom
-     */
-    this._zoom = defaultValue(options.zoom, 0)
-    /**
-     * 地图视图比例尺
-     * @member {Number} MapView.prototype.scale
-     */
-    this._scale = defaultValue(options.scale, undefined)
-    /**
-     * 地图视图最大比例尺
-     * @member {Number} MapView.prototype.maxScale
-     */
-    this.maxScale = defaultValue(options.maxScale, undefined)
-    /**
-     * 地图视图最小比例尺
-     * @member {Number} MapView.prototype.minScale
-     */
-    this.minScale = defaultValue(options.minScale, undefined)
-    /**
-     * 地图弹框popup
-     * @member {Popup} MapView.prototype.popup
-     */
-    this.popup = defaultValue(options.popup, undefined)
-    /**
-     * 视图空间参考系
-     * @readonly
-     * @member {SpatialReference} MapView.prototype._spatialReference
-     */
-    this._spatialReference = undefined
-    this._referenceLayer = undefined
-    this.crs = undefined
-    /**
-     * 是否锁定视图空间参考系
-     * @member {Boolean} MapView.prototype.spatialReferenceLocked
-     */
-    this.spatialReferenceLocked = defaultValue(
-      options.spatialReferenceLocked,
-      false
-    )
-    /**
-     * 试图是否静止
-     * @member {Boolean} MapView.prototype.stationary
-     * @readonly
-     */
-    this.stationary = true
-    /**
-     * 初始化图层的额外参数，请参考MapBoxGl的API文档
-     * @member {Object} MapView.prototype.extendOptions
-     */
-    this.extendOptions = defaultValue(options.extendOptions, {})
-    /**
-     * 地图视图最大显示范围。用户不设置时，将地图范围作为地图视图的最大显示范围，用户设置时采用用户设置的。地图视图初始化时，会根据此范围计算地图视图的最小比例尺，当瓦片数据的最大比例尺小于此比例尺时，无法显示。在相同视图大小下，fullExtent越大，地图视图的最小比例尺越小。
-     * @readonly
-     * @member {Extent} MapView.prototype.fullExtent
-     */
-    /**
-     * 初始化MapBoxGl视图的额外参数，请参考MapBox官网的图层初始化参数
-     * @member {Object} MapView.prototype.extendOptions
-     */
-    this.extendOptions = defaultValue(options.extendOptions, {})
-    if (options.fullExtent) {
-      let fullExtent = Extent.fromJSON(options.fullExtent.toJSON())
-      if (!fullExtent.spatialReference.isGeographic) {
-        fullExtent = Projection.project(
-          fullExtent,
-          new SpatialReference({
-            wkid: 4326
-          })
-        )
-      }
-      // 初始化地图最大范围（4326坐标系）
-      this._initFullExtent = fullExtent
-    }
-    // 地图最大范围（4326坐标系）
-    this._fullExtent = this._initFullExtent
-    // 地图范围，4326坐标系
-    this._mapExtent = null
-  }
-  /**
-   * 初始化一个地图视图对象
-   * @param isFirst 是否是第一次构造视图
-   * @private
-   * */
-  _initView(isFirst, options) {
-    const self = this
-    mapboxgl.accessToken =
-      'pk.eyJ1IjoiemtidWQiLCJhIjoiY2w5OGF2NXIyMzQ5bjNub2luem85Y2Z4OCJ9.uX09XQPOX5E7sOohws2l_Q'
-    // 如果是初次构造视图（初次获取到crs），且未设置视图中心点，则取_fullExtent中心作为视图中心点
-    if (isFirst &amp;&amp; !this._center) {
-      if (this.fullExtent) {
-        this._center = this._fullExtent.center
-      }
-    }
-    // 根据fullExtent获取leaflet的maxBounds
-    const maxBounds = this._getMaxBounds()
-    // 初始化比例尺
-    if (!this._zoom &amp;&amp; this._scale) {
-      this._initScale(this._scale)
-    }
-    let fitBoundsOptions = undefined
-    if (!this._center &amp;&amp; !this._zoom) {
-      if (this._extent) {
-        fitBoundsOptions = [
-          [this._extent.xmin, this._extent.ymin],
-          [this._extent.xmax, this._extent.ymax]
-        ]
-      }
-    }
-    const viewOptions = {
-      // 经纬度一定要设置crs参数
-      crs: this.crs,
-      // MapBox的maxBounds需要优化
-      maxBounds,
-      // 地图容器div的id
-      container: this._viewId,
-      // 设置地图样式信息
-      style: {
-        version: 8,
-        sources: {},
-        layers: [
-          {
-            id: getGUID(),
-            type: 'background',
-            paint: {
-              'background-color': 'rgba(255, 255, 255,1)'
-            }
-          }
-        ]
-      },
-      zoom: this._zoom,
-      center: this._center.coordinates,
-      fitBoundsOptions,
-      preserveDrawingBuffer: true
-    }
-    // 初始化参数可被用户覆盖
-    Object.keys(this.extendOptions).forEach((key) => {
-      viewOptions[key] = Object.assign(
-        viewOptions[key],
-        this.extendOptions[key]
-      )
-    })
-    this._innerView = new mapboxgl.Map(viewOptions)
-    this.engineType = 'mapboxgl'
-    // 初始化视图事件
-    this._initViewEvent()
-    if (!this._center &amp;&amp; !this._zoom &amp;&amp; this._extent) {
-      this.flyTo({ extent: this._this._extent }, { animate: false })
-    }
-    // 获取视图大小
-    this._initSize()
-    // 初始化最大比例尺和最小比例尺
-    this._initScaleLimit()
-    // 初始化地图视图弹框，目前仅支持location方式打开弹框
-    this._initPopup()
-    // 设置鼠标样式
-    this._initCursor()
-    return new Promise((resolve) => {
-      if (self._innerView.loaded()) {
-        resolve(self)
-      } else {
-        self._innerView.once('load', () => {
-          resolve(self)
-        })
-      }
-    })
-  }
-  // 只定义内部变量this.minScale、this.maxScale
-  _initScaleLimit() {
-    // maxScale对应maxZoom，minScale对应minZoom
-    // 如果用户设置了minScale/maxScale，则地图将直接采用用户设置的值。如果用户未设置地图视图会根据全图范围，计算视图的最小比例尺。
-    if (this._options.minScale !== undefined) {
-      // 在mapView上设置了minScale：
-      // 如果minScale大于0，则设置引擎的minZoom为minScale对应的层级；
-      // 如果minScale小于等于0，则设置引擎minZoom为undefined，minScale置为零。
-      if (this.minScale > 0) {
-        const zoom = this._getZoomByScale(this.minScale)
-        if (zoom !== undefined) {
-          this._innerView.setMinZoom(zoom)
-        }
-      } else {
-        this.minScale = 0
-        this._innerView.setMinZoom(undefined)
-      }
-    } else {
-      // 用户未设置minScale：(地图视图会根据全图范围，计算视图的最小比例尺。)
-      // 如果引擎上的minZoom有值且是有限值，则minScale为全图范围对应的比例尺；
-      // 否则，minZoom也为undefined。
-      const minZoom = this._innerView.getMinZoom()
-      if (isFinite(minZoom)) {
-        this.minScale = this._getScaleByZoom(this.minZoom)
-      } else {
-        this.minScale = undefined
-      }
-    }
-    if (this._options.maxScale !== undefined) {
-      // 在mapView上设置了maxScale：
-      // 如果maxScale大于0，则设置引擎的maxZoom为maxScale对应的层级；
-      // 如果maxScale小于等于0，则设置引擎maxZoom为undefined，maxScale置为0。
-      // 初始option设置过maxScale
-      if (this.maxScale > 0) {
-        const zoom = this._getZoomByScale(this.maxScale)
-        if (zoom !== undefined) {
-          this._innerView.setMaxZoom(zoom)
-        }
-      } else if (this.maxScale &lt;= 0) {
-        this.maxScale = 0
-        this._innerView.setMaxZoom(undefined)
-      }
-    } else {
-      // mapView没有设置maxScale：
-      // 如果引擎上的maxZoom有值且是有限值，则maxScale为引擎视图最大层级对应的比例尺；
-      // 否则，maxZoom也为undefined。
-      // 处理超过lod层级时，导致部分图层投影转换出现非法值问题
-      let maxZoom = this._innerView.getMaxZoom()
-      const crs = this.crs || {}
-      const options = crs.options || {}
-      const lods = options.lods
-      if (lods &amp;&amp; Array.isArray(lods)) {
-        if (maxZoom >= lods.length - 1) {
-          maxZoom = lods.length - 1
-          this._innerView.setMaxZoom(maxZoom)
-        }
-      }
-      if (isFinite(maxZoom)) {
-        this.maxScale = this._getScaleByZoom(maxZoom)
-      } else {
-        this.maxScale = undefined
-      }
-    }
-    if (!this._scale || this._scale &lt;= 0) {
-      // 当_scale没有值或小于等于0，取最小比例尺的值
-      this._scale = this.minScale
-    } else if (this._scale > this.minScale) {
-      // 当_scale大于minScale，则超出比例尺范围限制，_scale置为最小比例尺的值
-      this._scale = this.minScale
-    } else if (this._scale &lt; this.maxScale) {
-      // 当_scale小于maxScale，则超出比例尺范围限制，_scale置为最大比例尺的值
-      this._scale = this.maxScale
-    }
-  }
-  // 构造crs对象
-  _createCrsObject(options) {
-    mapboxCustomCRS(mapboxgl, proj4)
-    if (
-      !options.spatialReference ||
-      !options.resolutions ||
-      !options.origin ||
-      !options.extent
-    ) {
-      return
-    }
-    let wkt
-    if (options.spatialReference.wkid) {
-      wkt = Projection.getEPSGByWKID(options.spatialReference.wkid).strProject
-    } else if (options.spatialReference.wkt) {
-      wkt = options.spatialReference.wkt
-    }
-    const extentBounds = [
-      options.extent.xmin,
-      options.extent.ymin,
-      options.extent.xmax,
-      options.extent.ymax
-    ]
-    const code = `EPSG:${options.spatialReference.wkid}`
-    const def = wkt
-    const crs = new mapboxgl.Proj.CRS(code, def, {
-      resolutions: options.resolutions,
-      origin: options.origin,
-      tileSize: options.tileSize,
-      bounds: extentBounds,
-      lods: options.lod
-    })
-    crs.options = options
-    return crs
-  }
-  _reCreateView() {
-    // 重置视图
-    if (this._innerView) {
-      // 停止视图动画
-      this._innerView._animatingZoom = false
-      // 销毁容器，此处会停止飞行动画、pan动画
-      this._innerView.remove()
-    }
-    return this._initView(true, this._options)
-  }
-  _isEqualBounds(bounds1, bounds2) {
-    let isEqual = true
-    if (
-      bounds1 &amp;&amp;
-      bounds2 &amp;&amp;
-      Array.isArray(bounds1) &amp;&amp;
-      Array.isArray(bounds2) &amp;&amp;
-      bounds1.length === bounds2.length
-    ) {
-      for (const i in bounds1) {
-        if (bounds1[i] !== bounds2[i]) {
-          isEqual = false
-          break
-        }
-      }
-    } else if (
-      (!bounds1 &amp;&amp; !bounds2) ||
-      (Array.isArray(bounds1) &amp;&amp;
-        bounds1.length === 0 &amp;&amp;
-        Array.isArray(bounds2) &amp;&amp;
-        bounds2.length === 0)
-    ) {
-      isEqual = true
-    } else {
-      isEqual = false
-    }
-    return isEqual
-  }
-  /**
-   * 初始化地图视图事件
-   * @private
-   * */
-  _initViewEvent() {
-    const self = this
-    // 定义一个变量存储单击触发事件
-    this._clickStore = null
-    // 定义一个变量存储拖拽事件参数
-    this._dragParams = { isDrag: false, origin: null, action: '', button: null }
-    // 地图视图加载完毕事件
-    self.fire(ViewEventType.loaded, {})
-    // leaflet注册点击事件
-    this._innerView.on('click', (event) => {
-      // 单击触发事件，300ms延迟
-      self._clickStore = setTimeout(function () {
-        // 发送左键单击点击事件
-        if (self._clickStore) {
-          self.fire(ViewEventType.click, MapViewUtil.getMouseEvent(event, self))
-        }
-      }, 300)
-      // 发送立即点击事件
-      self.fire(
-        ViewEventType.immediateClick,
-        MapViewUtil.getMouseEvent(event, self)
-      )
-    })
-    // 注册鼠标右键按下事件
-    this._innerView.on('contextmenu', (event) => {
-      // 单击触发事件，300ms延迟
-      self._clickStore = setTimeout(function () {
-        // 发送鼠标右键按下事件
-        if (self._clickStore) {
-          self.fire(ViewEventType.click, MapViewUtil.getMouseEvent(event, self))
-        }
-      }, 300)
-      // 发送立即点击事件
-      self.fire(
-        ViewEventType.immediateClick,
-        MapViewUtil.getMouseEvent(event, self)
-      )
-    })
-    // 注册双击事件
-    this._innerView.on('dblclick', (event) => {
-      // 单击事件清理
-      if (self._clickStore) {
-        clearTimeout(this._clickStore)
-        self._clickStore = null
-      }
-      // 发送双击事件
-      self.fire(
-        ViewEventType.doubleClick,
-        MapViewUtil.getMouseEvent(event, self)
-      )
-    })
-    // 注册鼠标按下事件
-    this._innerView.on('mousedown', (event) => {
-      // 发送鼠标按下事件
-      self.fire(
-        ViewEventType.pointerDown,
-        MapViewUtil.getMouseEvent(event, self)
-      )
-      // 发送鼠标拖拽开始事件
-      if (!this._dragParams.isDrag) {
-        this._dragParams.origin = {
-          x: event.originalEvent.layerX,
-          y: event.originalEvent.layerY
-        }
-        this._dragParams.button = event.originalEvent.button
-        this._dragParams.action = 'mouse-down'
-        this._dragParams.isDrag = false
-      }
-    })
-    // 注册鼠标抬起事件
-    this._innerView.on('mouseup', (event) => {
-      // 发送鼠标抬起事件
-      self.fire(ViewEventType.pointerUp, MapViewUtil.getMouseEvent(event, self))
-      // 发送鼠标拖拽结束事件
-      if (self._dragParams.isDrag &amp;&amp; this._dragParams.action === 'update') {
-        this._dragParams.action = 'end'
-        self.fire(
-          ViewEventType.drag,
-          MapViewUtil.getDragEvent(
-            event,
-            self,
-            self._dragParams.origin,
-            this._dragParams.action
-          )
-        )
-      }
-      self._dragParams = {
-        isDrag: false,
-        origin: null,
-        action: '',
-        button: null
-      }
-    })
-    // 注册鼠标移动事件
-    this._innerView.on('mousemove', (event) => {
-      // 发送鼠标移动视图事件
-      self.fire(
-        ViewEventType.pointerMove,
-        MapViewUtil.getMouseEvent(event, self)
-      )
-      // console.log('self._dragParams.isDrag', self._dragParams.isDrag)
-      // 发送鼠标拖拽中事件
-      if (self._dragParams.isDrag) {
-        self.fire(
-          ViewEventType.drag,
-          MapViewUtil.getDragEvent(
-            event,
-            self,
-            self._dragParams.origin,
-            self._dragParams.action,
-            self._dragParams.button
-          )
-        )
-        self._dragParams.action = 'update'
-      } else if (this._dragParams.action === 'mouse-down') {
-        this._dragParams.action = 'start'
-        self._dragParams.isDrag = true
-      }
-    })
-    // 注册键盘按下事件
-    this._innerView.on('dragstart', (event) => {
-      // 发送鼠标拖拽开始事件
-      this._dragParams.origin = {
-        x: event.originalEvent.layerX,
-        y: event.originalEvent.layerY
-      }
-      this._dragParams.action = 'start'
-      // 发送键盘按下事件
-      self.fire(
-        ViewEventType.drag,
-        MapViewUtil.getDragEvent(
-          event,
-          self,
-          this._dragParams.origin,
-          this._dragParams.action
-        )
-      )
-    })
-    this._innerView.on('drag', (event) => {
-      // 发送键盘按下事件
-      this._dragParams.action = 'update'
-      self.fire(
-        ViewEventType.drag,
-        MapViewUtil.getDragEvent(
-          event,
-          self,
-          this._dragParams.origin,
-          this._dragParams.action
-        )
-      )
-    })
-    this._innerView.on('dragend', (event) => {
-      // 发送键盘按下事件
-      this._dragParams.action = 'end'
-      self.fire(
-        ViewEventType.drag,
-        MapViewUtil.getDragEvent(
-          event,
-          self,
-          this._dragParams.origin,
-          this._dragParams.action
-        )
-      )
-      self._dragParams = {
-        origin: null,
-        action: '',
-        button: null
-      }
-    })
-    this._innerView.on('rotatestart', (event) => {
-      // 发送鼠标拖拽开始事件
-      this._dragParams.origin = {
-        x: event.originalEvent.layerX,
-        y: event.originalEvent.layerY
-      }
-      this._dragParams.action = 'start'
-      // 发送键盘按下事件
-      self.fire(
-        ViewEventType.drag,
-        MapViewUtil.getDragEvent(
-          event,
-          self,
-          this._dragParams.origin,
-          this._dragParams.action
-        )
-      )
-    })
-    this._innerView.on('rotate', (event) => {
-      // 发送键盘按下事件
-      this._dragParams.action = 'update'
-      self.fire(
-        ViewEventType.drag,
-        MapViewUtil.getDragEvent(
-          event,
-          self,
-          this._dragParams.origin,
-          this._dragParams.action
-        )
-      )
-    })
-    this._innerView.on('rotateend', (event) => {
-      // 发送键盘按下事件
-      this._dragParams.action = 'end'
-      self.fire(
-        ViewEventType.drag,
-        MapViewUtil.getDragEvent(
-          event,
-          self,
-          this._dragParams.origin,
-          this._dragParams.action
-        )
-      )
-      self._dragParams = {
-        origin: null,
-        action: '',
-        button: null
-      }
-    })
-    // 注册视图开始改变事件
-    this._innerView.on('movestart', () => {
-      self.stationary = false
-    })
-    // 注册zoom变化事件
-    this._innerView.on('zoom', (event) => {
-      self._map.layers.forEach(function (layer) {
-        switch (layer.type) {
-          case LayerType.igsFeature:
-          case LayerType.graphics:
-            // showLayerByScale(self, layer)
-            break
-          default:
-            break
-        }
-      })
-      // 发送zoom变化事件
-      self.fire(ViewEventType.zoom, {
-        zoom: event.target._zoom,
-        event
-      })
-    })
-    // 注册zoom end事件
-    this._innerView.on('zoomend', (event) => {
-      // 更新地图视野范围，比例尺
-      self._zoomEndHandler()
-      // 发送地图视图改变事件
-      self.fire(
-        ViewEventType.viewChange,
-        MapViewUtil.getViewChangeEvent(event, self)
-      )
-    })
-    // 注册地图移动完成事件
-    this._innerView.on('moveend', (event) => {
-      // 更新地图视中心
-      self._moveEndHandler()
-      // 发送地图视图改变事件
-      self.fire(
-        ViewEventType.viewChange,
-        MapViewUtil.getViewChangeEvent(event, self)
-      )
-      // self.fire(ViewEventType.mapMove, event)
-      self.stationary = true
-    })
-    // 注册地图大小变化事件
-    this._innerView.on('resize', () => {
-      const oldWidth = Number(self.width)
-      const oldHeight = Number(self.height)
-      // 更新地图窗口宽高
-      self._initSize()
-      // 发送地图初始化后触发的事件
-      self.fire(ViewEventType.resize, {
-        oldWidth,
-        oldHeight,
-        width: self.width,
-        height: self.height
-      })
-    })
-    // 注册监控键盘事件
-    this._listenKey()
-  }
-  /**
-   * 设置（鼠标）操作地图事件是否可用
-   * @private
-   * @param {String} actionType 操作类型
-   * @param {Boolean} isEnable 是否可用
-   * */
-  _mapActionControl(actionType, isEnable) {
-    if (!this._innerView) return
-    if (actionType === 'drag-pan') {
-      // 左键拖拽地图
-      if (isEnable) {
-        this._innerView.dragPan.enable()
-      } else {
-        this._innerView.dragPan.disable()
-      }
-    } else if (actionType === 'double-click-zoom') {
-      // 双击放大地图
-      if (isEnable) {
-        this._innerView.doubleClickZoom.enable()
-      } else {
-        this._innerView.doubleClickZoom.disable()
-      }
-    } else if (actionType === 'drag-rotate') {
-      // 右键旋转地图
-      if (isEnable) {
-        this._innerView.dragRotate.enable()
-      } else {
-        this._innerView.dragRotate.disable()
-      }
-    }
-  }
-  /**
-   * 注册监控键盘事件
-   * @private
-   * */
-  _listenKey() {
-    const self = this
-    const canvas = this._innerView._canvas
-    canvas.setAttribute('tabIndex', '-1')
-    canvas.onclick = () => {
-      canvas.focus()
-    }
-    canvas.addEventListener('keydown', (event) => {
-      self.fire(ViewEventType.keyDown, MapViewUtil.getKeyEvent(event, self))
-    })
-    canvas.addEventListener('keyup', (event) => {
-      self.fire(ViewEventType.keyUp, MapViewUtil.getKeyEvent(event, self))
-    })
-  }
-  /**
-   * @description 初始化获取视图尺寸大小
-   * @private
-   */
-  _initSize() {
-    // const container = this._innerView.getContainer()
-    // this.width = container.offsetWidth
-    // this.height = container.offsetHeight
-    const canvas = this._innerView.getCanvas()
-    const width = canvas.style ? canvas.style.width : canvas.width
-    const height = canvas.style ? canvas.style.height : canvas.height
-    this.width = Number(width.toString().replace('px', ''))
-    this.height = Number(height.toString().replace('px', ''))
-  }
-  /**
-   * zoom end事件处理器
-   * @private
-   * */
-  _zoomEndHandler() {
-    // 更新地图视野范围
-    this.getExtent()
-    // 更新地图层级
-    this.getZoom()
-    // 更新地图比例尺
-    this.getScale()
-  }
-  /**
-   * @description 获取当前视图容器的宽高，单位像素&lt;a id='getSize'>&lt;/a>
-   * @return {Object} 当前视图容器的宽高对象
-   * */
-  getSize() {
-    return { width: this.width, height: this.height }
-  }
-  _moveEndHandler() {
-    // 更新地图视野中心
-    this.getCenter()
-    // 更新地图视野范围
-    this.getExtent()
-  }
-  // 创建layerView对象
-  _createLayerViewObj(layer) {
-    return getLayerView(this, layer)
-  }
-  /**
-   * 初始化弹窗
-   * @private
-   * */
-  _initPopup() {
-    this.popup = new Popup({ view: this })
-  }
-  /**
-   * &lt;a id='hitTest'>&lt;/a>
-   * @description 穿透检测，图元拾取。目前支持graphic类型拾取结果，支持图层类型GraphicLayer，FeatureLayer。
-   * @param {Object} screenPoint  屏幕像素坐标点，例如{ x: 900, y: 500 }
-   * @return {Array} 图元检测结果
-   * @example &lt;caption>&lt;h7>根据基础图层对象或者图层id查询并返回实际图层&lt;/h7>&lt;/caption>
-   * // ES6引入方式
-   * import { MapView } from "@mapgis/webclient-mapboxgl-plugin";
-   * import { Map, Point, Polygon, MultiPolygon ,Extent, GraphicsLayer, Feature, Circle, IGSFeatureLayer, IGSTileLayer } from "@mapgis/webclient-common";
-   * // 初始化图层管理容器
-   * const map = new Map();
-   * // 初始化地图视图对象
-   * this.mapView = new MapView({
-   *   // 视图id
-   *   viewId: "mapgis-2d-viewer",
-   *   // 图层管理容器
-   *   map: map,
-   * })
-   * // 创建一个要素crs
-   * const feature = [
-   *   new Feature({
-   *     id: '11113',
-   *     geometry: new Circle({
-   *       center: [113, 35],
-   *       radius: 10000,
-   *       radiusUnit: 'kilometers',
-   *     })
-   *   }),
-   *   new Feature({
-   *     id: '11114',
-   *     geometry: new Polygon({
-   *       coordinates: [
-   *         // 外圈
-   *         [
-   *           [113.0, 29.0],
-   *           [116.0, 29.0],
-   *           [116.0, 35.0],
-   *           [113.0, 35.0],
-   *           [113.0, 29.0]
-   *         ]
-   *       ]
-   *     })
-   *   }),
-   *   new Feature({
-   *     id: '11115',
-   *     geometry:new MultiPolygon({
-   *       coordinates: [
-   *         [
-   *           // 外圈
-   *           [
-   *             [112.0, 28.0],
-   *             [115.0, 28.0],
-   *             [115.0, 30.0],
-   *             [112.0, 30.0],
-   *             [112.0, 28.0]
-   *           ],
-   *           // 第一个内圈
-   *           [
-   *             [112.2, 28.2],
-   *             [112.2, 29.8],
-   *             [114.8, 29.8],
-   *             [114.8, 28.2],
-   *             [112.2, 28.2]
-   *           ]
-   *         ]
-   *       ]
-   *     })
-   *   })
-   * ]
-   * // 初始化几何图层
-   * const graphicsLayer = new GraphicsLayer({
-   *   graphics:feature
-   * })
-   * map.add(this.graphicsLayer)
-   * const result = this.mapView.hitTest({x:1100,y:600})
-   * */
-  hitTest(screenPoint) {
-    if (!this._innerView) return
-    const hitTestResult = []
-    const layerIds = this._getInnerStyleLayerIds()
-    // 使用引擎queryRenderedFeatures查询到引擎要素对象
-    const queryResult = this._innerView.queryRenderedFeatures(
-      [screenPoint.x, screenPoint.y],
-      {
-        layers: layerIds
-      }
-    )
-    queryResult.forEach((item) => {
-      if (
-        !item.properties ||
-        item.properties.id === undefined ||
-        !item.layer ||
-        !item.layer.id
-      ) {
-        return
-      }
-      // 从引擎要素对象上取到对应的公共层layerId、featureId
-      const layerId = item.layer.id.split('_')[0]
-      const featureId = item.properties.id
-      // 获取layer对象和feature对象
-      let layer = this.getLayer(layerId)
-      if (!layer) {
-        layer = this._graphicsLayers.find((layer) => layer.id === layerId)
-      }
-      let features = null
-      if (
-        layer.type === LayerType.igsFeature ||
-        layer.type === LayerType.geojson
-      ) {
-        const layerView = this._getLayerView(layer)
-        if (layerView.featureSet &amp;&amp; layerView.featureSet.features) {
-          features = layerView.featureSet.features.filter((item) => {
-            if (item.id === featureId) {
-              return item
-            }
-          })
-        }
-      } else if (layer.type === LayerType.graphics) {
-        if (layer.graphics) {
-          const featureCollection = layer.graphics.filter((item) => {
-            if (item.id === featureId) {
-              return item
-            }
-          })
-          features = featureCollection.items
-        }
-      }
-      const feature = features &amp;&amp; features.length > 0 ? features[0] : null
-      const graphicHit = {
-        graphic: feature,
-        layer,
-        mapPoint: this.toMap(screenPoint),
-        type: 'graphic'
-      }
-      hitTestResult.push(graphicHit)
-    })
-    return hitTestResult
-  }
-  // 获取mapbox内部的styleLayerId
-  _getInnerStyleLayerIds() {
-    let layerIds = []
-    const layers = this._map.allLayers.items.concat(this._graphicsLayers.items)
-    layers.forEach((layer) => {
-      if (
-        layer.type === LayerType.igsFeature ||
-        layer.type === LayerType.geojson
-      ) {
-        const innerLayerView = this._getLayerView(layer)
-        if (innerLayerView) {
-          layerIds = layerIds.concat(innerLayerView.layerIDs)
-        }
-      } else if (layer.type === LayerType.graphics) {
-        const innerLayer = this.getInnerLayer(layer)
-        if (innerLayer &amp;&amp; innerLayer.getStyleLayerIds) {
-          layerIds = layerIds.concat(innerLayer.getStyleLayerIds())
-        }
-      }
-    })
-    return layerIds
-  }
-  toMap(screenPoint) {
-    if (!screenPoint) return
-    const latLngPoint = this._innerView.unproject([
-      screenPoint.x,
-      screenPoint.y
-    ])
-    let geoPoint = new Point({
-      coordinates: [latLngPoint.lng, latLngPoint.lat]
-    })
-    if (this._spatialReference &amp;&amp; !this._spatialReference.isGeographic) {
-      geoPoint = Projection.project(geoPoint, this._spatialReference)
-    } else {
-      geoPoint.spatialReference = this._spatialReference
-    }
-    return geoPoint
-  }
-  toScreen(point) {
-    let _point = Geometry.fromJSON(point)
-    if (!_point.spatialReference.isGeographic) {
-      _point = Projection.project(
-        _point,
-        new SpatialReference({
-          wkid: 4326
-        })
-      )
-    }
-    const screenPoint = this._innerView.project([
-      _point.coordinates[0],
-      _point.coordinates[1]
-    ])
-    return screenPoint
-  }
-  /**
-   * &lt;a id='takeScreenshot'>&lt;/a>
-   * @description 屏幕快照
-   * @param {Object} [options = {}] 屏幕快照配置配置
-   * @param {PictureFormat} [options.format = PictureFormat.png] 照片格式，支持png，jpeg格式
-   * @param {String} [options.filename = 'screenshotFile'] 下载文件名
-   * @param {Number} [options.width = undefined] 图片宽度
-   * @param {Number} [options.height = undefined] 图片高度
-   * @param {Number} [options.x = undefined] 图片原点x
-   * @param {Number} [options.y = undefined] 图片原点y
-   * @param {Boolean} [options.isDownload = true] 是否下载图片
-   * @return {Object} 屏幕快照 {dataUrl String }，且浏览器会下载图片
-   * @example &lt;caption>&lt;h7>屏幕快照&lt;/h7>&lt;/caption>
-   * // ES5引入方式
-   * const { Map, MapView } = Zondy
-   * const { PictureFormat } = Zondy.Enum
-   * // ES6引入方式
-   * import { Map, MapView } from "@mapgis/webclient-mapboxgl-plugin"
-   * import { PictureFormat } from "@mapgis/webclient-common"
-   * // 初始化图层管理容器
-   * const map = new Map();
-   * // 初始化地图视图对象
-   * const mapView = new MapView({
-   *   // 二维场景视图的容器(html的div标签)ID
-   *   viewId: "二维场景视图的容器的id",
-   *   // 图层管理容器
-   *   map: map
-   * })
-   * // 设置屏幕快照参数
-   * const screenshotOptions: {
-   *    format: PictureFormat.png
-   * }
-   * // 开始屏幕快照
-   * mapView.takeScreenshot(screenshotOptions).then((result) => {
-   *   // 获取base64格式的url字符串
-   *   console.log("dataUrl:", result.dataUrl)
-   * })
-   * */
-  takeScreenshot(options) {
-    options.view = this
-    let screenshotResult = null
-    if (!this._screenshot) {
-      this._screenshot = new Screenshot(options)
-      screenshotResult = this._screenshot._addView()
-    } else {
-      screenshotResult = this._screenshot._addView()
-    }
-    return screenshotResult
-  }
-  flyTo(options, animateOptions = { animate: true }) {
-    options = defaultValue(options, {})
-    const zoom = defaultValue(options.zoom, 1)
-    // 获取center
-    const center = this._getFlyToCenter(options)
-    // 获取extent
-    const extent = this._getFlyToExtent(options)
-    if (this._innerView) {
-      if (center) {
-        this._innerView.flyTo({
-          center: [center.coordinates[0], center.coordinates[1]],
-          zoom
-        })
-      } else if (extent) {
-        this._innerView.fitBounds(
-          [
-            [extent.xmin, extent.ymin], // 西南
-            [extent.xmax, extent.ymax] // 东北
-          ],
-          animateOptions
-        )
-      }
-    }
-  }
-  /**
-   * 视点跳转为给定的目标&lt;a id='goTo'>&lt;/a>
-   * @param goToTarget 跳转参数
-   * @param {Point|Array}  [goToTarget.center]  视图跳转中心点
-   * @param {Number}  [goToTarget.zoom]  视图跳转层级
-   * @param {Number}  [goToTarget.scale]  视图跳转比例尺
-   * @param {Geometry|Array&lt;Geometry>|Collection&lt;Geometry>}  [goToTarget.target]  按范围跳转
-   * @param options 动画参数
-   * @param {Boolean}  [options.animate = true ]  新视图的过渡是否开启动画，默认开启动画
-   * @param {Number}  [options.duration = 200 ]  动画的持续时间，以毫秒为单位，默认200毫秒
-   * @example &lt;caption>&lt;h7>中心点跳转示例&lt;/h7>&lt;/caption>
-   * // ES5引入方式
-   * const { Map, MapView } = Zondy
-   * // ES6引入方式
-   * import { Map, MapViewMapboxgl as MapView } from "@mapgis/webclient-leaflet-plugin"
-   * // 初始化图层管理容器
-   * map = new .Map();
-   * // 初始化地图视图对象
-   * mapView = new MapView({
-   *   // 视图id
-   *   viewId: "view-id",
-   *   // 图层管理容器
-   *   map: map
-   * });
-   * // 视点跳转
-   * mapView.goTo({
-   *   // 跳转中心点
-   *   center: [115.47643872463577, 30.980700423496124],
-   *   // 地图层级
-   *   zoom: 8
-   * });
-   *
-   * @example &lt;caption>&lt;h7>按范围跳转示例&lt;/h7>&lt;/caption>
-   * // ES5引入方式
-   * const { Map, MapView } = Zondy
-   * const { Extent, Circle } = Zondy.Geometry
-   * // ES6引入方式
-   * import { Map, MapViewMapboxgl as MapView } from "@mapgis/webclient-leaflet-plugin"
-   * // 初始化图层管理容器
-   * map = new Map();
-   * // 初始化地图视图对象
-   * mapView = new MapView({
-   *   // 视图id
-   *   viewId: "view-id",
-   *   // 图层管理容器
-   *   map: map
-   * });
-   * const extent1 = new Extent({
-   *   xmin: 111.88463529230717,
-   *   ymin: 28.646934514163803,
-   *   xmax: 116.89989408129225,
-   *   ymax: 33.07991791253288,
-   * })
-   * const geometry2 = new Circle({
-   *   center: [111, 29],
-   *   radius: 100,
-   *   radiusUnit: "kilometers",
-   * })
-   * mapView
-   *   .goTo({
-   *     target: [extent1, geometry2],
-   *   })
-   *   .then(() => {
-   *     console.log("gotoExtent callback")
-   *   })
-   */
-  goTo(goToTarget = {}, options = {}) {
-    let center
-    let zoom
-    let resultPromise = new Promise((resolve) => {
-      resolve()
-    })
-    if (this._innerView) {
-      // 获取center,zoom
-      if (
-        !isNull(goToTarget.center) ||
-        !isNull(goToTarget.zoom) ||
-        !isNull(goToTarget.scale)
-      ) {
-        if (!isNull(goToTarget.center)) {
-          center = this._getFlyToCenter({ center: goToTarget.center })
-        } else {
-          center = this._center
-        }
-        // 同时设置scale和zoom时，scale优先于zoom
-        if (!isNull(goToTarget.scale) &amp;&amp; goToTarget.scale > 0) {
-          zoom = this._getZoomByScale(goToTarget.scale)
-        } else if (!isNull(goToTarget.zoom) &amp;&amp; goToTarget.zoom > 0) {
-          zoom = goToTarget.zoom
-        } else {
-          zoom = this._zoom
-        }
-      }
-      // 几何对象 或 几何数组 或 几何集合collection的 extent
-      let extent
-      if (!isNull(goToTarget.target)) {
-        const targetExtent = this._getTargetExtent(goToTarget.target)
-        if (
-          targetExtent.xmin !== targetExtent.xmax &amp;&amp;
-          targetExtent.ymin !== targetExtent.ymax
-        ) {
-          extent = targetExtent
-        } else {
-          center = this._getFlyToCenter({
-            center: new Point({
-              coordinates: [targetExtent.xmin, targetExtent.ymin]
-            })
-          })
-        }
-      }
-      // 获取goto动画参数
-      const animateOptions = { animate: true, duration: 200 }
-      if (!isNull(options)) {
-        if (!isNull(options.animate)) {
-          animateOptions.animate = options.animate
-        }
-        if (!isNull(options.duration)) {
-          animateOptions.duration = options.duration
-        }
-      }
-      if (center) {
-        // 中心点跳转
-        let centerLat = center.coordinates[1]
-        let centerLng = center.coordinates[0]
-        // 如果中心点超过fullExtent，则取fullExtent中心为当前中心点
-        if (this._fullExtent) {
-          if (
-            centerLat > this._fullExtent.ymax ||
-            centerLat &lt; this._fullExtent.ymin
-          ) {
-            centerLat = (this._fullExtent.ymax + this._fullExtent.ymin) / 2
-          }
-          if (
-            centerLng > this._fullExtent.xmax ||
-            centerLng &lt; this._fullExtent.xmin
-          ) {
-            centerLng = (this._fullExtent.xmax + this._fullExtent.xmin) / 2
-          }
-        }
-        if (isFinite(centerLat) &amp;&amp; isFinite(centerLng)) {
-          // 如果中心点坐标和层级与当前视图相同，则不跳转
-          let isSame = false
-          const viewCenter = this._innerView.getCenter()
-          if (
-            zoom === this._zoom &amp;&amp;
-            centerLat === viewCenter.lat &amp;&amp;
-            centerLng === viewCenter.lng
-          ) {
-            isSame = true
-          }
-          if (!isSame) {
-            const flyToOptions = {
-              center: [center.coordinates[0], center.coordinates[1]],
-              zoom
-            }
-            Object.assign(flyToOptions, animateOptions)
-            resultPromise = new Promise((resolve) => {
-              this._innerView.flyTo(flyToOptions)
-              this._innerView.once('moveend', () => {
-                resolve()
-              })
-            })
-          }
-        }
-      } else if (extent) {
-        // 范围跳转
-        let xmin = extent.xmin
-        let xmax = extent.xmax
-        let ymin = extent.ymin
-        let ymax = extent.ymax
-        if (this._fullExtent) {
-          if (xmin &lt; this._fullExtent.xmin) {
-            xmin = this._fullExtent.xmin
-          }
-          if (xmax > this._fullExtent.xmax) {
-            xmax = this._fullExtent.xmax
-          }
-          if (ymin &lt; this._fullExtent.ymin) {
-            ymin = this._fullExtent.ymin
-          }
-          if (ymax > this._fullExtent.ymax) {
-            ymax = this._fullExtent.ymax
-          }
-        }
-        if (
-          isFinite(xmin) &amp;&amp;
-          isFinite(xmax) &amp;&amp;
-          isFinite(ymin) &amp;&amp;
-          isFinite(ymax)
-        ) {
-          // 如果extent与当前地图视图范围所在中心和层级不一致，则跳转
-          // resultPromise = this._setViewExtent(extent, animateOptions)
-          this._innerView.fitBounds(
-            [
-              [extent.xmin, extent.ymin], // 西南
-              [extent.xmax, extent.ymax] // 东北
-            ],
-            animateOptions
-          )
-        }
-      }
-    }
-    return resultPromise
-  }
-  /**
-   * 获取当前视图的中心点(经纬度中心点)&lt;a id='getCenter'>&lt;/a>
-   * @return {Object} 中心点对象
-   * */
-  getCenter() {
-    const center = this._innerView.getCenter()
-    let centerCrs = new Point({ coordinates: [center.lng, center.lat] })
-    this._center = centerCrs
-    const spatialReference = this._spatialReference
-    if (!spatialReference.isGeographic) {
-      centerCrs = Projection.project(centerCrs, spatialReference)
-    }
-    return centerCrs
-  }
-  /**
-   * &lt;a id='setCenter'>&lt;/a>
-   * 设置缩视野中心&lt;a id='setCenter'>&lt;/a>
-   * @private
-   * @param {Point} value 视图中心
-   * */
-  setCenter(value) {
-    if (!this._innerView) return
-    if (Array.isArray(value) &amp;&amp; value.length > 1) {
-      this._center = new Point({
-        coordinates: [value[0], value[1]],
-        spatialReference: this._spatialReference
-      })
-      this.flyTo({ zoom: this._zoom, center: this._center })
-    } else if (value instanceof Point) {
-      this._center = value
-      this.flyTo({ zoom: this._zoom, center: this._center })
-    }
-  }
-  /**
-   * 获取当前缩放级数&lt;a id='getZoom'>&lt;/a>
-   * @return {Number} 当前缩放级数
-   * */
-  getZoom() {
-    this._zoom = this._innerView.getZoom()
-    return this._zoom
-  }
-  /**
-   * &lt;a id='setZoom'>&lt;/a>
-   * 设置缩放级数
-   * @private
-   * @param {Number} value 视图层级
-   * */
-  setZoom(value) {
-    if (!this._innerView) return
-    this._zoom = value
-    this.flyTo({ zoom: value, center: this._center })
-  }
-  /**
-   * 获取当前视图的地理范围&lt;a id='getExtent'>&lt;/a>
-   * @return {Extent}  获取当前视图的地理范围
-   * */
-  getExtent() {
-    if (!this._innerView) return
-    const latLngBounds = this._innerView.getBounds()
-    if (!latLngBounds || !latLngBounds._sw || !latLngBounds._ne) return
-    let extent = new Extent({
-      xmin: latLngBounds._sw.lng,
-      ymin: latLngBounds._sw.lat,
-      xmax: latLngBounds._ne.lng,
-      ymax: latLngBounds._ne.lat
-    })
-    const spatialReference = this._spatialReference
-    if (!spatialReference.isGeographic) {
-      extent = Projection.project(extent, spatialReference)
-    }
-    this._extent = extent
-    return extent
-  }
-  /**
-   * &lt;a id='setExtent'>&lt;/a>
-   * 设置视野范围
-   * @private
-   * @param {Extent} value 范围对象
-   * */
-  setExtent(value) {
-    if (!this._innerView) return
-    this._extent = value
-    this.flyTo({ extent: value })
-  }
-  /**
-   * &lt;a id='getScale'>&lt;/a>
-   * 获取当前比例尺
-   * @return {Number}  比例尺 实际10000米:地图1米
-   * */
-  getScale() {
-    const scale = this._getScaleByZoom(this._zoom)
-    this._scale = scale
-    return scale
-  }
-  /**
-   * 根据层级获取比例尺
-   * @private
-   * @param {Number}  zoom 层级
-   * @return {Number}  比例尺
-   * */
-  _getScaleByZoom(zoom) {
-    let scale
-    if (this.crs &amp;&amp; this.crs.options &amp;&amp; this.crs.options.lods) {
-      if (!isNull(zoom)) {
-        if (zoom % 1 === 0) {
-          const lod = this.crs.options.lods[zoom]
-          scale = lod.scale
-        } else {
-          const floorZoom = Math.floor(zoom)
-          const ceilZoom = Math.ceil(zoom)
-          const floorLod = this.crs.options.lods[floorZoom]
-          const ceilLod = this.crs.options.lods[ceilZoom]
-          if (floorLod === undefined &amp;&amp; ceilLod === undefined) {
-            scale = 0
-          } else if (floorLod === undefined) {
-            scale = ceilLod.scale
-          } else if (ceilLod === undefined) {
-            scale = floorLod.scale
-          } else {
-            scale =
-              floorLod.scale -
-              (floorLod.scale - ceilLod.scale) * (zoom - floorZoom)
-          }
-        }
-      }
-    }
-    return scale
-  }
-  /**
-   * 初始化地图视图比例尺
-   * @private
-   * */
-  _initScale(value) {
-    if (this._scale &amp;&amp; this._scale > 0) {
-      this._zoom = this._getZoomByScale(value)
-    }
-  }
-  /**
-   * 根据比例尺获取层级
-   * @private
-   * @param {Number}  value 比例尺
-   * @return {Object}  比例尺层级与层级对应的比例尺
-   * */
-  _getZoomByScale(value) {
-    let zoom = undefined
-    if (this.crs &amp;&amp; this.crs.options &amp;&amp; this.crs.options.lods) {
-      let validScaleIndex = -1
-      for (let i = 0; i &lt; this.crs.options.lods.length; i++) {
-        const item = this.crs.options.lods[i]
-        const lastItem = this.crs.options.lods[i - 1]
-        if (item.scale &lt;= 0) {
-          break
-        } else if (validScaleIndex &lt; 0) {
-          validScaleIndex = i
-        }
-        if (i === validScaleIndex) {
-          if (item.scale > 0 &amp;&amp; value >= item.scale) {
-            zoom = item.level
-            break
-          }
-        } else if (
-          value >= item.scale &amp;&amp;
-          value &lt;= lastItem.scale &amp;&amp;
-          lastItem.scale !== item.scale
-        ) {
-          zoom =
-            item.level - (value - item.scale) / (lastItem.scale - item.scale)
-          break
-        } else if (i === this.crs.options.lods.length - 1) {
-          if (item.scale > 0 &amp;&amp; value &lt;= item.scale) {
-            zoom = item.level
-            break
-          }
-        }
-      }
-    }
-    return zoom
-  }
-  /**
-   * &lt;a id='setScale'>&lt;/a>
-   * 设置当前比例尺
-   * @private
-   * @param {Number} value 比例尺 实际10000米:地图1米
-   * */
-  setScale(value) {
-    if (!this._innerView) return
-    const zoom = this._getZoomByScale(value)
-    // 视图定位
-    if (zoom) {
-      this.flyTo({ center: this._center, zoom })
-    }
-  }
-  // 根据地图范围得到最大限度视图范围
-  _getMaxBounds() {
-    if (this._fullExtent) {
-      return [
-        [this._fullExtent.xmin, this._fullExtent.ymin],
-        [this._fullExtent.xmax, this._fullExtent.ymax]
-      ]
-    } else {
-      return []
-    }
-  }
-  /**
-   * @description 比较两个crs对象是否相等
-   * @private
-   * @param {CRS} crs1 作比较的第一个CRS对象
-   * @param {CRS} crs2 作比较的第二个CRS对象
-   * @return {Boolean} crs对象是否相等
-   * */
-  _isEqualCrs(crs1, crs2) {
-    let isEqual = true
-    if (crs1 &amp;&amp; crs2) {
-      // 比较被设置的新Crs和当前this.crs是否相同。
-      // 判断标准 crs.option的resolutions,origin,bounds是否相等，以及crs.epsgCode相等
-      let crs1Info
-      if (crs1.epsgCode.split(':').length > 1) {
-        crs1Info = {
-          wkid: crs1.epsgCode.split(':')[1]
-        }
-      } else {
-        crs1Info = {
-          wkid: this.crs.epsgCode
-        }
-      }
-      let crs2Info
-      if (crs2.epsgCode.split(':').length > 1) {
-        crs2Info = {
-          wkid: crs2.epsgCode.split(':')[1]
-        }
-      } else {
-        crs2Info = {
-          wkid: crs2.epsgCode
-        }
-      }
-      let isEqualSR
-      if (crs2Info.wkid === undefined || crs1Info.wkid === undefined) {
-        isEqualSR = TileInfoUtil.isSameSpatialReference(
-          crs2Info.wkt,
-          crs1Info.wkt
-        )
-      } else {
-        isEqualSR = TileInfoUtil.isSameSpatialReference(
-          crs2Info.wkid,
-          crs1Info.wkid
-        )
-      }
-      if (isEqualSR) {
-        // ArcgisMapImage图层临时处理，服务数据extent有问题，暂为解决。4326、3857参考系构建对应的Leaflet参考系对象，
-        // 因此没有options，不参与对比bounds、resolutions，暂时组织比较wkid
-        // 问题解决后，统一比较 crs.options，该if条件可移除
-        if (
-          (crs2Info.wkid === '4326' || crs2Info.wkid === '3857') &amp;&amp;
-          !crs2.options
-        ) {
-          isEqual = true
-        }
-        if (crs2.options) {
-          const newCrsOptions = crs2.options
-          crs2Info.resolutions = newCrsOptions.resolutions
-          crs2Info.origin = newCrsOptions.origin
-          crs2Info.bounds = newCrsOptions.bounds
-          crs1Info.resolutions = this.crs.options.resolutions
-          crs1Info.origin = this.crs.options.origin
-          crs1Info.bounds = this.crs.options.bounds
-          if (
-            JSON.stringify(crs2Info.resolutions) !==
-              JSON.stringify(crs1Info.resolutions) ||
-            JSON.stringify(crs2Info.origin) !==
-              JSON.stringify(crs1Info.origin) ||
-            !this._isEqualBounds(crs1Info.bounds, crs2Info.bounds)
-          ) {
-            isEqual = false
-          }
-        }
-      } else {
-        isEqual = false
-      }
-    } else if ((!crs1 &amp;&amp; crs2) || (crs1 &amp;&amp; !crs2)) {
-      isEqual = false
-    }
-    return isEqual
-  }
-  /**
-   * &lt;a id='toJSON'>&lt;/a>
-   * 导出场景视图的配置文件
-   * @return {Object} 导出的配置文件
-   * */
-  toJSON() {
-    return {
-      extent: toJSON(this._extent, Extent),
-      center: toJSON(this._center, Point),
-      map: toJSON(this._map, Map),
-      viewId: this._viewId,
-      width: this.width,
-      height: this.height,
-      zoom: this.zoom,
-      scale: this.scale,
-      maxScale: this.maxScale,
-      minScale: this.minScale,
-      spatialReferenceLocked: this.spatialReferenceLocked
-    }
-  }
-}
-Object.defineProperties(MapView.prototype, {
-  scale: {
-    get() {
-      return this._scale
-    },
-    set(value) {
-      this.setScale(value)
-    }
-  },
-  zoom: {
-    get() {
-      return this._zoom
-    },
-    set(value) {
-      this.setZoom(value)
-    }
-  },
-  extent: {
-    get() {
-      return this._extent
-    },
-    set(value) {
-      this.setExtent(value)
-    }
-  },
-  center: {
-    get() {
-      let center = this._center
-      if (this._spatialReference) {
-        if (!this.spatialReference.isGeographic) {
-          center = Projection.project(this._center, this._spatialReference)
-        }
-      }
-      return center
-    },
-    set(value) {
-      this.setCenter(value)
-    }
-  },
-  // fullExtent: {
-  //   get() {
-  //     if (!this._initFullExtent) {
-  //       this._fullExtent = this._mapExtent
-  //     } else {
-  //       this._fullExtent = this._initFullExtent
-  //     }
-  //     let fullExtent
-  //     if (this.spatialReference &amp;&amp; this._fullExtent) {
-  //       if (!this.spatialReference.isGeographic) {
-  //         fullExtent = Projection.project(
-  //           this._fullExtent,
-  //           this.spatialReference
-  //         )
-  //       } else {
-  //         fullExtent = this._fullExtent
-  //       }
-  //     }
-  //     return fullExtent
-  //   },
-  //   set(value) {
-  //     let fullExtent
-  //     if (!value.spatialReference.isGeographic) {
-  //       fullExtent = Projection.project(
-  //         value,
-  //         new SpatialReference('EPSG:4326')
-  //       )
-  //     } else {
-  //       fullExtent = value
-  //     }
-  //     this._fullExtent = fullExtent
-  //     this._initFullExtent = Extent.fromJSON(fullExtent.toJSON())
-  //     // Extent的改变引起Crs的改变
-  //     this.setCrs()
-  //   }
-  // },
-  spatialReference: {
-    get() {
-      return this._spatialReference
-    },
-    set(value) {
-      // this._spatialReference = value
-    }
-  },
-  rotation: {
-    get() {
-      return this._rotation
-    },
-    set(value) {
-      // this._rotation = value
-      // if (this._innerView) {
-      //   this._innerView.setBearing(value)
-      // }
-    }
-  }
-})
-/**
- * 通过一个配置生成一个场景视图对象
- * @param {Object} json 场景视图配置
- * @return {MapView}
- * */
-MapViewMapboxgl.fromJSON = function (json) {
-  json = defaultValue(json, {})
-  return new MapViewMapboxgl(json)
-}
-Zondy.MapViewMapboxgl = MapViewMapboxgl
-export default MapViewMapboxgl
-</code></pre>
-        </article>
-    </section>
-            </div>
-            <footer class="footer">
-                <div class="content has-text-centered">
-                    <p>文档生成<a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.6.11</a></p>
-                    <p class="sidebar-created-by">
-                        <a href="http://www.smaryun.com" target="_blank">司马云</a> <span>© 2023 云生态圈</span>
-                        <a href="http://192.168.82.89:8086/#/index" target="_blank">MapGIS Client for JavaScript</a>
-                    </p>
-                </div>
-            </footer>
-        </div>
-        <div id="side-nav" class="side-nav">
-            <div style="margin-bottom: 10px;">
-                <img style="vertical-align: middle;margin-right: 10px;width: 30px;" src="./styles/anchor.png"/><a href="#page-title">构造函数</a>
-            </div>
-            <div style="margin-bottom: 10px;">
-                <img style="vertical-align: middle;margin-right: 10px;width: 30px;" src="./styles/anchor.png"/><a href="#member">成员变量</a>
-            </div>
-            <div style="margin-bottom: 10px;">
-                <img style="vertical-align: middle;margin-right: 10px;width: 30px;" src="./styles/anchor.png"/><a href="#function">方法</a>
-            </div>
-            <div>
-                <img style="vertical-align: middle;margin-right: 10px;width: 30px;" src="./styles/anchor.png"/><a href="#event">事件</a>
-            </div>
-        </div>
-    </div>
-<script src="scripts/linenumber.js"> </script>
-<script src="scripts/search.js"> </script>
-</body>
-</html>