@antv/l7-layers 2.10.1 → 2.10.2

package/es/tile/style/constants.js

@@ -1,17 +1,8 @@
+// TileLayer 需要代理的子图层的方法
+// 一般都是在 BaseLayer 上的方法
+export var ProxyFuncs = [
 /**
- * 瓦片图层的样式
+ * 1. 需要作用到所属子图层才会生效的方法
+ * 2. 不需要主动重新创建 model 的方法
  */
-export var Attributes = ['size', 'color', 'shape'];
-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);
-export var styles = {
-  'PointLayer': pointLayer,
-  'LineLayer': lineLayer,
-  'PolygonLayer': polygonLayer,
-  'RasterLayer': rasterLayer,
-  'MaskLayer': [],
-  'TileDebugLayer': []
-};
+'shape', 'color', 'size', 'style', 'animate', 'filter', 'rotate', 'scale', 'setBlend', 'setSelect', 'setActive'];

package/es/tile/style/utils.d.ts

@@ -1,9 +1,2 @@
-import { ILayer, IRendererService, ScaleAttributeType, IScaleValue } from '@antv/l7-core';
-import { IColorRamp } from '@antv/l7-utils';
-export declare function updateTexture(config: IColorRamp, layers: ILayer[], rendererService: IRendererService): import("@antv/l7-core").ITexture2D;
+import { ILayer } from '@antv/l7-core';
 export declare function updateLayersConfig(layers: ILayer[], key: string, value: any): void;
-export declare function setStyleAttributeField(layer: ILayer, parent: ILayer, style: ScaleAttributeType, value: IScaleValue | undefined | string | string[]): ILayer | undefined;
-export declare function getDefaultStyleAttributeField(layer: ILayer, type: string, style: string): string | string[] | 1;
-export declare function getLayerShape(layerType: string, layer: ILayer): string | string[];
-export declare function parseScaleValue(value: IScaleValue | string, type: string): (string | number | any[])[] | (import("@antv/l7-core").StyleAttributeField | ((...args: any[]) => [] | undefined))[];
-export declare function setScale(layer: ILayer, parent: ILayer): void;

package/es/tile/style/utils.js

@@ -1,22 +1,4 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { generateColorRamp } from '@antv/l7-utils';
-export function updateTexture(config, layers, rendererService) {
-  var createTexture2D = rendererService.createTexture2D;
-  var imageData = 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;
-}
 export function updateLayersConfig(layers, key, value) {
   layers.map(function (layer) {
     if (key === 'mask') {
@@ -28,112 +10,4 @@ export function updateLayersConfig(layers, key, value) {
       layer.updateLayerConfig(_defineProperty({}, key, value));
     }
   });
-}
-export function setStyleAttributeField(layer, parent, style, value) {
-  if (Array.isArray(value)) {
-    // @ts-ignore
-    layer[style].apply(layer, _toConsumableArray(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, _toConsumableArray(params));
-  }
-}
-export function getDefaultStyleAttributeField(layer, type, style) {
-  switch (style) {
-    case 'size':
-      return 1;
-
-    case 'color':
-      return '#fff';
-
-    case 'shape':
-      return getLayerShape(type, layer);
-
-    default:
-      return '';
-  }
-}
-export 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 '';
-  }
-}
-export 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 [];
-}
-export function setScale(layer, parent) {
-  var scaleOptions = parent.tileLayer.scaleField;
-  var scaleKeys = Object.keys(scaleOptions);
-  scaleKeys.map(function (key) {
-    layer.scale(key, scaleOptions[key]);
-  });
 }

package/es/tile/tileFactory/DebugTile.d.ts

@@ -0,0 +1,16 @@
+import Tile from './Tile';
+export default class DebugTile extends Tile {
+    initTileLayer(): Promise<void>;
+    protected getSourceOption(): {
+        data: {
+            type: string;
+            features: any;
+        };
+        options: {
+            parser: {
+                type: string;
+            };
+            transforms: import("@antv/l7-core").ITransform[];
+        };
+    };
+}

package/es/tile/tileFactory/DebugTile.js

@@ -0,0 +1,100 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+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 Tile from "./Tile";
+import PointLayer from "../../point";
+import LineLayer from "../../line";
+
+var DebugTile = /*#__PURE__*/function (_Tile) {
+  _inherits(DebugTile, _Tile);
+
+  var _super = _createSuper(DebugTile);
+
+  function DebugTile() {
+    _classCallCheck(this, DebugTile);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(DebugTile, [{
+    key: "initTileLayer",
+    value: function () {
+      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var sourceOptions, pointData, lineLayer, pointLayer;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                sourceOptions = this.getSourceOption();
+                pointData = sourceOptions.data.features[0].properties;
+                lineLayer = new LineLayer().source(sourceOptions.data, sourceOptions.options).size(1).shape('line').color('red');
+                pointLayer = new PointLayer({
+                  minZoom: this.z - 1,
+                  maxZoom: this.z + 1
+                }).source([pointData], {
+                  parser: {
+                    type: 'json',
+                    x: 'textLng',
+                    y: 'textLat'
+                  }
+                }).size(20).color('red').shape(this.key).style({
+                  stroke: '#fff',
+                  strokeWidth: 2
+                });
+                _context.next = 6;
+                return this.addLayer(lineLayer);
+
+              case 6:
+                _context.next = 8;
+                return this.addLayer(pointLayer);
+
+              case 8:
+                this.isLoaded = true;
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }()
+  }, {
+    key: "getSourceOption",
+    value: function getSourceOption() {
+      var rawSource = this.parent.getSource();
+      var features = this.sourceTile.data.layers['testTile'].features;
+      return {
+        data: {
+          type: 'FeatureCollection',
+          features: features
+        },
+        options: {
+          parser: {
+            type: 'geojson'
+          },
+          transforms: rawSource.transforms
+        }
+      };
+    }
+  }]);
+
+  return DebugTile;
+}(Tile);
+
+export { DebugTile as default };

package/es/tile/tileFactory/ImageTile.d.ts

@@ -0,0 +1,14 @@
+import Tile from './Tile';
+export default class ImageTile extends Tile {
+    initTileLayer(): Promise<void>;
+    protected getSourceOption(): {
+        data: any;
+        options: {
+            parser: {
+                type: string;
+                extent: import("@antv/l7-utils").TileBounds;
+            };
+            transforms: import("@antv/l7-core").ITransform[];
+        };
+    };
+}

package/es/tile/tileFactory/ImageTile.js

@@ -0,0 +1,89 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+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 ImageLayer from "../../image";
+import Tile from "./Tile";
+
+var ImageTile = /*#__PURE__*/function (_Tile) {
+  _inherits(ImageTile, _Tile);
+
+  var _super = _createSuper(ImageTile);
+
+  function ImageTile() {
+    _classCallCheck(this, ImageTile);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(ImageTile, [{
+    key: "initTileLayer",
+    value: function () {
+      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var attributes, layerOptions, sourceOptions, layer;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                attributes = this.parent.getLayerAttributeConfig();
+                layerOptions = this.parent.getLayerConfig();
+                sourceOptions = this.getSourceOption();
+                layer = new ImageLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options); // 初始化数据映射
+
+                attributes && Object.keys(attributes).forEach(function (type) {
+                  var _attributes$attr, _attributes$attr2;
+
+                  var attr = type; // @ts-ignore
+
+                  layer[attr]((_attributes$attr = attributes[attr]) === null || _attributes$attr === void 0 ? void 0 : _attributes$attr.field, (_attributes$attr2 = attributes[attr]) === null || _attributes$attr2 === void 0 ? void 0 : _attributes$attr2.values);
+                });
+                _context.next = 7;
+                return this.addLayer(layer);
+
+              case 7:
+                this.isLoaded = true;
+
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }()
+  }, {
+    key: "getSourceOption",
+    value: function getSourceOption() {
+      var rawSource = this.parent.getSource();
+      return {
+        data: this.sourceTile.data,
+        options: {
+          parser: {
+            type: 'image',
+            extent: this.sourceTile.bounds
+          },
+          transforms: rawSource.transforms
+        }
+      };
+    }
+  }]);
+
+  return ImageTile;
+}(Tile);
+
+export { ImageTile as default };

package/es/tile/tileFactory/MaskTile.d.ts

@@ -0,0 +1,17 @@
+import Tile from './Tile';
+export default class MaskTile extends Tile {
+    initTileLayer(): Promise<void>;
+    protected getSourceOption(): {
+        data: {
+            type: string;
+            features: any;
+        };
+        options: {
+            parser: {
+                type: string;
+                featureId: string | undefined;
+            };
+            transforms: import("@antv/l7-core").ITransform[];
+        };
+    };
+}

package/es/tile/tileFactory/MaskTile.js

@@ -0,0 +1,98 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+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 MaskLayer from "../../mask";
+import Tile from "./Tile";
+
+var MaskTile = /*#__PURE__*/function (_Tile) {
+  _inherits(MaskTile, _Tile);
+
+  var _super = _createSuper(MaskTile);
+
+  function MaskTile() {
+    _classCallCheck(this, MaskTile);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(MaskTile, [{
+    key: "initTileLayer",
+    value: function () {
+      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var attributes, layerOptions, sourceOptions, layer;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                attributes = this.parent.getLayerAttributeConfig();
+                layerOptions = this.parent.getLayerConfig();
+                sourceOptions = this.getSourceOption();
+                layer = new MaskLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options); // 初始化数据映射
+
+                attributes && Object.keys(attributes).forEach(function (type) {
+                  var _attributes$attr, _attributes$attr2;
+
+                  var attr = type; // @ts-ignore
+
+                  layer[attr]((_attributes$attr = attributes[attr]) === null || _attributes$attr === void 0 ? void 0 : _attributes$attr.field, (_attributes$attr2 = attributes[attr]) === null || _attributes$attr2 === void 0 ? void 0 : _attributes$attr2.values);
+                });
+                _context.next = 7;
+                return this.addLayer(layer);
+
+              case 7:
+                this.isLoaded = true;
+
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }()
+  }, {
+    key: "getSourceOption",
+    value: function getSourceOption() {
+      var rawSource = this.parent.getSource();
+
+      var _this$parent$getLayer = this.parent.getLayerConfig(),
+          sourceLayer = _this$parent$getLayer.sourceLayer,
+          featureId = _this$parent$getLayer.featureId;
+
+      var features = this.sourceTile.data.layers[sourceLayer].features;
+      return {
+        data: {
+          type: 'FeatureCollection',
+          features: features
+        },
+        options: {
+          parser: {
+            type: 'geojson',
+            featureId: featureId
+          },
+          transforms: rawSource.transforms
+        }
+      };
+    }
+  }]);
+
+  return MaskTile;
+}(Tile);
+
+export { MaskTile as default };

package/es/tile/tileFactory/RasterRGBTile.d.ts

@@ -0,0 +1,16 @@
+import Tile from './Tile';
+export default class RasterTile extends Tile {
+    initTileLayer(): Promise<void>;
+    protected getSourceOption(): {
+        data: any;
+        options: {
+            parser: {
+                type: string;
+                extent: import("@antv/l7-utils").TileBounds;
+                width: any;
+                height: any;
+            };
+            transforms: import("@antv/l7-core").ITransform[];
+        };
+    };
+}

package/es/tile/tileFactory/RasterRGBTile.js

@@ -0,0 +1,91 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+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 RasterLayer from "./layers/RasterDataLayer";
+import Tile from "./Tile";
+
+var RasterTile = /*#__PURE__*/function (_Tile) {
+  _inherits(RasterTile, _Tile);
+
+  var _super = _createSuper(RasterTile);
+
+  function RasterTile() {
+    _classCallCheck(this, RasterTile);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(RasterTile, [{
+    key: "initTileLayer",
+    value: function () {
+      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var attributes, layerOptions, sourceOptions, layer;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                attributes = this.parent.getLayerAttributeConfig();
+                layerOptions = this.parent.getLayerConfig();
+                sourceOptions = this.getSourceOption();
+                layer = new RasterLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options); // 初始化数据映射
+
+                attributes && Object.keys(attributes).forEach(function (type) {
+                  var _attributes$attr, _attributes$attr2;
+
+                  var attr = type; // @ts-ignore
+
+                  layer[attr]((_attributes$attr = attributes[attr]) === null || _attributes$attr === void 0 ? void 0 : _attributes$attr.field, (_attributes$attr2 = attributes[attr]) === null || _attributes$attr2 === void 0 ? void 0 : _attributes$attr2.values);
+                });
+                _context.next = 7;
+                return this.addLayer(layer);
+
+              case 7:
+                this.isLoaded = true;
+
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }()
+  }, {
+    key: "getSourceOption",
+    value: function getSourceOption() {
+      var rawSource = this.parent.getSource();
+      return {
+        data: this.sourceTile.data.data,
+        options: {
+          parser: {
+            type: 'rasterRgb',
+            extent: this.sourceTile.bounds,
+            width: this.sourceTile.data.width,
+            height: this.sourceTile.data.height
+          },
+          transforms: rawSource.transforms
+        }
+      };
+    }
+  }]);
+
+  return RasterTile;
+}(Tile);
+
+export { RasterTile as default };

package/es/tile/tileFactory/RasterTile.d.ts

@@ -0,0 +1,27 @@
+import Tile from './Tile';
+export default class RasterTile extends Tile {
+    private colorTexture;
+    initTileLayer(): Promise<void>;
+    protected getSourceOption(): {
+        data: any;
+        options: {
+            parser: {
+                type: string;
+                extent: import("@antv/l7-utils").TileBounds;
+                width: any;
+                height: any;
+            };
+            transforms: import("@antv/l7-core").ITransform[];
+        };
+    };
+    private getTileResource;
+    private initColorTexture;
+    private updateColorTexture;
+    /**
+     * 用于 style 更新 colorTexture 的优化
+     * @param arg
+     */
+    styleUpdate(...arg: any): void;
+    private createColorTexture;
+    destroy(): void;
+}