@antv/l7-layers 2.21.1 → 2.21.2

package/es/tile/core/BaseLayer.js

@@ -1,59 +1,66 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { lodashUtil } from '@antv/l7-utils';
 import { TileLayerService } from "../service/TileLayerService";
 import { TilePickService } from "../service/TilePickService";
 import { getTileFactory } from "../tile";
 import { ProxyFuncs } from "../utils/constants";
-var debounce = lodashUtil.debounce;
-var BaseTileLayer = /*#__PURE__*/function () {
-  // 瓦片是否加载成功
-
-  function BaseTileLayer(parent) {
-    var _this = this;
-    _classCallCheck(this, BaseTileLayer);
+const {
+  debounce
+} = lodashUtil;
+export default class BaseTileLayer {
+  constructor(parent) {
+    _defineProperty(this, "parent", void 0);
+    _defineProperty(this, "tileLayerService", void 0);
+    _defineProperty(this, "mapService", void 0);
+    _defineProperty(this, "layerService", void 0);
+    _defineProperty(this, "rendererService", void 0);
+    _defineProperty(this, "pickingService", void 0);
+    _defineProperty(this, "tilePickService", void 0);
+    _defineProperty(this, "tilesetManager", void 0);
     // 瓦片数据管理器
     _defineProperty(this, "initedTileset", false);
-    _defineProperty(this, "mapchange", function () {
+    // 瓦片是否加载成功
+    _defineProperty(this, "lastViewStates", void 0);
+    _defineProperty(this, "mapchange", () => {
       var _this$tilesetManager;
       // 图层不可见时，不触发加载瓦片
-      if (_this.parent.isVisible() === false) {
+      if (this.parent.isVisible() === false) {
         return;
       }
-      var _this$getCurrentView = _this.getCurrentView(),
-        latLonBounds = _this$getCurrentView.latLonBounds,
-        zoom = _this$getCurrentView.zoom;
-      if (_this.mapService.version === 'GAODE1.x') {
-        var _this$parent$getLayer = _this.parent.getLayerConfig(),
-          visible = _this$parent$getLayer.visible;
+      const {
+        latLonBounds,
+        zoom
+      } = this.getCurrentView();
+      if (this.mapService.version === 'GAODE1.x') {
+        const {
+          visible
+        } = this.parent.getLayerConfig();
         if (zoom < 2 && visible) {
-          _this.parent.updateLayerConfig({
+          this.parent.updateLayerConfig({
             visible: false
           });
-          _this.layerService.reRender();
+          this.layerService.reRender();
         } else if (zoom >= 2 && !visible) {
-          _this.parent.updateLayerConfig({
+          this.parent.updateLayerConfig({
             visible: true
           });
-          _this.layerService.reRender();
+          this.layerService.reRender();
         }
       }
-      if (_this.lastViewStates && _this.lastViewStates.zoom === zoom && _this.lastViewStates.latLonBounds.toString() === latLonBounds.toString()) {
+      if (this.lastViewStates && this.lastViewStates.zoom === zoom && this.lastViewStates.latLonBounds.toString() === latLonBounds.toString()) {
         return;
       }
-      _this.lastViewStates = {
-        zoom: zoom,
-        latLonBounds: latLonBounds
+      this.lastViewStates = {
+        zoom,
+        latLonBounds
       };
-      (_this$tilesetManager = _this.tilesetManager) === null || _this$tilesetManager === void 0 || _this$tilesetManager.throttleUpdate(zoom, latLonBounds);
+      (_this$tilesetManager = this.tilesetManager) === null || _this$tilesetManager === void 0 || _this$tilesetManager.throttleUpdate(zoom, latLonBounds);
     });
     //  防抖操作
     _defineProperty(this, "viewchange", debounce(this.mapchange, 24));
     this.parent = parent;
-    var container = this.parent.getContainer();
+    const container = this.parent.getContainer();
     this.rendererService = container.rendererService;
     this.layerService = container.layerService;
     this.mapService = container.mapService;
@@ -63,13 +70,13 @@ var BaseTileLayer = /*#__PURE__*/function () {
     this.tileLayerService = new TileLayerService({
       rendererService: this.rendererService,
       layerService: this.layerService,
-      parent: parent
+      parent
     });
     // 初始化拾取服务
     this.tilePickService = new TilePickService({
       tileLayerService: this.tileLayerService,
       layerService: this.layerService,
-      parent: parent
+      parent
     });
 
     // 重置
@@ -77,264 +84,181 @@ var BaseTileLayer = /*#__PURE__*/function () {
     this.proxy(parent);
     this.initTileSetManager();
   }
-  _createClass(BaseTileLayer, [{
-    key: "initTileSetManager",
-    value: function initTileSetManager() {
-      var _this$tilesetManager2;
-      var source = this.parent.getSource();
-      this.tilesetManager = source.tileset;
-      if (!this.initedTileset) {
-        this.bindTilesetEvent();
-        this.initedTileset = true;
-      }
-
-      // 图层不可见时，不触发加载瓦片
-      if (this.parent.isVisible() === false) {
-        return;
-      }
-      var _this$getCurrentView2 = this.getCurrentView(),
-        latLonBounds = _this$getCurrentView2.latLonBounds,
-        zoom = _this$getCurrentView2.zoom;
-      (_this$tilesetManager2 = this.tilesetManager) === null || _this$tilesetManager2 === void 0 || _this$tilesetManager2.update(zoom, latLonBounds);
+  initTileSetManager() {
+    var _this$tilesetManager2;
+    const source = this.parent.getSource();
+    this.tilesetManager = source.tileset;
+    if (!this.initedTileset) {
+      this.bindTilesetEvent();
+      this.initedTileset = true;
     }
-  }, {
-    key: "getCurrentView",
-    value: function getCurrentView() {
-      var bounds = this.mapService.getBounds();
-      var latLonBounds = [bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]];
-      var zoom = this.mapService.getZoom();
-      return {
-        latLonBounds: latLonBounds,
-        zoom: zoom
-      };
+
+    // 图层不可见时，不触发加载瓦片
+    if (this.parent.isVisible() === false) {
+      return;
     }
-  }, {
-    key: "bindTilesetEvent",
-    value: function bindTilesetEvent() {
-      var _this2 = this;
-      // 瓦片数据加载成功
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      this.tilesetManager.on('tile-loaded', function (tile) {
-        // 将事件抛出，图层上可以监听使用
-      });
+    const {
+      latLonBounds,
+      zoom
+    } = this.getCurrentView();
+    (_this$tilesetManager2 = this.tilesetManager) === null || _this$tilesetManager2 === void 0 || _this$tilesetManager2.update(zoom, latLonBounds);
+  }
+  getCurrentView() {
+    const bounds = this.mapService.getBounds();
+    const latLonBounds = [bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]];
+    const zoom = this.mapService.getZoom();
+    return {
+      latLonBounds,
+      zoom
+    };
+  }
+  bindTilesetEvent() {
+    // 瓦片数据加载成功
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    this.tilesetManager.on('tile-loaded', tile => {
+      // 将事件抛出，图层上可以监听使用
+    });
 
-      // 瓦片数据从缓存删除或被执行重新加载
-      this.tilesetManager.on('tile-unload', function (tile) {
-        // 将事件抛出，图层上可以监听使用
-        _this2.tileUnLoad(tile);
-      });
+    // 瓦片数据从缓存删除或被执行重新加载
+    this.tilesetManager.on('tile-unload', tile => {
+      // 将事件抛出，图层上可以监听使用
+      this.tileUnLoad(tile);
+    });
 
-      // 瓦片数据加载失败
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      this.tilesetManager.on('tile-error', function (error, tile) {
-        // 将事件抛出，图层上可以监听使用
-        _this2.tileError(error);
-      });
+    // 瓦片数据加载失败
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    this.tilesetManager.on('tile-error', (error, tile) => {
+      // 将事件抛出，图层上可以监听使用
+      this.tileError(error);
+    });
 
-      // 瓦片显隐状态更新
-      this.tilesetManager.on('tile-update', function () {
-        _this2.tileUpdate();
-      });
+    // 瓦片显隐状态更新
+    this.tilesetManager.on('tile-update', () => {
+      this.tileUpdate();
+    });
 
-      // 地图视野发生改变
-      this.mapService.on('zoomend', this.mapchange);
-      this.mapService.on('moveend', this.viewchange);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      this.tileLayerService.render();
-    }
-  }, {
-    key: "getLayers",
-    value: function getLayers() {
-      return this.tileLayerService.getLayers();
-    }
-  }, {
-    key: "getTiles",
-    value: function getTiles() {
-      return this.tileLayerService.getTiles();
-    }
-  }, {
-    key: "getTile",
-    value: function getTile(key) {
-      return this.tileLayerService.getTile(key);
-    }
-  }, {
-    key: "tileLoaded",
-    value:
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    function tileLoaded(tile) {
-      //
-    }
-  }, {
-    key: "tileError",
-    value: function tileError(error) {
-      console.warn('error:', error);
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      var _this$tilesetManager3;
-      this.mapService.off('zoomend', this.mapchange);
-      this.mapService.off('moveend', this.viewchange);
-      (_this$tilesetManager3 = this.tilesetManager) === null || _this$tilesetManager3 === void 0 || _this$tilesetManager3.destroy();
-      this.tileLayerService.destroy();
-    }
-    // 重新加载
-  }, {
-    key: "reload",
-    value: function reload() {
-      var _this$tilesetManager4;
-      // 瓦片重新加载
-      this.tilesetManager.clear();
-      var _this$getCurrentView3 = this.getCurrentView(),
-        latLonBounds = _this$getCurrentView3.latLonBounds,
-        zoom = _this$getCurrentView3.zoom;
-      (_this$tilesetManager4 = this.tilesetManager) === null || _this$tilesetManager4 === void 0 || _this$tilesetManager4.update(zoom, latLonBounds);
-    }
-  }, {
-    key: "tileUnLoad",
-    value: function tileUnLoad(tile) {
-      this.tileLayerService.removeTile(tile.key);
-    }
-  }, {
-    key: "tileUpdate",
-    value: function () {
-      var _tileUpdate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-        var _this3 = this;
-        var minZoom, maxZoom, tiles;
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              if (this.tilesetManager) {
-                _context2.next = 2;
-                break;
-              }
-              return _context2.abrupt("return");
-            case 2:
-              minZoom = this.parent.getMinZoom();
-              maxZoom = this.parent.getMaxZoom();
-              tiles = this.tilesetManager.tiles.filter(function (tile) {
-                return tile.isLoaded;
-              }) // 过滤未加载完成的
-              .filter(function (tile) {
-                return tile.isVisibleChange;
-              }) // 过滤未发生变化的
-              .filter(function (tile) {
-                return tile.data;
-              }) //
-              .filter(function (tile) {
-                return tile.z >= minZoom && tile.z < maxZoom;
-              }); // 过滤不可见见
-              _context2.next = 7;
-              return Promise.all(tiles.map( /*#__PURE__*/function () {
-                var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(tile) {
-                  var tileInstance, tileLayer;
-                  return _regeneratorRuntime.wrap(function _callee$(_context) {
-                    while (1) switch (_context.prev = _context.next) {
-                      case 0:
-                        if (_this3.tileLayerService.hasTile(tile.key)) {
-                          _context.next = 9;
-                          break;
-                        }
-                        tileInstance = getTileFactory(_this3.parent);
-                        tileLayer = new tileInstance(tile, _this3.parent);
-                        _context.next = 5;
-                        return tileLayer.initTileLayer();
-                      case 5:
-                        _this3.tilePickService.setPickState();
-                        if (tileLayer.getLayers().length !== 0) {
-                          _this3.tileLayerService.addTile(tileLayer);
-                          _this3.tileLayerService.updateTileVisible(tile);
-                          _this3.layerService.reRender();
-                        }
-                        _context.next = 12;
-                        break;
-                      case 9:
-                        // 已加载瓦片
-                        _this3.tileLayerService.updateTileVisible(tile);
-                        _this3.tilePickService.setPickState();
-                        _this3.layerService.reRender();
-                      case 12:
-                      case "end":
-                        return _context.stop();
-                    }
-                  }, _callee);
-                }));
-                return function (_x) {
-                  return _ref.apply(this, arguments);
-                };
-              }()));
-            case 7:
-              if (this.tilesetManager.isLoaded) {
-                // 将事件抛出，图层上可以使用瓦片
-                this.parent.emit('tiles-loaded', this.tilesetManager.currentTiles);
-              }
-            case 8:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function tileUpdate() {
-        return _tileUpdate.apply(this, arguments);
+    // 地图视野发生改变
+    this.mapService.on('zoomend', this.mapchange);
+    this.mapService.on('moveend', this.viewchange);
+  }
+  render() {
+    this.tileLayerService.render();
+  }
+  getLayers() {
+    return this.tileLayerService.getLayers();
+  }
+  getTiles() {
+    return this.tileLayerService.getTiles();
+  }
+  getTile(key) {
+    return this.tileLayerService.getTile(key);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tileLoaded(tile) {
+    //
+  }
+  tileError(error) {
+    console.warn('error:', error);
+  }
+  destroy() {
+    var _this$tilesetManager3;
+    this.mapService.off('zoomend', this.mapchange);
+    this.mapService.off('moveend', this.viewchange);
+    (_this$tilesetManager3 = this.tilesetManager) === null || _this$tilesetManager3 === void 0 || _this$tilesetManager3.destroy();
+    this.tileLayerService.destroy();
+  }
+  // 重新加载
+  reload() {
+    var _this$tilesetManager4;
+    // 瓦片重新加载
+    this.tilesetManager.clear();
+    const {
+      latLonBounds,
+      zoom
+    } = this.getCurrentView();
+    (_this$tilesetManager4 = this.tilesetManager) === null || _this$tilesetManager4 === void 0 || _this$tilesetManager4.update(zoom, latLonBounds);
+  }
+  tileUnLoad(tile) {
+    this.tileLayerService.removeTile(tile.key);
+  }
+  tileUpdate() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      if (!_this.tilesetManager) {
+        return;
       }
-      return tileUpdate;
-    }() // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "setPickState",
-    value: function setPickState(layers) {
-      return;
-    }
-  }, {
-    key: "pickRender",
-    value: function pickRender(target) {
-      this.tilePickService.pickRender(target);
-    }
-  }, {
-    key: "selectFeature",
-    value: function selectFeature(pickedColors) {
-      this.tilePickService.selectFeature(pickedColors);
-    }
-  }, {
-    key: "highlightPickedFeature",
-    value: function highlightPickedFeature(pickedColors) {
-      this.tilePickService.highlightPickedFeature(pickedColors);
-    }
-
-    /**
-     * 实现 TileLayer 对子图层方法的代理
-     * @param parent
-     */
-  }, {
-    key: "proxy",
-    value: function proxy(parent) {
-      var _this4 = this;
-      ProxyFuncs.forEach(function (func) {
-        // @ts-ignore
-        var oldStyleFunc = parent[func].bind(parent);
-        // @ts-ignore
-        parent[func] = function () {
-          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-          }
-          oldStyleFunc.apply(void 0, args);
-          _this4.getLayers().map(function (child) {
-            // @ts-ignore
-            child[func].apply(child, args);
-          });
-          // Tip: 目前在更新 RasterData 的 colorTexture 的时候需要额外优化
-          if (func === 'style') {
-            _this4.getTiles().forEach(function (tile) {
-              return tile.styleUpdate.apply(tile, args);
-            });
+      const minZoom = _this.parent.getMinZoom();
+      const maxZoom = _this.parent.getMaxZoom();
+      const tiles = _this.tilesetManager.tiles.filter(tile => tile.isLoaded) // 过滤未加载完成的
+      .filter(tile => tile.isVisibleChange) // 过滤未发生变化的
+      .filter(tile => tile.data) //
+      .filter(tile => tile.z >= minZoom && tile.z < maxZoom); // 过滤不可见见
+      yield Promise.all(tiles.map( /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (tile) {
+          // 未加载瓦片
+          if (!_this.tileLayerService.hasTile(tile.key)) {
+            const tileInstance = getTileFactory(_this.parent);
+            const tileLayer = new tileInstance(tile, _this.parent);
+            yield tileLayer.initTileLayer();
+            _this.tilePickService.setPickState();
+            if (tileLayer.getLayers().length !== 0) {
+              _this.tileLayerService.addTile(tileLayer);
+              _this.tileLayerService.updateTileVisible(tile);
+              _this.layerService.reRender();
+            }
+          } else {
+            // 已加载瓦片
+            _this.tileLayerService.updateTileVisible(tile);
+            _this.tilePickService.setPickState();
+            _this.layerService.reRender();
           }
-          return parent;
+        });
+        return function (_x) {
+          return _ref.apply(this, arguments);
         };
-      });
-    }
-  }]);
-  return BaseTileLayer;
-}();
-export { BaseTileLayer as default };
+      }()));
+      if (_this.tilesetManager.isLoaded) {
+        // 将事件抛出，图层上可以使用瓦片
+        _this.parent.emit('tiles-loaded', _this.tilesetManager.currentTiles);
+      }
+    })();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setPickState(layers) {
+    return;
+  }
+  pickRender(target) {
+    this.tilePickService.pickRender(target);
+  }
+  selectFeature(pickedColors) {
+    this.tilePickService.selectFeature(pickedColors);
+  }
+  highlightPickedFeature(pickedColors) {
+    this.tilePickService.highlightPickedFeature(pickedColors);
+  }
+
+  /**
+   * 实现 TileLayer 对子图层方法的代理
+   * @param parent
+   */
+  proxy(parent) {
+    ProxyFuncs.forEach(func => {
+      // @ts-ignore
+      const oldStyleFunc = parent[func].bind(parent);
+      // @ts-ignore
+      parent[func] = (...args) => {
+        oldStyleFunc(...args);
+        this.getLayers().map(child => {
+          // @ts-ignore
+          child[func](...args);
+        });
+        // Tip: 目前在更新 RasterData 的 colorTexture 的时候需要额外优化
+        if (func === 'style') {
+          this.getTiles().forEach(tile => tile.styleUpdate(...args));
+        }
+        return parent;
+      };
+    });
+  }
+}

package/es/tile/core/TileDebugLayer.js

@@ -1,28 +1,12 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), 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 _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; } catch (e) { return false; } }
 import BaseLayer from "../../core/BaseLayer";
-var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
-  _inherits(TileDebugLayer, _BaseLayer);
-  var _super = _createSuper(TileDebugLayer);
-  function TileDebugLayer() {
-    var _this;
-    _classCallCheck(this, TileDebugLayer);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _defineProperty(_assertThisInitialized(_this), "type", 'TileDebugLayer');
-    _defineProperty(_assertThisInitialized(_this), "zIndex", 10000);
-    _defineProperty(_assertThisInitialized(_this), "defaultSourceConfig", {
+export default class TileDebugLayer extends BaseLayer {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "type", 'TileDebugLayer');
+    _defineProperty(this, "zIndex", 10000);
+    _defineProperty(this, "defaultSourceConfig", {
       data: [],
       options: {
         parser: {
@@ -30,28 +14,10 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
         }
       }
     });
-    return _this;
   }
-  _createClass(TileDebugLayer, [{
-    key: "buildModels",
-    value: function () {
-      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return");
-            case 1:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }));
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
-      return buildModels;
-    }()
-  }]);
-  return TileDebugLayer;
-}(BaseLayer);
-export { TileDebugLayer as default };
+  buildModels() {
+    return _asyncToGenerator(function* () {
+      return;
+    })();
+  }
+}