@antv/l7-layers 2.10.1 → 2.10.2

package/es/tile/tileFactory/RasterTile.js

@@ -0,0 +1,186 @@
+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 { TYPES } from '@antv/l7-core';
+import { generateColorRamp } from '@antv/l7-utils';
+import RasterLayer from "./layers/RasterDataLayer";
+import Tile from "./Tile";
+import { isEqual } from 'lodash';
+var COLOR_TEXTURE = 'raster-colorTexture';
+var COLOR_TEXTURE_OPTION = 'raster-colorTexture-option';
+var DEFAULT_COLOR_TEXTURE_OPTION = {
+  positions: [0, 1],
+  colors: ['#000', '#fff']
+};
+
+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();
+                this.initColorTexture();
+                layer = new RasterLayer(_objectSpread(_objectSpread({}, layerOptions), {}, {
+                  colorTexture: this.colorTexture
+                })).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 = 8;
+                return this.addLayer(layer);
+
+              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();
+      return {
+        data: this.sourceTile.data.data,
+        options: {
+          parser: {
+            type: 'raster',
+            extent: this.sourceTile.bounds,
+            width: this.sourceTile.data.width,
+            height: this.sourceTile.data.height
+          },
+          transforms: rawSource.transforms
+        }
+      };
+    }
+  }, {
+    key: "getTileResource",
+    value: function getTileResource() {
+      return this.parent.tileLayer.tileLayerService.tileResource;
+    }
+  }, {
+    key: "initColorTexture",
+    value: function initColorTexture() {
+      var tileResource = this.getTileResource();
+      var colorTexture = tileResource.get(COLOR_TEXTURE);
+
+      if (colorTexture) {
+        this.colorTexture = colorTexture;
+      } else {
+        var container = this.parent.getContainer();
+        var rendererService = container.get(TYPES.IRendererService);
+
+        var _ref = this.parent.getLayerConfig(),
+            _ref$rampColors = _ref.rampColors,
+            rampColors = _ref$rampColors === void 0 ? DEFAULT_COLOR_TEXTURE_OPTION : _ref$rampColors;
+
+        this.colorTexture = this.createColorTexture(rampColors, rendererService);
+        tileResource.set(COLOR_TEXTURE, this.colorTexture);
+        tileResource.set(COLOR_TEXTURE_OPTION, rampColors);
+      }
+    }
+  }, {
+    key: "updateColorTexture",
+    value: function updateColorTexture() {
+      var tileResource = this.getTileResource();
+      tileResource.delete(COLOR_TEXTURE);
+      this.initColorTexture();
+    }
+    /**
+     * 用于 style 更新 colorTexture 的优化
+     * @param arg 
+     */
+
+  }, {
+    key: "styleUpdate",
+    value: function styleUpdate() {
+      var _this = this;
+
+      var tileResource = this.getTileResource();
+
+      for (var _len = arguments.length, arg = new Array(_len), _key = 0; _key < _len; _key++) {
+        arg[_key] = arguments[_key];
+      }
+
+      var _arg$rampColors = arg.rampColors,
+          rampColors = _arg$rampColors === void 0 ? DEFAULT_COLOR_TEXTURE_OPTION : _arg$rampColors;
+      var cacheRampColors = tileResource.get(COLOR_TEXTURE_OPTION);
+
+      if (!isEqual(rampColors, cacheRampColors)) {
+        this.updateColorTexture();
+      }
+
+      this.layers.forEach(function (layer) {
+        return layer.style({
+          colorTexture: _this.colorTexture
+        });
+      });
+    }
+  }, {
+    key: "createColorTexture",
+    value: function createColorTexture(config, rendererService) {
+      var createTexture2D = rendererService.createTexture2D;
+      var imageData = generateColorRamp(config);
+      var texture = createTexture2D({
+        data: imageData.data,
+        width: imageData.width,
+        height: imageData.height,
+        flipY: false
+      });
+      return texture;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.layers.forEach(function (layer) {
+        return layer.destroy();
+      });
+    }
+  }]);
+
+  return RasterTile;
+}(Tile);
+
+export { RasterTile as default };

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

@@ -0,0 +1,23 @@
+import { ILayer, ILngLat, ITile } from '@antv/l7-core';
+import { SourceTile } from '@antv/l7-utils';
+export default abstract class Tile implements ITile {
+    x: number;
+    y: number;
+    z: number;
+    key: string;
+    protected parent: ILayer;
+    sourceTile: SourceTile;
+    visible: boolean;
+    protected layers: ILayer[];
+    isLoaded: boolean;
+    constructor(sourceTile: SourceTile, parent: ILayer);
+    getLayers(): ILayer[];
+    styleUpdate(...arg: any): void;
+    abstract initTileLayer(): Promise<void>;
+    lnglatInBounds(lnglat: ILngLat): boolean;
+    protected addMask(layer: ILayer, mask: ILayer): Promise<void>;
+    protected addLayer(layer: ILayer): Promise<void>;
+    updateVisible(value: boolean): void;
+    updateOptions(key: string, value: any): void;
+    destroy(): void;
+}

package/es/tile/tileFactory/Tile.js

@@ -0,0 +1,136 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { createLayerContainer } from '@antv/l7-core';
+
+var Tile = /*#__PURE__*/function () {
+  function Tile(sourceTile, parent) {
+    _classCallCheck(this, Tile);
+
+    _defineProperty(this, "visible", true);
+
+    _defineProperty(this, "layers", []);
+
+    _defineProperty(this, "isLoaded", false);
+
+    this.parent = parent;
+    this.sourceTile = sourceTile;
+    this.x = sourceTile.x;
+    this.y = sourceTile.y;
+    this.z = sourceTile.z;
+    this.key = "".concat(this.x, "_").concat(this.y, "_").concat(this.z);
+  }
+
+  _createClass(Tile, [{
+    key: "getLayers",
+    value: function getLayers() {
+      return this.layers;
+    } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+  }, {
+    key: "styleUpdate",
+    value: function styleUpdate() {}
+  }, {
+    key: "lnglatInBounds",
+    value: function lnglatInBounds(lnglat) {
+      var _this$sourceTile$boun = _slicedToArray(this.sourceTile.bounds, 4),
+          minLng = _this$sourceTile$boun[0],
+          minLat = _this$sourceTile$boun[1],
+          maxLng = _this$sourceTile$boun[2],
+          maxLat = _this$sourceTile$boun[3];
+
+      var lng = lnglat.lng,
+          lat = lnglat.lat;
+      return lng >= minLng && lng <= maxLng && lat >= minLat && lat <= maxLat;
+    }
+  }, {
+    key: "addMask",
+    value: function () {
+      var _addMask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(layer, mask) {
+        var container;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                container = createLayerContainer(this.parent.sceneContainer);
+                mask.setContainer(container, this.parent.sceneContainer);
+                _context.next = 4;
+                return mask.init();
+
+              case 4:
+                layer.addMaskLayer(mask);
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function addMask(_x, _x2) {
+        return _addMask.apply(this, arguments);
+      }
+
+      return addMask;
+    }()
+  }, {
+    key: "addLayer",
+    value: function () {
+      var _addLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(layer) {
+        var container;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                // set flag
+                layer.isTileLayer = true;
+                container = createLayerContainer(this.parent.sceneContainer);
+                layer.setContainer(container, this.parent.sceneContainer);
+                this.layers.push(layer);
+                _context2.next = 6;
+                return layer.init();
+
+              case 6:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function addLayer(_x3) {
+        return _addLayer.apply(this, arguments);
+      }
+
+      return addLayer;
+    }()
+  }, {
+    key: "updateVisible",
+    value: function updateVisible(value) {
+      this.visible = value;
+      this.updateOptions('visible', value);
+    }
+  }, {
+    key: "updateOptions",
+    value: function updateOptions(key, value) {
+      this.layers.forEach(function (l) {
+        l.updateLayerConfig(_defineProperty({}, key, value));
+      });
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.layers.forEach(function (layer) {
+        return layer.destroy();
+      });
+    }
+  }]);
+
+  return Tile;
+}();
+
+export { Tile as default };

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

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

package/es/tile/tileFactory/VectorTile.js

@@ -0,0 +1,158 @@
+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 Tile from "./Tile";
+import { getTileLayer, getMaskLayer } from "./util";
+
+var VectorTile = /*#__PURE__*/function (_Tile) {
+  _inherits(VectorTile, _Tile);
+
+  var _super = _createSuper(VectorTile);
+
+  function VectorTile() {
+    _classCallCheck(this, VectorTile);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(VectorTile, [{
+    key: "initTileLayer",
+    value: function () {
+      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var attributes, layerOptions, vectorLayer, maskLayer, sourceOptions, layer, mask;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                attributes = this.parent.getLayerAttributeConfig();
+                layerOptions = this.parent.getLayerConfig();
+                vectorLayer = getTileLayer(this.parent.type);
+                maskLayer = getMaskLayer(this.parent.type);
+                layerOptions.mask = !!maskLayer;
+                sourceOptions = this.getSourceOption();
+
+                if (sourceOptions) {
+                  _context.next = 9;
+                  break;
+                }
+
+                this.isLoaded = true;
+                return _context.abrupt("return");
+
+              case 9:
+                layer = new vectorLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options); // 初始化数据映射
+
+                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);
+                });
+
+                if (!maskLayer) {
+                  _context.next = 15;
+                  break;
+                }
+
+                mask = new maskLayer({
+                  layerType: "MaskLayer"
+                }).source({
+                  type: 'FeatureCollection',
+                  features: [this.sourceTile.bboxPolygon]
+                }, {
+                  parser: {
+                    type: 'geojson'
+                  }
+                }); // .style({
+                //   opacity: 1
+                // });
+
+                _context.next = 15;
+                return this.addMask(layer, mask);
+
+              case 15:
+                _context.next = 17;
+                return this.addLayer(layer);
+
+              case 17:
+                this.setLayerMinMaxZoom(layer);
+                this.isLoaded = true;
+
+              case 19:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }() // Todo 校验数据有效性
+
+  }, {
+    key: "beforeInit",
+    value: function beforeInit() {}
+  }, {
+    key: "getSourceOption",
+    value: function getSourceOption() {
+      var rawSource = this.parent.getSource();
+
+      var _this$parent$getLayer = this.parent.getLayerConfig(),
+          _this$parent$getLayer2 = _this$parent$getLayer.sourceLayer,
+          sourceLayer = _this$parent$getLayer2 === void 0 ? 'defaultLayer' : _this$parent$getLayer2,
+          _this$parent$getLayer3 = _this$parent$getLayer.featureId,
+          featureId = _this$parent$getLayer3 === void 0 ? 'id' : _this$parent$getLayer3;
+
+      var vectorLayer = this.sourceTile.data.layers[sourceLayer];
+
+      if (!vectorLayer) {
+        return false;
+      }
+
+      var features = vectorLayer.features;
+      return {
+        data: {
+          type: 'FeatureCollection',
+          features: features
+        },
+        options: {
+          parser: {
+            type: 'geojson',
+            featureId: featureId
+          },
+          transforms: rawSource.transforms
+        }
+      };
+    }
+  }, {
+    key: "setLayerMinMaxZoom",
+    value: function setLayerMinMaxZoom(layer) {
+      // 文本图层设置，可见范围
+      if (layer.getModelType() === 'text') {
+        layer.updateLayerConfig({
+          maxZoom: this.z + 1,
+          minZoom: this.z - 1
+        });
+      }
+    }
+  }]);
+
+  return VectorTile;
+}(Tile);
+
+export { VectorTile as default };

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

@@ -1,5 +1,11 @@
-import { IParserCfg } from '@antv/l7-core';
-import VectorLineTile from './line';
-export declare type TileType = 'PolygonLayer' | 'PointLayer' | 'LineLayer' | 'RasterLayer' | 'MaskLayer' | 'TileDebugLayer';
-export declare function getTileFactory(tileType: TileType, parser: IParserCfg): typeof VectorLineTile;
+import { ILayer } from '@antv/l7-core';
+import VectorTile from './VectorTile';
+import DebugTile from './DebugTile';
+import ImageTile from './ImageTile';
+import RasterTile from './RasterTile';
+import RasterRGBTile from './RasterRGBTile';
+import MaskLayer from './MaskTile';
+export declare type TileType = 'VectorTile' | 'DebugTile' | 'PolygonLayer' | 'PointLayer' | 'LineLayer' | 'RasterLayer' | 'image' | 'MaskLayer' | 'TileDebugLayer';
+export declare function getTileFactory(layer: ILayer): typeof VectorTile | typeof DebugTile | typeof ImageTile | typeof RasterTile | typeof RasterRGBTile | typeof MaskLayer;
 export * from '../interface';
+export * from './Tile';

package/es/tile/tileFactory/index.js

@@ -1,38 +1,45 @@
-import { rasterDataTypes } from '@antv/l7-source';
-import VectorLineTile from "./line";
-import VectorPointLayer from "./point";
-import VectorPolygonTile from "./polygon";
-import VectorMask from "./mask";
-import RasterTileFactory from "./raster";
-import RasterDataFactory from "./rasterData";
-import TestTile from "./test";
-export function getTileFactory(tileType, parser) {
+import VectorTile from "./VectorTile";
+import DebugTile from "./DebugTile";
+import ImageTile from "./ImageTile";
+import RasterTile from "./RasterTile";
+import RasterRGBTile from "./RasterRGBTile";
+import MaskLayer from "./MaskTile";
+export function getTileFactory(layer) {
+  var tileType = layer.type;
+
   switch (tileType) {
     case 'PolygonLayer':
-      return VectorPolygonTile;
+      return VectorTile;
 
     case 'LineLayer':
-      return VectorLineTile;
+      return VectorTile;
 
     case 'PointLayer':
-      return VectorPointLayer;
-
-    case 'MaskLayer':
-      return VectorMask;
+      return VectorTile;
 
     case 'TileDebugLayer':
-      return TestTile;
+      return DebugTile;
+
+    case 'MaskLayer':
+      return MaskLayer;
 
     case 'RasterLayer':
-      if (rasterDataTypes.includes(parser.dataType)) {
-        return RasterDataFactory;
-      } else {
-        return RasterTileFactory;
+      var dataType = layer.getSource().parser.dataType;
+
+      switch (dataType) {
+        case 'rgb':
+          return RasterRGBTile;
+
+        case 'arraybuffer':
+          return RasterTile;
+
+        default:
+          return ImageTile;
       }
 
     default:
-      console.warn('Current Tile Not Exist!');
-      return RasterTileFactory;
+      return VectorTile;
   }
 }
-export * from "../interface";
+export * from "../interface";
+export * from "./Tile";

package/es/tile/tileFactory/layers/{rasterDataLayer.d.ts → RasterDataLayer.d.ts}

@@ -4,8 +4,8 @@ import RasterModel from '../../../raster/models/rasterTile';
 import RasterRgbModel from '../../../raster/models/rasterRgb';
 export default class RasterTiffLayer extends BaseLayer<Partial<IRasterLayerStyleOptions>> {
     type: string;
-    buildModels(): void;
-    rebuildModels(): void;
-    protected getModelType(): typeof RasterModel | typeof RasterRgbModel;
+    buildModels(): Promise<void>;
+    getModel(): typeof RasterRgbModel | typeof RasterModel;
+    getModelType(): string;
     protected getDefaultConfig(): {};
 }