@antv/l7-layers 2.8.45 → 2.9.2

package/lib/tile/manager/tilePickerManager.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _eventemitter = require("eventemitter3");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var TilePickManager = function (_EventEmitter) {
+  (0, _inherits2.default)(TilePickManager, _EventEmitter);
+
+  var _super = _createSuper(TilePickManager);
+
+  function TilePickManager(parent, rendererService, pickingService, children, layerService) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, TilePickManager);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isLastPicked", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "rendererService", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "pickingService", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "layerService", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "children", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "parent", void 0);
+    _this.parent = parent;
+    _this.rendererService = rendererService;
+    _this.pickingService = pickingService;
+    _this.layerService = layerService;
+    _this.children = children;
+    return _this;
+  }
+
+  (0, _createClass2.default)(TilePickManager, [{
+    key: "normalRender",
+    value: function normalRender(layers) {
+      var _this2 = this;
+
+      layers.filter(function (layer) {
+        return layer.inited;
+      }).filter(function (layer) {
+        return layer.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeRenderData.call();
+        layer.hooks.beforeRender.call();
+
+        if (layer.masks.length > 0) {
+          _this2.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+
+          layer.masks.map(function (m) {
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.render();
+        layer.hooks.afterRender.call();
+      });
+    }
+  }, {
+    key: "pickRender",
+    value: function pickRender(layers, target) {
+      var _this3 = this;
+
+      if (this.parent.type === 'RasterLayer') {
+        this.normalRender([this.parent]);
+      }
+
+      var isPicked = layers.filter(function (layer) {
+        return _this3.parent.needPick(target.type) && layer.inited && layer.isVisible();
+      }).some(function (layer) {
+        layer.hooks.beforePickingEncode.call();
+
+        if (layer.masks.length > 0) {
+          _this3.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+
+          layer.masks.map(function (m) {
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.renderModels(true);
+        layer.hooks.afterPickingEncode.call();
+
+        var layerPicked = _this3.pickingService.pickFromPickingFBO(layer, target);
+
+        if (layerPicked) {
+          _this3.emit('pick', {
+            type: target.type,
+            pickedColors: _this3.pickingService.pickedColors,
+            layer: layer
+          });
+
+          _this3.pickingService.pickedTileLayers = [_this3.parent];
+        }
+
+        return layerPicked;
+      });
+
+      if (!isPicked && this.isLastPicked && target.type !== 'click') {
+        this.pickingService.pickedTileLayers = [];
+        this.emit('unpick', {});
+        this.beforeHighlight([0, 0, 0]);
+      }
+
+      this.isLastPicked = isPicked;
+      return isPicked;
+    }
+  }, {
+    key: "clearPick",
+    value: function clearPick() {
+      this.children.filter(function (child) {
+        return child.inited && child.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeSelect.call([0, 0, 0]);
+      });
+      this.pickingService.pickedTileLayers = [];
+    }
+  }, {
+    key: "beforeHighlight",
+    value: function beforeHighlight(pickedColors) {
+      this.children.filter(function (child) {
+        return child.inited && child.isVisible();
+      }).map(function (child) {
+        child.hooks.beforeHighlight.call(pickedColors);
+      });
+    }
+  }, {
+    key: "beforeSelect",
+    value: function beforeSelect(pickedColors) {
+      this.children.filter(function (child) {
+        return child.inited && child.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeSelect.call(pickedColors);
+      });
+    }
+  }]);
+  return TilePickManager;
+}(_eventemitter.EventEmitter);
+
+exports.default = TilePickManager;
+//# sourceMappingURL=tilePickerManager.js.map

package/lib/tile/manager/tilePickerManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/tile/manager/tilePickerManager.ts"],"names":["TilePickManager","parent","rendererService","pickingService","children","layerService","layers","filter","layer","inited","isVisible","map","hooks","beforeRenderData","call","beforeRender","masks","length","clear","stencil","depth","framebuffer","m","render","afterRender","target","type","normalRender","isPicked","needPick","some","beforePickingEncode","renderModels","afterPickingEncode","layerPicked","pickFromPickingFBO","emit","pickedColors","pickedTileLayers","isLastPicked","beforeHighlight","child","beforeSelect","EventEmitter"],"mappings":"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","sourcesContent":["import {\n  IInteractionTarget,\n  ILayer,\n  ILayerService,\n  IPickingService,\n  IRendererService,\n  ITilePickManager,\n} from '@antv/l7-core';\nimport { EventEmitter } from 'eventemitter3';\nexport default class TilePickManager extends EventEmitter\n  implements ITilePickManager {\n  public isLastPicked: boolean = false;\n  private rendererService: IRendererService;\n  private pickingService: IPickingService;\n  private layerService: ILayerService;\n  private children: ILayer[];\n  private parent: ILayer;\n\n  constructor(\n    parent: ILayer,\n    rendererService: IRendererService,\n    pickingService: IPickingService,\n    children: ILayer[],\n    layerService: ILayerService,\n  ) {\n    super();\n    this.parent = parent;\n    this.rendererService = rendererService;\n    this.pickingService = pickingService;\n    this.layerService = layerService;\n    this.children = children;\n  }\n\n  /**\n   *\n   * @param layers\n   */\n  public normalRender(layers: ILayer[]) {\n    layers\n      .filter((layer) => layer.inited)\n      .filter((layer) => layer.isVisible())\n      .map((layer) => {\n        layer.hooks.beforeRenderData.call();\n        layer.hooks.beforeRender.call();\n        if (layer.masks.length > 0) {\n          // 清除上一次的模版缓存\n          this.rendererService.clear({\n            stencil: 0,\n            depth: 1,\n            framebuffer: null,\n          });\n          layer.masks.map((m: ILayer) => {\n            m.hooks.beforeRender.call();\n            m.render();\n            m.hooks.afterRender.call();\n          });\n        }\n        layer.render();\n        layer.hooks.afterRender.call();\n      });\n  }\n\n  public pickRender(layers: ILayer[], target: IInteractionTarget) {\n    // Tip: 在进行拾取渲染的时候也需要先渲染一遍父组件然后再渲染子组件\n    //  如需要在 栅格瓦片存在 Mask 的时候发生的拾取，那么就需要先渲染父组件（渲染父组件的帧缓冲）\n    if (this.parent.type === 'RasterLayer') {\n      this.normalRender([this.parent]);\n    }\n    const isPicked = layers\n      .filter(\n        (layer) =>\n          this.parent.needPick(target.type) &&\n          layer.inited &&\n          layer.isVisible(),\n      )\n      .some((layer) => {\n        layer.hooks.beforePickingEncode.call();\n        if (layer.masks.length > 0) {\n          // 清除上一次的模版缓存\n          this.rendererService.clear({\n            stencil: 0,\n            depth: 1,\n            framebuffer: null,\n          });\n\n          layer.masks.map((m: ILayer) => {\n            m.hooks.beforeRender.call();\n            m.render();\n            m.hooks.afterRender.call();\n          });\n        }\n        layer.renderModels(true);\n        layer.hooks.afterPickingEncode.call();\n        const layerPicked = this.pickingService.pickFromPickingFBO(\n          layer,\n          target,\n        );\n        if (layerPicked) {\n          this.emit('pick', {\n            type: target.type,\n            pickedColors: this.pickingService.pickedColors,\n            layer,\n          });\n          this.pickingService.pickedTileLayers = [this.parent];\n        }\n\n        return layerPicked;\n      });\n    if (!isPicked && this.isLastPicked && target.type !== 'click') {\n      // 只有上一次有被高亮选中，本次未选中的时候才需要清除选中状态\n      this.pickingService.pickedTileLayers = [];\n      this.emit('unpick', {});\n      this.beforeHighlight([0, 0, 0]);\n    }\n    this.isLastPicked = isPicked;\n    return isPicked;\n  }\n\n  public clearPick() {\n    this.children\n      .filter((child) => child.inited && child.isVisible())\n      .map((layer) => {\n        layer.hooks.beforeSelect.call([0, 0, 0]);\n      });\n    this.pickingService.pickedTileLayers = [];\n  }\n\n  public beforeHighlight(pickedColors: any) {\n    this.children\n      .filter((child) => child.inited && child.isVisible())\n      .map((child) => {\n        child.hooks.beforeHighlight.call(pickedColors);\n      });\n  }\n\n  public beforeSelect(pickedColors: any) {\n    this.children\n      .filter((child) => child.inited && child.isVisible())\n      .map((layer) => {\n        layer.hooks.beforeSelect.call(pickedColors);\n      });\n  }\n}\n"],"file":"tilePickerManager.js"}

package/lib/tile/models/tileModel.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _BaseModel2 = _interopRequireDefault(require("../../core/BaseModel"));
+
+var _tmsTileLayer = require("../tmsTileLayer");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var RasterTileModel = function (_BaseModel) {
+  (0, _inherits2.default)(RasterTileModel, _BaseModel);
+
+  var _super = _createSuper(RasterTileModel);
+
+  function RasterTileModel() {
+    (0, _classCallCheck2.default)(this, RasterTileModel);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(RasterTileModel, [{
+    key: "getUninforms",
+    value: function getUninforms() {
+      return {};
+    }
+  }, {
+    key: "initModels",
+    value: function initModels() {
+      var _this$layer$getSource;
+
+      if ((_this$layer$getSource = this.layer.getSource()) !== null && _this$layer$getSource !== void 0 && _this$layer$getSource.data.isTile) {
+        this.layer.tileLayer = new _tmsTileLayer.TMSTileLayer({
+          parent: this.layer,
+          rendererService: this.rendererService,
+          mapService: this.mapService,
+          layerService: this.layerService,
+          pickingService: this.pickingService
+        });
+      }
+
+      return this.buildModels();
+    }
+  }, {
+    key: "buildModels",
+    value: function buildModels() {
+      return [];
+    }
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes() {}
+  }]);
+  return RasterTileModel;
+}(_BaseModel2.default);
+
+exports.default = RasterTileModel;
+//# sourceMappingURL=tileModel.js.map

package/lib/tile/models/tileModel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/tile/models/tileModel.ts"],"names":["RasterTileModel","layer","getSource","data","isTile","tileLayer","TMSTileLayer","parent","rendererService","mapService","layerService","pickingService","buildModels","BaseModel"],"mappings":";;;;;;;;;;;;;;;;;;;AACA;;AACA;;;;;;IACqBA,e;;;;;;;;;;;;WACnB,wBAAqC;AACnC,aAAO,EAAP;AACD;;;WAED,sBAAoB;AAAA;;AAClB,mCAAI,KAAKC,KAAL,CAAWC,SAAX,EAAJ,kDAAI,sBAAwBC,IAAxB,CAA6BC,MAAjC,EAAyC;AACvC,aAAKH,KAAL,CAAWI,SAAX,GAAuB,IAAIC,0BAAJ,CAAiB;AACtCC,UAAAA,MAAM,EAAE,KAAKN,KADyB;AAEtCO,UAAAA,eAAe,EAAE,KAAKA,eAFgB;AAGtCC,UAAAA,UAAU,EAAE,KAAKA,UAHqB;AAItCC,UAAAA,YAAY,EAAE,KAAKA,YAJmB;AAKtCC,UAAAA,cAAc,EAAE,KAAKA;AALiB,SAAjB,CAAvB;AAOD;;AAED,aAAO,KAAKC,WAAL,EAAP;AACD;;;WAED,uBAAqB;AACnB,aAAO,EAAP;AACD;;;WAED,qCAAsC,CAErC;;;EAzB0CC,mB","sourcesContent":["import { IModelUniform } from '@antv/l7-core';\nimport BaseModel from '../../core/BaseModel';\nimport { TMSTileLayer } from '../tmsTileLayer';\nexport default class RasterTileModel extends BaseModel {\n  public getUninforms(): IModelUniform {\n    return {};\n  }\n\n  public initModels() {\n    if (this.layer.getSource()?.data.isTile) {\n      this.layer.tileLayer = new TMSTileLayer({\n        parent: this.layer,\n        rendererService: this.rendererService,\n        mapService: this.mapService,\n        layerService: this.layerService,\n        pickingService: this.pickingService,\n      });\n    }\n\n    return this.buildModels();\n  }\n\n  public buildModels() {\n    return [];\n  }\n\n  protected registerBuiltinAttributes() {\n    //\n  }\n}\n"],"file":"tileModel.js"}

package/lib/tile/tileFactory/base.js

@@ -0,0 +1,395 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+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 _l7Source = _interopRequireDefault(require("@antv/l7-source"));
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _mask = _interopRequireDefault(require("../../mask"));
+
+var _utils = require("../utils");
+
+var _vectorLayer = _interopRequireDefault(require("./vectorLayer"));
+
+var turf = _interopRequireWildcard(require("@turf/helpers"));
+
+var _union = _interopRequireDefault(require("@turf/union"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var TileFactory = function () {
+  function TileFactory(option) {
+    (0, _classCallCheck2.default)(this, TileFactory);
+    (0, _defineProperty2.default)(this, "type", void 0);
+    (0, _defineProperty2.default)(this, "parentLayer", void 0);
+    (0, _defineProperty2.default)(this, "mapService", void 0);
+    (0, _defineProperty2.default)(this, "rendererService", void 0);
+    (0, _defineProperty2.default)(this, "outSideEventTimer", null);
+    (0, _defineProperty2.default)(this, "layers", void 0);
+    (0, _defineProperty2.default)(this, "eventCache", {
+      click: 0,
+      mousemove: 0,
+      mouseup: 0,
+      mousedown: 0,
+      contextmenu: 0
+    });
+    this.parentLayer = option.parent;
+    this.mapService = option.mapService;
+    this.rendererService = option.rendererService;
+  }
+
+  (0, _createClass2.default)(TileFactory, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      return {
+        layers: [],
+        layerIDList: []
+      };
+    }
+  }, {
+    key: "getFeatureData",
+    value: function getFeatureData(tile, initOptions) {
+      var emptyData = {
+        features: [],
+        featureId: null,
+        vectorTileLayer: null,
+        source: null
+      };
+      var sourceLayer = initOptions.sourceLayer,
+          featureId = initOptions.featureId;
+
+      if (!sourceLayer) {
+        return emptyData;
+      }
+
+      var vectorTileLayer = tile.data.layers[sourceLayer];
+      var features = vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.features;
+
+      if (!(Array.isArray(features) && features.length > 0)) {
+        return emptyData;
+      } else {
+        var source = new _l7Source.default({
+          type: 'FeatureCollection',
+          features: features
+        }, {
+          parser: {
+            type: 'geojson',
+            featureId: featureId
+          }
+        });
+        return {
+          features: features,
+          featureId: featureId,
+          vectorTileLayer: vectorTileLayer,
+          source: source
+        };
+      }
+    }
+  }, {
+    key: "createLayer",
+    value: function createLayer(tileLayerOption) {
+      var L7Layer = tileLayerOption.L7Layer,
+          tile = tileLayerOption.tile,
+          initOptions = tileLayerOption.initOptions,
+          vectorTileLayer = tileLayerOption.vectorTileLayer,
+          source = tileLayerOption.source;
+      var mask = initOptions.mask,
+          color = initOptions.color,
+          layerType = initOptions.layerType,
+          size = initOptions.size,
+          shape = initOptions.shape;
+      var FactoryTileLayer = L7Layer ? L7Layer : _vectorLayer.default;
+      var layer = new FactoryTileLayer(_objectSpread({
+        visible: tile.isVisible,
+        tileOrigin: vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.l7TileOrigin,
+        coord: vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.l7TileCoord
+      }, this.getLayerInitOption(initOptions)));
+
+      if (layer.isVector) {
+        this.emitEvent([layer]);
+        layer.type = layerType;
+        layer.select(true);
+      }
+
+      layer.source(source);
+      this.setStyleAttributeField(layer, 'shape', shape);
+      this.setStyleAttributeField(layer, 'color', color);
+      this.setStyleAttributeField(layer, 'size', size);
+      var layers = [layer];
+
+      if (mask && layer.isVector) {
+        var masklayer = new _mask.default().source({
+          type: 'FeatureCollection',
+          features: [tile.bboxPolygon]
+        }).shape('fill');
+        layers.push(masklayer);
+        layer.addMaskLayer(masklayer);
+      }
+
+      (0, _utils.registerLayers)(this.parentLayer, layers);
+      this.layers = [layer];
+      return layer;
+    }
+  }, {
+    key: "updateStyle",
+    value: function updateStyle(styles) {
+      return '';
+    }
+  }, {
+    key: "getDefautStyleAttributeField",
+    value: function getDefautStyleAttributeField(layer, type) {
+      switch (type) {
+        case 'size':
+          return 2;
+
+        case 'color':
+          return '#fff';
+
+        case 'shape':
+          return (0, _utils.getLayerShape)(this.parentLayer.type, layer);
+
+        default:
+          return '';
+      }
+    }
+  }, {
+    key: "setStyleAttributeField",
+    value: function setStyleAttributeField(layer, type, value) {
+      if (Array.isArray(value)) {
+        layer[type].apply(layer, (0, _toConsumableArray2.default)(value));
+        return;
+      }
+
+      if (typeof value === 'string') {
+        layer[type](value);
+        return;
+      }
+
+      var defaultValue = this.getDefautStyleAttributeField(layer, type);
+
+      if (!value) {
+        layer[type](defaultValue);
+        return layer;
+      }
+
+      var params = this.parseScaleValue(value, type);
+
+      if (params.length === 0) {
+        layer[type](defaultValue);
+      } else {
+        layer[type].apply(layer, (0, _toConsumableArray2.default)(params));
+      }
+    }
+  }, {
+    key: "parseScaleValue",
+    value: function parseScaleValue(value, type) {
+      if (type === 'shape') {
+        if (typeof value === 'string') {
+          return [value];
+        } else if (value !== null && value !== void 0 && value.field) {
+          return [value === null || value === void 0 ? void 0 : value.field];
+        } else {
+          return [];
+        }
+      }
+
+      var _ref = value,
+          field = _ref.field,
+          values = _ref.values,
+          callback = _ref.callback;
+
+      if (field && values && Array.isArray(values)) {
+        return [field, values];
+      } else if (field && callback) {
+        return [field, callback];
+      } else if (field) {
+        return [field];
+      }
+
+      return [];
+    }
+  }, {
+    key: "getTile",
+    value: function getTile(lng, lat) {
+      var source = this.parentLayer.getSource();
+      var zoomOffset = source.parser.zoomOffset || 0;
+      var tilesetManager = source.tileset;
+      var zoom = this.mapService.getZoom();
+      var z = Math.ceil(zoom) + zoomOffset;
+      var xy = (0, _l7Utils.osmLonLat2TileXY)(lng, lat, z);
+      var tiles = tilesetManager.tiles.filter(function (t) {
+        return t.key === "".concat(xy[0], ",").concat(xy[1], ",").concat(z);
+      });
+      var tile = tiles[0];
+      return tile;
+    }
+  }, {
+    key: "emitEvent",
+    value: function emitEvent(layers, isVector) {
+      var _this = this;
+
+      layers.map(function (layer) {
+        layer.once('inited', function () {
+          layer.on('click', function (e) {
+            var _e$lngLat = e.lngLat,
+                lng = _e$lngLat.lng,
+                lat = _e$lngLat.lat;
+
+            var tile = _this.getTile(lng, lat);
+
+            _this.eventCache.click = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerClick', e, isVector, tile);
+          });
+          layer.on('mousemove', function (e) {
+            var _e$lngLat2 = e.lngLat,
+                lng = _e$lngLat2.lng,
+                lat = _e$lngLat2.lat;
+
+            var tile = _this.getTile(lng, lat);
+
+            _this.eventCache.mousemove = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e, isVector, tile);
+          });
+          layer.on('mouseup', function (e) {
+            _this.eventCache.mouseup = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseUp', e);
+          });
+          layer.on('mouseenter', function (e) {
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseEnter', e);
+          });
+          layer.on('mouseout', function (e) {
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseOut', e);
+          });
+          layer.on('mousedown', function (e) {
+            _this.eventCache.mousedown = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseDown', e);
+          });
+          layer.on('contextmenu', function (e) {
+            _this.eventCache.contextmenu = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerContextmenu', e);
+          });
+          layer.on('unclick', function (e) {
+            return _this.handleOutsideEvent('click', 'subLayerUnClick', layer, e);
+          });
+          layer.on('unmouseup', function (e) {
+            return _this.handleOutsideEvent('mouseup', 'subLayerUnMouseUp', layer, e);
+          });
+          layer.on('unmousedown', function (e) {
+            return _this.handleOutsideEvent('mousedown', 'subLayerUnMouseDown', layer, e);
+          });
+          layer.on('uncontextmenu', function (e) {
+            return _this.handleOutsideEvent('contextmenu', 'subLayerUnContextmenu', layer, e);
+          });
+        });
+      });
+    }
+  }, {
+    key: "getCombineFeature",
+    value: function getCombineFeature(features) {
+      var p = null;
+      features.map(function (feature) {
+        var polygon = turf.polygon(feature.coordinates);
+
+        if (p === null) {
+          p = polygon;
+        }
+
+        {
+          p = (0, _union.default)(p, polygon);
+        }
+      });
+      return p;
+    }
+  }, {
+    key: "getFeatureAndEmitEvent",
+    value: function getFeatureAndEmitEvent(layer, eventName, e, isVector, tile) {
+      var featureId = e.featureId;
+      var features = this.getAllFeatures(featureId);
+      e.feature = this.getCombineFeature(features);
+
+      if (isVector === false) {
+        e.pickedColors = (0, _utils.readPixel)(e.x, e.y, this.rendererService);
+        e.value = (0, _utils.readRasterValue)(tile, this.mapService, e.x, e.y);
+      }
+
+      this.parentLayer.emit(eventName, e);
+    }
+  }, {
+    key: "getAllFeatures",
+    value: function getAllFeatures(featureId) {
+      var allLayers = this.parentLayer.tileLayer.children;
+      var features = [];
+      allLayers.map(function (layer) {
+        var source = layer.getSource();
+        source.data.dataArray.map(function (feature) {
+          if (feature._id === featureId) {
+            features.push(feature);
+          }
+        });
+      });
+      return features;
+    }
+  }, {
+    key: "getLayerInitOption",
+    value: function getLayerInitOption(initOptions) {
+      var option = _objectSpread({}, initOptions);
+
+      delete option.color;
+      delete option.shape;
+      delete option.size;
+      delete option.coords;
+      delete option.sourceLayer;
+      delete option.coords;
+      return option;
+    }
+  }, {
+    key: "handleOutsideEvent",
+    value: function handleOutsideEvent(type, emitType, layer, e) {
+      var _this2 = this;
+
+      if (this.outSideEventTimer) {
+        clearTimeout(this.outSideEventTimer);
+        this.outSideEventTimer = null;
+      }
+
+      this.outSideEventTimer = setTimeout(function () {
+        if (_this2.eventCache[type] > 0) {
+          _this2.eventCache[type] = 0;
+        } else {
+          _this2.getFeatureAndEmitEvent(layer, emitType, e);
+        }
+      }, 64);
+    }
+  }]);
+  return TileFactory;
+}();
+
+exports.default = TileFactory;
+//# sourceMappingURL=base.js.map