@antv/l7-layers 2.9.32-alpha.3 → 2.9.32-alpha.5

package/es/tile/tileFactory/point.js

@@ -0,0 +1,63 @@
+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";
+
+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
+      });
+      layer.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      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,62 @@
+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";
+
+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
+      });
+      layer.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      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,58 @@
+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";
+
+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
+      });
+      layer.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      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,86 @@
+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";
+
+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 { registerLayers } from "../utils";
+import TileFactory from "./base";
+import RasterDataLayer from "./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.emitEvent([layer], false);
+      registerLayers(this.parentLayer, [layer]);
+      layer.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return RasterTiffTile;
+}(TileFactory);
+
+export { RasterTiffTile as default };

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

@@ -0,0 +1,20 @@
+import BaseLayer from '../../core/BaseLayer';
+import { IRasterLayerStyleOptions } from '../../core/interface';
+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;
+    protected getConfigSchema(): {
+        properties: {
+            opacity: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    };
+    protected getDefaultConfig(): {};
+}

package/es/tile/tileFactory/rasterDataLayer.js

@@ -0,0 +1,90 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+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 RasterModel from "../../raster/models/rasterTile";
+import RasterRgbModel from "../../raster/models/rasterRgb";
+
+var RasterTiffLayer = /*#__PURE__*/function (_BaseLayer) {
+  _inherits(RasterTiffLayer, _BaseLayer);
+
+  var _super = _createSuper(RasterTiffLayer);
+
+  function RasterTiffLayer() {
+    var _this;
+
+    _classCallCheck(this, RasterTiffLayer);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "type", _this.layerType);
+
+    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;
+
+      this.layerModel.buildModels(function (models) {
+        _this3.dispatchModelLoad(models);
+      });
+    }
+  }, {
+    key: "getModelType",
+    value: function getModelType() {
+      if (this.layerSource.parser.type === 'rasterRgb') {
+        return RasterRgbModel;
+      } else {
+        return RasterModel;
+      }
+    }
+  }, {
+    key: "getConfigSchema",
+    value: function getConfigSchema() {
+      return {
+        properties: {
+          opacity: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1
+          }
+        }
+      };
+    }
+  }, {
+    key: "getDefaultConfig",
+    value: function getDefaultConfig() {
+      return {};
+    }
+  }]);
+
+  return RasterTiffLayer;
+}(BaseLayer);
+
+export { RasterTiffLayer 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,105 @@
+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";
+
+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 "./vectorLayer";
+import { registerLayers } from "../utils";
+
+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'
+      }); // Tip: sign tile layer
+
+      text.isTileLayer = true;
+      line.isTileLayer = true;
+      registerLayers(this.parentLayer, [line, text]);
+      text.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      line.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      return {
+        layers: [line, text],
+        layerIDList: [line.id, text.id]
+      };
+    }
+  }]);
+
+  return TestTile;
+}(TileFactory);
+
+export { TestTile as default };

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

@@ -0,0 +1,38 @@
+import BaseLayer from '../../core/BaseLayer';
+import { ILineLayerStyleOptions, IPointLayerStyleOptions, IPolygonLayerStyleOptions, IMaskLayerStyleOptions } from '../../core/interface';
+import lineFillModel from '../../line/models/tile';
+import lineSimpleModel from '../../line/models/simpleTileLine';
+import pointTextModel from '../../point/models/tileText';
+import pointFillModel from '../../point/models/tile';
+import polygonFillModel from '../../polygon/models/tile';
+import maskModel from '../../mask/models/fill';
+declare type ILayerStyleOptions = IPolygonLayerStyleOptions & ILineLayerStyleOptions & IPointLayerStyleOptions & IMaskLayerStyleOptions;
+export default class VectorLayer extends BaseLayer<Partial<ILayerStyleOptions & {
+    needListen: boolean;
+}>> {
+    needListen: boolean;
+    isVector: boolean;
+    type: string;
+    private pickedID;
+    init(): this;
+    renderModels(isPicking?: boolean): this;
+    protected sourceEvent: () => void;
+    getPickID(): number | null;
+    setPickID(): number | null;
+    buildModels(): void;
+    rebuildModels(): void;
+    protected getModelType(): typeof lineFillModel | typeof lineSimpleModel | typeof pointTextModel | typeof pointFillModel | typeof polygonFillModel | typeof maskModel;
+    protected getLineModel(): typeof lineFillModel | typeof lineSimpleModel;
+    protected getPointModel(): typeof pointTextModel | typeof pointFillModel;
+    protected getConfigSchema(): {
+        properties: {
+            opacity: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    };
+    protected getDefaultConfig(): {};
+}
+export {};