@antv/l7-layers 2.9.21 → 2.9.23

package/lib/tile/tileFactory/base.js

@@ -1,436 +1,325 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof = require("@babel/runtime/helpers/typeof");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tile/tileFactory/base.ts
+var base_exports = {};
+__export(base_exports, {
+  default: () => TileFactory
 });
-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, "zoomOffset", void 0);
-    (0, _defineProperty2.default)(this, "tilesetManager", void 0);
-    (0, _defineProperty2.default)(this, "layers", void 0);
-    (0, _defineProperty2.default)(this, "eventCache", {
+module.exports = __toCommonJS(base_exports);
+var import_l7_source = __toESM(require("@antv/l7-source"));
+var import_l7_utils = require("@antv/l7-utils");
+var import_mask = __toESM(require("../../mask"));
+var import_utils = require("../utils");
+var import_vectorLayer = __toESM(require("./vectorLayer"));
+var turf = __toESM(require("@turf/helpers"));
+var import_union = __toESM(require("@turf/union"));
+var TileFactory = class {
+  constructor(option) {
+    this.outSideEventTimer = null;
+    this.eventCache = {
       click: 0,
       mousemove: 0,
       mouseup: 0,
       mousedown: 0,
       contextmenu: 0
-    });
+    };
     this.parentLayer = option.parent;
     this.mapService = option.mapService;
     this.rendererService = option.rendererService;
-    var source = this.parentLayer.getSource();
+    const source = this.parentLayer.getSource();
     this.zoomOffset = source.parser.zoomOffset || 0;
     this.tilesetManager = source.tileset;
   }
-
-  (0, _createClass2.default)(TileFactory, [{
-    key: "createTile",
-    value: function createTile(tile, initOptions) {
+  createTile(tile, initOptions) {
+    return {
+      layers: [],
+      layerIDList: []
+    };
+  }
+  getFeatureData(tile, initOptions) {
+    const emptyData = {
+      features: [],
+      featureId: null,
+      vectorTileLayer: null,
+      source: null
+    };
+    const { sourceLayer, featureId } = initOptions;
+    if (!sourceLayer) {
+      return emptyData;
+    }
+    const vectorTileLayer = tile.data.layers[sourceLayer];
+    const features = vectorTileLayer == null ? void 0 : vectorTileLayer.features;
+    if (!(Array.isArray(features) && features.length > 0)) {
+      return emptyData;
+    } else {
+      const source = new import_l7_source.default({
+        type: "FeatureCollection",
+        features
+      }, {
+        parser: {
+          type: "geojson",
+          featureId
+        }
+      });
       return {
-        layers: [],
-        layerIDList: []
+        features,
+        featureId,
+        vectorTileLayer,
+        source
       };
     }
-  }, {
-    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.setScale(layer);
-      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 '';
+  }
+  createLayer(tileLayerOption) {
+    const {
+      L7Layer,
+      tile,
+      initOptions,
+      vectorTileLayer,
+      source
+    } = tileLayerOption;
+    const { mask, color, layerType, size, shape } = initOptions;
+    const FactoryTileLayer = L7Layer ? L7Layer : import_vectorLayer.default;
+    const layer = new FactoryTileLayer({
+      visible: tile.isVisible,
+      tileOrigin: vectorTileLayer == null ? void 0 : vectorTileLayer.l7TileOrigin,
+      coord: vectorTileLayer == null ? void 0 : vectorTileLayer.l7TileCoord,
+      ...this.getLayerInitOption(initOptions)
+    });
+    if (layer.isVector) {
+      this.emitEvent([layer]);
+      layer.type = layerType;
+      layer.select(true);
     }
-  }, {
-    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 '';
-      }
+    layer.source(source);
+    this.setScale(layer);
+    this.setStyleAttributeField(layer, "shape", shape);
+    this.setStyleAttributeField(layer, "color", color);
+    this.setStyleAttributeField(layer, "size", size);
+    const layers = [layer];
+    if (mask && layer.isVector) {
+      const masklayer = new import_mask.default().source({
+        type: "FeatureCollection",
+        features: [tile.bboxPolygon]
+      }).shape("fill");
+      layers.push(masklayer);
+      layer.addMaskLayer(masklayer);
     }
-  }, {
-    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));
-      }
+    (0, import_utils.registerLayers)(this.parentLayer, layers);
+    this.layers = [layer];
+    return layer;
+  }
+  updateStyle(styles) {
+    return "";
+  }
+  getDefautStyleAttributeField(layer, type) {
+    switch (type) {
+      case "size":
+        return 2;
+      case "color":
+        return "#fff";
+      case "shape":
+        return (0, import_utils.getLayerShape)(this.parentLayer.type, layer);
+      default:
+        return "";
     }
-  }, {
-    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 [];
+  }
+  setStyleAttributeField(layer, type, value) {
+    if (Array.isArray(value)) {
+      layer[type](...value);
+      return;
     }
-  }, {
-    key: "getTile",
-    value: function getTile(lng, lat) {
-      var zoom = this.mapService.getZoom();
-      var z = Math.ceil(zoom) + this.zoomOffset;
-      var xy = (0, _l7Utils.osmLonLat2TileXY)(lng, lat, z);
-      var tiles = this.tilesetManager.tiles.filter(function (t) {
-        return t.key === "".concat(xy[0], ",").concat(xy[1], ",").concat(z);
-      });
-      var tile = tiles[0];
-      return tile;
+    if (typeof value === "string") {
+      layer[type](value);
+      return;
     }
-  }, {
-    key: "emitEvent",
-    value: function emitEvent(layers, isVector) {
-      var _this = this;
-
-      layers.map(function (layer) {
-        layer.once('inited', function () {
-          layer.on('click', function (e) {
-            _this.eventCache.click = 1;
-
-            if (_this.parentLayer.type === 'RasterLayer') {
-              var _e$lngLat = e.lngLat,
-                  lng = _e$lngLat.lng,
-                  lat = _e$lngLat.lat;
-
-              var tile = _this.getTile(lng, lat);
-
-              _this.getFeatureAndEmitEvent(layer, 'subLayerClick', e, isVector, tile);
-            } else {
-              _this.getFeatureAndEmitEvent(layer, 'subLayerClick', e);
-            }
-          });
-          layer.on('mousemove', function (e) {
-            _this.eventCache.mousemove = 1;
-
-            if (_this.parentLayer.type === 'RasterLayer') {
-              var _e$lngLat2 = e.lngLat,
-                  lng = _e$lngLat2.lng,
-                  lat = _e$lngLat2.lat;
-
-              var tile = _this.getTile(lng, lat);
-
-              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e, isVector, tile);
-            } else {
-              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e);
-            }
-          });
-          layer.on('mouseup', function (e) {
-            _this.eventCache.mouseup = 1;
-
-            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseUp', e);
-          });
-          layer.on('mouseenter', function (e) {
-            if (_this.parentLayer.type === 'RasterLayer') {
-              var _e$lngLat3 = e.lngLat,
-                  lng = _e$lngLat3.lng,
-                  lat = _e$lngLat3.lat;
-
-              var tile = _this.getTile(lng, lat);
-
-              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e, isVector, tile);
-            } else {
-              _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);
-          });
-        });
-      });
+    const defaultValue = this.getDefautStyleAttributeField(layer, type);
+    if (!value) {
+      layer[type](defaultValue);
+      return layer;
     }
-  }, {
-    key: "getCombineFeature",
-    value: function getCombineFeature(features) {
-      var p = null;
-      var properties = features[0];
-      features.map(function (feature) {
-        var polygon = turf.polygon(feature.coordinates);
-
-        if (p === null) {
-          p = polygon;
-        }
-
-        {
-          p = (0, _union.default)(p, polygon);
-        }
-      });
-
-      if (properties) {
-        p.properties = _objectSpread({}, properties);
-      }
-
-      return p;
+    const params = this.parseScaleValue(value, type);
+    if (params.length === 0) {
+      layer[type](defaultValue);
+    } else {
+      layer[type](...params);
     }
-  }, {
-    key: "getFeatureAndEmitEvent",
-    value: function getFeatureAndEmitEvent(layer, eventName, e, isVector, tile) {
-      if (isVector === false) {
-        e.value = (0, _utils.readRasterValue)(tile, this.mapService, e.x, e.y);
+  }
+  parseScaleValue(value, type) {
+    if (type === "shape") {
+      if (typeof value === "string") {
+        return [value];
+      } else if (value == null ? void 0 : value.field) {
+        return [value == null ? void 0 : value.field];
       } else {
-        var featureId = e.featureId;
-        var features = this.getAllFeatures(featureId);
-
-        try {
-          e.feature = this.getCombineFeature(features);
-        } catch (err) {
-          console.warn('Combine Featuer Err! Return First Feature!');
-          e.feature = features[0];
-        }
+        return [];
       }
-
-      this.parentLayer.emit(eventName, e);
     }
-  }, {
-    key: "setScale",
-    value: function setScale(layer) {
-      var scaleOptions = this.parentLayer.tileLayer.scaleField;
-      var scaleKeys = Object.keys(scaleOptions);
-      scaleKeys.map(function (key) {
-        layer.scale(key, scaleOptions[key]);
-      });
+    const { field, values, callback } = value;
+    if (field && values && Array.isArray(values)) {
+      return [field, values];
+    } else if (field && callback) {
+      return [field, callback];
+    } else if (field) {
+      return [field];
     }
-  }, {
-    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 [];
+  }
+  getTile(lng, lat) {
+    const zoom = this.mapService.getZoom();
+    const z = Math.ceil(zoom) + this.zoomOffset;
+    const xy = (0, import_l7_utils.osmLonLat2TileXY)(lng, lat, z);
+    const tiles = this.tilesetManager.tiles.filter((t) => t.key === `${xy[0]},${xy[1]},${z}`);
+    const tile = tiles[0];
+    return tile;
+  }
+  emitEvent(layers, isVector) {
+    layers.map((layer) => {
+      layer.once("inited", () => {
+        layer.on("click", (e) => {
+          this.eventCache.click = 1;
+          if (this.parentLayer.type === "RasterLayer") {
+            const { lng, lat } = e.lngLat;
+            const tile = this.getTile(lng, lat);
+            this.getFeatureAndEmitEvent(layer, "subLayerClick", e, isVector, tile);
+          } else {
+            this.getFeatureAndEmitEvent(layer, "subLayerClick", e);
+          }
+        });
+        layer.on("mousemove", (e) => {
+          this.eventCache.mousemove = 1;
+          if (this.parentLayer.type === "RasterLayer") {
+            const { lng, lat } = e.lngLat;
+            const tile = this.getTile(lng, lat);
+            this.getFeatureAndEmitEvent(layer, "subLayerMouseMove", e, isVector, tile);
+          } else {
+            this.getFeatureAndEmitEvent(layer, "subLayerMouseMove", e);
           }
         });
+        layer.on("mouseup", (e) => {
+          this.eventCache.mouseup = 1;
+          this.getFeatureAndEmitEvent(layer, "subLayerMouseUp", e);
+        });
+        layer.on("mouseenter", (e) => {
+          if (this.parentLayer.type === "RasterLayer") {
+            const { lng, lat } = e.lngLat;
+            const tile = this.getTile(lng, lat);
+            this.getFeatureAndEmitEvent(layer, "subLayerMouseMove", e, isVector, tile);
+          } else {
+            this.getFeatureAndEmitEvent(layer, "subLayerMouseEnter", e);
+          }
+        });
+        layer.on("mouseout", (e) => {
+          this.getFeatureAndEmitEvent(layer, "subLayerMouseOut", e);
+        });
+        layer.on("mousedown", (e) => {
+          this.eventCache.mousedown = 1;
+          this.getFeatureAndEmitEvent(layer, "subLayerMouseDown", e);
+        });
+        layer.on("contextmenu", (e) => {
+          this.eventCache.contextmenu = 1;
+          this.getFeatureAndEmitEvent(layer, "subLayerContextmenu", e);
+        });
+        layer.on("unclick", (e) => this.handleOutsideEvent("click", "subLayerUnClick", layer, e));
+        layer.on("unmouseup", (e) => this.handleOutsideEvent("mouseup", "subLayerUnMouseUp", layer, e));
+        layer.on("unmousedown", (e) => this.handleOutsideEvent("mousedown", "subLayerUnMouseDown", layer, e));
+        layer.on("uncontextmenu", (e) => this.handleOutsideEvent("contextmenu", "subLayerUnContextmenu", layer, e));
       });
-      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;
+    });
+  }
+  getCombineFeature(features) {
+    let p = null;
+    const properties = features[0];
+    features.map((feature) => {
+      const polygon2 = turf.polygon(feature.coordinates);
+      if (p === null) {
+        p = polygon2;
+      }
+      {
+        p = (0, import_union.default)(p, polygon2);
+      }
+    });
+    if (properties) {
+      p.properties = { ...properties };
     }
-  }, {
-    key: "handleOutsideEvent",
-    value: function handleOutsideEvent(type, emitType, layer, e) {
-      var _this2 = this;
-
-      if (this.outSideEventTimer) {
-        clearTimeout(this.outSideEventTimer);
-        this.outSideEventTimer = null;
+    return p;
+  }
+  getFeatureAndEmitEvent(layer, eventName, e, isVector, tile) {
+    if (isVector === false) {
+      e.value = (0, import_utils.readRasterValue)(tile, this.mapService, e.x, e.y);
+    } else {
+      const featureId = e.featureId;
+      const features = this.getAllFeatures(featureId);
+      try {
+        e.feature = this.getCombineFeature(features);
+      } catch (err) {
+        console.warn("Combine Featuer Err! Return First Feature!");
+        e.feature = features[0];
       }
-
-      this.outSideEventTimer = setTimeout(function () {
-        if (_this2.eventCache[type] > 0) {
-          _this2.eventCache[type] = 0;
-        } else {
-          _this2.getFeatureAndEmitEvent(layer, emitType, e);
+    }
+    this.parentLayer.emit(eventName, e);
+  }
+  setScale(layer) {
+    const scaleOptions = this.parentLayer.tileLayer.scaleField;
+    const scaleKeys = Object.keys(scaleOptions);
+    scaleKeys.map((key) => {
+      layer.scale(key, scaleOptions[key]);
+    });
+  }
+  getAllFeatures(featureId) {
+    const allLayers = this.parentLayer.tileLayer.children;
+    const features = [];
+    allLayers.map((layer) => {
+      const source = layer.getSource();
+      source.data.dataArray.map((feature) => {
+        if (feature._id === featureId) {
+          features.push(feature);
         }
-      }, 64);
+      });
+    });
+    return features;
+  }
+  getLayerInitOption(initOptions) {
+    const option = { ...initOptions };
+    delete option.color;
+    delete option.shape;
+    delete option.size;
+    delete option.coords;
+    delete option.sourceLayer;
+    delete option.coords;
+    return option;
+  }
+  handleOutsideEvent(type, emitType, layer, e) {
+    if (this.outSideEventTimer) {
+      clearTimeout(this.outSideEventTimer);
+      this.outSideEventTimer = null;
     }
-  }]);
-  return TileFactory;
-}();
-
-exports.default = TileFactory;
-//# sourceMappingURL=base.js.map
+    this.outSideEventTimer = setTimeout(() => {
+      if (this.eventCache[type] > 0) {
+        this.eventCache[type] = 0;
+      } else {
+        this.getFeatureAndEmitEvent(layer, emitType, e);
+      }
+    }, 64);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});