@antv/l7-layers 2.10.6 → 2.10.7

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

@@ -0,0 +1,27 @@
+import { ILayer } from '@antv/l7-core';
+import Tile from './Tile';
+export default class VectorTile extends Tile {
+    initTileLayer(): Promise<void>;
+    protected addTileMask(layer: ILayer): Promise<void>;
+    protected getSourceOption(): {
+        data: {
+            type: string;
+            features: any;
+        };
+        options: {
+            parser: {
+                type: string;
+                featureId: string;
+            };
+            transforms: import("@antv/l7-core").ITransform[];
+        };
+    };
+    protected setLayerMinMaxZoom(layer: ILayer): void;
+    getFeatures(sourceLayer: string): any;
+    /**
+     * 在一个 Tile 中可能存在一个相同 ID 的 feature
+     * @param id
+     * @returns
+     */
+    getFeatureById(id: number): import("@antv/l7-core").IParseDataItem[];
+}

package/es/tile/tileFactory/VectorTile.js

@@ -0,0 +1,198 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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 _inherits from "@babel/runtime/helpers/esm/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/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, isNeedMask } from "./util";
+import MaskLayer from "../../mask";
+
+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, 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();
+                layerOptions.mask = isNeedMask(this.parent.type) || layerOptions.mask;
+                vectorLayer = getTileLayer(this.parent.type);
+                sourceOptions = this.getSourceOption();
+
+                if (sourceOptions) {
+                  _context.next = 8;
+                  break;
+                }
+
+                this.isLoaded = true;
+                return _context.abrupt("return");
+
+              case 8:
+                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 (!layerOptions.mask) {
+                  _context.next = 13;
+                  break;
+                }
+
+                _context.next = 13;
+                return this.addTileMask(layer);
+
+              case 13:
+                _context.next = 15;
+                return this.addLayer(layer);
+
+              case 15:
+                this.setLayerMinMaxZoom(layer);
+                this.isLoaded = true;
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }() // Todo 校验数据有效性
+
+  }, {
+    key: "addTileMask",
+    value: function () {
+      var _addTileMask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(layer) {
+        var mask;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                mask = new MaskLayer({
+                  layerType: "MaskLayer"
+                }).source({
+                  type: 'FeatureCollection',
+                  features: [this.sourceTile.bboxPolygon]
+                }, {
+                  parser: {
+                    type: 'geojson',
+                    featureId: 'id'
+                  }
+                });
+                _context2.next = 3;
+                return this.addMask(layer, mask);
+
+              case 3:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function addTileMask(_x) {
+        return _addTileMask.apply(this, arguments);
+      }
+
+      return addTileMask;
+    }()
+  }, {
+    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 features = this.getFeatures(sourceLayer);
+      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
+        });
+      }
+    }
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(sourceLayer) {
+      var source = this.sourceTile.data;
+      return source.getTileData(sourceLayer);
+    }
+    /**
+     * 在一个 Tile 中可能存在一个相同 ID 的 feature
+     * @param id 
+     * @returns 
+     */
+
+  }, {
+    key: "getFeatureById",
+    value: function getFeatureById(id) {
+      var layer = this.getMainLayer();
+
+      if (!layer) {
+        return [];
+      }
+
+      return layer.getSource().data.dataArray.filter(function (d) {
+        return d._id === id;
+      });
+    }
+  }]);
+
+  return VectorTile;
+}(Tile);
+
+export { VectorTile as default };

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

@@ -1,5 +1,12 @@
-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 RasterTerrainRGBTile from './RasterTerrainRGBTile';
+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 RasterTerrainRGBTile | typeof MaskLayer;
 export * from '../interface';
+export * from './Tile';

package/es/tile/tileFactory/index.js

@@ -1,38 +1,49 @@
-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 RasterTerrainRGBTile from "./RasterTerrainRGBTile";
+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;
+
+        case "terrainRGB":
+          return RasterTerrainRGBTile;
+
+        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(): {};
 }

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

@@ -1,3 +1,4 @@
+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";
@@ -5,6 +6,7 @@ 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); }; }
 
@@ -30,39 +32,49 @@ var RasterTiffLayer = /*#__PURE__*/function (_BaseLayer) {
 
     _this = _super.call.apply(_super, [this].concat(args));
 
-    _defineProperty(_assertThisInitialized(_this), "type", _this.layerType);
+    _defineProperty(_assertThisInitialized(_this), "type", 'RasterLayer');
 
     return _this;
   }
 
   _createClass(RasterTiffLayer, [{
     key: "buildModels",
-    value: function buildModels() {
-      var _this2 = this;
-
-      var model = this.getModelType();
-      this.layerModel = new model(this);
-      this.layerModel.initModels(function (models) {
-        _this2.dispatchModelLoad(models);
-      });
-    }
-  }, {
-    key: "rebuildModels",
-    value: function rebuildModels() {
-      var _this3 = this;
+    value: function () {
+      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var model;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                model = this.getModel();
+                this.layerModel = new model(this);
+                _context.next = 4;
+                return this.initLayerModels();
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
 
-      this.layerModel.buildModels(function (models) {
-        _this3.dispatchModelLoad(models);
-      });
+      return buildModels;
+    }()
+  }, {
+    key: "getModel",
+    value: function getModel() {
+      var type = this.getModelType();
+      return type === 'rasterRgb' ? RasterRgbModel : RasterModel;
     }
   }, {
     key: "getModelType",
     value: function getModelType() {
-      if (this.layerSource.parser.type === 'rasterRgb') {
-        return RasterRgbModel;
-      } else {
-        return RasterModel;
-      }
+      return this.layerSource.parser.type === 'rasterRgb' ? 'rasterRgb' : 'raster';
     }
   }, {
     key: "getDefaultConfig",

package/es/tile/tileFactory/layers/{tileTest.d.ts → TileDebugLayer.d.ts}

@@ -2,14 +2,14 @@ import BaseLayer from '../../../core/BaseLayer';
 import { IBaseLayerStyleOptions } from '../../../core/interface';
 export default class TileDebugLayer extends BaseLayer<IBaseLayerStyleOptions> {
     type: string;
+    zIndex: number;
     defaultSourceConfig: {
         data: never[];
         options: {
             parser: {
                 type: string;
-                cancelExtent: boolean;
             };
         };
     };
-    buildModels(): void;
+    buildModels(): Promise<void>;
 }

package/es/tile/tileFactory/layers/{tileTest.js → TileDebugLayer.js}

@@ -1,3 +1,4 @@
+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";
@@ -5,13 +6,13 @@ 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";
-import TileModel from "../../models/tileModel";
 
 var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
   _inherits(TileDebugLayer, _BaseLayer);
@@ -31,12 +32,13 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
 
     _defineProperty(_assertThisInitialized(_this), "type", 'TileDebugLayer');
 
+    _defineProperty(_assertThisInitialized(_this), "zIndex", 10000);
+
     _defineProperty(_assertThisInitialized(_this), "defaultSourceConfig", {
       data: [],
       options: {
         parser: {
-          type: 'testTile',
-          cancelExtent: true
+          type: 'testTile'
         }
       }
     });
@@ -46,14 +48,25 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
 
   _createClass(TileDebugLayer, [{
     key: "buildModels",
-    value: function buildModels() {
-      var _this2 = this;
+    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:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
 
-      this.layerModel = new TileModel(this);
-      this.layerModel.initModels(function (models) {
-        _this2.dispatchModelLoad(models);
-      });
-    }
+      return buildModels;
+    }()
   }]);
 
   return TileDebugLayer;

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

@@ -0,0 +1,5 @@
+import PointLayer from '../../point/index';
+import LineLayer from '../../line';
+import PolygonLayer from '../../polygon';
+export declare function getTileLayer(type: string): typeof LineLayer | typeof PointLayer | typeof PolygonLayer;
+export declare function isNeedMask(type: string): boolean;

package/es/tile/tileFactory/util.js

@@ -0,0 +1,21 @@
+import PointLayer from "../../point/index";
+import LineLayer from "../../line";
+import PolygonLayer from "../../polygon";
+export function getTileLayer(type) {
+  if (type === 'PolygonLayer') {
+    return PolygonLayer;
+  }
+
+  if (type === 'LineLayer') {
+    return LineLayer;
+  }
+
+  if (type === 'PointLayer') {
+    return PointLayer;
+  }
+
+  return PointLayer;
+}
+export function isNeedMask(type) {
+  return ['PolygonLayer', 'LineLayer'].indexOf(type) !== -1;
+}

package/es/tile/tileLayer/BaseLayer.d.ts

@@ -0,0 +1,45 @@
+import { ILayer, IMapService, ILayerService, IRendererService, IPickingService, IInteractionTarget } from '@antv/l7-core';
+import { SourceTile, TilesetManager } from '@antv/l7-utils';
+import { TileLayerService } from '../service/TileLayerService';
+import { TilePickService } from '../service/TilePickService';
+export default class BaseTileLayer {
+    private parent;
+    tileLayerService: TileLayerService;
+    protected mapService: IMapService;
+    protected layerService: ILayerService;
+    protected rendererService: IRendererService;
+    protected pickingService: IPickingService;
+    protected tilePickService: TilePickService;
+    tilesetManager: TilesetManager;
+    initedTileset: boolean;
+    protected lastViewStates: {
+        zoom: number;
+        latLonBounds: [number, number, number, number];
+    };
+    constructor(parent: ILayer);
+    protected initTileSetManager(): void;
+    protected mapchange(): void;
+    protected getCurrentView(): {
+        latLonBounds: [number, number, number, number];
+        zoom: number;
+    };
+    private bindTilesetEvent;
+    render(): void;
+    getLayers(): ILayer[];
+    getTiles(): import("@antv/l7-core").ITile[];
+    viewchange: import("lodash").DebouncedFunc<() => void>;
+    tileLoaded(tile: SourceTile): void;
+    tileError(error: Error): void;
+    destroy(): void;
+    tileUnLoad(tile: SourceTile): void;
+    tileUpdate(): Promise<void>;
+    setPickState(layers: ILayer[]): void;
+    pickRender(target: IInteractionTarget): void;
+    selectFeature(pickedColors: Uint8Array | undefined): void;
+    highlightPickedFeature(pickedColors: Uint8Array | undefined): void;
+    /**
+     * 实现 TileLayer 对子图层方法的代理
+     * @param parent
+     */
+    private proxy;
+}