map-ol-utils 0.1.27 → 0.1.29

package/dist/index.cjs

@@ -69,6 +69,7 @@ var index_exports = {};
 __export(index_exports, {
   GeometryType: () => GeometryType,
   activeFeatureByUid: () => activeFeatureByUid,
+  addFeaturesByLayer: () => addFeaturesByLayer,
   addMassMarksLayer: () => addMassMarksLayer,
   appendFeaturesByLayer: () => appendFeaturesByLayer,
   buildMassMarksStyles: () => buildMassMarksStyles,
@@ -126,19 +127,9 @@ var import_Map = __toESM(require("ol/Map"), 1);
 var import_View = __toESM(require("ol/View"), 1);
 var import_control = require("ol/control");
 
-// src/layer-utils.ts
-var import_format = require("ol/format");
-var import_ol = require("ol");
-var import_Cluster = __toESM(require("ol/source/Cluster"), 1);
-var import_interaction = require("ol/interaction");
-var import_Circle = __toESM(require("ol/style/Circle"), 1);
+// src/overlay.ts
 var import_gcoord = __toESM(require("gcoord"), 1);
-var import_Vector = __toESM(require("ol/layer/Vector"), 1);
-var import_Vector2 = __toESM(require("ol/source/Vector"), 1);
-var import_geom = require("ol/geom");
-var import_condition = require("ol/events/condition");
-var import_extent = require("ol/extent");
-var import_style = require("ol/style");
+var import_ol = require("ol");
 var removeOverlays = (key = "") => {
   if (instance) {
     const overlays = instance.getOverlays().getArray().filter((overlay) => overlay.get(key || "position"));
@@ -164,6 +155,18 @@ var createAnimationMarker = (imgUrl, data) => {
   overlay.set("_isAnimationMarker", true);
   instance.addOverlay(overlay);
 };
+var createOverlay = (config = { id: "popup-container", positioning: "top-center" }) => {
+  return new import_ol.Overlay(
+    Object.assign(
+      {
+        element: document.getElementById(config.id) || void 0
+      },
+      config
+    )
+  );
+};
+
+// src/layer-manager.ts
 var resetActiveVector = () => {
   removeOverlays();
   const layers = instance.getAllLayers();
@@ -172,167 +175,6 @@ var resetActiveVector = () => {
     interaction == null ? void 0 : interaction.getFeatures().clear();
   });
 };
-var setFitViewByCoords = (coords, mapInstance = instance, fitOptions) => {
-  const view = mapInstance.getView();
-  if (coords.length === 1) {
-    view.animate(__spreadValues({
-      zoom: 14,
-      duration: 1e3,
-      center: coords[0]
-    }, fitOptions || {}));
-  } else {
-    const extent = (0, import_extent.boundingExtent)(coords);
-    view.fit(extent, __spreadValues({
-      padding: [50, 50, 50, 50],
-      duration: 1e3
-    }, fitOptions || {}));
-  }
-};
-var setFitViewByGeom = (geom, mapInstance = instance, fitOptions) => {
-  mapInstance.getView().fit(geom, __spreadValues({
-    padding: [50, 50, 50, 50],
-    duration: 1e3
-  }, fitOptions || {}));
-};
-var setFitViewByLayer = (layer, mapInstance = instance, fitOptions) => {
-  var _a;
-  const extent = ((_a = layer.getSource()) == null ? void 0 : _a.getExtent()) || [];
-  mapInstance.getView().fit(extent, __spreadValues({
-    padding: [50, 50, 50, 50],
-    duration: 1e3
-  }, fitOptions || {}));
-};
-var assembleGeoJson = (dataList, config) => {
-  const { key, crsForm } = config;
-  const tempList = [];
-  dataList.forEach((item) => {
-    try {
-      const pathArray = Array.isArray(item[key]) ? item[key] : JSON.parse(item[key] || "[]");
-      if (pathArray.length) {
-        const type = item["geoType"] || determineGeometryType(pathArray);
-        if (type !== "Invalid" /* Invalid */) {
-          tempList.push({
-            type: "Feature",
-            properties: __spreadValues({}, item),
-            geometry: {
-              type,
-              coordinates: pathArray
-            }
-          });
-        }
-      }
-    } catch (e) {
-      console.error(`\u521B\u5EFA\u7EBF\u72B6\u6570\u636E\u5931\u8D25\uFF1A${e}`);
-    }
-  });
-  return import_gcoord.default.transform(
-    { type: "FeatureCollection", features: tempList },
-    crsForm || import_gcoord.default.WGS84,
-    import_gcoord.default.WGS84
-  );
-};
-var createVectorStyle = (feature, config) => {
-  const {
-    isLine,
-    colorMap,
-    fillColor,
-    colorKey,
-    strokeColor,
-    fillOpacity,
-    strokeWeight,
-    activeFillColor,
-    activeFillOpacity,
-    activeStrokeColor,
-    activeStrokeWeight
-  } = config || {};
-  const data = feature.getProperties();
-  const activeStyle = new import_style.Style({
-    stroke: new import_style.Stroke({
-      width: activeStrokeWeight || strokeWeight || 4,
-      color: activeStrokeColor || (colorKey ? (colorMap == null ? void 0 : colorMap.get(data[colorKey])) || strokeColor : strokeColor)
-    })
-  });
-  const unActiveStyle = new import_style.Style({
-    stroke: new import_style.Stroke({
-      width: strokeWeight || 2,
-      color: colorKey ? (colorMap == null ? void 0 : colorMap.get(data[colorKey])) || strokeColor : strokeColor
-    })
-  });
-  if (!isLine) {
-    activeStyle.setFill(
-      new import_style.Fill({
-        color: hexToRgba(
-          activeFillColor || fillColor || "",
-          activeFillOpacity || 1
-        ) || hexToRgba(
-          (colorKey ? (colorMap == null ? void 0 : colorMap.get(data[colorKey])) || fillColor : fillColor) || "",
-          fillOpacity || 1
-        )
-      })
-    );
-    unActiveStyle.setFill(
-      new import_style.Fill({
-        color: hexToRgba(
-          (colorKey ? (colorMap == null ? void 0 : colorMap.get(data[colorKey])) || fillColor : fillColor) || "",
-          fillOpacity || 1
-        )
-      })
-    );
-  }
-  feature.setProperties(
-    Object.assign(data, {
-      activeStyle,
-      unActiveStyle
-    })
-  );
-  return unActiveStyle;
-};
-var createBusinessLayer = (dataList, config) => {
-  const { isAutoFit, layerName, openClick } = config;
-  const geoJson = assembleGeoJson(dataList, config);
-  const vectorLayer = new import_Vector.default({
-    zIndex: 5,
-    className: layerName ? layerName : "ol-layer",
-    source: new import_Vector2.default({
-      features: new import_format.GeoJSON().readFeatures(geoJson).map((feature) => {
-        feature.setStyle(createVectorStyle(feature, config));
-        return feature;
-      })
-    })
-  });
-  if (openClick) {
-    createSelectByLayer(vectorLayer);
-  }
-  vectorLayer.setProperties({
-    _isCustom: true,
-    _isAutoFit: isAutoFit,
-    _isVectorLayer: true,
-    _vectorConfig: config,
-    _layerName: layerName,
-    _dataList: [...dataList],
-    _uuidSet: new Set(dataList.map((item) => item._uuid) || [])
-  });
-  return vectorLayer;
-};
-var appendFeaturesByLayer = (targetLayer, dataList, crsForm) => {
-  const vectorSource = targetLayer.getSource();
-  const tempSet = targetLayer.get("_uuidSet") || /* @__PURE__ */ new Set();
-  dataList.forEach((item) => tempSet.add(item._uuid));
-  targetLayer.set("_uuidSet", tempSet);
-  const { _vectorConfig: config } = targetLayer.getProperties() || {};
-  const geoJson = assembleGeoJson(
-    dataList,
-    Object.assign({}, config, { crsForm })
-  );
-  vectorSource.addFeatures(
-    new import_format.GeoJSON().readFeatures(geoJson).map((feature) => {
-      feature.setStyle(createVectorStyle(feature, config));
-      return feature;
-    })
-  );
-};
-var createVectorFaceLayer = (dataList = [], config) => createBusinessLayer(dataList, Object.assign({}, config, { isLine: false }));
-var createVectorLineLayer = (dataList = [], config) => createBusinessLayer(dataList, Object.assign({}, config, { isLine: true }));
 var removeAllLayers = () => {
   removeOverlays();
   if (instance) {
@@ -395,57 +237,416 @@ var activeFeatureByUid = (uid) => {
     }
   }
 };
-var buildMassMarksStyles = (getImgUrlFn) => {
-  return (iconConfig) => {
-    const {
-      baseUrl,
-      markerIcon,
-      statusNum = 5,
-      activeScale = 1.3,
-      markerSize = [32, 32]
-    } = iconConfig;
-    const getMarkerUrl = getImgUrlFn(baseUrl);
-    const [x, y] = markerSize;
-    const massMarksStyles = new Array(statusNum * 2);
-    for (let i = 0; i < statusNum; i++) {
-      const imageUrl = getMarkerUrl(`${markerIcon}-${i}`, ".webp");
-      massMarksStyles[i] = new import_style.Style({
-        zIndex: 88 + i,
-        image: new import_style.Icon({
-          width: x,
-          height: y,
-          src: imageUrl,
-          anchor: [0.5, 1]
-        })
-      });
-      const activeImage = getMarkerUrl(`${markerIcon}-${i}-active`, ".webp");
-      massMarksStyles[i + statusNum] = new import_style.Style({
-        zIndex: 120,
-        image: new import_style.Icon({
-          width: x * activeScale,
-          height: y * activeScale,
-          anchor: [0.5, 1],
-          src: activeImage ? activeImage : imageUrl
-        })
-      });
+
+// src/create-map.ts
+var import_interaction = require("ol/interaction");
+
+// src/base-layer.ts
+var import_source = require("ol/source");
+var import_tilegrid = require("ol/tilegrid");
+var import_layer = require("ol/layer");
+var import_WMTS = __toESM(require("ol/tilegrid/WMTS"), 1);
+
+// src/constants.ts
+var DEFAULT_TIANDITU_TK = "c77eddc667c5bed016fded560baf93e7";
+var DEFAULT_ZHEJIANG_TOKEN = "3b0cdd02-c366-4363-b6de-081a9f12b364";
+
+// src/base-layer.ts
+var createBaseLayer = (layerName = "hzsyvector_dark") => {
+  const config = {
+    zIndex: -5,
+    preload: 1,
+    minZoom: 8,
+    maxZoom: 21,
+    source: new import_source.XYZ({
+      tileGrid: new import_tilegrid.TileGrid({
+        tileSize: 256,
+        resolutions: [
+          0.00549933137253187,
+          0.00274966568626595,
+          0.00137483284313297,
+          687416421566485e-18,
+          343708210783242e-18,
+          171854105391621e-18,
+          859270526958104e-19,
+          429635263479052e-19,
+          214817631739526e-19,
+          107408815869763e-19,
+          537044079348816e-20,
+          268522039674407e-20,
+          134261019837204e-20
+        ],
+        origin: [118.122911693886, 31.2869311022836],
+        extent: [
+          116.43263049006,
+          28.6201742126026,
+          123.705594256347,
+          31.9765041681924
+        ]
+      }),
+      projection: "EPSG:4326",
+      urls: [
+        `https://cb.hangzhoumap.gov.cn/E36CCEA93443D1495DB9B9F2B2FFE348CB1A367D75176F815040AB19E54CDCA5DAAA25813AF965E2ABD0CC2463DD1223/PBS/rest/services/hzsyvector_dark/Mapserver/tile/${layerName}/{z}/{y}/{x}`
+      ]
+    }),
+    properties: {
+      _isBaseLayer: true,
+      _layerName: layerName
     }
-    return massMarksStyles;
   };
+  return new import_layer.Tile(config);
 };
-var selectEventHandle = (vectorLayer, feature) => {
-  const data = feature.getProperties();
-  const { activeStyle } = data;
-  feature.setStyle(activeStyle);
-  emitter_default.emit("selected-feature", data);
-  vectorLayer.set("_hasActive", true);
-  if (vectorLayer.get("_isDynamic")) {
-    const activeImage = activeStyle.getImage();
-    setTimeout(() => {
-      emitter_default.emit(
-        "dynamic-marker",
-        Object.assign({}, data.rawData || {}, {
-          lnglat: data.lnglat,
-          style: data.style,
+var createMapWorldLayer = (layerName, tk = DEFAULT_TIANDITU_TK) => {
+  const [name, matrixSet] = layerName.split("_");
+  const config = {
+    preload: 1,
+    zIndex: -10,
+    cacheSize: 20240,
+    properties: {
+      _isBaseLayer: true,
+      _layerName: layerName
+    },
+    source: new import_source.WMTS({
+      crossOrigin: "anonymous",
+      projection: "EPSG:4326",
+      wrapX: true,
+      layer: name,
+      style: "default",
+      version: "1.0.0",
+      format: "image/png",
+      matrixSet,
+      tileGrid: new import_WMTS.default({
+        tileSize: 256,
+        origin: [-180, 90],
+        matrixIds: [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6",
+          "7",
+          "8",
+          "9",
+          "10",
+          "11",
+          "12",
+          "13",
+          "14",
+          "15",
+          "16",
+          "17",
+          "18",
+          "19"
+        ],
+        resolutions: [
+          0.703125,
+          0.3515625,
+          0.17578125,
+          0.087890625,
+          0.0439453125,
+          0.02197265625,
+          0.010986328125,
+          0.0054931640625,
+          0.00274658203125,
+          0.001373291015625,
+          6866455078125e-16,
+          34332275390625e-17,
+          171661376953125e-18,
+          858306884765625e-19,
+          4291534423828125e-20,
+          21457672119140625e-21,
+          10728836059570312e-21,
+          5364418029785156e-21,
+          2682209014892578e-21
+        ]
+      }),
+      url: `https://t{0-7}.tianditu.gov.cn/${layerName}/wmts?tk=${tk}`
+    })
+  };
+  return new import_layer.Tile(config);
+};
+var createZheJiangLayer = (layerName = "emap", tk = DEFAULT_ZHEJIANG_TOKEN) => {
+  return new import_layer.Tile({
+    preload: 1,
+    minZoom: 4,
+    maxZoom: 20,
+    zIndex: -10,
+    cacheSize: 20240,
+    source: new import_source.XYZ({
+      wrapX: true,
+      projection: "EPSG:4326",
+      crossOrigin: "anonymous",
+      url: `https://ditu{0-6}.zjzwfw.gov.cn/services/wmts/${layerName}/default/oss/getTile/{z}/{y}/{x}?token=${tk}`
+    })
+  });
+};
+var getLayerByName = (name) => instance.getAllLayers().find((item) => (item.get("_layerName") || item.getClassName()) === name);
+var removeLayerByName = (name) => {
+  const layer = getLayerByName(name);
+  if (layer) {
+    const source = layer.getSource();
+    if (source && source.dispose) {
+      source.dispose();
+    }
+    instance.removeLayer(layer);
+    layer.dispose();
+  }
+};
+var changeLayersByNames = (activeNames, allLayerNames) => {
+  const changeLayers = instance.getAllLayers().filter((item) => allLayerNames.includes(item.getClassName()));
+  changeLayers.forEach((layer) => {
+    layer.setVisible(activeNames == null ? void 0 : activeNames.includes(layer.getClassName()));
+  });
+};
+
+// src/create-map.ts
+var instance;
+var mapCenter = [119.71512016971076, 30.122490541963536];
+var createMapInstance = (config = {}) => {
+  if (instance) {
+    return instance;
+  }
+  instance = createMap(config);
+  return instance;
+};
+var createMap = (config = {}) => {
+  const innerConfig = Object.assign(
+    {
+      zoom: 9.4,
+      maxZoom: 18,
+      minZoom: 9.4,
+      center: mapCenter,
+      baseLayer: "vec-layer",
+      projection: "EPSG:4326",
+      layers: [createBaseLayer()],
+      constrainResolution: false,
+      smoothExtentConstraint: false,
+      tk: DEFAULT_TIANDITU_TK
+    },
+    config || {}
+  );
+  const map = new import_Map.default({
+    view: new import_View.default(innerConfig),
+    controls: (0, import_control.defaults)({
+      zoom: false,
+      rotate: false,
+      attribution: false
+    }),
+    interactions: (0, import_interaction.defaults)({
+      pinchRotate: false,
+      doubleClickZoom: false,
+      altShiftDragRotate: false
+    }),
+    layers: innerConfig.layers || [createBaseLayer()]
+  });
+  mapCenter = innerConfig.center || mapCenter;
+  map.activeBaseLayer = innerConfig.baseLayer;
+  map.getLayerByName = getLayerByName;
+  map.removeLayerByName = removeLayerByName;
+  map.changeLayersByNames = changeLayersByNames;
+  map.on("pointermove", (evt) => {
+    map.getTargetElement().style.cursor = map.hasFeatureAtPixel(evt.pixel) ? "pointer" : "";
+  });
+  return map;
+};
+var disposeMap = () => {
+  instance.getOverlays().forEach((overlay) => {
+    instance.removeOverlay(overlay);
+  });
+  instance.getInteractions().clear();
+  const layers = instance.getAllLayers();
+  layers.forEach((layer) => {
+    const source = layer.getSource();
+    if (source && source.dispose) {
+      source.dispose();
+    }
+    instance.removeLayer(layer);
+    layer.dispose();
+  });
+  instance.setTarget("");
+  instance.dispose();
+  instance = void 0;
+};
+var getMapInstance = () => instance;
+var resetZoomAndCenter = (center = mapCenter) => {
+  if (instance) {
+    const view = instance.getView();
+    view.animate({
+      zoom: 9.4,
+      center,
+      duration: 1e3
+    });
+  }
+};
+var resetMap = (config = { center: mapCenter, isClearAll: true }) => {
+  removeAllLayers();
+  resetZoomAndCenter(config.center || mapCenter);
+};
+
+// src/helper.ts
+var hexToRgba = (hex, alpha) => {
+  if (hex.startsWith("#")) {
+    let tempHex = hex.replace("#", "");
+    if (tempHex.length === 3) {
+      tempHex = tempHex[0] + tempHex[0] + tempHex[1] + tempHex[1] + tempHex[2] + tempHex[2];
+    }
+    const r = parseInt(tempHex.substring(0, 2), 16);
+    const g = parseInt(tempHex.substring(2, 4), 16);
+    const b = parseInt(tempHex.substring(4, 6), 16);
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+  } else {
+    return hex;
+  }
+};
+var getLayersDataList = () => {
+  var _a;
+  return ((_a = instance) == null ? void 0 : _a.getAllLayers().map((layer) => layer.get("_dataList") || []).flat(2)) || [];
+};
+var determineGeometryType = (coordinates) => {
+  const getArrayDepth = (arr) => {
+    if (!Array.isArray(arr) || arr.length === 0) return 0;
+    return 1 + getArrayDepth(arr[0]);
+  };
+  const isClosedRing = (coords) => {
+    if (!Array.isArray(coords) || coords.length < 3) return false;
+    const first = coords[0];
+    const last = coords[coords.length - 1];
+    return first[0] === last[0] && first[1] === last[1];
+  };
+  const isValidCoordinate = (coord) => {
+    return Array.isArray(coord) && coord.length >= 2 && typeof coord[0] === "number" && typeof coord[1] === "number";
+  };
+  const isValidLineString = (coords) => {
+    return Array.isArray(coords) && coords.length >= 2 && coords.every(isValidCoordinate);
+  };
+  const isValidPolygon = (coords) => {
+    if (!Array.isArray(coords)) return false;
+    const rings = getArrayDepth(coords) === 2 ? [coords] : coords;
+    return rings.every(
+      (ring) => Array.isArray(ring) && ring.length >= 4 && isClosedRing(ring) && ring.every(isValidCoordinate)
+    );
+  };
+  const depth = getArrayDepth(coordinates);
+  try {
+    if (depth < 2 || !coordinates || coordinates.length === 0) {
+      return "Invalid" /* Invalid */;
+    } else if (depth === 2 && isValidLineString(coordinates)) {
+      return isClosedRing(coordinates) && coordinates.length >= 4 ? "Polygon" /* Polygon */ : "LineString" /* LineString */;
+    } else if (depth === 3 && Array.isArray(coordinates) && coordinates.every(isValidLineString)) {
+      if (isValidPolygon(coordinates)) {
+        return "Polygon" /* Polygon */;
+      } else if (coordinates.every((arr) => !isClosedRing(arr))) {
+        return "MultiLineString" /* MultiLineString */;
+      } else {
+        return "Invalid" /* Invalid */;
+      }
+    } else if (depth === 4 && Array.isArray(coordinates) && coordinates.every((rings) => isValidPolygon(rings))) {
+      return "MultiPolygon" /* MultiPolygon */;
+    } else {
+      return "Invalid" /* Invalid */;
+    }
+  } catch (error) {
+    console.error("Error analyzing coordinates:", error);
+    return "Invalid" /* Invalid */;
+  }
+};
+
+// src/ogc-utils.ts
+var import_source2 = require("ol/source");
+var import_Tile = __toESM(require("ol/layer/Tile"), 1);
+var import_format = require("ol/format");
+var import_WMTS2 = require("ol/source/WMTS");
+var parser = new import_format.WMTSCapabilities();
+var capabilitiesMap = /* @__PURE__ */ new Map();
+var getCapabilities = (url) => {
+  return new Promise((resolve) => {
+    const capabilities = capabilitiesMap.get(url);
+    if (capabilities) {
+      resolve(capabilities);
+    } else {
+      fetch(url).then((data) => data.text()).then((text) => {
+        const capabilities2 = parser.read(text);
+        capabilitiesMap.set(url, capabilities2);
+        resolve(capabilities2);
+      });
+    }
+  });
+};
+var createWmtsLayer = (serverUrl) => (config) => __async(null, null, function* () {
+  const { style, format, version, layerName, matrixSet } = config;
+  const [workspace, datastore] = layerName.split(":");
+  const capabilitiesUrl = `${serverUrl}/${workspace}/${datastore}/gwc/service/wmts?request=GetCapabilities`;
+  return new Promise((resolve, reject) => {
+    getCapabilities(capabilitiesUrl).then((data) => {
+      const options = (0, import_WMTS2.optionsFromCapabilities)(data, {
+        Style: style || "",
+        layer: datastore,
+        version: version || "1.1.0",
+        format: format || "image/png",
+        matrixSet: matrixSet || "EPSG:4326"
+      });
+      if (options) {
+        resolve(
+          new import_Tile.default({
+            zIndex: 3,
+            className: layerName,
+            source: new import_source2.WMTS(options)
+          })
+        );
+      } else {
+        reject(new Error("Unable to create TileLayer"));
+      }
+    });
+  });
+});
+
+// src/view-fit.ts
+var import_extent = require("ol/extent");
+var DEFAULT_FIT_OPTIONS = {
+  padding: [50, 50, 50, 50],
+  duration: 1e3
+};
+var setFitViewByCoords = (coords, mapInstance = instance, fitOptions) => {
+  const view = mapInstance.getView();
+  if (coords.length === 1) {
+    view.animate(__spreadValues({
+      zoom: 14,
+      duration: 1e3,
+      center: coords[0]
+    }, fitOptions || {}));
+  } else {
+    const extent = (0, import_extent.boundingExtent)(coords);
+    view.fit(extent, __spreadValues(__spreadValues({}, DEFAULT_FIT_OPTIONS), fitOptions || {}));
+  }
+};
+var setFitViewByGeom = (geom, mapInstance = instance, fitOptions) => {
+  mapInstance.getView().fit(geom, __spreadValues(__spreadValues({}, DEFAULT_FIT_OPTIONS), fitOptions || {}));
+};
+var setFitViewByLayer = (layer, mapInstance = instance, fitOptions) => {
+  var _a;
+  const extent = ((_a = layer.getSource()) == null ? void 0 : _a.getExtent()) || [];
+  mapInstance.getView().fit(extent, __spreadValues(__spreadValues({}, DEFAULT_FIT_OPTIONS), fitOptions || {}));
+};
+
+// src/select.ts
+var import_extent2 = require("ol/extent");
+var import_interaction2 = require("ol/interaction");
+var import_condition = require("ol/events/condition");
+var selectEventHandle = (vectorLayer, feature) => {
+  const data = feature.getProperties();
+  const { activeStyle } = data;
+  feature.setStyle(activeStyle);
+  emitter_default.emit("selected-feature", data);
+  vectorLayer.set("_hasActive", true);
+  if (vectorLayer.get("_isDynamic")) {
+    const activeImage = activeStyle.getImage();
+    setTimeout(() => {
+      emitter_default.emit(
+        "dynamic-marker",
+        Object.assign({}, data.rawData || {}, {
+          lnglat: data.lnglat,
+          style: data.style,
           crsForm: data.crsForm,
           width: activeImage.getWidth(),
           height: activeImage.getHeight()
@@ -459,12 +660,12 @@ var selectEventHandle = (vectorLayer, feature) => {
     view.animate({
       duration: 1e3,
       zoom: view.getZoom(),
-      center: (0, import_extent.getCenter)(feature.getGeometry().getExtent())
+      center: (0, import_extent2.getCenter)(feature.getGeometry().getExtent())
     });
   }
 };
 var createSelectByLayer = (vectorLayer) => {
-  const interaction = new import_interaction.Select({
+  const interaction = new import_interaction2.Select({
     style: null,
     multi: false,
     hitTolerance: 10,
@@ -477,626 +678,457 @@ var createSelectByLayer = (vectorLayer) => {
           hasFeature = true;
         },
         {
-          layerFilter: (layer) => layer === vectorLayer
-        }
-      );
-      return (0, import_condition.singleClick)(evt) && hasFeature;
-    }
-  });
-  interaction.on("select", (evt) => {
-    const { selected, deselected } = evt;
-    if (selected.length) {
-      const feature = selected[0];
-      const isClusterLayer = vectorLayer.get("_isClusterLayer");
-      if (isClusterLayer) {
-        const features = feature.get("features");
-        if (features.length === 1) {
-          selectEventHandle(vectorLayer, features[0]);
-        }
-      } else {
-        selectEventHandle(vectorLayer, feature);
-      }
-    }
-    if (deselected.length) {
-      const feature = deselected[0];
-      const data = feature.getProperties();
-      feature.setStyle(data.unActiveStyle);
-      vectorLayer.set("_hasActive", false);
-    }
-  });
-  instance.addInteraction(interaction);
-  vectorLayer.set("_selectInteraction", interaction);
-  return interaction;
-};
-var createMassMarksLayer = (dataList, styleList = []) => {
-  const features = dataList.map((item) => {
-    const { crsForm } = item;
-    const coord = import_gcoord.default.transform(
-      [+item.lnglat[0], +item.lnglat[1]],
-      crsForm || import_gcoord.default.WGS84,
-      import_gcoord.default.WGS84
-    );
-    const feature = new import_ol.Feature({
-      geometry: new import_geom.Point(coord)
-    });
-    feature.setProperties(__spreadProps(__spreadValues({}, item), {
-      unActiveStyle: styleList[item.style],
-      activeStyle: styleList[item.style + styleList.length / 2]
-    }));
-    feature.setStyle(styleList[item.style]);
-    return feature;
-  });
-  const vectorLayer = new import_Vector.default({
-    zIndex: 2e3,
-    source: new import_Vector2.default({
-      features
-    })
-  });
-  vectorLayer.setProperties({
-    _isCustom: true,
-    _isVectorLayer: true,
-    _isMassMarksLayer: true,
-    _statusNum: styleList.length / 2,
-    _dataList: [...dataList],
-    _uuidSet: new Set(dataList.map((item) => item._uuid) || [])
-  });
-  return vectorLayer;
-};
-var addMassMarksLayer = (getImgUrlFn) => {
-  return (dataList = [], iconConfig, openClick = true) => {
-    const {
-      offset = [0, 0],
-      baseUrl,
-      hasLine,
-      hasFace,
-      layerName,
-      isDynamic,
-      isAutoFit,
-      statusNum,
-      markerIcon,
-      marksStyles,
-      markerSize,
-      activeScale,
-      vectorConfig
-    } = iconConfig;
-    const massMarksStyles = marksStyles ? marksStyles : buildMassMarksStyles(getImgUrlFn)({
-      baseUrl,
-      markerIcon,
-      markerSize,
-      statusNum: statusNum || 5,
-      activeScale: activeScale || 1.3
-    });
-    const massMarksLayer = createMassMarksLayer(dataList, massMarksStyles);
-    if (openClick) {
-      massMarksLayer.setProperties({
-        _offset: offset,
-        _isAutoFit: isAutoFit
-      });
-      createSelectByLayer(massMarksLayer);
-    }
-    if (hasLine) {
-      const vectorLayer = createBusinessLayer(
-        dataList,
-        Object.assign(
-          {},
-          {
-            key: "line",
-            isLine: true,
-            openClick: false,
-            strokeWeight: 4,
-            strokeColor: "rgba(29, 235, 255, 0.8)"
-          },
-          vectorConfig || {}
-        )
-      );
-      instance.addLayer(vectorLayer);
-    }
-    if (hasFace) {
-      const vectorLayer = createBusinessLayer(
-        dataList,
-        Object.assign(
-          {},
-          {
-            isLine: false,
-            key: "faceList",
-            strokeWeight: 1,
-            openClick: false,
-            fillColor: "#4247DF",
-            strokeStyle: "dashed",
-            strokeColor: "#4247DF"
-          },
-          vectorConfig || {}
-        )
+          layerFilter: (layer) => layer === vectorLayer
+        }
       );
-      instance.addLayer(vectorLayer);
+      return (0, import_condition.singleClick)(evt) && hasFeature;
     }
-    massMarksLayer.setProperties({
-      _isCustom: true,
-      _offset: offset,
-      _hasLine: hasLine,
-      _hasFace: hasFace,
-      className: layerName,
-      _layerName: layerName,
-      _isVectorLayer: true,
-      _isDynamic: isDynamic
-    });
-    instance.addLayer(massMarksLayer);
-    return massMarksLayer;
-  };
-};
-var updateMarksLayersByStatus = (checkedStatusList = []) => {
-  const hideStyle = new import_style.Style({});
-  const tempList = [];
-  const targetLayers = instance.getAllLayers().filter((layer) => layer.get("_isMassMarksLayer"));
-  targetLayers.forEach((layer) => {
-    const features = layer.getSource().getFeatures();
-    features.forEach((feature) => {
-      const data = feature.getProperties();
-      if (!checkedStatusList.includes(data.status)) {
-        feature.setStyle(hideStyle);
+  });
+  interaction.on("select", (evt) => {
+    const { selected, deselected } = evt;
+    if (selected.length) {
+      const feature = selected[0];
+      const isClusterLayer = vectorLayer.get("_isClusterLayer");
+      if (isClusterLayer) {
+        const features = feature.get("features");
+        if (features.length === 1) {
+          selectEventHandle(vectorLayer, features[0]);
+        }
       } else {
-        tempList.push(data);
-        feature.setStyle(data.unActiveStyle);
+        selectEventHandle(vectorLayer, feature);
       }
-    });
-  });
-  return tempList;
-};
-var createOverlay = (config = { id: "popup-container", positioning: "top-center" }) => {
-  return new import_ol.Overlay(
-    Object.assign(
-      {
-        element: document.getElementById(config.id) || void 0
-      },
-      config
-    )
-  );
-};
-var createClusterLayer = (dataList, config) => {
-  const count = dataList.length;
-  const styleCache = {};
-  const {
-    distance,
-    minDistance,
-    openClick,
-    buildStyle,
-    singleStyles,
-    computedRadius,
-    layerName = "cluster-layer"
-  } = config;
-  const innerComputedRadius = (size) => Math.pow(size / count, 1 / 18);
-  styleCache[1] = singleStyles;
-  const innerBuildStyle = (feature) => {
-    const size = feature.get("features").length;
-    let style = styleCache[size];
-    const tempRadius = computedRadius ? computedRadius(size) : innerComputedRadius(size);
-    if (!style) {
-      style = new import_style.Style({
-        image: new import_Circle.default({
-          radius: tempRadius * 20,
-          stroke: new import_style.Stroke({
-            width: 2,
-            color: `hsla(${180 - tempRadius * 180}, 100%, 40%, 1)`
-          }),
-          fill: new import_style.Fill({
-            color: `hsla(${180 - tempRadius * 180}, 100%, 50%, 1)`
-          })
-        }),
-        text: new import_style.Text({
-          text: size.toString(),
-          fill: new import_style.Fill({
-            color: `hsla(${180 - tempRadius * 180}, 100%, 10%, 1)`
-          }),
-          textBaseline: "middle"
-        })
-      });
-      styleCache[size] = style;
     }
-    if (Array.isArray(style)) {
-      const tempFeature = feature.get("features")[0];
-      const index = tempFeature.get("styleIndex") || 0;
-      tempFeature.setProperties({
-        unActiveStyle: style[index],
-        activeStyle: style[index + style.length / 2]
-      });
-      return style[index];
+    if (deselected.length) {
+      const feature = deselected[0];
+      const data = feature.getProperties();
+      feature.setStyle(data.unActiveStyle);
+      vectorLayer.set("_hasActive", false);
     }
-    return style;
-  };
-  const vectorLayer = new import_Vector.default({
-    zIndex: 200,
-    className: layerName,
-    source: new import_Cluster.default({
-      distance: distance || 80,
-      minDistance: minDistance || 0,
-      source: new import_Vector2.default({
-        features: dataList.map((item) => {
-          const feature = new import_ol.Feature(new import_geom.Point(item.lnglat));
-          feature.setProperties(item);
-          return feature;
-        })
-      })
-    }),
-    style: (feature) => buildStyle ? buildStyle(feature) : innerBuildStyle(feature)
-  });
-  vectorLayer.setProperties({
-    _isCustom: true,
-    _isVectorLayer: true,
-    _isClusterLayer: true
   });
-  if (openClick) {
-    createSelectByLayer(vectorLayer);
-  }
-  return vectorLayer;
+  instance.addInteraction(interaction);
+  vectorLayer.set("_selectInteraction", interaction);
+  return interaction;
 };
 
-// src/create-map.ts
-var import_interaction2 = require("ol/interaction");
-
-// src/base-layer.ts
-var import_source = require("ol/source");
-var import_source2 = require("ol/source");
-var import_tilegrid = require("ol/tilegrid");
-var import_layer = require("ol/layer");
-var import_WMTS = __toESM(require("ol/tilegrid/WMTS"), 1);
-var createBaseLayer = (layerName = "hzsyvector_dark") => {
-  const config = {
-    zIndex: -5,
-    preload: 1,
-    minZoom: 8,
-    maxZoom: 21,
-    source: new import_source.XYZ({
-      tileGrid: new import_tilegrid.TileGrid({
-        tileSize: 256,
-        resolutions: [
-          0.00549933137253187,
-          0.00274966568626595,
-          0.00137483284313297,
-          687416421566485e-18,
-          343708210783242e-18,
-          171854105391621e-18,
-          859270526958104e-19,
-          429635263479052e-19,
-          214817631739526e-19,
-          107408815869763e-19,
-          537044079348816e-20,
-          268522039674407e-20,
-          134261019837204e-20
-        ],
-        origin: [118.122911693886, 31.2869311022836],
-        extent: [
-          116.43263049006,
-          28.6201742126026,
-          123.705594256347,
-          31.9765041681924
-        ]
-      }),
-      projection: "EPSG:4326",
-      urls: [
-        `https://ywtg.citybrain.hangzhou.gov.cn/${layerName}/{z}/{y}/{x}`,
-        `https://ywtg.citybrain.hangzhou.gov.cn:9456/${layerName}/{z}/{y}/{x}`,
-        `https://ywtg.citybrain.hangzhou.gov.cn:9457/${layerName}/{z}/{y}/{x}`,
-        `https://ywtg.citybrain.hangzhou.gov.cn:9458/${layerName}/{z}/{y}/{x}`,
-        `https://ywtg.citybrain.hangzhou.gov.cn:9459/${layerName}/{z}/{y}/{x}`
-      ]
-    }),
-    properties: {
-      _isBaseLayer: true,
-      _layerName: layerName
-    }
-  };
-  return new import_layer.Tile(config);
-};
-var createMapWorldLayer = (layerName, tk = "c77eddc667c5bed016fded560baf93e7") => {
-  const [name, matrixSet] = layerName.split("_");
-  const config = {
-    preload: 1,
-    zIndex: -10,
-    cacheSize: 20240,
-    properties: {
-      _isBaseLayer: true,
-      _layerName: layerName
-    },
-    source: new import_source2.WMTS({
-      crossOrigin: "anonymous",
-      projection: "EPSG:4326",
-      wrapX: true,
-      layer: name,
-      style: "default",
-      version: "1.0.0",
-      format: "image/png",
-      matrixSet,
-      tileGrid: new import_WMTS.default({
-        tileSize: 256,
-        origin: [-180, 90],
-        matrixIds: [
-          "1",
-          "2",
-          "3",
-          "4",
-          "5",
-          "6",
-          "7",
-          "8",
-          "9",
-          "10",
-          "11",
-          "12",
-          "13",
-          "14",
-          "15",
-          "16",
-          "17",
-          "18",
-          "19"
-        ],
-        resolutions: [
-          0.703125,
-          0.3515625,
-          0.17578125,
-          0.087890625,
-          0.0439453125,
-          0.02197265625,
-          0.010986328125,
-          0.0054931640625,
-          0.00274658203125,
-          0.001373291015625,
-          6866455078125e-16,
-          34332275390625e-17,
-          171661376953125e-18,
-          858306884765625e-19,
-          4291534423828125e-20,
-          21457672119140625e-21,
-          10728836059570312e-21,
-          5364418029785156e-21,
-          2682209014892578e-21
-        ]
-      }),
-      url: `https://t{0-7}.tianditu.gov.cn/${layerName}/wmts?tk=${tk}`
-    })
-  };
-  return new import_layer.Tile(config);
+// src/vector-layer.ts
+var import_format2 = require("ol/format");
+var import_gcoord2 = __toESM(require("gcoord"), 1);
+var import_Vector = __toESM(require("ol/layer/Vector"), 1);
+var import_Vector2 = __toESM(require("ol/source/Vector"), 1);
+var import_style = require("ol/style");
+var resolveColor = (data, colorKey, colorMap, fallback) => colorKey ? (colorMap == null ? void 0 : colorMap.get(data[colorKey])) || fallback : fallback;
+var assembleGeoJson = (dataList, config) => {
+  const { key, crsForm } = config;
+  const tempList = [];
+  dataList.forEach((item) => {
+    try {
+      const raw = item[key];
+      const pathArray = Array.isArray(raw) ? raw : JSON.parse(raw || "[]");
+      if (pathArray.length) {
+        const type = item["geoType"] || determineGeometryType(pathArray);
+        if (type !== "Invalid" /* Invalid */) {
+          tempList.push({
+            type: "Feature",
+            properties: __spreadValues({}, item),
+            geometry: {
+              type,
+              coordinates: pathArray
+            }
+          });
+        }
+      }
+    } catch (e) {
+      console.error(`\u521B\u5EFA\u7EBF\u72B6\u6570\u636E\u5931\u8D25\uFF1A${e}`);
+    }
+  });
+  return import_gcoord2.default.transform(
+    { type: "FeatureCollection", features: tempList },
+    crsForm || import_gcoord2.default.WGS84,
+    import_gcoord2.default.WGS84
+  );
 };
-var createZheJiangLayer = (layerName = "emap", tk = "3b0cdd02-c366-4363-b6de-081a9f12b364") => {
-  return new import_layer.Tile({
-    preload: 1,
-    minZoom: 4,
-    maxZoom: 20,
-    zIndex: -10,
-    cacheSize: 20240,
-    source: new import_source.XYZ({
-      wrapX: true,
-      projection: "EPSG:4326",
-      crossOrigin: "anonymous",
-      url: `https://ditu{0-6}.zjzwfw.gov.cn/services/wmts/${layerName}/default/oss/getTile/{z}/{y}/{x}?token=${tk}`
+var createVectorStyle = (feature, config) => {
+  const {
+    isLine,
+    colorMap,
+    fillColor,
+    colorKey,
+    strokeColor,
+    fillOpacity,
+    strokeWeight,
+    activeFillColor,
+    activeFillOpacity,
+    activeStrokeColor,
+    activeStrokeWeight
+  } = config || {};
+  const data = feature.getProperties();
+  const activeStyle = new import_style.Style({
+    stroke: new import_style.Stroke({
+      width: activeStrokeWeight || strokeWeight || 4,
+      color: activeStrokeColor || resolveColor(data, colorKey, colorMap, strokeColor)
     })
   });
-};
-var getLayerByName = (name) => instance.getAllLayers().find((item) => (item.get("_layerName") || item.getClassName()) === name);
-var removeLayerByName = (name) => {
-  const layer = instance.getAllLayers().find((item) => (item.get("_layerName") || item.getClassName()) === name);
-  if (layer) {
-    const source = layer.getSource();
-    if (source && source.dispose) {
-      source.dispose();
-    }
-    instance.removeLayer(layer);
-    layer.dispose();
+  const unActiveStyle = new import_style.Style({
+    stroke: new import_style.Stroke({
+      width: strokeWeight || 2,
+      color: resolveColor(data, colorKey, colorMap, strokeColor)
+    })
+  });
+  if (!isLine) {
+    activeStyle.setFill(
+      new import_style.Fill({
+        color: hexToRgba(
+          activeFillColor || fillColor || "",
+          activeFillOpacity || 1
+        ) || hexToRgba(
+          resolveColor(data, colorKey, colorMap, fillColor) || "",
+          fillOpacity || 1
+        )
+      })
+    );
+    unActiveStyle.setFill(
+      new import_style.Fill({
+        color: hexToRgba(
+          resolveColor(data, colorKey, colorMap, fillColor) || "",
+          fillOpacity || 1
+        )
+      })
+    );
   }
-};
-var changeLayersByNames = (activeNames, allLayerNames) => {
-  const changeLayers = instance.getAllLayers().filter((item) => allLayerNames.includes(item.getClassName()));
-  changeLayers.forEach((layer) => {
-    layer.setVisible(activeNames == null ? void 0 : activeNames.includes(layer.getClassName()));
+  feature.setProperties({
+    activeStyle,
+    unActiveStyle
   });
+  return unActiveStyle;
 };
-
-// src/create-map.ts
-var instance;
-var mapCenter = [119.71512016971076, 30.122490541963536];
-var createMapInstance = (config = {}) => {
-  if (instance) {
-    return instance;
+var createBusinessLayer = (dataList, config) => {
+  const { isAutoFit, layerName, openClick } = config;
+  const geoJson = assembleGeoJson(dataList, config);
+  const vectorLayer = new import_Vector.default({
+    zIndex: 5,
+    className: layerName ? layerName : "ol-layer",
+    source: new import_Vector2.default({
+      features: new import_format2.GeoJSON().readFeatures(geoJson).map((feature) => {
+        feature.setStyle(createVectorStyle(feature, config));
+        return feature;
+      })
+    })
+  });
+  if (openClick) {
+    createSelectByLayer(vectorLayer);
   }
-  instance = createMap(config);
-  return instance;
+  vectorLayer.setProperties({
+    _isCustom: true,
+    _isAutoFit: isAutoFit,
+    _isVectorLayer: true,
+    _vectorConfig: config,
+    _layerName: layerName,
+    _dataList: [...dataList],
+    _uuidSet: new Set(dataList.map((item) => item._uuid) || [])
+  });
+  return vectorLayer;
 };
-var createMap = (config = {}) => {
-  const innerConfig = Object.assign(
-    {
-      zoom: 9.4,
-      maxZoom: 18,
-      minZoom: 9.4,
-      center: mapCenter,
-      baseLayer: "vec-layer",
-      projection: "EPSG:4326",
-      layers: [createBaseLayer()],
-      constrainResolution: false,
-      smoothExtentConstraint: false,
-      tk: "c77eddc667c5bed016fded560baf93e7"
-    },
-    config || {}
+var appendFeaturesByLayer = (targetLayer, dataList, crsForm) => {
+  const vectorSource = targetLayer.getSource();
+  const tempSet = targetLayer.get("_uuidSet") || /* @__PURE__ */ new Set();
+  dataList.forEach((item) => tempSet.add(item._uuid));
+  targetLayer.set("_uuidSet", tempSet);
+  const { _vectorConfig: config } = targetLayer.getProperties() || {};
+  const geoJson = assembleGeoJson(
+    dataList,
+    Object.assign({}, config, { crsForm })
   );
-  const instance2 = new import_Map.default({
-    view: new import_View.default(innerConfig),
-    controls: (0, import_control.defaults)({
-      zoom: false,
-      rotate: false,
-      attribution: false
-    }),
-    interactions: (0, import_interaction2.defaults)({
-      pinchRotate: false,
-      doubleClickZoom: false,
-      altShiftDragRotate: false
-    }),
-    layers: innerConfig.layers || [createBaseLayer()]
-  });
-  mapCenter = innerConfig.center || mapCenter;
-  instance2.activeBaseLayer = innerConfig.baseLayer;
-  instance2.getLayerByName = getLayerByName;
-  instance2.removeLayerByName = removeLayerByName;
-  instance2.changeLayersByNames = changeLayersByNames;
-  instance2.on("pointermove", (evt) => {
-    instance2.getTargetElement().style.cursor = instance2.hasFeatureAtPixel(
-      evt.pixel
-    ) ? "pointer" : "";
+  vectorSource.addFeatures(
+    new import_format2.GeoJSON().readFeatures(geoJson).map((feature) => {
+      feature.setStyle(createVectorStyle(feature, config));
+      return feature;
+    })
+  );
+};
+var createVectorFaceLayer = (dataList = [], config) => createBusinessLayer(dataList, Object.assign({}, config, { isLine: false }));
+var createVectorLineLayer = (dataList = [], config) => createBusinessLayer(dataList, Object.assign({}, config, { isLine: true }));
+
+// src/mass-marks.ts
+var import_ol2 = require("ol");
+var import_geom = require("ol/geom");
+var import_gcoord3 = __toESM(require("gcoord"), 1);
+var import_style2 = require("ol/style");
+var import_Vector3 = __toESM(require("ol/layer/Vector"), 1);
+var import_Vector4 = __toESM(require("ol/source/Vector"), 1);
+var buildMassMarksStyles = (getImgUrlFn) => {
+  return (iconConfig) => {
+    const {
+      baseUrl,
+      markerIcon,
+      statusNum = 5,
+      activeScale = 1.3,
+      markerSize = [32, 32]
+    } = iconConfig;
+    const getMarkerUrl = getImgUrlFn(baseUrl);
+    const [x, y] = markerSize;
+    const massMarksStyles = new Array(statusNum * 2);
+    for (let i = 0; i < statusNum; i++) {
+      const imageUrl = getMarkerUrl(`${markerIcon}-${i}`, ".webp");
+      massMarksStyles[i] = new import_style2.Style({
+        zIndex: 88 + i,
+        image: new import_style2.Icon({
+          width: x,
+          height: y,
+          src: imageUrl,
+          anchor: [0.5, 1]
+        })
+      });
+      const activeImage = getMarkerUrl(`${markerIcon}-${i}-active`, ".webp");
+      massMarksStyles[i + statusNum] = new import_style2.Style({
+        zIndex: 120,
+        image: new import_style2.Icon({
+          width: x * activeScale,
+          height: y * activeScale,
+          anchor: [0.5, 1],
+          src: activeImage ? activeImage : imageUrl
+        })
+      });
+    }
+    return massMarksStyles;
+  };
+};
+var createFeatures = (dataList, styleList = []) => {
+  return dataList.map((item) => {
+    const { crsForm } = item;
+    const coord = import_gcoord3.default.transform(
+      [+item.lnglat[0], +item.lnglat[1]],
+      crsForm || import_gcoord3.default.WGS84,
+      import_gcoord3.default.WGS84
+    );
+    const feature = new import_ol2.Feature({
+      geometry: new import_geom.Point(coord)
+    });
+    feature.setProperties(__spreadProps(__spreadValues({}, item), {
+      unActiveStyle: styleList[item.style],
+      activeStyle: styleList[item.style + styleList.length / 2]
+    }));
+    feature.setStyle(styleList[item.style]);
+    return feature;
   });
-  return instance2;
 };
-var disposeMap = () => {
-  instance.getOverlays().forEach((overlay) => {
-    instance.removeOverlay(overlay);
+var addFeaturesByLayer = (targetLayer, dataList, config) => {
+  const massMarksStyles = targetLayer.get("_massMarksStyles");
+  const targetSource = targetLayer == null ? void 0 : targetLayer.getSource();
+  const { clear } = config;
+  if (clear) {
+    targetSource == null ? void 0 : targetSource.clear();
+  }
+  targetSource == null ? void 0 : targetSource.addFeatures(createFeatures(dataList, massMarksStyles));
+};
+var createMassMarksLayer = (dataList, styleList = []) => {
+  const vectorLayer = new import_Vector3.default({
+    zIndex: 2e3,
+    source: new import_Vector4.default({
+      features: createFeatures(dataList, styleList)
+    })
   });
-  instance.getInteractions().clear();
-  const layers = instance.getAllLayers();
-  layers.forEach((layer) => {
-    const source = layer.getSource();
-    if (source && source.dispose) {
-      source.dispose();
-    }
-    instance.removeLayer(layer);
-    layer.dispose();
+  vectorLayer.setProperties({
+    _isCustom: true,
+    _isVectorLayer: true,
+    _isMassMarksLayer: true,
+    _statusNum: styleList.length / 2,
+    _dataList: [...dataList],
+    _uuidSet: new Set(dataList.map((item) => item._uuid) || [])
   });
-  instance.setTarget("");
-  instance.dispose();
-  instance = void 0;
+  return vectorLayer;
 };
-var getMapInstance = () => instance;
-var resetZoomAndCenter = (center = mapCenter) => {
-  if (instance) {
-    const view = instance.getView();
-    view.animate({
-      zoom: 9.4,
-      center,
-      duration: 1e3
+var addMassMarksLayer = (getImgUrlFn) => {
+  return (dataList = [], iconConfig, openClick = true) => {
+    const {
+      offset = [0, 0],
+      baseUrl,
+      hasLine,
+      hasFace,
+      layerName,
+      isDynamic,
+      isAutoFit,
+      statusNum,
+      markerIcon,
+      marksStyles,
+      markerSize,
+      activeScale,
+      vectorConfig
+    } = iconConfig;
+    const massMarksStyles = marksStyles ? marksStyles : buildMassMarksStyles(getImgUrlFn)({
+      baseUrl,
+      markerIcon,
+      markerSize,
+      statusNum: statusNum || 5,
+      activeScale: activeScale || 1.3
     });
-  }
-};
-var resetMap = (config = { center: mapCenter, isClearAll: true }) => {
-  removeAllLayers();
-  resetZoomAndCenter(config.center || mapCenter);
-};
-
-// src/helper.ts
-var hexToRgba = (hex, alpha) => {
-  if (hex.startsWith("#")) {
-    let tempHex = hex.replace("#", "");
-    if (tempHex.length === 3) {
-      tempHex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+    const massMarksLayer = createMassMarksLayer(dataList, massMarksStyles);
+    if (openClick) {
+      massMarksLayer.setProperties({
+        _offset: offset,
+        _isAutoFit: isAutoFit
+      });
+      createSelectByLayer(massMarksLayer);
     }
-    const r = parseInt(tempHex.substring(0, 2), 16);
-    const g = parseInt(tempHex.substring(2, 4), 16);
-    const b = parseInt(tempHex.substring(4, 6), 16);
-    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
-  } else {
-    return hex;
-  }
-};
-var getLayersDataList = () => {
-  var _a;
-  return ((_a = instance) == null ? void 0 : _a.getAllLayers().map((layer) => layer.get("_dataList") || []).flat(2)) || [];
-};
-var determineGeometryType = (coordinates) => {
-  const getArrayDepth = (arr) => {
-    if (!Array.isArray(arr)) return 0;
-    return 1 + Math.max(...arr.map((item) => getArrayDepth(item)), 0);
-  };
-  const isClosedRing = (coords) => {
-    if (!Array.isArray(coords) || coords.length < 3) return false;
-    const first = coords[0];
-    const last = coords[coords.length - 1];
-    return first[0] === last[0] && first[1] === last[1];
-  };
-  const isValidCoordinate = (coord) => {
-    return Array.isArray(coord) && coord.length >= 2 && typeof coord[0] === "number" && typeof coord[1] === "number";
-  };
-  const isValidLineString = (coords) => {
-    return Array.isArray(coords) && coords.length >= 2 && coords.every(isValidCoordinate);
-  };
-  const isValidPolygon = (coords) => {
-    if (!Array.isArray(coords)) return false;
-    const rings = getArrayDepth(coords) === 2 ? [coords] : coords;
-    return rings.every(
-      (ring) => Array.isArray(ring) && ring.length >= 4 && isClosedRing(ring) && ring.every(isValidCoordinate)
-    );
+    if (hasLine) {
+      const vectorLayer = createBusinessLayer(
+        dataList,
+        Object.assign(
+          {},
+          {
+            key: "line",
+            isLine: true,
+            openClick: false,
+            strokeWeight: 4,
+            strokeColor: "rgba(29, 235, 255, 0.8)"
+          },
+          vectorConfig || {}
+        )
+      );
+      instance.addLayer(vectorLayer);
+    }
+    if (hasFace) {
+      const vectorLayer = createBusinessLayer(
+        dataList,
+        Object.assign(
+          {},
+          {
+            isLine: false,
+            key: "faceList",
+            strokeWeight: 1,
+            openClick: false,
+            fillColor: "#4247DF",
+            strokeStyle: "dashed",
+            strokeColor: "#4247DF"
+          },
+          vectorConfig || {}
+        )
+      );
+      instance.addLayer(vectorLayer);
+    }
+    massMarksLayer.setProperties({
+      _isCustom: true,
+      _offset: offset,
+      _hasLine: hasLine,
+      _hasFace: hasFace,
+      className: layerName,
+      _layerName: layerName,
+      _isVectorLayer: true,
+      _isDynamic: isDynamic,
+      _massMarksStyles: massMarksStyles
+    });
+    instance.addLayer(massMarksLayer);
+    return massMarksLayer;
   };
-  const depth = getArrayDepth(coordinates);
-  try {
-    if (depth < 2 || !coordinates || coordinates.length === 0) {
-      return "Invalid" /* Invalid */;
-    } else if (depth === 2 && isValidLineString(coordinates)) {
-      return isClosedRing(coordinates) && coordinates.length >= 4 ? "Polygon" /* Polygon */ : "LineString" /* LineString */;
-    } else if (depth === 3 && Array.isArray(coordinates) && coordinates.every(isValidLineString)) {
-      if (isValidPolygon(coordinates)) {
-        return "Polygon" /* Polygon */;
-      } else if (coordinates.every((arr) => !isClosedRing(arr))) {
-        return "MultiLineString" /* MultiLineString */;
+};
+var updateMarksLayersByStatus = (checkedStatusList = []) => {
+  const hideStyle = new import_style2.Style({});
+  const tempList = [];
+  const targetLayers = instance.getAllLayers().filter((layer) => layer.get("_isMassMarksLayer"));
+  targetLayers.forEach((layer) => {
+    const features = layer.getSource().getFeatures();
+    features.forEach((feature) => {
+      const data = feature.getProperties();
+      if (!checkedStatusList.includes(data.status)) {
+        feature.setStyle(hideStyle);
       } else {
-        return "Invalid" /* Invalid */;
+        tempList.push(data);
+        feature.setStyle(data.unActiveStyle);
       }
-    } else if (depth === 4 && Array.isArray(coordinates) && coordinates.every((rings) => isValidPolygon(rings))) {
-      return "MultiPolygon" /* MultiPolygon */;
-    } else {
-      return "Invalid" /* Invalid */;
-    }
-  } catch (error) {
-    console.error("Error analyzing coordinates:", error);
-    return "Invalid" /* Invalid */;
-  }
+    });
+  });
+  return tempList;
 };
 
-// src/ogc-utils.ts
-var import_source3 = require("ol/source");
-var import_Tile = __toESM(require("ol/layer/Tile"), 1);
-var import_format2 = require("ol/format");
-var import_WMTS2 = require("ol/source/WMTS");
-var parser = new import_format2.WMTSCapabilities();
-var capabilitiesMap = /* @__PURE__ */ new Map();
-var getCapabilities = (url) => {
-  return new Promise((resolve) => {
-    const capabilities = capabilitiesMap.get(url);
-    if (capabilities) {
-      resolve(capabilities);
-    } else {
-      fetch(url).then((data) => data.text()).then((text) => {
-        const capabilities2 = parser.read(text);
-        capabilitiesMap.set(url, capabilities2);
-        resolve(capabilities2);
+// src/cluster.ts
+var import_ol3 = require("ol");
+var import_geom2 = require("ol/geom");
+var import_Cluster = __toESM(require("ol/source/Cluster"), 1);
+var import_Circle = __toESM(require("ol/style/Circle"), 1);
+var import_Vector5 = __toESM(require("ol/layer/Vector"), 1);
+var import_Vector6 = __toESM(require("ol/source/Vector"), 1);
+var import_style3 = require("ol/style");
+var createClusterLayer = (dataList, config) => {
+  const count = dataList.length;
+  const styleCache = {};
+  const {
+    distance,
+    minDistance,
+    openClick,
+    buildStyle,
+    singleStyles,
+    computedRadius,
+    layerName = "cluster-layer"
+  } = config;
+  const innerComputedRadius = (size) => Math.pow(size / count, 1 / 18);
+  styleCache[1] = singleStyles;
+  const innerBuildStyle = (feature) => {
+    const size = feature.get("features").length;
+    let style = styleCache[size];
+    const tempRadius = computedRadius ? computedRadius(size) : innerComputedRadius(size);
+    if (!style) {
+      style = new import_style3.Style({
+        image: new import_Circle.default({
+          radius: tempRadius * 20,
+          stroke: new import_style3.Stroke({
+            width: 2,
+            color: `hsla(${180 - tempRadius * 180}, 100%, 40%, 1)`
+          }),
+          fill: new import_style3.Fill({
+            color: `hsla(${180 - tempRadius * 180}, 100%, 50%, 1)`
+          })
+        }),
+        text: new import_style3.Text({
+          text: size.toString(),
+          fill: new import_style3.Fill({
+            color: `hsla(${180 - tempRadius * 180}, 100%, 10%, 1)`
+          }),
+          textBaseline: "middle"
+        })
       });
+      styleCache[size] = style;
     }
-  });
-};
-var createWmtsLayer = (serverUrl) => (config) => __async(null, null, function* () {
-  const { style, format, version, layerName, matrixSet } = config;
-  const [workspace, datastore] = layerName.split(":");
-  const capabilitiesUrl = `${serverUrl}/${workspace}/${datastore}/gwc/service/wmts?request=GetCapabilities`;
-  return new Promise((resolve, reject) => {
-    getCapabilities(capabilitiesUrl).then((data) => {
-      const options = (0, import_WMTS2.optionsFromCapabilities)(data, {
-        Style: style || "",
-        layer: datastore,
-        version: version || "1.1.0",
-        format: format || "image/png",
-        matrixSet: matrixSet || "EPSG:4326"
+    if (Array.isArray(style)) {
+      const tempFeature = feature.get("features")[0];
+      const index = tempFeature.get("styleIndex") || 0;
+      tempFeature.setProperties({
+        unActiveStyle: style[index],
+        activeStyle: style[index + style.length / 2]
       });
-      if (options) {
-        resolve(
-          new import_Tile.default({
-            zIndex: 3,
-            className: layerName,
-            source: new import_source3.WMTS(options)
-          })
-        );
-      } else {
-        reject(new Error("Unable to create TileLayer"));
-      }
-    });
+      return style[index];
+    }
+    return style;
+  };
+  const vectorLayer = new import_Vector5.default({
+    zIndex: 200,
+    className: layerName,
+    source: new import_Cluster.default({
+      distance: distance || 80,
+      minDistance: minDistance || 0,
+      source: new import_Vector6.default({
+        features: dataList.map((item) => {
+          const feature = new import_ol3.Feature(new import_geom2.Point(item.lnglat));
+          feature.setProperties(item);
+          return feature;
+        })
+      })
+    }),
+    style: (feature) => buildStyle ? buildStyle(feature) : innerBuildStyle(feature)
   });
-});
+  vectorLayer.setProperties({
+    _isCustom: true,
+    _isVectorLayer: true,
+    _isClusterLayer: true
+  });
+  if (openClick) {
+    createSelectByLayer(vectorLayer);
+  }
+  return vectorLayer;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GeometryType,
   activeFeatureByUid,
+  addFeaturesByLayer,
   addMassMarksLayer,
   appendFeaturesByLayer,
   buildMassMarksStyles,