map-ol-utils 0.1.30 → 0.2.0

package/dist/index.js

@@ -1,1096 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/types.ts
-var GeometryType = /* @__PURE__ */ ((GeometryType2) => {
-  GeometryType2["LineString"] = "LineString";
-  GeometryType2["MultiLineString"] = "MultiLineString";
-  GeometryType2["Polygon"] = "Polygon";
-  GeometryType2["MultiPolygon"] = "MultiPolygon";
-  GeometryType2["Invalid"] = "Invalid";
-  return GeometryType2;
-})(GeometryType || {});
-
-// src/emitter.ts
-import mitt from "mitt";
-var emitter = mitt();
-var emitter_default = emitter;
-
-// src/create-map.ts
-import Map2 from "ol/Map";
-import View from "ol/View";
-import { defaults } from "ol/control";
-
-// src/overlay.ts
-import gcoord from "gcoord";
-import { Overlay } from "ol";
-var removeOverlays = (key = "") => {
-  if (instance) {
-    const overlays = instance.getOverlays().getArray().filter((overlay) => overlay.get(key || "position"));
-    overlays.forEach((overlay) => instance.removeOverlay(overlay));
-  }
-};
-var removeAnimationMarker = () => removeOverlays("_isAnimationMarker");
-var createAnimationMarker = (imgUrl, data) => {
-  removeAnimationMarker();
-  const { width, height, lnglat, crsForm } = data;
-  const element = document.createElement("div");
-  element.innerHTML = `<img src=${imgUrl} height=${height} width=${width} alt="" />`;
-  const overlay = new Overlay({
-    element,
-    stopEvent: false,
-    positioning: "bottom-center",
-    position: gcoord.transform(
-      [+lnglat[0], +lnglat[1]],
-      crsForm || gcoord.WGS84,
-      gcoord.WGS84
-    )
-  });
-  overlay.set("_isAnimationMarker", true);
-  instance.addOverlay(overlay);
-};
-var createOverlay = (config = { id: "popup-container", positioning: "top-center" }) => {
-  return new Overlay(
-    Object.assign(
-      {
-        element: document.getElementById(config.id) || void 0
-      },
-      config
-    )
-  );
-};
-
-// src/layer-manager.ts
-var resetActiveVector = () => {
-  removeOverlays();
-  const layers = instance.getAllLayers();
-  layers.forEach((layer) => {
-    const interaction = layer.get("_selectInteraction");
-    interaction == null ? void 0 : interaction.getFeatures().clear();
-  });
-};
-var removeAllLayers = () => {
-  removeOverlays();
-  if (instance) {
-    instance.getAllLayers().forEach((layer) => {
-      if (!layer.get("_isBaseLayer")) {
-        const source = layer.getSource();
-        if (source && source.dispose) {
-          source.dispose();
-        }
-        instance.removeLayer(layer);
-        layer.dispose();
-      }
-    });
-  }
-};
-var resetActiveFeature = () => {
-  removeOverlays();
-  const targetLayers = instance.getAllLayers().filter((layer) => layer.get("_isVectorLayer"));
-  targetLayers.forEach((layer) => {
-    const selectInteraction = layer.get("_selectInteraction");
-    if (selectInteraction) {
-      selectInteraction.dispatchEvent({
-        type: "select",
-        selected: [],
-        mapBrowserEvent: void 0,
-        deselected: selectInteraction.getFeatures().getArray()
-      });
-      selectInteraction.getFeatures().clear();
-    }
-  });
-};
-var activeFeatureByUid = (uid) => {
-  var _a;
-  const targetLayers = instance.getAllLayers().filter((layer) => layer.get("_isVectorLayer"));
-  if (targetLayers.length) {
-    const targetLayer = targetLayers.find(
-      (layer) => layer.get("_uuidSet").has(uid) && layer.get("_selectInteraction")
-    );
-    if (targetLayer) {
-      const tempList = ((_a = targetLayer.getSource()) == null ? void 0 : _a.getFeatures()) || [];
-      const targetFeature = tempList.find(
-        (feature) => feature.get("_uuid") === uid
-      );
-      const selectInteraction = targetLayer.get("_selectInteraction");
-      if (selectInteraction) {
-        const collection = selectInteraction.getFeatures().getArray();
-        const hasFeature = collection.find(
-          (feature) => feature.get("_uuid") === uid
-        );
-        if (!hasFeature) {
-          selectInteraction.dispatchEvent({
-            type: "select",
-            deselected: collection,
-            selected: [targetFeature],
-            mapBrowserEvent: void 0
-          });
-          selectInteraction.getFeatures().push(targetFeature);
-        }
-      }
-    }
-  }
-};
-
-// src/create-map.ts
-import { defaults as interactionDefaults } from "ol/interaction";
-
-// src/base-layer.ts
-import { XYZ, WMTS } from "ol/source";
-import { TileGrid } from "ol/tilegrid";
-import { Tile } from "ol/layer";
-import WMTSTileGrid from "ol/tilegrid/WMTS";
-
-// 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 XYZ({
-      tileGrid: new 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/${layerName}/Mapserver/tile/{z}/{y}/{x}`
-      ]
-    }),
-    properties: {
-      _isBaseLayer: true,
-      _layerName: layerName
-    }
-  };
-  return new Tile(config);
-};
-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 WMTS({
-      crossOrigin: "anonymous",
-      projection: "EPSG:4326",
-      wrapX: true,
-      layer: name,
-      style: "default",
-      version: "1.0.0",
-      format: "image/png",
-      matrixSet,
-      tileGrid: new WMTSTileGrid({
-        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 Tile(config);
-};
-var createZheJiangLayer = (layerName = "emap", tk = DEFAULT_ZHEJIANG_TOKEN) => {
-  return new Tile({
-    preload: 1,
-    minZoom: 4,
-    maxZoom: 20,
-    zIndex: -10,
-    cacheSize: 20240,
-    source: new 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 Map2({
-    view: new View(innerConfig),
-    controls: defaults({
-      zoom: false,
-      rotate: false,
-      attribution: false
-    }),
-    interactions: interactionDefaults({
-      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
-import { WMTS as WMTS2 } from "ol/source";
-import TileLayer from "ol/layer/Tile";
-import { WMTSCapabilities } from "ol/format";
-import { optionsFromCapabilities } from "ol/source/WMTS";
-var parser = new 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 = optionsFromCapabilities(data, {
-        Style: style || "",
-        layer: datastore,
-        version: version || "1.1.0",
-        format: format || "image/png",
-        matrixSet: matrixSet || "EPSG:4326"
-      });
-      if (options) {
-        resolve(
-          new TileLayer({
-            zIndex: 3,
-            className: layerName,
-            source: new WMTS2(options)
-          })
-        );
-      } else {
-        reject(new Error("Unable to create TileLayer"));
-      }
-    });
-  });
-});
-
-// src/view-fit.ts
-import { boundingExtent } from "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 = 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
-import { getCenter } from "ol/extent";
-import { Select } from "ol/interaction";
-import { singleClick } from "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()
-        })
-      );
-    }, 1e3);
-  }
-  const isAutoFit = vectorLayer.get("_isAutoFit");
-  if (isAutoFit) {
-    const view = instance.getView();
-    view.animate({
-      duration: 1e3,
-      zoom: view.getZoom(),
-      center: getCenter(feature.getGeometry().getExtent())
-    });
-  }
-};
-var createSelectByLayer = (vectorLayer) => {
-  const interaction = new Select({
-    style: null,
-    multi: false,
-    hitTolerance: 10,
-    layers: [vectorLayer],
-    condition: (evt) => {
-      let hasFeature = false;
-      instance.forEachFeatureAtPixel(
-        evt.pixel,
-        () => {
-          hasFeature = true;
-        },
-        {
-          layerFilter: (layer) => layer === vectorLayer
-        }
-      );
-      return 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;
-};
-
-// src/vector-layer.ts
-import { GeoJSON } from "ol/format";
-import gcoord2 from "gcoord";
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import { Fill, Style, Stroke } from "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 gcoord2.transform(
-    { type: "FeatureCollection", features: tempList },
-    crsForm || gcoord2.WGS84,
-    gcoord2.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 Style({
-    stroke: new Stroke({
-      width: activeStrokeWeight || strokeWeight || 4,
-      color: activeStrokeColor || resolveColor(data, colorKey, colorMap, strokeColor)
-    })
-  });
-  const unActiveStyle = new Style({
-    stroke: new Stroke({
-      width: strokeWeight || 2,
-      color: resolveColor(data, colorKey, colorMap, strokeColor)
-    })
-  });
-  if (!isLine) {
-    activeStyle.setFill(
-      new Fill({
-        color: hexToRgba(
-          activeFillColor || fillColor || "",
-          activeFillOpacity || 1
-        ) || hexToRgba(
-          resolveColor(data, colorKey, colorMap, fillColor) || "",
-          fillOpacity || 1
-        )
-      })
-    );
-    unActiveStyle.setFill(
-      new Fill({
-        color: hexToRgba(
-          resolveColor(data, colorKey, colorMap, fillColor) || "",
-          fillOpacity || 1
-        )
-      })
-    );
-  }
-  feature.setProperties({
-    activeStyle,
-    unActiveStyle
-  });
-  return unActiveStyle;
-};
-var createBusinessLayer = (dataList, config) => {
-  const { isAutoFit, layerName, openClick } = config;
-  const geoJson = assembleGeoJson(dataList, config);
-  const vectorLayer = new VectorLayer({
-    zIndex: 5,
-    className: layerName ? layerName : "ol-layer",
-    source: new VectorSource({
-      features: new 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 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
-import { Feature } from "ol";
-import { Point } from "ol/geom";
-import gcoord3 from "gcoord";
-import { Icon, Style as Style2 } from "ol/style";
-import VectorLayer2 from "ol/layer/Vector";
-import VectorSource2 from "ol/source/Vector";
-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 Style2({
-        zIndex: 88 + i,
-        image: new Icon({
-          width: x,
-          height: y,
-          src: imageUrl,
-          anchor: [0.5, 1]
-        })
-      });
-      const activeImage = getMarkerUrl(`${markerIcon}-${i}-active`, ".webp");
-      massMarksStyles[i + statusNum] = new Style2({
-        zIndex: 120,
-        image: new 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 = gcoord3.transform(
-      [+item.lnglat[0], +item.lnglat[1]],
-      crsForm || gcoord3.WGS84,
-      gcoord3.WGS84
-    );
-    const feature = new Feature({
-      geometry: new 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;
-  });
-};
-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 VectorLayer2({
-    zIndex: 2e3,
-    source: new VectorSource2({
-      features: createFeatures(dataList, styleList)
-    })
-  });
-  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 || {}
-        )
-      );
-      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;
-  };
-};
-var updateMarksLayersByStatus = (checkedStatusList = []) => {
-  const hideStyle = new Style2({});
-  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 {
-        tempList.push(data);
-        feature.setStyle(data.unActiveStyle);
-      }
-    });
-  });
-  return tempList;
-};
-
-// src/cluster.ts
-import { Feature as Feature2 } from "ol";
-import { Point as Point2 } from "ol/geom";
-import Cluster from "ol/source/Cluster";
-import CircleStyle from "ol/style/Circle";
-import VectorLayer3 from "ol/layer/Vector";
-import VectorSource3 from "ol/source/Vector";
-import { Fill as Fill2, Style as Style3, Stroke as Stroke2, Text } from "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 Style3({
-        image: new CircleStyle({
-          radius: tempRadius * 20,
-          stroke: new Stroke2({
-            width: 2,
-            color: `hsla(${180 - tempRadius * 180}, 100%, 40%, 1)`
-          }),
-          fill: new Fill2({
-            color: `hsla(${180 - tempRadius * 180}, 100%, 50%, 1)`
-          })
-        }),
-        text: new Text({
-          text: size.toString(),
-          fill: new Fill2({
-            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];
-    }
-    return style;
-  };
-  const vectorLayer = new VectorLayer3({
-    zIndex: 200,
-    className: layerName,
-    source: new Cluster({
-      distance: distance || 80,
-      minDistance: minDistance || 0,
-      source: new VectorSource3({
-        features: dataList.map((item) => {
-          const feature = new Feature2(new Point2(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;
-};
-export {
-  GeometryType,
-  activeFeatureByUid,
-  addFeaturesByLayer,
-  addMassMarksLayer,
-  appendFeaturesByLayer,
-  buildMassMarksStyles,
-  createAnimationMarker,
-  createBaseLayer,
-  createBusinessLayer,
-  createClusterLayer,
-  createMap,
-  createMapInstance,
-  createMapWorldLayer,
-  createMassMarksLayer,
-  createOverlay,
-  createSelectByLayer,
-  createVectorFaceLayer,
-  createVectorLineLayer,
-  createWmtsLayer,
-  createZheJiangLayer,
-  disposeMap,
-  emitter_default as emitter,
-  getLayerByName,
-  getLayersDataList,
-  getMapInstance,
-  instance,
-  removeAllLayers,
-  removeLayerByName,
-  removeOverlays,
-  resetActiveFeature,
-  resetActiveVector,
-  resetMap,
-  resetZoomAndCenter,
-  setFitViewByCoords,
-  setFitViewByGeom,
-  setFitViewByLayer,
-  updateMarksLayersByStatus
-};