@antv/l7-layers 2.9.26-alpha.0 → 2.9.26

package/es/tile/tileFactory/polygon.js

@@ -0,0 +1,59 @@
+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
+      });
+      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/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
+      });
+      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,80 @@
+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 opacity = initOptions.opacity,
+          domain = initOptions.domain,
+          clampHigh = initOptions.clampHigh,
+          clampLow = initOptions.clampLow,
+          rampColors = initOptions.rampColors,
+          rampColorsData = initOptions.rampColorsData,
+          mask = initOptions.mask;
+      var rasterdata = tile.data;
+
+      if (!rasterdata.data) {
+        console.warn('raster data not exist!');
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = new RasterDataLayer({
+        visible: tile.isVisible,
+        mask: mask
+      }).source(rasterdata.data, {
+        parser: {
+          type: 'raster',
+          width: rasterdata.width,
+          height: rasterdata.height,
+          extent: tile.bboxPolygon.bbox
+        }
+      }).style({
+        opacity: opacity,
+        domain: domain,
+        clampHigh: clampHigh,
+        clampLow: clampLow,
+        rampColors: rampColors,
+        rampColorsData: rampColorsData
+      });
+      this.emitEvent([layer], false);
+      registerLayers(this.parentLayer, [layer]);
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return RasterTiffTile;
+}(TileFactory);
+
+export { RasterTiffTile as default };

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

@@ -0,0 +1,19 @@
+import BaseLayer from '../../core/BaseLayer';
+import { IRasterLayerStyleOptions } from '../../core/interface';
+import RasterModel from '../../raster/models/raster';
+export default class RasterTiffLayer extends BaseLayer<Partial<IRasterLayerStyleOptions>> {
+    type: string;
+    buildModels(): void;
+    rebuildModels(): void;
+    protected getModelType(): typeof RasterModel;
+    protected getConfigSchema(): {
+        properties: {
+            opacity: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    };
+    protected getDefaultConfig(): {};
+}

package/es/tile/tileFactory/rasterDataLayer.js

@@ -0,0 +1,87 @@
+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/raster";
+
+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.models = models;
+
+        _this2.renderLayers();
+      });
+    }
+  }, {
+    key: "rebuildModels",
+    value: function rebuildModels() {
+      var _this3 = this;
+
+      this.layerModel.buildModels(function (models) {
+        return _this3.models = models;
+      });
+    }
+  }, {
+    key: "getModelType",
+    value: function getModelType() {
+      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,82 @@
+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'
+      }).source([properties], {
+        parser: {
+          type: 'json',
+          x: 'textLng',
+          y: 'textLat'
+        }
+      }).shape('key', 'text').size(20).color('#000').style({
+        stroke: '#fff',
+        strokeWidth: 2
+      });
+      var line = new VectorLayer({
+        layerType: 'LineLayer'
+      }).source({
+        type: 'FeatureCollection',
+        features: features
+      }).shape('simple').color('#000');
+      registerLayers(this.parentLayer, [line, text]);
+      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,29 @@
+import BaseLayer from '../../core/BaseLayer';
+import { ILineLayerStyleOptions, IPointLayerStyleOptions, IPolygonLayerStyleOptions } from '../../core/interface';
+import lineFillModel from '../../line/models/tile';
+import lineSimpleModel from '../../line/models/simpleLine';
+import pointTextModel from '../../point/models/tileText';
+import pointFillModel from '../../point/models/tile';
+import polygonFillModel from '../../polygon/models/tile';
+export default class VectorLayer extends BaseLayer<Partial<IPolygonLayerStyleOptions & ILineLayerStyleOptions & IPointLayerStyleOptions>> {
+    isVector: boolean;
+    type: string;
+    private pickedID;
+    getPickID(): number | null;
+    setPickID(): number | null;
+    buildModels(): void;
+    rebuildModels(): void;
+    protected getModelType(): typeof lineFillModel | typeof lineSimpleModel | typeof pointTextModel | typeof pointFillModel | typeof polygonFillModel;
+    protected getLineModel(): typeof lineFillModel | typeof lineSimpleModel;
+    protected getPointModel(): typeof pointTextModel | typeof pointFillModel;
+    protected getConfigSchema(): {
+        properties: {
+            opacity: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    };
+    protected getDefaultConfig(): {};
+}

package/es/tile/tileFactory/vectorLayer.js

@@ -0,0 +1,161 @@
+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 lineFillModel from "../../line/models/tile";
+import lineSimpleModel from "../../line/models/simpleLine";
+import pointTextModel from "../../point/models/tileText";
+import pointFillModel from "../../point/models/tile";
+import polygonFillModel from "../../polygon/models/tile";
+
+var VectorLayer = /*#__PURE__*/function (_BaseLayer) {
+  _inherits(VectorLayer, _BaseLayer);
+
+  var _super = _createSuper(VectorLayer);
+
+  function VectorLayer() {
+    var _this;
+
+    _classCallCheck(this, VectorLayer);
+
+    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), "isVector", true);
+
+    _defineProperty(_assertThisInitialized(_this), "type", _this.layerType);
+
+    _defineProperty(_assertThisInitialized(_this), "pickedID", null);
+
+    return _this;
+  }
+
+  _createClass(VectorLayer, [{
+    key: "getPickID",
+    value: function getPickID() {
+      return this.pickedID;
+    }
+  }, {
+    key: "setPickID",
+    value: function setPickID() {
+      return this.pickedID;
+    }
+  }, {
+    key: "buildModels",
+    value: function buildModels() {
+      var _this2 = this;
+
+      var model = this.getModelType();
+      this.layerModel = new model(this);
+      this.layerModel.initModels(function (models) {
+        _this2.models = models;
+
+        _this2.renderLayers();
+      });
+    }
+  }, {
+    key: "rebuildModels",
+    value: function rebuildModels() {
+      var _this3 = this;
+
+      this.layerModel.buildModels(function (models) {
+        return _this3.models = models;
+      });
+    }
+  }, {
+    key: "getModelType",
+    value: function getModelType() {
+      switch (this.layerType) {
+        case 'PolygonLayer':
+          return polygonFillModel;
+
+        case 'LineLayer':
+          return this.getLineModel();
+
+        case 'PointLayer':
+          return this.getPointModel();
+
+        default:
+          return pointFillModel;
+      }
+    }
+  }, {
+    key: "getLineModel",
+    value: function getLineModel() {
+      var _shapeAttribute$scale;
+
+      var shapeAttribute = this.styleAttributeService.getLayerStyleAttribute('shape');
+      var shape = shapeAttribute === null || shapeAttribute === void 0 ? void 0 : (_shapeAttribute$scale = shapeAttribute.scale) === null || _shapeAttribute$scale === void 0 ? void 0 : _shapeAttribute$scale.field;
+
+      switch (shape) {
+        case 'tileline':
+        case 'line':
+          return lineFillModel;
+
+        case 'simple':
+          return lineSimpleModel;
+
+        default:
+          return lineFillModel;
+      }
+    }
+  }, {
+    key: "getPointModel",
+    value: function getPointModel() {
+      var layerData = this.getEncodedData();
+
+      var _this$getLayerConfig = this.getLayerConfig(),
+          shape2d = _this$getLayerConfig.shape2d;
+
+      var item = layerData.find(function (fe) {
+        return fe.hasOwnProperty('shape');
+      }); // only support pointFill & pointText now
+
+      if (item) {
+        var shape = item.shape;
+
+        if ((shape2d === null || shape2d === void 0 ? void 0 : shape2d.indexOf(shape)) !== -1) {
+          return pointFillModel;
+        } else {
+          return pointTextModel;
+        }
+      } else {
+        return pointFillModel;
+      }
+    }
+  }, {
+    key: "getConfigSchema",
+    value: function getConfigSchema() {
+      return {
+        properties: {
+          opacity: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1
+          }
+        }
+      };
+    }
+  }, {
+    key: "getDefaultConfig",
+    value: function getDefaultConfig() {
+      return {};
+    }
+  }]);
+
+  return VectorLayer;
+}(BaseLayer);
+
+export { VectorLayer as default };

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

@@ -0,0 +1,47 @@
+import { IInteractionTarget, ILayer, ITileLayer, ITileLayerManager, ITileLayerOPtions } from '@antv/l7-core';
+import { Tile, TilesetManager } from '@antv/l7-utils';
+export default class BaseTileLayer implements ITileLayer {
+    get children(): ILayer[];
+    type: string;
+    sourceLayer: string;
+    parent: ILayer;
+    initedTileset: boolean;
+    tilesetManager: TilesetManager | undefined;
+    tileLayerManager: ITileLayerManager;
+    scaleField: any;
+    private lastViewStates;
+    private timer;
+    private mapService;
+    private layerService;
+    private pickColors;
+    constructor({ parent, rendererService, mapService, layerService, pickingService, transforms }: ITileLayerOPtions);
+    /**
+     * 渲染瓦片的图层
+     */
+    render(): void;
+    clearPick(type: string): void;
+    /**
+     * 清除 select 的选中状态
+     */
+    clearPickState(): void;
+    /**
+     * 瓦片图层独立的拾取逻辑
+     * @param target
+     * @returns
+     */
+    pickLayers(target: IInteractionTarget): boolean;
+    tileLoaded(tile: Tile): void;
+    tileError(error: Error): void;
+    tileUnLoad(tile: Tile): void;
+    tileUpdate(): void;
+    protected setPickState(layers: ILayer[]): void;
+    private bindSubLayerPick;
+    private setHighlight;
+    private setSelect;
+    private selectFeature;
+    private bindSubLayerEvent;
+    private initTileSetManager;
+    private mapchange;
+    private bindTilesetEvent;
+    private getCurrentView;
+}