@antv/l7-layers 2.10.5 → 2.10.7

package/lib/tile/service/TileLayerService.js

@@ -0,0 +1,233 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileLayerService = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+require("reflect-metadata");
+
+var TileLayerService = /*#__PURE__*/function () {
+  /**
+   * tileResource 用于存储瓦片的全局资源
+   */
+  function TileLayerService(_ref) {
+    var rendererService = _ref.rendererService,
+        layerService = _ref.layerService,
+        parent = _ref.parent;
+    (0, _classCallCheck2.default)(this, TileLayerService);
+    (0, _defineProperty2.default)(this, "tileResource", new Map());
+    (0, _defineProperty2.default)(this, "_tiles", []);
+    this.rendererService = rendererService;
+    this.layerService = layerService;
+    this.parent = parent;
+  }
+
+  (0, _createClass2.default)(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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var _this2 = this;
+
+        var layers;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                layers = this.getRenderLayers();
+                layers.map( /*#__PURE__*/function () {
+                  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(layer) {
+                    return _regenerator.default.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, (0, _toConsumableArray2.default)(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, (0, _toConsumableArray2.default)(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;
+}();
+
+exports.TileLayerService = TileLayerService;

package/lib/tile/service/TilePickService.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TilePickService = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _l7Core = require("@antv/l7-core");
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _TileSourceService = require("./TileSourceService");
+
+var SELECT = 'select';
+var ACTIVE = 'active';
+
+var TilePickService = /*#__PURE__*/function () {
+  function TilePickService(_ref) {
+    var layerService = _ref.layerService,
+        tileLayerService = _ref.tileLayerService,
+        parent = _ref.parent;
+    (0, _classCallCheck2.default)(this, TilePickService);
+    (0, _defineProperty2.default)(this, "tilePickID", new Map());
+    this.layerService = layerService;
+    this.tileLayerService = tileLayerService;
+    this.parent = parent;
+    this.tileSourceService = new _TileSourceService.TileSourceService();
+  }
+
+  (0, _createClass2.default)(TilePickService, [{
+    key: "pickRender",
+    value: function pickRender(target) {
+      // 一个 TileLayer 有多个 Tile，但是会同时触发事件的只有一个 Tile
+      var tile = this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
+
+      if (tile) {
+        // TODO 多图层拾取
+        var pickLayer = tile.getMainLayer();
+        pickLayer === null || pickLayer === void 0 ? void 0 : pickLayer.layerPickService.pickRender(target);
+      }
+    }
+  }, {
+    key: "pick",
+    value: function pick(layer, target) {
+      var container = this.parent.getContainer();
+      var pickingService = container.get(_l7Core.TYPES.IPickingService);
+
+      if (layer.type === 'RasterLayer') {
+        var tile = this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
+
+        if (tile && tile.getMainLayer() !== undefined) {
+          var pickLayer = tile.getMainLayer();
+          return pickLayer.layerPickService.pickRasterLayer(pickLayer, target, this.parent);
+        }
+
+        return false;
+      }
+
+      this.pickRender(target);
+      return pickingService.pickFromPickingFBO(layer, target);
+    }
+  }, {
+    key: "selectFeature",
+    value: function selectFeature(pickedColors) {
+      // @ts-ignore
+      var _pickedColors = (0, _slicedToArray2.default)(pickedColors, 3),
+          r = _pickedColors[0],
+          g = _pickedColors[1],
+          b = _pickedColors[2];
+
+      var id = this.color2PickId(r, g, b);
+      this.tilePickID.set(SELECT, id);
+      this.updateHighLight(r, g, b, SELECT);
+    }
+  }, {
+    key: "highlightPickedFeature",
+    value: function highlightPickedFeature(pickedColors) {
+      // @ts-ignore
+      var _pickedColors2 = (0, _slicedToArray2.default)(pickedColors, 3),
+          r = _pickedColors2[0],
+          g = _pickedColors2[1],
+          b = _pickedColors2[2];
+
+      var id = this.color2PickId(r, g, b);
+      this.tilePickID.set(ACTIVE, id);
+      this.updateHighLight(r, g, b, ACTIVE);
+    }
+  }, {
+    key: "updateHighLight",
+    value: function updateHighLight(r, g, b, type) {
+      this.tileLayerService.tiles.map(function (tile) {
+        var layer = tile.getMainLayer();
+
+        switch (type) {
+          case SELECT:
+            layer === null || layer === void 0 ? void 0 : layer.hooks.beforeSelect.call([r, g, b]);
+            break;
+
+          case ACTIVE:
+            layer === null || layer === void 0 ? void 0 : layer.hooks.beforeHighlight.call([r, g, b]);
+            break;
+        }
+      });
+    }
+  }, {
+    key: "setPickState",
+    value: function setPickState() {
+      var selectColor = this.tilePickID.get(SELECT);
+      var activeColor = this.tilePickID.get(ACTIVE);
+
+      if (selectColor) {
+        var _this$pickId2Color = this.pickId2Color(selectColor),
+            _this$pickId2Color2 = (0, _slicedToArray2.default)(_this$pickId2Color, 3),
+            r = _this$pickId2Color2[0],
+            g = _this$pickId2Color2[1],
+            b = _this$pickId2Color2[2];
+
+        this.updateHighLight(r, g, b, SELECT);
+        return;
+      }
+
+      if (activeColor) {
+        var _this$pickId2Color3 = this.pickId2Color(activeColor),
+            _this$pickId2Color4 = (0, _slicedToArray2.default)(_this$pickId2Color3, 3),
+            _r = _this$pickId2Color4[0],
+            _g = _this$pickId2Color4[1],
+            _b = _this$pickId2Color4[2];
+
+        this.updateHighLight(_r, _g, _b, ACTIVE);
+        return;
+      }
+    }
+  }, {
+    key: "color2PickId",
+    value: function color2PickId(r, g, b) {
+      return (0, _l7Utils.decodePickingColor)(new Uint8Array([r, g, b]));
+    }
+  }, {
+    key: "pickId2Color",
+    value: function pickId2Color(str) {
+      return (0, _l7Utils.encodePickingColor)(str);
+    }
+    /** 从瓦片中根据数据 */
+
+  }, {
+    key: "getFeatureById",
+    value: function getFeatureById(pickedFeatureIdx) {
+      // 提取当前可见瓦片
+      var tiles = this.tileLayerService.getTiles().filter(function (tile) {
+        return tile.visible;
+      }); // 提取当前可见瓦片中匹配 ID 的 feature 列表
+
+      var features = [];
+      tiles.map(function (tile) {
+        features.push.apply(features, (0, _toConsumableArray2.default)(tile.getFeatureById(pickedFeatureIdx)));
+      });
+
+      if (features.length <= 0) {
+        return null;
+      } // 将 feature 列表合并后返回
+      // 统一返回成 polygon 的格式 点、线、面可以通用
+      // const data = this.tileSourceService.getCombineFeature(features);
+
+
+      return [];
+    } // Tip: for interface define
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+  }, {
+    key: "pickRasterLayer",
+    value: function pickRasterLayer(layer, target, parent) {
+      return false;
+    }
+  }]);
+  return TilePickService;
+}();
+
+exports.TilePickService = TilePickService;

package/lib/tile/service/TileSourceService.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileSourceService = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var turf = _interopRequireWildcard(require("@turf/helpers"));
+
+var _union = _interopRequireDefault(require("@turf/union"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * 专门处理 Tile 数据相关
+ */
+var TileSourceService = /*#__PURE__*/function () {
+  function TileSourceService() {
+    (0, _classCallCheck2.default)(this, TileSourceService);
+  }
+
+  (0, _createClass2.default)(TileSourceService, [{
+    key: "getCombineFeature",
+    value: function getCombineFeature(features) {
+      var p = null;
+      var properties = features[0];
+      features.map(function (feature) {
+        var polygon = turf.polygon(feature.coordinates);
+
+        if (p === null) {
+          p = polygon;
+        } else {
+          p = (0, _union.default)(p, polygon);
+        }
+      });
+
+      if (properties) {
+        p.properties = (0, _objectSpread2.default)({}, properties);
+      }
+
+      return p;
+    }
+  }]);
+  return TileSourceService;
+}();
+
+exports.TileSourceService = TileSourceService;

package/lib/tile/style/constants.js

@@ -3,24 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.styles = exports.Attributes = void 0;
-
+exports.ProxyFuncs = void 0;
+// TileLayer 需要代理的子图层的方法
+// 一般都是在 BaseLayer 上的方法
+var ProxyFuncs = [
 /**
- * 瓦片图层的样式
+ * 1. 需要作用到所属子图层才会生效的方法
+ * 2. 不需要主动重新创建 model 的方法
  */
-var Attributes = ['size', 'color', 'shape'];
-exports.Attributes = Attributes;
-var common = ['opacity', 'zIndex'];
-var rasterLayer = ['mask', 'rampColors', 'domain', 'clampHigh', 'clampLow', 'pixelConstant', 'pixelConstantR', 'pixelConstantG', 'pixelConstantB', 'pixelConstantRGB'].concat(common);
-var pointLayer = ['stroke', 'strokeWidth', 'strokeOpacity', 'color', 'shape', 'size'].concat(common);
-var lineLayer = ['stroke', 'strokeWidth', 'strokeOpacity', 'color', 'shape', 'size'].concat(common);
-var polygonLayer = ['color', 'shape'].concat(common);
-var styles = {
-  'PointLayer': pointLayer,
-  'LineLayer': lineLayer,
-  'PolygonLayer': polygonLayer,
-  'RasterLayer': rasterLayer,
-  'MaskLayer': [],
-  'TileDebugLayer': []
-};
-exports.styles = styles;
+'shape', 'color', 'size', 'style', 'animate', 'filter', 'rotate', 'scale', 'setBlend', 'setSelect', 'setActive'];
+exports.ProxyFuncs = ProxyFuncs;

package/lib/tile/style/utils.js

@@ -5,37 +5,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getDefaultStyleAttributeField = getDefaultStyleAttributeField;
-exports.getLayerShape = getLayerShape;
-exports.parseScaleValue = parseScaleValue;
-exports.setScale = setScale;
-exports.setStyleAttributeField = setStyleAttributeField;
 exports.updateLayersConfig = updateLayersConfig;
-exports.updateTexture = updateTexture;
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _l7Utils = require("@antv/l7-utils");
-
-function updateTexture(config, layers, rendererService) {
-  var createTexture2D = rendererService.createTexture2D;
-  var imageData = (0, _l7Utils.generateColorRamp)(config);
-  var texture = createTexture2D({
-    data: imageData.data,
-    width: imageData.width,
-    height: imageData.height,
-    flipY: false
-  });
-  layers.map(function (layer) {
-    layer.updateLayerConfig({
-      colorTexture: texture
-    });
-  });
-  return texture;
-}
-
 function updateLayersConfig(layers, key, value) {
   layers.map(function (layer) {
     if (key === 'mask') {
@@ -47,117 +20,4 @@ function updateLayersConfig(layers, key, value) {
       layer.updateLayerConfig((0, _defineProperty2.default)({}, key, value));
     }
   });
-}
-
-function setStyleAttributeField(layer, parent, style, value) {
-  if (Array.isArray(value)) {
-    // @ts-ignore
-    layer[style].apply(layer, (0, _toConsumableArray2.default)(value));
-    return;
-  }
-
-  if (typeof value === 'string') {
-    layer[style](value);
-    return;
-  }
-
-  var defaultValue = getDefaultStyleAttributeField(layer, parent.type, style);
-
-  if (!value) {
-    layer[style](defaultValue);
-    return layer;
-  }
-
-  var params = parseScaleValue(value, style);
-
-  if (params.length === 0) {
-    layer[style](defaultValue);
-  } else {
-    // @ts-ignore
-    layer[style].apply(layer, (0, _toConsumableArray2.default)(params));
-  }
-}
-
-function getDefaultStyleAttributeField(layer, type, style) {
-  switch (style) {
-    case 'size':
-      return 1;
-
-    case 'color':
-      return '#fff';
-
-    case 'shape':
-      return getLayerShape(type, layer);
-
-    default:
-      return '';
-  }
-}
-
-function getLayerShape(layerType, layer) {
-  var _layerShape$scale;
-
-  var layerShape = layer.getAttribute('shape');
-
-  if (layerShape && (_layerShape$scale = layerShape.scale) !== null && _layerShape$scale !== void 0 && _layerShape$scale.field) {
-    var _layerShape$scale2;
-
-    if (((_layerShape$scale2 = layerShape.scale) === null || _layerShape$scale2 === void 0 ? void 0 : _layerShape$scale2.values) === 'text') {
-      return [layerShape.scale.field, layerShape.scale.values];
-    }
-
-    return layerShape.scale.field;
-  }
-
-  switch (layerType) {
-    case 'PolygonLayer':
-      return 'fill';
-
-    case 'LineLayer':
-      return 'tileline';
-
-    case 'PointLayer':
-      return 'circle';
-
-    case 'RasterLayer':
-      return 'image';
-
-    default:
-      return '';
-  }
-}
-
-function parseScaleValue(value, type) {
-  if (type === 'shape') {
-    if (typeof value === 'string') {
-      return [value];
-    } else if (value !== null && value !== void 0 && value.field) {
-      return [value === null || value === void 0 ? void 0 : value.field];
-    } else {
-      return [];
-    }
-  }
-
-  var _ref = value,
-      field = _ref.field,
-      values = _ref.values,
-      callback = _ref.callback;
-
-  if (field && values && Array.isArray(values)) {
-    return [field, values];
-  } else if (field && callback) {
-    return [field, callback];
-  } else if (field) {
-    return [field];
-  }
-
-  return [];
-}
-
-function setScale(layer, parent) {
-  var scaleOptions = parent.tileLayer.scaleField;
-  var scaleKeys = Object.keys(scaleOptions);
-  scaleKeys.map(function (key) {
-    layer.scale(key, scaleOptions[key]);
-  });
 }