@antv/l7-layers 2.25.7 → 2.25.9

package/lib/tile/interaction/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearPickState = clearPickState;
+exports.selectFeature = selectFeature;
+exports.setFeatureActive = setFeatureActive;
+exports.setFeatureSelect = setFeatureSelect;
+exports.setHighlight = setHighlight;
+exports.setPickState = setPickState;
+exports.setSelect = setSelect;
+var _l7Utils = require("@antv/l7-utils");
+function clearPickState(layers) {
+  layers.filter(layer => layer.inited && layer.isVisible()).filter(layer => layer.getCurrentSelectedId() !== null).map(layer => {
+    selectFeature(layer, new Uint8Array([0, 0, 0, 0]));
+    layer.setCurrentSelectedId(null);
+  });
+}
+function setSelect(layers, pickedColors, renderList) {
+  const selectedId = (0, _l7Utils.decodePickingColor)(pickedColors);
+  let pickColor;
+  layers.map(layer => {
+    if (layer.getCurrentSelectedId() === null || selectedId !== layer.getCurrentSelectedId()) {
+      selectFeature(layer, pickedColors);
+      layer.setCurrentSelectedId(selectedId);
+      pickColor = pickedColors;
+    } else {
+      selectFeature(layer, new Uint8Array([0, 0, 0, 0])); // toggle select
+      layer.setCurrentSelectedId(null);
+      pickColor = null;
+    }
+  });
+  // unselect normal layer
+  renderList.filter(layer => layer.inited && layer.isVisible() && layer.needPick('click')).filter(layer => layer.getCurrentSelectedId() !== null).map(layer => {
+    selectFeature(layer, new Uint8Array([0, 0, 0, 0]));
+    layer.setCurrentSelectedId(null);
+  });
+  return pickColor;
+}
+function setHighlight(layers, pickedColors) {
+  const pickId = (0, _l7Utils.decodePickingColor)(pickedColors);
+  layers.filter(layer => layer.inited && layer.isVisible())
+  // @ts-ignore
+  .filter(layer => layer.getPickID() !== pickId).map(layer => {
+    // @ts-ignore
+    layer.setPickID(pickId);
+    layer.hooks.beforeHighlight.call(pickedColors);
+  });
+}
+function setPickState(layers, pickColors) {
+  if (pickColors.select) {
+    layers.map(layer => {
+      selectFeature(layer, pickColors.select);
+    });
+  }
+  if (pickColors.active) {
+    layers.filter(layer => layer.inited && layer.isVisible()).map(layer => {
+      layer.hooks.beforeHighlight.call(pickColors.active);
+    });
+  }
+}
+function selectFeature(layer, pickedColors) {
+  // @ts-ignore
+  const [r, g, b] = pickedColors;
+  layer.hooks.beforeSelect.call([r, g, b]);
+}
+function setFeatureSelect(color, layers) {
+  const id = (0, _l7Utils.decodePickingColor)(color);
+  layers.map(layer => {
+    selectFeature(layer, color);
+    layer.setCurrentSelectedId(id);
+  });
+}
+function setFeatureActive(color, layers) {
+  const id = (0, _l7Utils.decodePickingColor)(color);
+  layers.map(layer => {
+    layer.hooks.beforeHighlight.call(color);
+    layer.setCurrentPickId(id);
+  });
+}

package/lib/tile/interface.d.ts

@@ -0,0 +1,29 @@
+import type { ILayer, IMapService, IRendererService, ISource, ISubLayerInitOptions } from '@antv/l7-core';
+import type { SourceTile } from '@antv/l7-utils';
+export type Timeout = any;
+export type CacheEvent = 'click' | 'mousemove' | 'mouseup' | 'mousedown' | 'contextmenu';
+export interface ITileFactoryOptions {
+    parent: ILayer;
+    mapService: IMapService;
+    rendererService: IRendererService;
+}
+export interface ITileStyles {
+    [key: string]: any;
+}
+export interface ILayerTileConfig {
+    L7Layer?: any;
+    tile: SourceTile;
+    initOptions: ISubLayerInitOptions;
+    vectorTileLayer?: any;
+    source: ISource;
+    needListen?: boolean;
+}
+export interface ITileFactory {
+    loaded: boolean;
+    layers: ILayer[];
+    createTile(tile: SourceTile, initOptions: ISubLayerInitOptions): {
+        layers: ILayer[];
+    };
+    createLayer(option: ILayerTileConfig): ILayer;
+    updateStyle(styles: ITileStyles): string;
+}

package/lib/tile/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/tile/service/TileLayerService.d.ts

@@ -0,0 +1,58 @@
+import type { ILayer, ILayerService, ILngLat, IRendererService, ITile } from '@antv/l7-core';
+import type { SourceTile } from '@antv/l7-utils';
+interface ITileLayerServiceOptions {
+    rendererService: IRendererService;
+    layerService: ILayerService;
+    parent: ILayer;
+}
+export declare class TileLayerService {
+    /**
+     * tileResource 用于存储瓦片的全局资源
+     */
+    tileResource: Map<any, any>;
+    private rendererService;
+    private layerService;
+    private parent;
+    /**
+     * 使用 Map 存储瓦片实例，查找复杂度从 O(n) 降为 O(1)
+     */
+    private layerTilesMap;
+    /**
+     * 待销毁瓦片队列，用于分帧销毁
+     */
+    private pendingDestroyQueue;
+    private maxDestroyPerFrame;
+    /**
+     * 渲染图层缓存
+     */
+    private renderLayersCache;
+    private renderCacheDirty;
+    constructor({ rendererService, layerService, parent }: ITileLayerServiceOptions);
+    get tiles(): ITile[];
+    /**
+     * 获取待销毁瓦片数量
+     */
+    get pendingDestroyCount(): number;
+    hasTile(tileKey: string): boolean;
+    addTile(tile: ITile): void;
+    getTile(tileKey: string): ITile | undefined;
+    getVisibleTileBylngLat(lngLat: ILngLat): ITile | undefined;
+    removeTile(tileKey: string): void;
+    /**
+     * 分帧销毁待销毁队列中的瓦片
+     */
+    processPendingDestroys(): void;
+    /**
+     * 标记渲染缓存为脏
+     */
+    markRenderCacheDirty(): void;
+    updateTileVisible(sourceTile: SourceTile): void;
+    isParentLoaded(sourceTile: SourceTile): boolean;
+    isChildrenLoaded(sourceTile: SourceTile): boolean;
+    render(): Promise<void>;
+    getRenderLayers(): ILayer[];
+    getLayers(): ILayer[];
+    getTiles(): ITile[];
+    destroy(): void;
+}
+export {};

package/lib/tile/service/TileLayerService.js

@@ -0,0 +1,203 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileLayerService = void 0;
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+class TileLayerService {
+  constructor({
+    rendererService,
+    layerService,
+    parent
+  }) {
+    /**
+     * tileResource 用于存储瓦片的全局资源
+     */
+    (0, _defineProperty2.default)(this, "tileResource", new Map());
+    (0, _defineProperty2.default)(this, "rendererService", void 0);
+    (0, _defineProperty2.default)(this, "layerService", void 0);
+    (0, _defineProperty2.default)(this, "parent", void 0);
+    /**
+     * 使用 Map 存储瓦片实例，查找复杂度从 O(n) 降为 O(1)
+     */
+    (0, _defineProperty2.default)(this, "layerTilesMap", new Map());
+    /**
+     * 待销毁瓦片队列，用于分帧销毁
+     */
+    (0, _defineProperty2.default)(this, "pendingDestroyQueue", []);
+    (0, _defineProperty2.default)(this, "maxDestroyPerFrame", 3);
+    /**
+     * 渲染图层缓存
+     */
+    (0, _defineProperty2.default)(this, "renderLayersCache", null);
+    (0, _defineProperty2.default)(this, "renderCacheDirty", true);
+    this.rendererService = rendererService;
+    this.layerService = layerService;
+    this.parent = parent;
+  }
+  get tiles() {
+    return Array.from(this.layerTilesMap.values());
+  }
+
+  /**
+   * 获取待销毁瓦片数量
+   */
+  get pendingDestroyCount() {
+    return this.pendingDestroyQueue.length;
+  }
+  hasTile(tileKey) {
+    return this.layerTilesMap.has(tileKey);
+  }
+  addTile(tile) {
+    this.layerTilesMap.set(tile.key, tile);
+    this.markRenderCacheDirty();
+  }
+  getTile(tileKey) {
+    return this.layerTilesMap.get(tileKey);
+  }
+  getVisibleTileBylngLat(lngLat) {
+    // 加载完成 & 可见 & 鼠标选中
+    for (const tile of this.layerTilesMap.values()) {
+      if (tile.isLoaded && tile.visible && tile.lnglatInBounds(lngLat)) {
+        return tile;
+      }
+    }
+    return undefined;
+  }
+  removeTile(tileKey) {
+    const tile = this.layerTilesMap.get(tileKey);
+    if (tile) {
+      this.layerTilesMap.delete(tileKey);
+      // 放入待销毁队列，分帧销毁
+      this.pendingDestroyQueue.push(tile);
+      this.markRenderCacheDirty();
+    }
+  }
+
+  /**
+   * 分帧销毁待销毁队列中的瓦片
+   */
+  processPendingDestroys() {
+    const count = Math.min(this.pendingDestroyQueue.length, this.maxDestroyPerFrame);
+    for (let i = 0; i < count; i++) {
+      const tile = this.pendingDestroyQueue.shift();
+      if (tile) {
+        tile.destroy();
+      }
+    }
+  }
+
+  /**
+   * 标记渲染缓存为脏
+   */
+  markRenderCacheDirty() {
+    this.renderCacheDirty = true;
+  }
+  updateTileVisible(sourceTile) {
+    const tile = this.getTile(sourceTile.key);
+    if (sourceTile.isVisible) {
+      // 不可见 => 可见 兄弟节点加载完成
+      if (sourceTile.parent) {
+        const flag = this.isChildrenLoaded(sourceTile.parent);
+        tile === null || tile === void 0 || tile.updateVisible(flag);
+      } else {
+        tile === null || tile === void 0 || tile.updateVisible(true);
+      }
+    } else {
+      // 可见 => 不可见 兄弟节点加载完成
+      if (sourceTile.parent) {
+        const flag = this.isChildrenLoaded(sourceTile.parent);
+        tile === null || tile === void 0 || tile.updateVisible(!flag);
+      } else {
+        tile === null || tile === void 0 || tile.updateVisible(false);
+      }
+    }
+    this.markRenderCacheDirty();
+  }
+  isParentLoaded(sourceTile) {
+    const parentTile = sourceTile.parent;
+    if (!parentTile) {
+      return true;
+    }
+    const tile = this.getTile(parentTile === null || parentTile === void 0 ? void 0 : parentTile.key);
+    if (tile !== null && tile !== void 0 && tile.isLoaded) {
+      // 递归父级
+      return true;
+    }
+    return false;
+  }
+  isChildrenLoaded(sourceTile) {
+    const childrenTile = sourceTile === null || sourceTile === void 0 ? void 0 : sourceTile.children;
+    if (childrenTile.length === 0) {
+      return true;
+    }
+    return childrenTile.every(tile => {
+      const tileLayer = this.getTile(tile === null || tile === void 0 ? void 0 : tile.key);
+      if (!tileLayer) {
+        return true;
+      }
+      return (tileLayer === null || tileLayer === void 0 ? void 0 : tileLayer.isLoaded) === true;
+    });
+  }
+  render() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      // 每帧处理部分待销毁瓦片
+      _this.processPendingDestroys();
+      const layers = _this.getRenderLayers();
+      const renders = layers.map( /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2.default)(function* (layer) {
+          yield _this.layerService.renderTileLayer(layer);
+        });
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+      yield Promise.all(renders);
+    })();
+  }
+  getRenderLayers() {
+    // 使用缓存避免每帧重建
+    if (!this.renderCacheDirty && this.renderLayersCache) {
+      return this.renderLayersCache;
+    }
+    const layers = [];
+    this.layerTilesMap.forEach(tile => {
+      if (tile.visible && tile.isLoaded) {
+        layers.push(...tile.getLayers());
+      }
+    });
+    this.renderLayersCache = layers;
+    this.renderCacheDirty = false;
+    return layers;
+  }
+  getLayers() {
+    const layers = [];
+    this.layerTilesMap.forEach(tile => {
+      if (tile.isLoaded) {
+        layers.push(...tile.getLayers());
+      }
+    });
+    return layers;
+  }
+  getTiles() {
+    return Array.from(this.layerTilesMap.values());
+  }
+  destroy() {
+    // 先处理待销毁队列中的残留瓦片
+    while (this.pendingDestroyQueue.length > 0) {
+      const tile = this.pendingDestroyQueue.shift();
+      tile === null || tile === void 0 || tile.destroy();
+    }
+    // 销毁所有已加载的瓦片
+    this.layerTilesMap.forEach(t => t.destroy());
+    this.layerTilesMap.clear();
+    // 清理缓存
+    this.renderLayersCache = null;
+    this.tileResource.clear();
+  }
+}
+exports.TileLayerService = TileLayerService;

package/lib/tile/service/TilePickService.d.ts

@@ -0,0 +1,26 @@
+import type { IInteractionTarget, ILayer, ILayerService, ITilePickService } from '@antv/l7-core';
+import type { TileLayerService } from './TileLayerService';
+export interface ITilePickServiceOptions {
+    layerService: ILayerService;
+    tileLayerService: TileLayerService;
+    parent: ILayer;
+}
+export declare class TilePickService implements ITilePickService {
+    private layerService;
+    private tileLayerService;
+    private tileSourceService;
+    private parent;
+    private tilePickID;
+    constructor({ layerService, tileLayerService, parent }: ITilePickServiceOptions);
+    pickRender(target: IInteractionTarget): void;
+    pick(layer: ILayer, target: IInteractionTarget): Promise<boolean>;
+    selectFeature(pickedColors: Uint8Array | undefined): void;
+    highlightPickedFeature(pickedColors: Uint8Array | undefined): void;
+    updateHighLight(r: number, g: number, b: number, type: string): void;
+    setPickState(): void;
+    private color2PickId;
+    private pickId2Color;
+    /** 从瓦片中根据数据 */
+    getFeatureById(pickedFeatureIdx: number): any[];
+    pickRasterLayer(): boolean;
+}

package/lib/tile/service/TilePickService.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TilePickService = void 0;
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _l7Utils = require("@antv/l7-utils");
+var _TileSourceService = require("./TileSourceService");
+const SELECT = 'select';
+const ACTIVE = 'active';
+class TilePickService {
+  constructor({
+    layerService,
+    tileLayerService,
+    parent
+  }) {
+    (0, _defineProperty2.default)(this, "layerService", void 0);
+    (0, _defineProperty2.default)(this, "tileLayerService", void 0);
+    (0, _defineProperty2.default)(this, "tileSourceService", void 0);
+    (0, _defineProperty2.default)(this, "parent", void 0);
+    (0, _defineProperty2.default)(this, "tilePickID", new Map());
+    this.layerService = layerService;
+    this.tileLayerService = tileLayerService;
+    this.parent = parent;
+    this.tileSourceService = new _TileSourceService.TileSourceService();
+  }
+  pickRender(target) {
+    // 一个 TileLayer 有多个 Tile，但是会同时触发事件的只有一个 Tile
+    const tile = this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
+    if (tile) {
+      // TODO 多图层拾取
+      const pickLayer = tile.getMainLayer();
+      pickLayer === null || pickLayer === void 0 || pickLayer.layerPickService.pickRender(target);
+    }
+  }
+  pick(layer, target) {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      const container = _this.parent.getContainer();
+      const pickingService = container.pickingService;
+      if (layer.type === 'RasterLayer') {
+        const tile = _this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
+        if (tile && tile.getMainLayer() !== undefined) {
+          const pickLayer = tile.getMainLayer();
+          return pickLayer.layerPickService.pickRasterLayer(pickLayer, target, _this.parent);
+        }
+        return false;
+      }
+      _this.pickRender(target);
+      return pickingService.pickFromPickingFBO(layer, target);
+    })();
+  }
+  selectFeature(pickedColors) {
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    const id = this.color2PickId(r, g, b);
+    this.tilePickID.set(SELECT, id);
+    this.updateHighLight(r, g, b, SELECT);
+  }
+  highlightPickedFeature(pickedColors) {
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    const id = this.color2PickId(r, g, b);
+    this.tilePickID.set(ACTIVE, id);
+    this.updateHighLight(r, g, b, ACTIVE);
+  }
+  updateHighLight(r, g, b, type) {
+    // 只遍历已加载的瓦片，跳过不可见的
+    for (const tile of this.tileLayerService.tiles) {
+      if (!tile.isLoaded) continue;
+      const layer = tile.getMainLayer();
+      switch (type) {
+        case SELECT:
+          layer === null || layer === void 0 || layer.hooks.beforeSelect.call([r, g, b]);
+          break;
+        case ACTIVE:
+          layer === null || layer === void 0 || layer.hooks.beforeHighlight.call([r, g, b]);
+          break;
+      }
+    }
+  }
+  setPickState() {
+    const selectColor = this.tilePickID.get(SELECT);
+    const activeColor = this.tilePickID.get(ACTIVE);
+    if (selectColor) {
+      const [r, g, b] = this.pickId2Color(selectColor);
+      this.updateHighLight(r, g, b, SELECT);
+      return;
+    }
+    if (activeColor) {
+      const [r, g, b] = this.pickId2Color(activeColor);
+      this.updateHighLight(r, g, b, ACTIVE);
+      return;
+    }
+  }
+  color2PickId(r, g, b) {
+    return (0, _l7Utils.decodePickingColor)(new Uint8Array([r, g, b]));
+  }
+  pickId2Color(str) {
+    return (0, _l7Utils.encodePickingColor)(str);
+  }
+
+  /** 从瓦片中根据数据 */
+  getFeatureById(pickedFeatureIdx) {
+    // 提取当前可见瓦片并合并 features
+    const features = [];
+    for (const tile of this.tileLayerService.tiles) {
+      if (tile.visible && tile.isLoaded) {
+        const tileFeatures = tile.getFeatureById(pickedFeatureIdx);
+        // 直接 push 而非使用扩展操作符
+        for (let i = 0; i < tileFeatures.length; i++) {
+          features.push(tileFeatures[i]);
+        }
+      }
+    }
+
+    // 将 feature 列表合并后返回
+    // 统一返回成 polygon 的格式 点、线、面可以通用
+
+    // const data = this.tileSourceService.getCombineFeature(features);
+
+    return features;
+  }
+
+  // Tip: for interface define
+
+  pickRasterLayer() {
+    return false;
+  }
+}
+exports.TilePickService = TilePickService;

package/lib/tile/service/TileSourceService.d.ts

@@ -0,0 +1,7 @@
+import type { IParseDataItem } from '@antv/l7-core';
+/**
+ * 专门处理 Tile 数据相关
+ */
+export declare class TileSourceService {
+    getCombineFeature(features: IParseDataItem[]): any;
+}

package/lib/tile/service/TileSourceService.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileSourceService = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var turf = _interopRequireWildcard(require("@turf/helpers"));
+var _union = _interopRequireDefault(require("@turf/union"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * 专门处理 Tile 数据相关
+ */
+class TileSourceService {
+  getCombineFeature(features) {
+    let p = null;
+    const properties = features[0];
+    features.map(feature => {
+      const polygon = turf.polygon(feature.coordinates);
+      // tslint:disable-next-line: prefer-conditional-expression
+      if (p === null) {
+        p = polygon;
+      } else {
+        p = (0, _union.default)(p, polygon);
+      }
+    });
+    if (properties) {
+      p.properties = (0, _objectSpread2.default)({}, properties);
+    }
+    return p;
+  }
+}
+exports.TileSourceService = TileSourceService;

package/lib/tile/tile/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/lib/tile/tile/DebugTile.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _line = _interopRequireDefault(require("../../line"));
+var _point = _interopRequireDefault(require("../../point"));
+var _Tile = _interopRequireDefault(require("./Tile"));
+class DebugTile extends _Tile.default {
+  initTileLayer() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      const sourceOptions = _this.getSourceOption();
+      const pointData = sourceOptions.data.features[0].properties;
+      const lineLayer = new _line.default().source(sourceOptions.data, sourceOptions.options).size(1).shape('line').color('red');
+      const pointLayer = new _point.default({
+        minZoom: _this.z - 1,
+        maxZoom: _this.z + 1,
+        textAllowOverlap: true
+      }).source([pointData], {
+        parser: {
+          type: 'json',
+          x: 'x',
+          y: 'y'
+        }
+      }).size(20).color('red').shape(_this.key).style({
+        stroke: '#fff',
+        strokeWidth: 2
+      });
+      yield _this.addLayer(lineLayer);
+      yield _this.addLayer(pointLayer);
+      _this.isLoaded = true;
+    })();
+  }
+  getSourceOption() {
+    const rawSource = this.parent.getSource();
+    const features = this.sourceTile.data.layers.testTile.features;
+    return {
+      data: {
+        type: 'FeatureCollection',
+        features
+      },
+      options: {
+        parser: {
+          type: 'geojson'
+        },
+        transforms: rawSource.transforms
+      }
+    };
+  }
+}
+exports.default = DebugTile;

package/lib/tile/tile/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[];
+        };
+    };
+}