@antv/l7-layers 2.10.6 → 2.10.9

package/es/tile/manager/base.js

@@ -1,55 +1,143 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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 { getTileFactory } from "../tileFactory";
-import { registerLayers } from "../utils";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { createLayerContainer } from '@antv/l7-core';
+import { updateLayersConfig } from "../style/utils";
 export var Base = /*#__PURE__*/function () {
   function Base() {
     _classCallCheck(this, Base);
 
     _defineProperty(this, "tileCache", new Map());
+
+    _defineProperty(this, "tileLayerCache", new Map());
   }
 
   _createClass(Base, [{
+    key: "initTileLayers",
+    value: function () {
+      var _initTileLayers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(layers, tile) {
+        var _this = this;
+
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", Promise.all(layers.map( /*#__PURE__*/function () {
+                  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(layer) {
+                    var container;
+                    return _regeneratorRuntime.wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            container = createLayerContainer(_this.parent.sceneContainer);
+                            layer.setContainer(container, _this.parent.sceneContainer);
+                            _context.next = 4;
+                            return layer.init();
+
+                          case 4:
+                            _this.addChild(layer);
+
+                            tile.layerLoad();
+
+                            _this.render();
+
+                          case 7:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }));
+
+                  return function (_x3) {
+                    return _ref.apply(this, arguments);
+                  };
+                }())));
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function initTileLayers(_x, _x2) {
+        return _initTileLayers.apply(this, arguments);
+      }
+
+      return initTileLayers;
+    }()
+  }, {
+    key: "render",
+    value: function render() {
+      this.parent.renderLayers();
+    }
+  }, {
     key: "hasTile",
     value: function hasTile(tile) {
-      return !!this.tileCache.has(tile.key);
-    }
+      return this.tileCache.has(tile.key);
+    } // 添加图层
+
   }, {
     key: "addTile",
-    value: function addTile(tile) {
-      var _tile$layerIDList;
+    value: function () {
+      var _addTile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(tile) {
+        var layerCollections;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (!this.hasTile(tile)) {
+                  _context3.next = 2;
+                  break;
+                }
 
-      // oldTile 存在的时候暂时直接结束
-      // TODO：合并不存在的时候
-      if (this.hasTile(tile)) return {
-        layers: [],
-        layerIDList: []
-      }; // 存储当前 tile
+                return _context3.abrupt("return", {
+                  layers: []
+                });
 
-      this.tileCache.set(tile.key, tile); // 创建 tile 对应的 layers
+              case 2:
+                // 存储当前 tile
+                this.tileCache.set(tile.key, tile); // 创建 tile 对应的 layers
 
-      var layerCollections = this.tileFactory.createTile(tile, this.initOptions); // regist layer 将创建出来的 layer 进行注册初始化操作
+                layerCollections = this.tileFactory.createTile(tile, this.initOptions); // // 初始化图层
 
-      registerLayers(this.parent, layerCollections.layers);
+                _context3.next = 6;
+                return this.initTileLayers(layerCollections.layers, tile);
 
-      (_tile$layerIDList = tile.layerIDList).push.apply(_tile$layerIDList, _toConsumableArray(layerCollections.layerIDList)); // add layer into layerGroup
+              case 6:
+                this.tileLayerCache.set(tile.key, layerCollections.layers); // const visible =  tile.parent ? tile.parent.children.every(t=>this.tileLayerCache.has(t.key)) : true
+                // tile.parent?.children.forEach((t)=>{
+                //   updateLayersConfig(this.getLayers(t),'visible',visible)
+                // })
 
+                return _context3.abrupt("return", layerCollections);
 
-      this.addChildren(layerCollections.layers);
-      layerCollections.layers.map(function (layer) {
-        layer.once('modelLoaded', function () {
-          tile.layerLoad();
-        });
-      });
-      return layerCollections;
-    }
+              case 8:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function addTile(_x4) {
+        return _addTile.apply(this, arguments);
+      }
+
+      return addTile;
+    }()
   }, {
     key: "removeTile",
     value: function removeTile(tile) {
       this.tileCache.delete(tile.key);
-      this.removeChildren(tile.layerIDList, false);
+      var layers = this.tileLayerCache.get(tile.key);
+      this.tileLayerCache.delete(tile.key);
+      this.removeLayers(layers, false);
     }
   }, {
     key: "addChild",
@@ -64,18 +152,16 @@ export var Base = /*#__PURE__*/function () {
       (_this$children = this.children).push.apply(_this$children, _toConsumableArray(layers));
     }
   }, {
-    key: "removeChildren",
-    value: function removeChildren(layerIDList) {
+    key: "removeLayers",
+    value: function removeLayers() {
+      var layers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       var refresh = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var remveLayerList = [];
-      var cacheLayerList = [];
-      this.children.filter(function (child) {
-        layerIDList.includes(child.id) ? remveLayerList.push(child) : cacheLayerList.push(child);
+      this.children = this.children.filter(function (child) {
+        return !layers.includes(child);
       });
-      remveLayerList.map(function (layer) {
+      layers.map(function (layer) {
         return layer.destroy(refresh);
       });
-      this.children = cacheLayerList;
     }
   }, {
     key: "removeChild",
@@ -89,11 +175,10 @@ export var Base = /*#__PURE__*/function () {
       layer.destroy();
     }
   }, {
-    key: "getChildren",
-    value: function getChildren(layerIDList) {
-      return this.children.filter(function (child) {
-        return layerIDList.includes(child.id);
-      });
+    key: "getLayers",
+    value: function getLayers(tile) {
+      if (!tile) return [];
+      return this.tileLayerCache.get(tile.key) || [];
     }
   }, {
     key: "getChild",
@@ -117,14 +202,11 @@ export var Base = /*#__PURE__*/function () {
     }
   }, {
     key: "initTileFactory",
-    value: function initTileFactory() {
-      var source = this.parent.getSource();
-      var TileFactory = getTileFactory(this.parent.type, source.parser);
-      this.tileFactory = new TileFactory({
-        parent: this.parent,
-        mapService: this.mapService,
-        rendererService: this.rendererService
-      });
+    value: function initTileFactory() {// this.tileFactory = new TileFactory({
+      //   parent: this.parent,
+      //   mapService: this.mapService,
+      //   rendererService: this.rendererService,
+      // });
     }
   }, {
     key: "getSourceLayer",
@@ -137,9 +219,92 @@ export var Base = /*#__PURE__*/function () {
         return sourceLayer;
       }
     }
+  }, {
+    key: "updateTileVisible",
+    value: function updateTileVisible(tile, layerService) {
+      var layers = this.getLayers(tile);
+      if (layers.length === 0) return;
+
+      if (tile.isVisible) {
+        // 如果可见直接进行渲染，父级发
+        updateLayersConfig(layers, 'visible', tile.isVisible);
+      } else {
+        // 如果不可见，放大，等到子瓦片渲染完成，缩小：父级渲染成功
+        // console.log('updateTileVisible',`${tile.x}_${tile.y}_${tile.z}`,tile.isVisible)
+        // console.log(tile);
+        // console.log(`子瓦片${tile.x}/${tile.y}/${tile.z}`,tile.children.length)
+        // tile.children.forEach((t)=>{
+        //   console.log(`${t.x}/${t.y}/${t.z}`)
+        // })
+        updateLayersConfig(layers, 'visible', tile.isVisible);
+      } // this.listenLoad(tile, () => {
+      //   this.isTileAllLoad(tile) && updateLayersConfig(layers, 'visible', tile.isVisible);
+      // })
+
+    }
+  }, {
+    key: "listenLoad",
+    value: function listenLoad(tile, callback) {
+      var _tile$parent;
+
+      tile.once('layerLoaded', function () {
+        callback();
+      });
+      tile.children.map(function (childTile) {
+        childTile.once('layerLoaded', function () {
+          callback();
+        });
+      });
+      (_tile$parent = tile.parent) === null || _tile$parent === void 0 ? void 0 : _tile$parent.once('layerLoaded', function () {
+        callback();
+      });
+    }
+  }, {
+    key: "isTileLoaded",
+    value: function isTileLoaded(tile) {
+      if (tile.isLoad) return true;
+      var isLoad = this.getLayers(tile).length === tile.loadedLayers;
+      tile.isLoad = isLoad;
+      return isLoad;
+    }
+  }, {
+    key: "isTileChildLoaded",
+    value: function isTileChildLoaded(tile) {
+      var _this2 = this;
+
+      if (tile.isChildLoad) return true;
+      var children = tile.children;
+      var isLoad = children.filter(function (child) {
+        return _this2.isTileLoaded(child);
+      }).length === children.length;
+      tile.isChildLoad = isLoad;
+      return isLoad;
+    }
+  }, {
+    key: "isTileParentLoaded",
+    value: function isTileParentLoaded(tile) {
+      var parent = tile.parent;
+
+      if (!parent) {
+        return true;
+      } else {
+        return this.isTileLoaded(parent);
+      }
+    }
+  }, {
+    key: "isTileAllLoad",
+    value: function isTileAllLoad(tile) {
+      var tileLoaded = this.isTileLoaded(tile);
+      var tileChildLoaded = this.isTileChildLoaded(tile);
+      var tileParentLoaded = this.isTileParentLoaded(tile);
+      return tileLoaded && tileChildLoaded && tileParentLoaded;
+    }
   }, {
     key: "destroy",
-    value: function destroy() {}
+    value: function destroy() {
+      this.tileCache.clear();
+      this.tileLayerCache.clear();
+    }
   }]);
 
   return Base;

package/es/tile/service/TileLayerService.d.ts

@@ -0,0 +1,34 @@
+import { ILayer, ILayerService, ILngLat, IRendererService, ITile } from '@antv/l7-core';
+import { SourceTile } from '@antv/l7-utils';
+import 'reflect-metadata';
+interface TileLayerServiceOptions {
+    rendererService: IRendererService;
+    layerService: ILayerService;
+    parent: ILayer;
+}
+export declare class TileLayerService {
+    /**
+     * tileResource 用于存储瓦片的全局资源
+     */
+    tileResource: Map<any, any>;
+    private rendererService;
+    private layerService;
+    private parent;
+    private _tiles;
+    constructor({ rendererService, layerService, parent }: TileLayerServiceOptions);
+    get tiles(): ITile[];
+    hasTile(tileKey: string): boolean;
+    addTile(tile: ITile): void;
+    getTile(tileKey: string): ITile | undefined;
+    getVisibleTileBylngLat(lngLat: ILngLat): ITile | undefined;
+    removeTile(tileKey: string): void;
+    updateTileVisible(sourceTile: SourceTile): void;
+    isParentLoaded(sourceTile: SourceTile): boolean;
+    isChildrenLoaded(sourceTile: SourceTile): boolean;
+    render(): Promise<void>;
+    getRenderLayers(): ILayer[];
+    getLayers(): ILayer[];
+    getTiles(): ITile[];
+    destroy(): void;
+}
+export {};

package/es/tile/service/TileLayerService.js

@@ -0,0 +1,220 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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 'reflect-metadata';
+export var TileLayerService = /*#__PURE__*/function () {
+  /**
+   * tileResource 用于存储瓦片的全局资源
+   */
+  function TileLayerService(_ref) {
+    var rendererService = _ref.rendererService,
+        layerService = _ref.layerService,
+        parent = _ref.parent;
+
+    _classCallCheck(this, TileLayerService);
+
+    _defineProperty(this, "tileResource", new Map());
+
+    _defineProperty(this, "_tiles", []);
+
+    this.rendererService = rendererService;
+    this.layerService = layerService;
+    this.parent = parent;
+  }
+
+  _createClass(TileLayerService, [{
+    key: "tiles",
+    get: function get() {
+      return this._tiles;
+    }
+  }, {
+    key: "hasTile",
+    value: function hasTile(tileKey) {
+      return this._tiles.some(function (tile) {
+        return tile.key === tileKey;
+      });
+    }
+  }, {
+    key: "addTile",
+    value: function addTile(tile) {
+      this._tiles.push(tile);
+    }
+  }, {
+    key: "getTile",
+    value: function getTile(tileKey) {
+      return this._tiles.find(function (tile) {
+        return tile.key === tileKey;
+      });
+    }
+  }, {
+    key: "getVisibleTileBylngLat",
+    value: function getVisibleTileBylngLat(lngLat) {
+      // 加载完成 & 可见 & 鼠标选中
+      return this._tiles.find(function (tile) {
+        return tile.isLoaded && tile.visible && tile.lnglatInBounds(lngLat);
+      });
+    }
+  }, {
+    key: "removeTile",
+    value: function removeTile(tileKey) {
+      var index = this._tiles.findIndex(function (tile) {
+        return tile.key === tileKey;
+      });
+
+      var tile = this._tiles.splice(index, 1);
+
+      tile[0] && tile[0].destroy();
+    }
+  }, {
+    key: "updateTileVisible",
+    value: function updateTileVisible(sourceTile) {
+      var tile = this.getTile(sourceTile.key); // if(sourceTile.isVisible) {
+      //   // 不可见 => 可见 兄弟节点加载完成
+      //   if(sourceTile.parent) {
+      //     const flag = this.isChildrenLoaded(sourceTile.parent)
+      //     tile?.updateVisible(flag);
+      //   } else {
+      //     tile?.updateVisible(true);
+      //   }
+      // } else {
+      //    // 可见 => 不可见 兄弟节点加载完成
+      //    if(sourceTile.parent) {
+      //     const flag = this.isChildrenLoaded(sourceTile.parent)
+      //     tile?.updateVisible(!flag);
+      //   } else {
+      //     tile?.updateVisible(false);
+      //   }
+      // }
+
+      tile === null || tile === void 0 ? void 0 : tile.updateVisible(sourceTile.isVisible);
+    }
+  }, {
+    key: "isParentLoaded",
+    value: function isParentLoaded(sourceTile) {
+      var parentTile = sourceTile.parent;
+
+      if (!parentTile) {
+        return true;
+      }
+
+      var tile = this.getTile(parentTile === null || parentTile === void 0 ? void 0 : parentTile.key);
+
+      if (tile !== null && tile !== void 0 && tile.isLoaded) {
+        // 递归父级
+        return true;
+      }
+
+      return false;
+    }
+  }, {
+    key: "isChildrenLoaded",
+    value: function isChildrenLoaded(sourceTile) {
+      var _this = this;
+
+      var childrenTile = sourceTile === null || sourceTile === void 0 ? void 0 : sourceTile.children;
+
+      if (childrenTile.length === 0) {
+        return true;
+      }
+
+      return childrenTile.some(function (tile) {
+        var tileLayer = _this.getTile(tile === null || tile === void 0 ? void 0 : tile.key);
+
+        return (tileLayer === null || tileLayer === void 0 ? void 0 : tileLayer.isLoaded) === false;
+      });
+    }
+  }, {
+    key: "render",
+    value: function () {
+      var _render = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var _this2 = this;
+
+        var layers;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                layers = this.getRenderLayers();
+                layers.map( /*#__PURE__*/function () {
+                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(layer) {
+                    return _regeneratorRuntime.wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            _context.next = 2;
+                            return _this2.layerService.renderLayer(layer);
+
+                          case 2:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }));
+
+                  return function (_x) {
+                    return _ref2.apply(this, arguments);
+                  };
+                }());
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function render() {
+        return _render.apply(this, arguments);
+      }
+
+      return render;
+    }()
+  }, {
+    key: "getRenderLayers",
+    value: function getRenderLayers() {
+      var tileList = this._tiles.filter(function (t) {
+        return t.visible && t.isLoaded;
+      });
+
+      var layers = [];
+      tileList.map(function (tile) {
+        return layers.push.apply(layers, _toConsumableArray(tile.getLayers()));
+      });
+      return layers;
+    }
+  }, {
+    key: "getLayers",
+    value: function getLayers() {
+      var tileList = this._tiles.filter(function (t) {
+        return t.isLoaded;
+      });
+
+      var layers = [];
+      tileList.map(function (tile) {
+        return layers.push.apply(layers, _toConsumableArray(tile.getLayers()));
+      });
+      return layers;
+    }
+  }, {
+    key: "getTiles",
+    value: function getTiles() {
+      return this._tiles;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._tiles.forEach(function (t) {
+        return t.destroy();
+      });
+
+      this.tileResource.clear();
+    }
+  }]);
+
+  return TileLayerService;
+}();

package/es/tile/service/TilePickService.d.ts

@@ -0,0 +1,26 @@
+import { ILayerService, ITilePickService, IInteractionTarget, ILayer } from '@antv/l7-core';
+import { TileLayerService } from './TileLayerService';
+export interface ITilePickServiceOptions {
+    layerService: ILayerService;
+    tileLayerService: TileLayerService;
+    parent: ILayer;
+}
+export declare class TilePickService implements ITilePickService {
+    private layerService;
+    private tileLayerService;
+    private tileSourceService;
+    private parent;
+    private tilePickID;
+    constructor({ layerService, tileLayerService, parent }: ITilePickServiceOptions);
+    pickRender(target: IInteractionTarget): void;
+    pick(layer: ILayer, target: IInteractionTarget): boolean;
+    selectFeature(pickedColors: Uint8Array | undefined): void;
+    highlightPickedFeature(pickedColors: Uint8Array | undefined): void;
+    updateHighLight(r: number, g: number, b: number, type: string): void;
+    setPickState(): void;
+    private color2PickId;
+    private pickId2Color;
+    /** 从瓦片中根据数据 */
+    getFeatureById(pickedFeatureIdx: number): never[] | null;
+    pickRasterLayer(layer: ILayer, target: IInteractionTarget, parent?: ILayer): boolean;
+}