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

package/lib/tile/tileFactory/base.js

@@ -1,343 +1,466 @@
-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
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-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 import_polygon_to_line = __toESM(require("@turf/polygon-to-line"));
-var TileFactory = class {
-  constructor(option) {
-    this.outSideEventTimer = null;
-    this.eventCache = {
+exports.default = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+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"));
+
+var _polygonToLine = _interopRequireDefault(require("@turf/polygon-to-line"));
+
+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; }
+
+var TileFactory = /*#__PURE__*/function () {
+  // 用于记录图层内事件，辅助判断图层外事件逻辑
+  function TileFactory(option) {
+    (0, _classCallCheck2.default)(this, TileFactory);
+    (0, _defineProperty2.default)(this, "outSideEventTimer", null);
+    (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;
-    const source = this.parentLayer.getSource();
+    var source = this.parentLayer.getSource();
     this.zoomOffset = source.parser.zoomOffset || 0;
     this.tilesetManager = source.tileset;
   }
-  createTile(tile, initOptions) {
-    return {
-      layers: [],
-      layerIDList: []
-    };
-  }
-  getFeatureData(tile, initOptions) {
-    const emptyData = {
-      features: [],
-      featureId: null,
-      vectorTileLayer: null,
-      source: null
-    };
-    const { sourceLayer, featureId, transforms, layerType, shape } = initOptions;
-    if (!sourceLayer) {
-      return emptyData;
+
+  (0, _createClass2.default)(TileFactory, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      return {
+        layers: [],
+        layerIDList: []
+      };
     }
-    const vectorTileLayer = tile.data.layers[sourceLayer];
-    const features = vectorTileLayer == null ? void 0 : vectorTileLayer.features;
-    if (!(Array.isArray(features) && features.length > 0)) {
-      return emptyData;
-    } else {
-      let geofeatures = [];
-      if (layerType === "LineLayer" && shape === "simple") {
-        features.map((feature) => {
-          if (feature.geometry.type === "MultiPolygon") {
-            const linefeatures = (0, import_polygon_to_line.default)(feature).features;
-            geofeatures.push(...linefeatures);
-          } else if (feature.geometry.type === "Polygon") {
-            feature.geometry.type = "MultiLineString";
-            geofeatures.push(feature);
-          } else {
-            geofeatures.push(feature);
-          }
-        });
+  }, {
+    key: "getFeatureData",
+    value: function getFeatureData(tile, initOptions) {
+      var emptyData = {
+        features: [],
+        featureId: null,
+        vectorTileLayer: null,
+        source: null
+      };
+      var sourceLayer = initOptions.sourceLayer,
+          featureId = initOptions.featureId,
+          transforms = initOptions.transforms,
+          layerType = initOptions.layerType,
+          shape = initOptions.shape;
+
+      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 {
-        geofeatures = features;
+        var geofeatures = [];
+
+        if (layerType === 'LineLayer' && shape === 'simple') {
+          features.map(function (feature) {
+            if (feature.geometry.type === 'MultiPolygon') {
+              var _geofeatures;
+
+              // @ts-ignore
+              var linefeatures = (0, _polygonToLine.default)(feature).features;
+
+              (_geofeatures = geofeatures).push.apply(_geofeatures, (0, _toConsumableArray2.default)(linefeatures));
+            } else if (feature.geometry.type === 'Polygon') {
+              feature.geometry.type = 'MultiLineString';
+              geofeatures.push(feature);
+            } else {
+              geofeatures.push(feature);
+            }
+          });
+        } else {
+          geofeatures = features;
+        }
+
+        var source = new _l7Source.default({
+          type: 'FeatureCollection',
+          features: geofeatures
+        }, {
+          parser: {
+            type: 'geojson',
+            featureId: featureId
+          },
+          transforms: transforms
+        });
+        return {
+          features: geofeatures,
+          featureId: featureId,
+          vectorTileLayer: vectorTileLayer,
+          source: source
+        };
       }
-      const source = new import_l7_source.default({
-        type: "FeatureCollection",
-        features: geofeatures
-      }, {
-        parser: {
-          type: "geojson",
-          featureId
-        },
-        transforms
-      });
-      return {
-        features: geofeatures,
-        featureId,
-        vectorTileLayer,
-        source
-      };
     }
-  }
-  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: "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((0, _objectSpread2.default)({
+        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))); // vector layer set config
+
+      if (layer.isVector) {
+        this.emitEvent([layer]);
+        layer.type = layerType;
+        layer.select(true);
+      } // set source
+
+
+      layer.source(source); // set scale
+
+      this.setScale(layer); // set scale attribute field
+
+      this.setStyleAttributeField(layer, 'shape', shape);
+      this.setStyleAttributeField(layer, 'color', color);
+      this.setStyleAttributeField(layer, 'size', size); // set mask
+
+      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);
+      } // regist layer
+
+
+      (0, _utils.registerLayers)(this.parentLayer, layers);
+      this.layers = [layer];
+      return layer;
     }
-    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: "updateStyle",
+    value: function updateStyle(styles) {
+      return '';
     }
-    (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: "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 '';
+      }
     }
-  }
-  setStyleAttributeField(layer, type, value) {
-    if (Array.isArray(value)) {
-      layer[type](...value);
-      return;
+  }, {
+    key: "setStyleAttributeField",
+    value: function setStyleAttributeField(layer, type, value) {
+      if (Array.isArray(value)) {
+        // @ts-ignore
+        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 {
+        // @ts-ignore
+        layer[type].apply(layer, (0, _toConsumableArray2.default)(params));
+      }
     }
-    if (typeof value === "string") {
-      layer[type](value);
-      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 [];
     }
-    const defaultValue = this.getDefautStyleAttributeField(layer, type);
-    if (!value) {
-      layer[type](defaultValue);
-      return layer;
+  }, {
+    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;
     }
-    const params = this.parseScaleValue(value, type);
-    if (params.length === 0) {
-      layer[type](defaultValue);
-    } else {
-      layer[type](...params);
+  }, {
+    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);
+          }); // out side
+
+          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);
+          });
+        });
+      });
     }
-  }
-  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];
+  }, {
+    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 = (0, _objectSpread2.default)({}, properties);
+      }
+
+      return p;
+    }
+  }, {
+    key: "getFeatureAndEmitEvent",
+    value: function getFeatureAndEmitEvent(layer, eventName, e, isVector, tile) {
+      if (isVector === false) {
+        // raster tile get rgb
+        // e.pickedColors = readPixel(e.x, e.y, this.rendererService);
+        // raster tile origin value
+        e.value = (0, _utils.readRasterValue)(tile, this.mapService, e.x, e.y);
       } else {
-        return [];
+        // VectorLayer
+        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];
+        }
       }
+
+      this.parentLayer.emit(eventName, e);
     }
-    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: "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]);
+      });
     }
-    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);
+  }, {
+    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);
           }
         });
-        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));
       });
-    });
-  }
-  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 };
+      return features;
     }
-    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];
-      }
+  }, {
+    key: "getLayerInitOption",
+    value: function getLayerInitOption(initOptions) {
+      var option = (0, _objectSpread2.default)({}, initOptions);
+      delete option.color;
+      delete option.shape;
+      delete option.size;
+      delete option.coords;
+      delete option.sourceLayer;
+      delete option.coords;
+      return option;
     }
-    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);
+  }, {
+    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);
         }
-      });
-    });
-    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;
+      }, 64);
     }
-    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 = {});
+  }]);
+  return TileFactory;
+}();
+
+exports.default = TileFactory;