@antv/l7-layers 2.10.3 → 2.10.4

package/es/tile/tileFactory/mask.js

@@ -0,0 +1,60 @@
+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";
+
+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 TileFactory from "./base";
+
+var VectorMaskTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(VectorMaskTile, _TileFactory);
+
+  var _super = _createSuper(VectorMaskTile);
+
+  function VectorMaskTile(option) {
+    var _this;
+
+    _classCallCheck(this, VectorMaskTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(VectorMaskTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$getFeatureData = this.getFeatureData(tile, initOptions),
+          features = _this$getFeatureData.features,
+          vectorTileLayer = _this$getFeatureData.vectorTileLayer,
+          source = _this$getFeatureData.source;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = this.createLayer({
+        tile: tile,
+        initOptions: initOptions,
+        vectorTileLayer: vectorTileLayer,
+        source: source,
+        needListen: false
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return VectorMaskTile;
+}(TileFactory);
+
+export { VectorMaskTile as default };

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

@@ -0,0 +1,12 @@
+import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactoryOptions } from '../interface';
+import TileFactory from './base';
+export default class VectorPointTile extends TileFactory {
+    parentLayer: ILayer;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: any[];
+        layerIDList: any[];
+    };
+}

package/es/tile/tileFactory/point.js

@@ -0,0 +1,60 @@
+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";
+
+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 TileFactory from "./base";
+
+var VectorPointTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(VectorPointTile, _TileFactory);
+
+  var _super = _createSuper(VectorPointTile);
+
+  function VectorPointTile(option) {
+    var _this;
+
+    _classCallCheck(this, VectorPointTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(VectorPointTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$getFeatureData = this.getFeatureData(tile, initOptions),
+          features = _this$getFeatureData.features,
+          vectorTileLayer = _this$getFeatureData.vectorTileLayer,
+          source = _this$getFeatureData.source;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = this.createLayer({
+        tile: tile,
+        initOptions: initOptions,
+        vectorTileLayer: vectorTileLayer,
+        source: source,
+        needListen: false
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return VectorPointTile;
+}(TileFactory);
+
+export { VectorPointTile as default };

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

@@ -0,0 +1,12 @@
+import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactoryOptions } from '../interface';
+import TileFactory from './base';
+export default class VectorPolygonTile extends TileFactory {
+    parentLayer: ILayer;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: any[];
+        layerIDList: any[];
+    };
+}

package/es/tile/tileFactory/polygon.js

@@ -0,0 +1,59 @@
+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";
+
+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 TileFactory from "./base";
+
+var VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(VectorPolygonTile, _TileFactory);
+
+  var _super = _createSuper(VectorPolygonTile);
+
+  function VectorPolygonTile(option) {
+    var _this;
+
+    _classCallCheck(this, VectorPolygonTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(VectorPolygonTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$getFeatureData = this.getFeatureData(tile, initOptions),
+          features = _this$getFeatureData.features,
+          vectorTileLayer = _this$getFeatureData.vectorTileLayer,
+          source = _this$getFeatureData.source;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = this.createLayer({
+        tile: tile,
+        initOptions: initOptions,
+        vectorTileLayer: vectorTileLayer,
+        source: source
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return VectorPolygonTile;
+}(TileFactory);
+
+export { VectorPolygonTile as default };

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

@@ -0,0 +1,12 @@
+import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactoryOptions } from '../interface';
+import TileFactory from './base';
+export default class RasterTile extends TileFactory {
+    parentLayer: ILayer;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: any[];
+        layerIDList: any[];
+    };
+}

package/es/tile/tileFactory/raster.js

@@ -0,0 +1,55 @@
+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";
+
+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 Source from '@antv/l7-source';
+import ImageLayer from "../../image";
+import TileFactory from "./base";
+
+var RasterTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(RasterTile, _TileFactory);
+
+  var _super = _createSuper(RasterTile);
+
+  function RasterTile(option) {
+    var _this;
+
+    _classCallCheck(this, RasterTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(RasterTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var source = new Source(tile.data, {
+        parser: {
+          type: 'image',
+          extent: tile.bounds
+        }
+      });
+      var layer = this.createLayer({
+        L7Layer: ImageLayer,
+        tile: tile,
+        initOptions: initOptions,
+        source: source
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return RasterTile;
+}(TileFactory);
+
+export { RasterTile as default };

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

@@ -0,0 +1,12 @@
+import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactoryOptions } from '../interface';
+import TileFactory from './base';
+export default class RasterTiffTile extends TileFactory {
+    parentLayer: ILayer;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: ILayer[];
+        layerIDList: string[];
+    };
+}

package/es/tile/tileFactory/rasterData.js

@@ -0,0 +1,81 @@
+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";
+
+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 TileFactory from "./base";
+import RasterDataLayer from "./layers/rasterDataLayer";
+
+var RasterTiffTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(RasterTiffTile, _TileFactory);
+
+  var _super = _createSuper(RasterTiffTile);
+
+  function RasterTiffTile(option) {
+    var _this;
+
+    _classCallCheck(this, RasterTiffTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(RasterTiffTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$parentLayer, _this$parentLayer$get, _this$parentLayer$get2;
+
+      var colorTexture = initOptions.colorTexture,
+          opacity = initOptions.opacity,
+          domain = initOptions.domain,
+          clampHigh = initOptions.clampHigh,
+          clampLow = initOptions.clampLow,
+          mask = initOptions.mask;
+      var rasterData = tile.data;
+
+      if (!rasterData.data) {
+        console.warn('raster data not exist!');
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var dataType = (_this$parentLayer = this.parentLayer) === null || _this$parentLayer === void 0 ? void 0 : (_this$parentLayer$get = _this$parentLayer.getSource()) === null || _this$parentLayer$get === void 0 ? void 0 : (_this$parentLayer$get2 = _this$parentLayer$get.parser) === null || _this$parentLayer$get2 === void 0 ? void 0 : _this$parentLayer$get2.dataType;
+      var layer = new RasterDataLayer({
+        visible: tile.isVisible,
+        mask: mask
+      }).source(rasterData.data, {
+        parser: {
+          // 数据栅格分为单通道栅格和多通道彩色栅格
+          type: dataType === 'rgb' ? 'rasterRgb' : 'raster',
+          width: rasterData.width,
+          height: rasterData.height,
+          extent: tile.bboxPolygon.bbox
+        }
+      }).style({
+        colorTexture: colorTexture,
+        opacity: opacity,
+        // TODO: 目前从 domain 从父瓦片图层的 style 进行配置，后续考虑从每个时机请求的栅格文件中进行配置
+        domain: domain,
+        clampHigh: clampHigh,
+        clampLow: clampLow
+      });
+      this.emitRasterEvent([layer]);
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return RasterTiffTile;
+}(TileFactory);
+
+export { RasterTiffTile as default };

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

@@ -0,0 +1,12 @@
+import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactoryOptions } from '../interface';
+import TileFactory from './base';
+export default class TestTile extends TileFactory {
+    parentLayer: ILayer;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: ILayer[];
+        layerIDList: string[];
+    };
+}

package/es/tile/tileFactory/test.js

@@ -0,0 +1,94 @@
+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";
+
+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 TileFactory from "./base";
+import VectorLayer from "./layers/vectorLayer";
+
+var TestTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(TestTile, _TileFactory);
+
+  var _super = _createSuper(TestTile);
+
+  function TestTile(option) {
+    var _this;
+
+    _classCallCheck(this, TestTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(TestTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var sourceLayer = initOptions.sourceLayer;
+
+      if (!sourceLayer) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var vectorTileLayer = tile.data.layers[sourceLayer];
+      var features = vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.features;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var properties = features[0].properties;
+      var text = new VectorLayer({
+        layerType: 'PointLayer',
+        usage: 'basemap',
+        needListen: false
+      }).source([properties], {
+        parser: {
+          type: 'json',
+          x: 'textLng',
+          y: 'textLat',
+          cancelExtent: true
+        }
+      }).shape('key', 'text').style({
+        size: 20,
+        color: '#000',
+        stroke: '#fff',
+        strokeWidth: 2
+      });
+      var line = new VectorLayer({
+        layerType: 'LineLayer',
+        usage: 'basemap',
+        needListen: false
+      }).source({
+        type: 'FeatureCollection',
+        features: features
+      }, {
+        parser: {
+          type: 'geojson',
+          cancelExtent: true
+        }
+      }).shape('simple').style({
+        color: '#000'
+      });
+      return {
+        layers: [line, text],
+        layerIDList: [line.id, text.id]
+      };
+    }
+  }]);
+
+  return TestTile;
+}(TileFactory);
+
+export { TestTile as default };

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

@@ -0,0 +1,6 @@
+import { IBaseTileLayer, ITileLayerOPtions, IBaseTileLayerManager } from '@antv/l7-core';
+import { Base } from './base';
+export declare class MapTileLayer extends Base implements IBaseTileLayer {
+    tileLayerManager: IBaseTileLayerManager;
+    constructor({ parent, rendererService, mapService, layerService, }: ITileLayerOPtions);
+}

package/es/tile/tileLayer/MapTileLayer.js

@@ -0,0 +1,48 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+
+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 { BaseMapTileLayerManager } from "../manager/mapLayerManager";
+import { Base } from "./base";
+export var MapTileLayer = /*#__PURE__*/function (_Base) {
+  _inherits(MapTileLayer, _Base);
+
+  var _super = _createSuper(MapTileLayer);
+
+  function MapTileLayer(_ref) {
+    var _parentSource$data;
+
+    var _this;
+
+    var parent = _ref.parent,
+        rendererService = _ref.rendererService,
+        mapService = _ref.mapService,
+        layerService = _ref.layerService;
+
+    _classCallCheck(this, MapTileLayer);
+
+    _this = _super.call(this);
+    var parentSource = parent.getSource();
+
+    var _ref2 = (parentSource === null || parentSource === void 0 ? void 0 : (_parentSource$data = parentSource.data) === null || _parentSource$data === void 0 ? void 0 : _parentSource$data.tilesetOptions) || {},
+        sourceLayer = _ref2.sourceLayer;
+
+    _this.sourceLayer = sourceLayer;
+    _this.parent = parent;
+    _this.mapService = mapService;
+    _this.layerService = layerService;
+    _this.tileLayerManager = new BaseMapTileLayerManager(parent, mapService, rendererService);
+
+    _this.initTileSetManager();
+
+    return _this;
+  }
+
+  return _createClass(MapTileLayer);
+}(Base);

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

@@ -0,0 +1,22 @@
+import { IInteractionTarget, ILayer, ITileLayer, ITileLayerManager, ITileLayerOPtions } from '@antv/l7-core';
+import { Base } from './base';
+export declare class TileLayer extends Base implements ITileLayer {
+    get children(): ILayer[];
+    tileLayerManager: ITileLayerManager;
+    private pickColors;
+    constructor({ parent, rendererService, mapService, layerService, pickingService, transforms }: ITileLayerOPtions);
+    clearPick(type: string): void;
+    /**
+     * 清除 select 的选中状态
+     */
+    clearPickState(): void;
+    /**
+     * 瓦片图层独立的拾取逻辑
+     * @param target
+     * @returns
+     */
+    pickLayers(target: IInteractionTarget): boolean;
+    setPickState(layers: ILayer[]): void;
+    private bindSubLayerPick;
+    protected bindSubLayerEvent(): void;
+}