@antv/l7-layers 2.21.0 → 2.21.2

package/lib/tile/interaction/getRasterData.js

@@ -1,54 +1,46 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.readPixel = readPixel;
 exports.readRasterValue = readRasterValue;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _l7Utils = require("@antv/l7-utils");
 function readRasterValue(tile, mapService, x, y) {
   var _tile$bboxPolygon, _tile$data, _tile$data2, _tile$data3;
-  var bbox = (tile === null || tile === void 0 || (_tile$bboxPolygon = tile.bboxPolygon) === null || _tile$bboxPolygon === void 0 ? void 0 : _tile$bboxPolygon.bbox) || [0, 0, 10, -10];
-  var _bbox = (0, _slicedToArray2.default)(bbox, 4),
-    _bbox$ = _bbox[0],
-    minLng = _bbox$ === void 0 ? 0 : _bbox$,
-    _bbox$2 = _bbox[1],
-    minLat = _bbox$2 === void 0 ? 0 : _bbox$2,
-    _bbox$3 = _bbox[2],
-    maxLng = _bbox$3 === void 0 ? 10 : _bbox$3,
-    _bbox$4 = _bbox[3],
-    maxLat = _bbox$4 === void 0 ? -10 : _bbox$4;
-  var tileXY = mapService.lngLatToContainer([minLng, minLat]);
-  var tileMaxXY = mapService.lngLatToContainer([maxLng, maxLat]);
-  var tilePixelWidth = tileMaxXY.x - tileXY.x;
-  var tilePixelHeight = tileXY.y - tileMaxXY.y;
-  var pos = [(x - tileXY.x) / tilePixelWidth,
+  const bbox = (tile === null || tile === void 0 || (_tile$bboxPolygon = tile.bboxPolygon) === null || _tile$bboxPolygon === void 0 ? void 0 : _tile$bboxPolygon.bbox) || [0, 0, 10, -10];
+  const [minLng = 0, minLat = 0, maxLng = 10, maxLat = -10] = bbox;
+  const tileXY = mapService.lngLatToContainer([minLng, minLat]);
+  const tileMaxXY = mapService.lngLatToContainer([maxLng, maxLat]);
+  const tilePixelWidth = tileMaxXY.x - tileXY.x;
+  const tilePixelHeight = tileXY.y - tileMaxXY.y;
+  const pos = [(x - tileXY.x) / tilePixelWidth,
   // x
   (y - tileMaxXY.y) / tilePixelHeight // y
   ];
-
-  var tileWidth = (tile === null || tile === void 0 || (_tile$data = tile.data) === null || _tile$data === void 0 ? void 0 : _tile$data.width) || 1;
-  var tileHeight = (tile === null || tile === void 0 || (_tile$data2 = tile.data) === null || _tile$data2 === void 0 ? void 0 : _tile$data2.height) || 1;
-  var indexX = Math.floor(pos[0] * tileWidth);
-  var indexY = Math.floor(pos[1] * tileHeight);
-  var index = Math.max(0, indexY - 1) * tileWidth + indexX;
-  var data = tile === null || tile === void 0 || (_tile$data3 = tile.data) === null || _tile$data3 === void 0 ? void 0 : _tile$data3.data[index];
+  const tileWidth = (tile === null || tile === void 0 || (_tile$data = tile.data) === null || _tile$data === void 0 ? void 0 : _tile$data.width) || 1;
+  const tileHeight = (tile === null || tile === void 0 || (_tile$data2 = tile.data) === null || _tile$data2 === void 0 ? void 0 : _tile$data2.height) || 1;
+  const indexX = Math.floor(pos[0] * tileWidth);
+  const indexY = Math.floor(pos[1] * tileHeight);
+  const index = Math.max(0, indexY - 1) * tileWidth + indexX;
+  const data = tile === null || tile === void 0 || (_tile$data3 = tile.data) === null || _tile$data3 === void 0 ? void 0 : _tile$data3.data[index];
   return data;
 }
 function readPixel(x, y, rendererService) {
-  var readPixels = rendererService.readPixels,
-    getViewportSize = rendererService.getViewportSize;
-  var xInDevicePixel = x * _l7Utils.DOM.DPR;
-  var yInDevicePixel = y * _l7Utils.DOM.DPR;
-  var _getViewportSize = getViewportSize(),
-    width = _getViewportSize.width,
-    height = _getViewportSize.height;
+  const {
+    readPixels,
+    getViewportSize
+  } = rendererService;
+  const xInDevicePixel = x * _l7Utils.DOM.DPR;
+  const yInDevicePixel = y * _l7Utils.DOM.DPR;
+  const {
+    width,
+    height
+  } = getViewportSize();
   if (xInDevicePixel > width - 1 * _l7Utils.DOM.DPR || xInDevicePixel < 0 || yInDevicePixel > height - 1 * _l7Utils.DOM.DPR || yInDevicePixel < 0) {
     return false;
   }
-  var pickedColors = readPixels({
+  const pickedColors = readPixels({
     x: Math.floor(xInDevicePixel),
     // 视口坐标系原点在左上，而 WebGL 在左下，需要翻转 Y 轴
     y: Math.floor(height - (y + 1) * _l7Utils.DOM.DPR),

package/lib/tile/interaction/utils.d.ts

@@ -0,0 +1,11 @@
+import type { ILayer } from '@antv/l7-core';
+export declare function clearPickState(layers: ILayer[]): void;
+export declare function setSelect(layers: ILayer[], pickedColors: any, renderList: ILayer[]): undefined;
+export declare function setHighlight(layers: ILayer[], pickedColors: any): void;
+export declare function setPickState(layers: ILayer[], pickColors: {
+    select: any;
+    active: any;
+}): void;
+export declare function selectFeature(layer: ILayer, pickedColors: Uint8Array | undefined): void;
+export declare function setFeatureSelect(color: any, layers: ILayer[]): void;
+export declare function setFeatureActive(color: any, layers: ILayer[]): void;

package/lib/tile/interaction/utils.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -11,22 +10,17 @@ exports.setFeatureSelect = setFeatureSelect;
 exports.setHighlight = setHighlight;
 exports.setPickState = setPickState;
 exports.setSelect = setSelect;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _l7Utils = require("@antv/l7-utils");
 function clearPickState(layers) {
-  layers.filter(function (layer) {
-    return layer.inited && layer.isVisible();
-  }).filter(function (layer) {
-    return layer.getCurrentSelectedId() !== null;
-  }).map(function (layer) {
+  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) {
-  var selectedId = (0, _l7Utils.decodePickingColor)(pickedColors);
-  var pickColor;
-  layers.map(function (layer) {
+  const selectedId = (0, _l7Utils.decodePickingColor)(pickedColors);
+  let pickColor;
+  layers.map(layer => {
     if (layer.getCurrentSelectedId() === null || selectedId !== layer.getCurrentSelectedId()) {
       selectFeature(layer, pickedColors);
       layer.setCurrentSelectedId(selectedId);
@@ -38,25 +32,17 @@ function setSelect(layers, pickedColors, renderList) {
     }
   });
   // unselect normal layer
-  renderList.filter(function (layer) {
-    return layer.inited && layer.isVisible() && layer.needPick('click');
-  }).filter(function (layer) {
-    return layer.getCurrentSelectedId() !== null;
-  }).map(function (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) {
-  var pickId = (0, _l7Utils.decodePickingColor)(pickedColors);
-  layers.filter(function (layer) {
-    return layer.inited && layer.isVisible();
-  })
+  const pickId = (0, _l7Utils.decodePickingColor)(pickedColors);
+  layers.filter(layer => layer.inited && layer.isVisible())
   // @ts-ignore
-  .filter(function (layer) {
-    return layer.getPickID() !== pickId;
-  }).map(function (layer) {
+  .filter(layer => layer.getPickID() !== pickId).map(layer => {
     // @ts-ignore
     layer.setPickID(pickId);
     layer.hooks.beforeHighlight.call(pickedColors);
@@ -64,36 +50,31 @@ function setHighlight(layers, pickedColors) {
 }
 function setPickState(layers, pickColors) {
   if (pickColors.select) {
-    layers.map(function (layer) {
+    layers.map(layer => {
       selectFeature(layer, pickColors.select);
     });
   }
   if (pickColors.active) {
-    layers.filter(function (layer) {
-      return layer.inited && layer.isVisible();
-    }).map(function (layer) {
+    layers.filter(layer => layer.inited && layer.isVisible()).map(layer => {
       layer.hooks.beforeHighlight.call(pickColors.active);
     });
   }
 }
 function selectFeature(layer, pickedColors) {
   // @ts-ignore
-  var _pickedColors = (0, _slicedToArray2.default)(pickedColors, 3),
-    r = _pickedColors[0],
-    g = _pickedColors[1],
-    b = _pickedColors[2];
+  const [r, g, b] = pickedColors;
   layer.hooks.beforeSelect.call([r, g, b]);
 }
 function setFeatureSelect(color, layers) {
-  var id = (0, _l7Utils.decodePickingColor)(color);
-  layers.map(function (layer) {
+  const id = (0, _l7Utils.decodePickingColor)(color);
+  layers.map(layer => {
     selectFeature(layer, color);
     layer.setCurrentSelectedId(id);
   });
 }
 function setFeatureActive(color, layers) {
-  var id = (0, _l7Utils.decodePickingColor)(color);
-  layers.map(function (layer) {
+  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/service/TileLayerService.d.ts

@@ -0,0 +1,33 @@
+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;
+    private layerTiles;
+    constructor({ rendererService, layerService, parent, }: ITileLayerServiceOptions);
+    get tiles(): ITile[];
+    hasTile(tileKey: string): boolean;
+    addTile(tile: ITile): void;
+    getTile(tileKey: string): ITile | undefined;
+    getVisibleTileBylngLat(lngLat: ILngLat): ITile | undefined;
+    removeTile(tileKey: string): 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

@@ -5,199 +5,127 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TileLayerService = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var TileLayerService = exports.TileLayerService = /*#__PURE__*/function () {
-  function TileLayerService(_ref) {
-    var rendererService = _ref.rendererService,
-      layerService = _ref.layerService,
-      parent = _ref.parent;
-    (0, _classCallCheck2.default)(this, TileLayerService);
+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);
     (0, _defineProperty2.default)(this, "layerTiles", []);
     this.rendererService = rendererService;
     this.layerService = layerService;
     this.parent = parent;
   }
-  (0, _createClass2.default)(TileLayerService, [{
-    key: "tiles",
-    get: function get() {
-      return this.layerTiles;
-    }
-  }, {
-    key: "hasTile",
-    value: function hasTile(tileKey) {
-      return this.layerTiles.some(function (tile) {
-        return tile.key === tileKey;
-      });
-    }
-  }, {
-    key: "addTile",
-    value: function addTile(tile) {
-      this.layerTiles.push(tile);
-    }
-  }, {
-    key: "getTile",
-    value: function getTile(tileKey) {
-      return this.layerTiles.find(function (tile) {
-        return tile.key === tileKey;
-      });
-    }
-  }, {
-    key: "getVisibleTileBylngLat",
-    value: function getVisibleTileBylngLat(lngLat) {
-      // 加载完成 & 可见 & 鼠标选中
-      return this.layerTiles.find(function (tile) {
-        return tile.isLoaded && tile.visible && tile.lnglatInBounds(lngLat);
-      });
-    }
-  }, {
-    key: "removeTile",
-    value: function removeTile(tileKey) {
-      var index = this.layerTiles.findIndex(function (t) {
-        return t.key === tileKey;
-      });
-      var tile = this.layerTiles.splice(index, 1);
-      if (tile[0]) {
-        tile[0].destroy();
-      }
+  get tiles() {
+    return this.layerTiles;
+  }
+  hasTile(tileKey) {
+    return this.layerTiles.some(tile => tile.key === tileKey);
+  }
+  addTile(tile) {
+    this.layerTiles.push(tile);
+  }
+  getTile(tileKey) {
+    return this.layerTiles.find(tile => tile.key === tileKey);
+  }
+  getVisibleTileBylngLat(lngLat) {
+    // 加载完成 & 可见 & 鼠标选中
+    return this.layerTiles.find(tile => tile.isLoaded && tile.visible && tile.lnglatInBounds(lngLat));
+  }
+  removeTile(tileKey) {
+    const index = this.layerTiles.findIndex(t => t.key === tileKey);
+    const tile = this.layerTiles.splice(index, 1);
+    if (tile[0]) {
+      tile[0].destroy();
     }
-  }, {
-    key: "updateTileVisible",
-    value: function updateTileVisible(sourceTile) {
-      var tile = this.getTile(sourceTile.key);
-      if (sourceTile.isVisible) {
-        // 不可见 => 可见 兄弟节点加载完成
-        if (sourceTile.parent) {
-          var flag = this.isChildrenLoaded(sourceTile.parent);
-          tile === null || tile === void 0 || tile.updateVisible(flag);
-        } else {
-          tile === null || tile === void 0 || tile.updateVisible(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 {
-        // 可见 => 不可见 兄弟节点加载完成
-        if (sourceTile.parent) {
-          var _flag = this.isChildrenLoaded(sourceTile.parent);
-          tile === null || tile === void 0 || tile.updateVisible(!_flag);
-        } else {
-          tile === null || tile === void 0 || tile.updateVisible(false);
-        }
-      }
-    }
-  }, {
-    key: "isParentLoaded",
-    value: function isParentLoaded(sourceTile) {
-      var parentTile = sourceTile.parent;
-      if (!parentTile) {
-        return true;
-      }
-      var tile = this.getTile(parentTile === null || parentTile === void 0 ? void 0 : parentTile.key);
-      if (tile !== null && tile !== void 0 && tile.isLoaded) {
-        // 递归父级
-        return true;
-      }
-      return false;
-    }
-  }, {
-    key: "isChildrenLoaded",
-    value: function isChildrenLoaded(sourceTile) {
-      var _this = this;
-      var childrenTile = sourceTile === null || sourceTile === void 0 ? void 0 : sourceTile.children;
-      if (childrenTile.length === 0) {
-        return true;
+        tile === null || tile === void 0 || tile.updateVisible(true);
       }
-      return childrenTile.every(function (tile) {
-        var 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;
-      });
-    }
-  }, {
-    key: "render",
-    value: function () {
-      var _render = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-        var _this2 = this;
-        var layers, renders;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              layers = this.getRenderLayers();
-              renders = layers.map( /*#__PURE__*/function () {
-                var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(layer) {
-                  return _regenerator.default.wrap(function _callee$(_context) {
-                    while (1) switch (_context.prev = _context.next) {
-                      case 0:
-                        _context.next = 2;
-                        return _this2.layerService.renderTileLayer(layer);
-                      case 2:
-                      case "end":
-                        return _context.stop();
-                    }
-                  }, _callee);
-                }));
-                return function (_x) {
-                  return _ref2.apply(this, arguments);
-                };
-              }());
-              _context2.next = 4;
-              return Promise.all(renders);
-            case 4:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function render() {
-        return _render.apply(this, arguments);
+    } 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);
       }
-      return render;
-    }()
-  }, {
-    key: "getRenderLayers",
-    value: function getRenderLayers() {
-      var tileList = this.layerTiles.filter(function (t) {
-        return t.visible && t.isLoaded;
-      });
-      var layers = [];
-      tileList.map(function (tile) {
-        return layers.push.apply(layers, (0, _toConsumableArray2.default)(tile.getLayers()));
-      });
-      return layers;
     }
-  }, {
-    key: "getLayers",
-    value: function getLayers() {
-      var tileList = this.layerTiles.filter(function (t) {
-        return t.isLoaded;
-      });
-      var layers = [];
-      tileList.map(function (tile) {
-        return layers.push.apply(layers, (0, _toConsumableArray2.default)(tile.getLayers()));
-      });
-      return layers;
+  }
+  isParentLoaded(sourceTile) {
+    const parentTile = sourceTile.parent;
+    if (!parentTile) {
+      return true;
     }
-  }, {
-    key: "getTiles",
-    value: function getTiles() {
-      return this.layerTiles;
+    const tile = this.getTile(parentTile === null || parentTile === void 0 ? void 0 : parentTile.key);
+    if (tile !== null && tile !== void 0 && tile.isLoaded) {
+      // 递归父级
+      return true;
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.layerTiles.forEach(function (t) {
-        return t.destroy();
-      });
-      this.tileResource.clear();
+    return false;
+  }
+  isChildrenLoaded(sourceTile) {
+    const childrenTile = sourceTile === null || sourceTile === void 0 ? void 0 : sourceTile.children;
+    if (childrenTile.length === 0) {
+      return true;
     }
-  }]);
-  return TileLayerService;
-}();
+    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* () {
+      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() {
+    const tileList = this.layerTiles.filter(t => t.visible && t.isLoaded);
+    const layers = [];
+    tileList.map(tile => layers.push(...tile.getLayers()));
+    return layers;
+  }
+  getLayers() {
+    const tileList = this.layerTiles.filter(t => t.isLoaded);
+    const layers = [];
+    tileList.map(tile => layers.push(...tile.getLayers()));
+    return layers;
+  }
+  getTiles() {
+    return this.layerTiles;
+  }
+  destroy() {
+    this.layerTiles.forEach(t => t.destroy());
+    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;
+}