vue-openlayers-plugin 1.0.32 → 1.0.34

package/lib/{index-1335ec37.mjs → index-d683decb.mjs}

@@ -41751,7 +41751,7 @@ function checkProj$1(item) {
     item
   );
 }
-function proj4$2(fromProjOrToProj, toProjOrCoord, coord) {
+function proj4$3(fromProjOrToProj, toProjOrCoord, coord) {
   var fromProj;
   var toProj;
   var single = false;
@@ -45755,7 +45755,7 @@ function includedProjections$1(proj42) {
   proj42.Proj.projections.add(eqearth$1);
   proj42.Proj.projections.add(bonne$1);
 }
-const proj4$1 = Object.assign(proj4$2, {
+const proj4$1 = Object.assign(proj4$3, {
   defaultDatum: "WGS84",
   Proj: Projection$3,
   WGS84: new Projection$3("WGS84"),
@@ -45768,6 +45768,10 @@ const proj4$1 = Object.assign(proj4$2, {
   version: "__VERSION__"
 });
 includedProjections$1(proj4$1);
+const proj4$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: proj4$1
+}, Symbol.toStringTag, { value: "Module" }));
 let registered$1 = null;
 function register$3(proj42) {
   registered$1 = proj42;
@@ -45854,11 +45858,9 @@ class EventManager {
         "map:contextmenu",
         "map:pointermove",
         "map:moveend",
-        "map:zoomchange",
-        "map:featureinfo"
+        "map:zoomchange"
       ],
-      debounceDelay: config.debounceDelay ?? 100,
-      enableFeatureInfo: config.enableFeatureInfo ?? true
+      debounceDelay: config.debounceDelay ?? 100
     };
     this.mittEmitter = this.config.mittInstance || mitt();
     this.lastZoom = this.map.getView().getZoom() || 0;
@@ -45880,9 +45882,6 @@ class EventManager {
           pixel,
           originalEvent: event.originalEvent
         });
-        if (this.config.enableFeatureInfo) {
-          this.handleFeatureInfoQuery(coordinate, pixel);
-        }
       });
     }
     if (enabledEvents.includes("map:dblclick")) {
@@ -45959,23 +45958,6 @@ class EventManager {
     this.map.on(eventType, handler);
     this.listeners.set(key, () => this.map.un(eventType, handler));
   }
-  /**
-   * 处理要素信息查询
-   */
-  async handleFeatureInfoQuery(coordinate, pixel) {
-    try {
-      const layerData = await this.layerManager.getFeatureInfoAtCoordinate(coordinate, {});
-      if (layerData.length > 0) {
-        this.emit("map:featureinfo", {
-          coordinate,
-          pixel,
-          layerData
-        });
-      }
-    } catch (error2) {
-      console.warn("获取要素信息失败:", error2);
-    }
-  }
   /**
    * 防抖处理
    */
@@ -46030,12 +46012,6 @@ class EventManager {
   getMittEmitter() {
     return this.mittEmitter;
   }
-  /**
-   * 手动触发要素信息查询
-   */
-  async queryFeatureInfo(coordinate, pixel) {
-    return await this.layerManager.getFeatureInfoAtCoordinate(coordinate, {});
-  }
   /**
    * 更新配置
    */
@@ -69065,23 +69041,218 @@ function getUnitOptions(type) {
       return [{ value: "auto", label: "自动" }];
   }
 }
+const STORAGE_CONFIG = {
+  MAX_MEASUREMENTS: 200,
+  // 最大测量结果数量（降低到200）
+  MAX_LAYER_CONFIGS: 50,
+  // 最大图层配置数量（降低到50）
+  QUOTA_WARNING_THRESHOLD: 0.6,
+  // 配额警告阈值（60%）
+  AUTO_CLEANUP_THRESHOLD: 0.7,
+  // 自动清理阈值（70%）
+  COMPRESSION_ENABLED: true,
+  // 是否启用压缩
+  BATCH_CLEANUP_SIZE: 20
+  // 批量清理数量（降低到20）
+};
+class DataCompressor {
+  static compress(data) {
+    try {
+      return btoa(encodeURIComponent(data));
+    } catch {
+      return data;
+    }
+  }
+  static decompress(compressedData) {
+    try {
+      return decodeURIComponent(atob(compressedData));
+    } catch {
+      return compressedData;
+    }
+  }
+}
 class MapStorage {
+  // 防止递归清理
   constructor(instanceId) {
     __publicField(this, "storageKeys");
     __publicField(this, "instanceId");
+    __publicField(this, "isCleaningUp", false);
     this.instanceId = instanceId || "default";
     this.storageKeys = {
       MEASUREMENTS: `${this.instanceId}_openlayer_measurements`,
       LAYER_CONFIGS: `${this.instanceId}_openlayer_layer_configs`,
       MAP_STATE: `${this.instanceId}_openlayer_map_state`
     };
+    this.initCleanup();
+  }
+  /**
+   * 初始化清理过量数据
+   */
+  initCleanup() {
+    try {
+      const measurementsData = localStorage.getItem(this.storageKeys.MEASUREMENTS);
+      if (measurementsData) {
+        const decompressed = DataCompressor.decompress(measurementsData);
+        const measurements = JSON.parse(decompressed);
+        if (measurements.length > STORAGE_CONFIG.MAX_MEASUREMENTS) {
+          const cleanedMeasurements = measurements.sort((a3, b10) => (b10.timestamp || 0) - (a3.timestamp || 0)).slice(0, STORAGE_CONFIG.MAX_MEASUREMENTS);
+          const compressed = DataCompressor.compress(JSON.stringify(cleanedMeasurements));
+          localStorage.setItem(this.storageKeys.MEASUREMENTS, compressed);
+          console.log(`初始化清理测量结果：${measurements.length} -> ${cleanedMeasurements.length}`);
+        }
+      }
+      const layerConfigsData = localStorage.getItem(this.storageKeys.LAYER_CONFIGS);
+      if (layerConfigsData) {
+        const decompressed = DataCompressor.decompress(layerConfigsData);
+        const layerConfigs = JSON.parse(decompressed);
+        if (layerConfigs.length > STORAGE_CONFIG.MAX_LAYER_CONFIGS) {
+          const cleanedConfigs = layerConfigs.slice(0, STORAGE_CONFIG.MAX_LAYER_CONFIGS);
+          const compressed = DataCompressor.compress(JSON.stringify(cleanedConfigs));
+          localStorage.setItem(this.storageKeys.LAYER_CONFIGS, compressed);
+          console.log(`初始化清理图层配置：${layerConfigs.length} -> ${cleanedConfigs.length}`);
+        }
+      }
+    } catch (error2) {
+      console.error("初始化清理失败:", error2);
+    }
+  }
+  /**
+   * 检查localStorage配额使用情况
+   */
+  checkStorageQuota() {
+    let used = 0;
+    const available = 5 * 1024 * 1024;
+    try {
+      for (let key in localStorage) {
+        if (localStorage.hasOwnProperty(key)) {
+          used += localStorage[key].length + key.length;
+        }
+      }
+    } catch {
+      used = 0;
+    }
+    return {
+      used,
+      available,
+      percentage: available > 0 ? used / available : 0
+    };
+  }
+  /**
+   * 自动清理旧数据
+   */
+  autoCleanup() {
+    if (this.isCleaningUp) {
+      console.warn("清理操作正在进行中，跳过重复调用");
+      return;
+    }
+    this.isCleaningUp = true;
+    try {
+      const quota = this.checkStorageQuota();
+      if (quota.percentage >= STORAGE_CONFIG.AUTO_CLEANUP_THRESHOLD) {
+        console.warn("存储空间不足，开始自动清理旧数据");
+        try {
+          const measurementsData = localStorage.getItem(this.storageKeys.MEASUREMENTS);
+          if (measurementsData) {
+            const decompressed = DataCompressor.decompress(measurementsData);
+            const measurements = JSON.parse(decompressed);
+            if (measurements.length > STORAGE_CONFIG.BATCH_CLEANUP_SIZE) {
+              const cleanedMeasurements = measurements.sort((a3, b10) => (b10.timestamp || 0) - (a3.timestamp || 0)).slice(0, STORAGE_CONFIG.MAX_MEASUREMENTS - STORAGE_CONFIG.BATCH_CLEANUP_SIZE);
+              const compressed = DataCompressor.compress(JSON.stringify(cleanedMeasurements));
+              localStorage.setItem(this.storageKeys.MEASUREMENTS, compressed);
+              console.log(`清理测量结果：${measurements.length} -> ${cleanedMeasurements.length}`);
+            }
+          }
+        } catch (error2) {
+          console.error("清理测量结果失败:", error2);
+        }
+        try {
+          const layerConfigsData = localStorage.getItem(this.storageKeys.LAYER_CONFIGS);
+          if (layerConfigsData) {
+            const decompressed = DataCompressor.decompress(layerConfigsData);
+            const layerConfigs = JSON.parse(decompressed);
+            if (layerConfigs.length > STORAGE_CONFIG.BATCH_CLEANUP_SIZE) {
+              const cleanedConfigs = layerConfigs.slice(0, STORAGE_CONFIG.MAX_LAYER_CONFIGS - STORAGE_CONFIG.BATCH_CLEANUP_SIZE);
+              const compressed = DataCompressor.compress(JSON.stringify(cleanedConfigs));
+              localStorage.setItem(this.storageKeys.LAYER_CONFIGS, compressed);
+              console.log(`清理图层配置：${layerConfigs.length} -> ${cleanedConfigs.length}`);
+            }
+          }
+        } catch (error2) {
+          console.error("清理图层配置失败:", error2);
+        }
+      }
+    } finally {
+      this.isCleaningUp = false;
+    }
+  }
+  /**
+   * 安全存储数据（带配额检查）
+   */
+  safeSetItem(key, value) {
+    try {
+      if (!this.isCleaningUp) {
+        const quota = this.checkStorageQuota();
+        if (quota.percentage >= STORAGE_CONFIG.QUOTA_WARNING_THRESHOLD) {
+          console.warn(`存储空间使用率已达${Math.round(quota.percentage * 100)}%`);
+          if (quota.percentage >= STORAGE_CONFIG.AUTO_CLEANUP_THRESHOLD) {
+            this.autoCleanup();
+          }
+        }
+      }
+      const compressedValue = DataCompressor.compress(value);
+      localStorage.setItem(key, compressedValue);
+      return true;
+    } catch (error2) {
+      if (error2 instanceof DOMException && error2.code === 22) {
+        console.error("存储配额已满，尝试清理后重试");
+        if (!this.isCleaningUp) {
+          this.autoCleanup();
+          try {
+            const compressedValue = DataCompressor.compress(value);
+            localStorage.setItem(key, compressedValue);
+            return true;
+          } catch {
+            console.error("清理后仍无法存储，数据过大或配额不足");
+            return false;
+          }
+        } else {
+          console.error("清理过程中存储失败，跳过重试");
+          return false;
+        }
+      }
+      console.error("存储失败:", error2);
+      return false;
+    }
+  }
+  /**
+   * 安全获取数据（带解压缩）
+   */
+  safeGetItem(key) {
+    try {
+      const item = localStorage.getItem(key);
+      if (item) {
+        return DataCompressor.decompress(item);
+      }
+      return null;
+    } catch (error2) {
+      console.error("获取数据失败:", error2);
+      return null;
+    }
   }
   /**
    * 保存测量结果
    */
   saveMeasurements(measurements) {
     try {
-      localStorage.setItem(this.storageKeys.MEASUREMENTS, JSON.stringify(measurements));
+      let limitedMeasurements = measurements.sort((a3, b10) => (b10.timestamp || 0) - (a3.timestamp || 0)).slice(0, STORAGE_CONFIG.MAX_MEASUREMENTS);
+      limitedMeasurements = limitedMeasurements.map((m2) => ({
+        ...m2,
+        timestamp: m2.timestamp || Date.now()
+      }));
+      const success = this.safeSetItem(this.storageKeys.MEASUREMENTS, JSON.stringify(limitedMeasurements));
+      if (!success) {
+        console.error("保存测量结果失败: 存储空间不足");
+      }
     } catch (error2) {
       console.error("保存测量结果失败:", error2);
     }
@@ -69091,7 +69262,7 @@ class MapStorage {
    */
   getMeasurements() {
     try {
-      const data = localStorage.getItem(this.storageKeys.MEASUREMENTS);
+      const data = this.safeGetItem(this.storageKeys.MEASUREMENTS);
       return data ? JSON.parse(data) : [];
     } catch (error2) {
       console.error("获取测量结果失败:", error2);
@@ -69124,18 +69295,31 @@ class MapStorage {
    */
   saveLayerConfigs(configs) {
     try {
-      const configsToSave = configs.map((config) => ({
-        id: config.id,
-        name: config.name,
-        type: config.type,
-        url: config.url,
-        visible: config.visible,
-        opacity: config.opacity,
-        zIndex: config.zIndex,
-        legend: config.legend,
-        metadata: config.metadata
-      }));
-      localStorage.setItem(this.storageKeys.LAYER_CONFIGS, JSON.stringify(configsToSave));
+      const limitedConfigs = configs.slice(0, STORAGE_CONFIG.MAX_LAYER_CONFIGS);
+      const configsToSave = limitedConfigs.map((config) => {
+        const optimizedConfig = {
+          id: config.id,
+          name: config.name,
+          type: config.type,
+          visible: config.visible
+        };
+        if (config.url)
+          optimizedConfig.url = config.url;
+        if (config.opacity !== void 0 && config.opacity !== 1)
+          optimizedConfig.opacity = config.opacity;
+        if (config.zIndex !== void 0 && config.zIndex !== 0)
+          optimizedConfig.zIndex = config.zIndex;
+        if (config.legend)
+          optimizedConfig.legend = config.legend;
+        if (config.metadata && Object.keys(config.metadata).length > 0) {
+          optimizedConfig.metadata = config.metadata;
+        }
+        return optimizedConfig;
+      });
+      const success = this.safeSetItem(this.storageKeys.LAYER_CONFIGS, JSON.stringify(configsToSave));
+      if (!success) {
+        console.error("保存图层配置失败: 存储空间不足");
+      }
     } catch (error2) {
       console.error("保存图层配置失败:", error2);
     }
@@ -69145,7 +69329,7 @@ class MapStorage {
    */
   getLayerConfigs() {
     try {
-      const data = localStorage.getItem(this.storageKeys.LAYER_CONFIGS);
+      const data = this.safeGetItem(this.storageKeys.LAYER_CONFIGS);
       return data ? JSON.parse(data) : [];
     } catch (error2) {
       console.error("获取图层配置失败:", error2);
@@ -69158,7 +69342,10 @@ class MapStorage {
   saveMapState(center2, zoom, rotation = 0) {
     try {
       const state = { center: center2, zoom, rotation, timestamp: Date.now() };
-      localStorage.setItem(this.storageKeys.MAP_STATE, JSON.stringify(state));
+      const success = this.safeSetItem(this.storageKeys.MAP_STATE, JSON.stringify(state));
+      if (!success) {
+        console.error("保存地图状态失败: 存储空间不足");
+      }
     } catch (error2) {
       console.error("保存地图状态失败:", error2);
     }
@@ -69168,7 +69355,7 @@ class MapStorage {
    */
   getMapState() {
     try {
-      const data = localStorage.getItem(this.storageKeys.MAP_STATE);
+      const data = this.safeGetItem(this.storageKeys.MAP_STATE);
       return data ? JSON.parse(data) : null;
     } catch (error2) {
       console.error("获取地图状态失败:", error2);
@@ -69196,10 +69383,101 @@ class MapStorage {
     });
     return Math.round(total / 1024 * 100) / 100;
   }
+  /**
+   * 获取详细的存储状态信息
+   */
+  getStorageStatus() {
+    const quota = this.checkStorageQuota();
+    const measurements = this.getMeasurements();
+    const layerConfigs = this.getLayerConfigs();
+    const warnings = [];
+    if (quota.percentage >= STORAGE_CONFIG.QUOTA_WARNING_THRESHOLD) {
+      warnings.push(`存储空间使用率已达${Math.round(quota.percentage * 100)}%`);
+    }
+    if (measurements.length >= STORAGE_CONFIG.MAX_MEASUREMENTS * 0.8) {
+      warnings.push(`测量结果数量接近上限 (${measurements.length}/${STORAGE_CONFIG.MAX_MEASUREMENTS})`);
+    }
+    if (layerConfigs.length >= STORAGE_CONFIG.MAX_LAYER_CONFIGS * 0.8) {
+      warnings.push(`图层配置数量接近上限 (${layerConfigs.length}/${STORAGE_CONFIG.MAX_LAYER_CONFIGS})`);
+    }
+    return {
+      quota,
+      instanceSize: this.getStorageSize(),
+      measurementCount: measurements.length,
+      layerConfigCount: layerConfigs.length,
+      compressionEnabled: STORAGE_CONFIG.COMPRESSION_ENABLED,
+      warnings
+    };
+  }
+  /**
+   * 手动清理存储
+   */
+  manualCleanup(options = {}) {
+    const {
+      clearMeasurements = false,
+      clearLayerConfigs = false,
+      clearMapState = false,
+      keepRecentCount = 50
+    } = options;
+    if (clearMeasurements) {
+      if (keepRecentCount > 0) {
+        const measurements = this.getMeasurements();
+        const recentMeasurements = measurements.sort((a3, b10) => (b10.timestamp || 0) - (a3.timestamp || 0)).slice(0, keepRecentCount);
+        this.saveMeasurements(recentMeasurements);
+      } else {
+        this.clearMeasurements();
+      }
+    }
+    if (clearLayerConfigs) {
+      if (keepRecentCount > 0) {
+        const layerConfigs = this.getLayerConfigs();
+        const recentConfigs = layerConfigs.slice(0, keepRecentCount);
+        this.saveLayerConfigs(recentConfigs);
+      } else {
+        localStorage.removeItem(this.storageKeys.LAYER_CONFIGS);
+      }
+    }
+    if (clearMapState) {
+      localStorage.removeItem(this.storageKeys.MAP_STATE);
+    }
+  }
+  /**
+   * 导出存储数据（用于备份）
+   */
+  exportData() {
+    return {
+      measurements: this.getMeasurements(),
+      layerConfigs: this.getLayerConfigs(),
+      mapState: this.getMapState(),
+      exportTime: Date.now()
+    };
+  }
+  /**
+   * 导入存储数据（用于恢复）
+   */
+  importData(data) {
+    try {
+      if (data.measurements) {
+        this.saveMeasurements(data.measurements);
+      }
+      if (data.layerConfigs) {
+        this.saveLayerConfigs(data.layerConfigs);
+      }
+      if (data.mapState) {
+        const { center: center2, zoom, rotation } = data.mapState;
+        this.saveMapState(center2, zoom, rotation);
+      }
+      return true;
+    } catch (error2) {
+      console.error("导入数据失败:", error2);
+      return false;
+    }
+  }
 }
 function createMapStorage(instanceId) {
   return new MapStorage(instanceId);
 }
+new MapStorage("global");
 class MeasurementTool {
   constructor(map2, storage2, options = {}) {
     __publicField(this, "map");
@@ -69299,7 +69577,7 @@ class MeasurementTool {
   }
   // 清除特定要素的测量结果标注
   clearFeatureTooltips(feature2) {
-    const featureId2 = feature2.getId() || feature2.ol_uid;
+    const featureId2 = feature2.getId && feature2.getId() || feature2.ol_uid || feature2.get("id");
     const nodesToRemove = this.nodeMarkers.filter((node) => {
       const nodeFeatureId = node.get("parentFeatureId");
       return nodeFeatureId === featureId2;
@@ -69426,7 +69704,7 @@ class MeasurementTool {
     const tooltip = this.createSegmentTooltipOverlay(center2, areaText);
     tooltips.push(tooltip);
     this.map.addOverlay(tooltip);
-    const featureId2 = feature2.getId() || feature2.ol_uid;
+    const featureId2 = feature2.getId && feature2.getId() || feature2.ol_uid || feature2.get("id");
     const tooltipElement = tooltip.getElement();
     this.areaTooltips.push({
       element: tooltipElement,
@@ -69443,7 +69721,7 @@ class MeasurementTool {
       const tooltip = this.createSegmentTooltipOverlay(vertex, angleText);
       tooltips.push(tooltip);
       this.map.addOverlay(tooltip);
-      const featureId2 = feature2.getId() || feature2.ol_uid;
+      const featureId2 = feature2.getId && feature2.getId() || feature2.ol_uid || feature2.get("id");
       const tooltipElement = tooltip.getElement();
       this.angleTooltips.push({
         element: tooltipElement,
@@ -81149,7 +81427,7 @@ let BaseLayer$2 = class BaseLayer2 {
         const styles = customCss.split(";").filter((style) => style.trim());
         styles.forEach((style) => {
           const [property, value] = style.split(":").map((s2) => s2.trim());
-          if (property && value) {
+          if (property && value && canvas) {
             canvas.style[property] = value;
           }
         });
@@ -81179,17 +81457,20 @@ let BaseLayer$2 = class BaseLayer2 {
    * 清除图层样式
    */
   clearLayerStyles() {
-    var _a3, _b3;
     if (!this.layer)
       return;
-    const canvas = (_b3 = (_a3 = this.layer.getRenderer()) == null ? void 0 : _a3.getCanvas) == null ? void 0 : _b3.call(_a3);
+    const renderer = this.layer.getRenderer();
+    let canvas = null;
+    if (renderer && typeof renderer.getCanvas === "function") {
+      canvas = renderer.getCanvas();
+    }
     if (canvas) {
       if (this.config.customCss) {
         const customCss = this.config.customCss;
         const styles = customCss.split(";").filter((style) => style.trim());
         styles.forEach((style) => {
           const [property] = style.split(":").map((s2) => s2.trim());
-          if (property) {
+          if (property && canvas) {
             canvas.style[property] = "";
           }
         });
@@ -81458,18 +81739,121 @@ class WMSLayerHandler extends BaseLayer$2 {
   getFeatureInfoUrl(coordinate, resolution, projection2, params2) {
     const layer2 = this.getLayer();
     const source = layer2.getSource();
-    if (source && this.map) {
-      return source.getFeatureInfoUrl(
+    if (!source)
+      return void 0;
+    return source.getFeatureInfoUrl(
+      coordinate,
+      resolution,
+      projection2,
+      {
+        "INFO_FORMAT": "application/json",
+        "FEATURE_COUNT": 10,
+        ...params2
+      }
+    );
+  }
+  /**
+   * 通过坐标获取要素信息
+   */
+  async getFeatureInfoAtCoordinate(coordinate, options = {}) {
+    const {
+      infoFormat = "application/json",
+      featureCount = 10,
+      resolution,
+      projection: projection2 = "EPSG:3857"
+    } = options;
+    try {
+      const map2 = this.map;
+      if (!map2) {
+        console.warn("地图实例未初始化");
+        return [];
+      }
+      const view = map2.getView();
+      const currentResolution = resolution || view.getResolution();
+      const currentProjection = view.getProjection().getCode();
+      if (!currentResolution) {
+        console.warn("无法获取地图分辨率");
+        return [];
+      }
+      const url = this.getFeatureInfoUrl(
         coordinate,
-        resolution,
-        projection2,
+        currentResolution,
+        currentProjection,
         {
-          "INFO_FORMAT": "application/json",
-          ...params2
+          "INFO_FORMAT": infoFormat,
+          "FEATURE_COUNT": featureCount
         }
-      ) || void 0;
+      );
+      if (!url) {
+        console.warn("无法构建GetFeatureInfo请求URL");
+        return [];
+      }
+      console.log("WMS GetFeatureInfo请求URL:", url);
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const data = await response.json();
+      const features2 = this.parseFeatureInfoResponse(data);
+      return features2.map((feature2) => {
+        const properties = feature2.properties || {};
+        return {
+          ...feature2,
+          properties: {
+            ...properties,
+            layerId: this.config.id,
+            layerName: this.config.name,
+            layerType: "wms"
+          },
+          // 添加OpenLayers Feature兼容方法
+          getProperties: () => ({
+            ...properties,
+            layerId: this.config.id,
+            layerName: this.config.name,
+            layerType: "wms"
+          }),
+          get: (key) => properties[key],
+          setProperties: (props) => {
+            Object.assign(properties, props);
+          }
+        };
+      });
+    } catch (error2) {
+      console.error("WMS GetFeatureInfo查询失败:", error2);
+      return [];
     }
-    return void 0;
+  }
+  /**
+   * 解析GetFeatureInfo响应数据
+   */
+  parseFeatureInfoResponse(data) {
+    const features2 = [];
+    try {
+      if (data.type === "FeatureCollection" && data.features) {
+        return data.features;
+      }
+      if (data.type === "Feature") {
+        return [data];
+      }
+      if (Array.isArray(data)) {
+        return data;
+      }
+      if (typeof data === "object" && data !== null) {
+        for (const key in data) {
+          if (Array.isArray(data[key])) {
+            return data[key];
+          }
+        }
+        return [{
+          type: "Feature",
+          properties: data,
+          geometry: null
+        }];
+      }
+    } catch (error2) {
+      console.error("解析WMS响应数据失败:", error2);
+    }
+    return features2;
   }
 }
 class WMTSLayerHandler extends BaseLayer$2 {
@@ -82481,8 +82865,7 @@ class GeoJSONLayerHandler extends BaseLayer$2 {
     view.fit(extent3, {
       padding: fitOptions.padding,
       maxZoom: fitOptions.maxZoom,
-      duration: fitOptions.duration,
-      minZoom: fitOptions.minZoom
+      duration: fitOptions.duration
     });
     console.log(`已定位到 ${features2.length} 个 GeoJSON 要素`);
   }
@@ -82810,7 +83193,7 @@ class KMLLayerHandler extends BaseLayer$2 {
 }
 class GMLLayerHandler extends BaseLayer$2 {
   constructor(config, map2) {
-    super(config, map2);
+    super(config);
     __publicField(this, "vectorSource", null);
     __publicField(this, "gmlFormat", null);
     this.initializeGMLFormat();
@@ -82825,21 +83208,18 @@ class GMLLayerHandler extends BaseLayer$2 {
       case "2":
       case "2.0":
         this.gmlFormat = new GML$1({
-          className: gmlConfig.className,
           srsName: gmlConfig.srsName || "EPSG:4326"
         });
         break;
       case "3":
       case "3.0":
         this.gmlFormat = new GML3$1({
-          className: gmlConfig.className,
           srsName: gmlConfig.srsName || "EPSG:4326"
         });
         break;
       case "3.2":
       default:
         this.gmlFormat = new GML32$1({
-          className: gmlConfig.className,
           srsName: gmlConfig.srsName || "EPSG:4326"
         });
         break;
@@ -83694,7 +84074,7 @@ class ClusterLayerHandler extends BaseLayer$2 {
    * 更新图层配置
    */
   updateLayerConfig(config) {
-    super.updateLayerConfig(config);
+    super.updateConfig(config);
     if (config.clusterDistance !== void 0) {
       this.setDistance(config.clusterDistance);
     }
@@ -462706,9 +463086,56 @@ class TileSuperMapRestHandler extends BaseLayer$2 {
     __publicField(this, "styleApplyAttempts", 0);
     __publicField(this, "maxStyleApplyAttempts", 5);
   }
+  /**
+   * 转换SuperMap返回的数据格式为标准格式
+   * 将fieldNames和fieldValues转换为标准的key-value properties格式
+   * @param feature SuperMap返回的要素数据
+   * @returns 转换后的标准格式数据
+   */
+  transformSupermapFeature(feature2) {
+    console.log("transformSupermapFeature 输入:", feature2);
+    console.log("输入类型:", typeof feature2);
+    console.log("是否有fieldNames:", !!feature2.fieldNames);
+    console.log("是否有fieldValues:", !!feature2.fieldValues);
+    console.log("fieldNames类型:", Array.isArray(feature2.fieldNames) ? "array" : typeof feature2.fieldNames);
+    console.log("fieldValues类型:", Array.isArray(feature2.fieldValues) ? "array" : typeof feature2.fieldValues);
+    const hasFieldNames = feature2.fieldNames && (Array.isArray(feature2.fieldNames) || feature2.fieldNames.length !== void 0);
+    const hasFieldValues = feature2.fieldValues && (Array.isArray(feature2.fieldValues) || feature2.fieldValues.length !== void 0);
+    console.log("hasFieldNames:", hasFieldNames);
+    console.log("hasFieldValues:", hasFieldValues);
+    if (hasFieldNames && hasFieldValues) {
+      const properties = {};
+      console.log("开始转换 fieldNames:", feature2.fieldNames);
+      console.log("开始转换 fieldValues:", feature2.fieldValues);
+      const fieldNames2 = Array.isArray(feature2.fieldNames) ? feature2.fieldNames : Object.values(feature2.fieldNames || {});
+      const fieldValues = Array.isArray(feature2.fieldValues) ? feature2.fieldValues : Object.values(feature2.fieldValues || {});
+      console.log("转换后的fieldNames数组:", fieldNames2);
+      console.log("转换后的fieldValues数组:", fieldValues);
+      fieldNames2.forEach((fieldName, index2) => {
+        if (index2 < fieldValues.length) {
+          properties[fieldName] = fieldValues[index2];
+          console.log(`转换字段: ${fieldName} = ${fieldValues[index2]}`);
+        }
+      });
+      console.log("转换后的 properties:", properties);
+      const result = {
+        ...feature2,
+        properties,
+        // 保留原始的fieldNames和fieldValues以备需要
+        _original: {
+          fieldNames: feature2.fieldNames,
+          fieldValues: feature2.fieldValues
+        }
+      };
+      console.log("transformSupermapFeature 输出:", result);
+      return result;
+    }
+    console.log("不是SuperMap格式，直接返回:", feature2);
+    return feature2;
+  }
   setupEPSG4490() {
-    proj4$1.defs("EPSG:4490", "+proj=longlat +ellps=GRS80 +no_defs +type=crs");
-    register$3(proj4$1);
+    (void 0)("EPSG:4490", "+proj=longlat +ellps=GRS80 +no_defs +type=crs");
+    register$3(proj4$2);
     console.log("EPSG:4490投影已注册");
   }
   async createLayer() {
@@ -462851,8 +463278,11 @@ class TileSuperMapRestHandler extends BaseLayer$2 {
       let mapJsonUrl = config.url;
       if (mapJsonUrl.includes("/rest/maps/")) {
         const match2 = mapJsonUrl.match(/(.*\/rest\/maps\/[^/]+)/);
-        if (match2) {
+        if (match2 && match2.length > 1) {
           mapJsonUrl = match2[1] + ".json";
+        } else {
+          console.warn("无法从URL中提取map.json路径，跳过元数据获取");
+          return sourceOptions;
         }
       }
       console.log(`正在获取SuperMap服务元数据: ${mapJsonUrl}`);
@@ -463014,7 +463444,12 @@ class TileSuperMapRestHandler extends BaseLayer$2 {
     const source = (_a3 = this.layer) == null ? void 0 : _a3.getSource();
     if (source) {
       let needsRecreate = false;
-      const recreateConfigs = ["format", "transparent", "cacheEnabled", "autoFetchMetadata"];
+      const recreateConfigs = [
+        "format",
+        "transparent",
+        "cacheEnabled",
+        "autoFetchMetadata"
+      ];
       for (const key of recreateConfigs) {
         if (newConfig[key] !== void 0 && newConfig[key] !== this.config[key]) {
           needsRecreate = true;
@@ -463050,6 +463485,568 @@ class TileSuperMapRestHandler extends BaseLayer$2 {
       console.error("重新创建SuperMap图层失败:", error2);
     }
   }
+  /**
+   * 根据地图当前分辨率动态计算点选容差
+   * @param map OpenLayers Map 对象
+   * @param baseTolerance 基础容差（地图坐标系单位，默认为 5）
+   * @returns number 动态计算后的 tolerance
+   */
+  getDynamicTolerance(baseTolerance = 500) {
+    if (!this.map || !this.map.getView)
+      return baseTolerance;
+    const resolution = this.map.getView().getResolution();
+    if (!resolution)
+      return baseTolerance;
+    const dynamicTolerance = baseTolerance * resolution;
+    return dynamicTolerance;
+  }
+  /**
+   * 点选查询要素（类似 WMS GetFeatureInfo）
+   * @param lon 经度
+   * @param lat 纬度
+   * @param options 查询选项
+   * @returns Promise<any[]> 查询到的要素数组
+   */
+  async queryFeatureByPointOL(lon2, lat2, options = {}) {
+    const {
+      datasetNames = ["hms:Football_field"],
+      serviceUrl = "http://172.16.201.151/iserver/services/data-hms-public/rest/data",
+      tolerance: tolerance2 = 0.027,
+      vectorLayer = null
+    } = options;
+    const point2 = new Point$b([lon2, lat2]);
+    let smGeom = Util2.toSuperMapGeometry(point2);
+    if (!smGeom) {
+      const SuperMap2 = window.SuperMap || globalThis.SuperMap;
+      if (SuperMap2 && SuperMap2.Geometry && typeof SuperMap2.Geometry.Point === "function") {
+        smGeom = new SuperMap2.Geometry.Point(lon2, lat2);
+      } else {
+        console.warn("无法构造 SuperMap.Geometry.Point");
+        return [];
+      }
+    }
+    const queryParams = new GetFeaturesByGeometryParameters({
+      datasetNames,
+      geometry: smGeom,
+      spatialQueryMode: "INTERSECT"
+      // WMS 点选风格就是 INTERSECT
+      // tolerance 参数在此版本中不支持，已移除
+    });
+    return new Promise((resolve, reject2) => {
+      new FeatureService2(serviceUrl).getFeaturesByGeometry(
+        queryParams,
+        (result) => {
+          var _a3, _b3, _c2;
+          if (result.error) {
+            console.error("iServer 错误:", result.error);
+            reject2(result.error);
+            return;
+          }
+          const rawFeatures = ((_b3 = (_a3 = result.result) == null ? void 0 : _a3.features) == null ? void 0 : _b3.features) || [];
+          console.log("SuperMap查询结果:", result);
+          console.log("原始要素数组:", rawFeatures);
+          const features2 = rawFeatures.map((feature2) => {
+            console.log("转换前的SuperMap要素:", feature2);
+            console.log("要素的fieldNames:", feature2.fieldNames);
+            console.log("要素的fieldValues:", feature2.fieldValues);
+            const transformedFeature = this.transformSupermapFeature(feature2);
+            console.log("转换后的标准要素:", transformedFeature);
+            console.log("转换后的properties:", transformedFeature.properties);
+            return transformedFeature;
+          });
+          if (vectorLayer) {
+            (_c2 = vectorLayer.getSource()) == null ? void 0 : _c2.clear();
+            features2.forEach((f2) => {
+              var _a4;
+              const olFeat = new Feature$6(Util2.toSuperMapGeometry(f2.geometry));
+              olFeat.setProperties(f2.properties || {});
+              (_a4 = vectorLayer.getSource()) == null ? void 0 : _a4.addFeature(olFeat);
+            });
+          }
+          resolve(features2);
+        }
+      );
+    });
+  }
+  /**
+   * 通过缓冲区查询要素的公共方法
+   * @param lon 经度
+   * @param lat 纬度
+   * @param options 查询选项
+   * @returns Promise<Feature[]> 查询到的要素数组
+   */
+  async getFeaturesByBuffer(lon2 = 93.53179023100006, lat2 = 42.81598224900006, options = {}) {
+    try {
+      const {
+        bufferDistance = 0.027,
+        datasetNames = ["hms:Football_field"],
+        serviceUrl = "http://172.16.201.151/iserver/services/data-hms-public/rest/data",
+        vectorLayer = null
+      } = options;
+      const olPoint = new Point$b([lon2, lat2]);
+      let smGeom = Util2.toSuperMapGeometry(olPoint);
+      console.log("Util.toSuperMapGeometry ->", smGeom);
+      if (!smGeom) {
+        const SuperMap2 = window.SuperMap || globalThis.SuperMap;
+        if (SuperMap2 && SuperMap2.Geometry && typeof SuperMap2.Geometry.Point === "function") {
+          smGeom = new SuperMap2.Geometry.Point(lon2, lat2);
+          console.log("使用全局 SuperMap.Geometry.Point 构建 smGeom:", smGeom);
+        } else {
+          console.warn(
+            "无法取得全局 SuperMap，无法构造 SuperMap.Geometry.Point。建议使用方案A的 REST 调用绕开。"
+          );
+        }
+      }
+      if (!smGeom) {
+        console.error(
+          "无法构建 SuperMap Geometry（smGeom 为 null）。请使用方案A 或检查 iClient 的引入方式。"
+        );
+        return [];
+      }
+      const bufferParams = new GetFeaturesByBufferParameters({
+        datasetNames,
+        bufferDistance,
+        // 举例（300m ≈ 0.0027°），注意单位和坐标系一致
+        geometry: smGeom,
+        spatialQueryMode: "INTERSECT"
+      });
+      return new Promise((resolve, reject2) => {
+        new FeatureService2(serviceUrl).getFeaturesByBuffer(
+          bufferParams,
+          (serviceResult) => {
+            var _a3, _b3, _c2, _d;
+            console.log("serviceResult:", serviceResult);
+            if (serviceResult.error) {
+              console.error("iServer error:", serviceResult.error);
+              reject2(new Error("iServer 返回错误，详见控制台"));
+              return;
+            }
+            const rawFeatures = ((_b3 = (_a3 = serviceResult.result) == null ? void 0 : _a3.features) == null ? void 0 : _b3.features) || [];
+            const feats = rawFeatures.map((f2) => {
+              const transformedFeature = this.transformSupermapFeature(f2);
+              console.log("Buffer查询 - 转换前的SuperMap数据:", f2);
+              console.log("Buffer查询 - 转换后的标准数据:", transformedFeature);
+              const olFeat = new Feature$6(Util2.toSuperMapGeometry(f2.geometry));
+              olFeat.setProperties(transformedFeature.properties || {});
+              return olFeat;
+            });
+            if (vectorLayer) {
+              (_c2 = vectorLayer.getSource()) == null ? void 0 : _c2.clear();
+              if (feats.length) {
+                (_d = vectorLayer.getSource()) == null ? void 0 : _d.addFeatures(feats);
+              }
+            }
+            console.log("查询并绘制完成，count:", feats.length);
+            resolve(feats);
+          }
+        );
+      });
+    } catch (err2) {
+      console.error("queryBuffer 捕获异常：", err2);
+      throw new Error("查询异常，详见控制台");
+    }
+  }
+  // ✅ 构建数据服务 URL（适配 map-hmsmap 服务）
+  buildDataServerUrl(baseUrl) {
+    const mapServiceMatch = baseUrl.match(/services\/map-(.+?)\/rest/);
+    if (!mapServiceMatch) {
+      throw new Error("无法从地图服务 URL 推导数据服务地址");
+    }
+    const workspaceName = mapServiceMatch[1];
+    return `${baseUrl.split("/services")[0]}/services/data-${workspaceName}/rest`;
+  }
+  // ✅ 获取默认数据集（示例）
+  getDefaultDatasets() {
+    return ["football_field@hmsmap"];
+  }
+  /**
+   * 通过边界范围查询要素
+   * @param bounds 边界范围 [minX, minY, maxX, maxY]
+   * @param options 查询选项
+   * @returns Promise<any[]> 查询结果
+   */
+  async getFeaturesByBounds(bounds2, options = {}) {
+    var _a3;
+    const config = this.config;
+    if (!config.url) {
+      console.warn("SuperMap图层缺少服务URL，无法进行要素查询");
+      return [];
+    }
+    const {
+      maxFeatures = 100,
+      datasetNames,
+      returnContent = true,
+      targetProjection
+    } = options;
+    try {
+      const mapProjection = (_a3 = this.map) == null ? void 0 : _a3.getView().getProjection();
+      const projectionCode = targetProjection || (mapProjection == null ? void 0 : mapProjection.getCode()) || "EPSG:4326";
+      let transformedBounds = bounds2;
+      if (mapProjection && targetProjection && mapProjection.getCode() !== targetProjection) {
+        const bottomLeft = transform$l(
+          [bounds2[0], bounds2[1]],
+          mapProjection.getCode(),
+          targetProjection
+        );
+        const topRight = transform$l(
+          [bounds2[2], bounds2[3]],
+          mapProjection.getCode(),
+          targetProjection
+        );
+        transformedBounds = [
+          bottomLeft[0],
+          bottomLeft[1],
+          topRight[0],
+          topRight[1]
+        ];
+      }
+      const serviceUrl = this.buildDataServiceUrl(config.url);
+      console.log(`开始SuperMap边界查询:`, {
+        bounds: transformedBounds,
+        serviceUrl,
+        projection: projectionCode
+      });
+      const boundsParams = new GetFeaturesByBoundsParameters({
+        datasetNames: datasetNames || this.extractDatasetNames(config.url),
+        bounds: transformedBounds,
+        maxFeatures,
+        returnContent
+      });
+      const boundsService = new GetFeaturesByBoundsService(serviceUrl);
+      return new Promise((resolve, reject2) => {
+        boundsService.getFeaturesByBounds(
+          boundsParams,
+          (serviceResult) => {
+            var _a4;
+            if (serviceResult.type === "processCompleted") {
+              const result = serviceResult.result;
+              if (result && result.features) {
+                console.log(
+                  `SuperMap边界查询成功，找到 ${result.features.length} 个要素`
+                );
+                resolve(result.features);
+              } else {
+                console.log("SuperMap边界查询完成，但未找到要素");
+                resolve([]);
+              }
+            } else {
+              console.error("SuperMap边界查询失败:", serviceResult.error);
+              reject2(
+                new Error(((_a4 = serviceResult.error) == null ? void 0 : _a4.errorMsg) || "边界查询失败")
+              );
+            }
+          }
+        );
+      });
+    } catch (error2) {
+      console.error("SuperMap边界查询异常:", error2);
+      return [];
+    }
+  }
+  /**
+   * 通过几何对象查询要素
+   * @param geometry OpenLayers几何对象
+   * @param options 查询选项
+   * @returns Promise<any[]> 查询结果
+   */
+  async getFeaturesByGeometry(geometry2, options = {}) {
+    const config = this.config;
+    if (!config.url) {
+      console.warn("SuperMap图层缺少服务URL，无法进行要素查询");
+      return [];
+    }
+    const {
+      maxFeatures = 100,
+      datasetNames,
+      returnContent = true,
+      spatialQueryMode = "INTERSECT",
+      targetProjection
+    } = options;
+    try {
+      const serviceUrl = this.buildDataServiceUrl(config.url);
+      console.log(`开始SuperMap几何查询:`, {
+        geometryType: geometry2.getType(),
+        spatialQueryMode,
+        serviceUrl
+      });
+      const geometryParams = new GetFeaturesByGeometryParameters({
+        datasetNames: datasetNames || this.extractDatasetNames(config.url),
+        geometry: geometry2,
+        maxFeatures,
+        returnContent,
+        spatialQueryMode
+      });
+      const geometryService = new GetFeaturesByGeometryService(serviceUrl);
+      return new Promise((resolve, reject2) => {
+        geometryService.getFeaturesByGeometry(
+          geometryParams,
+          (serviceResult) => {
+            var _a3;
+            if (serviceResult.type === "processCompleted") {
+              const result = serviceResult.result;
+              if (result && result.features) {
+                console.log(
+                  `SuperMap几何查询成功，找到 ${result.features.length} 个要素`
+                );
+                resolve(result.features);
+              } else {
+                console.log("SuperMap几何查询完成，但未找到要素");
+                resolve([]);
+              }
+            } else {
+              console.error("SuperMap几何查询失败:", serviceResult.error);
+              reject2(
+                new Error(((_a3 = serviceResult.error) == null ? void 0 : _a3.errorMsg) || "几何查询失败")
+              );
+            }
+          }
+        );
+      });
+    } catch (error2) {
+      console.error("SuperMap几何查询异常:", error2);
+      return [];
+    }
+  }
+  /**
+   * 通过SQL条件查询要素
+   * @param sqlCondition SQL查询条件
+   * @param options 查询选项
+   * @returns Promise<any[]> 查询结果
+   */
+  async getFeaturesBySQL(sqlCondition, options = {}) {
+    const config = this.config;
+    if (!config.url) {
+      console.warn("SuperMap图层缺少服务URL，无法进行要素查询");
+      return [];
+    }
+    const {
+      maxFeatures = 100,
+      datasetNames,
+      returnContent = true,
+      targetProjection
+    } = options;
+    try {
+      const serviceUrl = this.buildDataServiceUrl(config.url);
+      console.log(`开始SuperMap SQL查询:`, {
+        sqlCondition,
+        serviceUrl
+      });
+      const sqlParams = new GetFeaturesBySQLParameters({
+        datasetNames: datasetNames || this.extractDatasetNames(config.url),
+        queryParameter: {
+          name: "sqlQuery",
+          attributeFilter: sqlCondition
+        },
+        maxFeatures,
+        returnContent
+      });
+      const sqlService = new GetFeaturesBySQLService(serviceUrl);
+      return new Promise((resolve, reject2) => {
+        sqlService.getFeaturesBySQL(sqlParams, (serviceResult) => {
+          var _a3;
+          if (serviceResult.type === "processCompleted") {
+            const result = serviceResult.result;
+            if (result && result.features) {
+              console.log(
+                `SuperMap SQL查询成功，找到 ${result.features.length} 个要素`
+              );
+              resolve(result.features);
+            } else {
+              console.log("SuperMap SQL查询完成，但未找到要素");
+              resolve([]);
+            }
+          } else {
+            console.error("SuperMap SQL查询失败:", serviceResult.error);
+            reject2(new Error(((_a3 = serviceResult.error) == null ? void 0 : _a3.errorMsg) || "SQL查询失败"));
+          }
+        });
+      });
+    } catch (error2) {
+      console.error("SuperMap SQL查询异常:", error2);
+      return [];
+    }
+  }
+  /**
+   * 通过要素ID查询要素
+   * @param featureIds 要素ID数组
+   * @param options 查询选项
+   * @returns Promise<any[]> 查询结果
+   */
+  async getFeaturesByIDs(featureIds, options = {}) {
+    const config = this.config;
+    if (!config.url) {
+      console.warn("SuperMap图层缺少服务URL，无法进行要素查询");
+      return [];
+    }
+    const { datasetNames, returnContent = true, targetProjection } = options;
+    try {
+      const serviceUrl = this.buildDataServiceUrl(config.url);
+      console.log(`开始SuperMap ID查询:`, {
+        featureIds,
+        serviceUrl
+      });
+      const idsParams = new GetFeaturesByIDsParameters({
+        datasetNames: datasetNames || this.extractDatasetNames(config.url),
+        IDs: featureIds,
+        returnContent
+      });
+      const idsService = new GetFeaturesByIDsService(serviceUrl);
+      return new Promise((resolve, reject2) => {
+        idsService.getFeaturesByIDs(idsParams, (serviceResult) => {
+          var _a3;
+          if (serviceResult.type === "processCompleted") {
+            const result = serviceResult.result;
+            if (result && result.features) {
+              console.log(
+                `SuperMap ID查询成功，找到 ${result.features.length} 个要素`
+              );
+              resolve(result.features);
+            } else {
+              console.log("SuperMap ID查询完成，但未找到要素");
+              resolve([]);
+            }
+          } else {
+            console.error("SuperMap ID查询失败:", serviceResult.error);
+            reject2(new Error(((_a3 = serviceResult.error) == null ? void 0 : _a3.errorMsg) || "ID查询失败"));
+          }
+        });
+      });
+    } catch (error2) {
+      console.error("SuperMap ID查询异常:", error2);
+      return [];
+    }
+  }
+  /**
+   * 构建数据服务URL
+   * @param mapUrl 地图服务URL
+   * @returns 数据服务URL
+   */
+  buildDataServiceUrl(mapUrl) {
+    try {
+      const url = new URL(mapUrl);
+      if (url.pathname.includes("/rest/data")) {
+        console.log(`已经是数据服务URL: ${mapUrl}`);
+        return mapUrl;
+      }
+      if (url.pathname.includes("/rest/maps/")) {
+        const dataServiceUrl = mapUrl.replace(
+          /\/rest\/maps\/.*$/,
+          "/rest/data"
+        );
+        console.log(`构建数据服务URL: ${mapUrl} -> ${dataServiceUrl}`);
+        return dataServiceUrl;
+      }
+      const pathParts = url.pathname.split("/").filter((part) => part);
+      const servicesIndex = pathParts.findIndex((part) => part === "services");
+      if (servicesIndex !== -1 && servicesIndex + 1 < pathParts.length) {
+        const serviceName = pathParts[servicesIndex + 1];
+        const basePath = pathParts.slice(0, servicesIndex + 2).join("/");
+        const dataServiceUrl = `${url.protocol}//${url.host}/${basePath}/rest/data`;
+        console.log(
+          `从服务名称构建数据服务URL: ${mapUrl} -> ${dataServiceUrl}`
+        );
+        return dataServiceUrl;
+      }
+      throw new Error(`无法解析SuperMap服务URL格式: ${mapUrl}`);
+    } catch (error2) {
+      console.error("构建数据服务URL失败:", error2);
+      return mapUrl;
+    }
+  }
+  /**
+   * 从地图服务URL中提取数据集名称
+   * @param mapUrl 地图服务URL
+   * @returns 数据集名称数组
+   */
+  extractDatasetNames(mapUrl) {
+    try {
+      const url = new URL(mapUrl);
+      const pathParts = url.pathname.split("/").filter((part) => part);
+      const mapsIndex = pathParts.findIndex((part) => part === "maps");
+      if (mapsIndex !== -1 && mapsIndex + 1 < pathParts.length) {
+        const mapName = pathParts[mapsIndex + 1];
+        console.log(`从URL提取到地图名称: ${mapName}`);
+        return [mapName];
+      }
+      const config = this.config;
+      if (config.datasetNames && Array.isArray(config.datasetNames)) {
+        console.log(`使用配置中的数据集名称: ${config.datasetNames}`);
+        return config.datasetNames;
+      }
+      console.warn("无法确定数据集名称，将查询所有可用数据集");
+      return [];
+    } catch (error2) {
+      console.error("提取数据集名称失败:", error2);
+      return [];
+    }
+  }
+  /**
+   * 为popup等功能提供的便捷方法：通过点击坐标获取要素信息
+   * @param coordinate 点击坐标
+   * @param options 查询选项
+   * @returns Promise<any[]> 要素信息数组
+   */
+  async getFeatureInfoAtCoordinate(coordinate, options = {}) {
+    var _a3, _b3, _c2, _d, _e2, _f;
+    const {
+      bufferDistance = 100,
+      maxFeatures = options.featureCount || 10,
+      queryMethod
+    } = options;
+    try {
+      let features2 = [];
+      const finalQueryMethod = queryMethod || ((_a3 = this.config.supermapConfig) == null ? void 0 : _a3.queryMethod) || "point";
+      console.log(`使用查询方式: ${finalQueryMethod}`);
+      if (finalQueryMethod === "buffer") {
+        const configuredBufferDistance = ((_b3 = this.config.supermapConfig) == null ? void 0 : _b3.bufferDistance) || bufferDistance;
+        features2 = await this.getFeaturesByBuffer(
+          coordinate[0],
+          coordinate[1],
+          {
+            bufferDistance: configuredBufferDistance / 1e3,
+            // 转换为度数单位
+            datasetNames: (_c2 = this.config.supermapConfig) == null ? void 0 : _c2.datasetNames,
+            serviceUrl: (_d = this.config.supermapConfig) == null ? void 0 : _d.featureServiceUrl
+          }
+        );
+      } else {
+        features2 = await this.queryFeatureByPointOL(
+          coordinate[0],
+          coordinate[1],
+          {
+            datasetNames: (_e2 = this.config.supermapConfig) == null ? void 0 : _e2.datasetNames,
+            serviceUrl: (_f = this.config.supermapConfig) == null ? void 0 : _f.featureServiceUrl
+            // tolerance 参数已移除，使用默认值
+          }
+        );
+      }
+      return features2.slice(0, maxFeatures).map((feature2) => {
+        if (feature2 && typeof feature2.getProperties === "function") {
+          const properties = feature2.getProperties() || {};
+          feature2.setProperties({
+            ...properties,
+            layerId: this.config.id,
+            layerName: this.config.name,
+            layerType: "supermap-rest"
+          });
+          return feature2;
+        } else {
+          return {
+            ...feature2,
+            properties: {
+              ...feature2.properties || {},
+              layerId: this.config.id,
+              layerName: this.config.name,
+              layerType: "supermap-rest"
+            }
+          };
+        }
+      });
+    } catch (error2) {
+      console.error("获取要素信息失败:", error2);
+      return [];
+    }
+  }
 }
 class CanvasLayerHandler extends BaseLayer$2 {
   constructor() {
@@ -463202,7 +464199,7 @@ class CanvasLayerHandler extends BaseLayer$2 {
    * 更新图层配置
    */
   updateLayerConfig(config) {
-    super.updateLayerConfig(config);
+    super.updateConfig(config);
     if (config.canvasConfig) {
       this.updateCanvasConfig(config.canvasConfig);
     }
@@ -463921,176 +464918,6 @@ class LayerManager {
   getLayerHandler(layerId) {
     return this.layerHandlers.get(layerId);
   }
-  /**
-   * 根据坐标获取图层要素信息（用于tooltip）
-   */
-  async getFeatureInfoAtCoordinate(coordinate, options = {}) {
-    const results = [];
-    const { layers, infoFormat = "application/json", featureCount = 10 } = options;
-    const view = this.map.getView();
-    const resolution = view.getResolution();
-    const projection2 = view.getProjection();
-    for (const [layerId, config] of this.layerConfigs) {
-      if (!config.visible)
-        continue;
-      if (layers && layers.length > 0 && !layers.includes(layerId)) {
-        continue;
-      }
-      const handler = this.layerHandlers.get(layerId);
-      if (!handler)
-        continue;
-      try {
-        const featureInfoConfig = config.featureInfo;
-        if (featureInfoConfig == null ? void 0 : featureInfoConfig.enabled) {
-          if (featureInfoConfig.customApi) {
-            try {
-              const customApi = featureInfoConfig.customApi;
-              const requestUrl = customApi.url;
-              const method = customApi.method || "GET";
-              const requestParams = {};
-              if (customApi.params) {
-                if (customApi.params.coordinate) {
-                  requestParams[customApi.params.coordinate] = coordinate;
-                }
-                if (customApi.params.layer) {
-                  requestParams[customApi.params.layer] = layerId;
-                }
-                Object.keys(customApi.params).forEach((key) => {
-                  if (key !== "coordinate" && key !== "layer") {
-                    requestParams[key] = customApi.params[key];
-                  }
-                });
-              }
-              const requestOptions = {
-                method,
-                headers: {
-                  "Content-Type": "application/json"
-                }
-              };
-              let finalUrl = requestUrl;
-              if (method.toUpperCase() === "POST") {
-                requestOptions.body = JSON.stringify(requestParams);
-              } else {
-                const urlParams = new URLSearchParams();
-                Object.keys(requestParams).forEach((key) => {
-                  if (Array.isArray(requestParams[key])) {
-                    urlParams.append(key, requestParams[key].join(","));
-                  } else {
-                    urlParams.append(key, String(requestParams[key]));
-                  }
-                });
-                finalUrl = `${requestUrl}?${urlParams.toString()}`;
-              }
-              const response = await fetch(finalUrl, requestOptions);
-              if (response.ok) {
-                let data = await response.json();
-                if (customApi.responseHandler) {
-                  try {
-                    const handlerFunc = new Function("data", `return (${customApi.responseHandler})(data)`);
-                    data = handlerFunc(data);
-                  } catch (error2) {
-                    console.warn("自定义响应处理函数执行失败:", error2);
-                  }
-                }
-                const features2 = Array.isArray(data) ? data : data.features || [];
-                if (features2.length > 0) {
-                  results.push({
-                    layerId,
-                    layerName: config.name,
-                    features: features2
-                  });
-                  continue;
-                }
-              }
-            } catch (error2) {
-              console.warn(`自定义接口查询失败 (${layerId}):`, error2);
-            }
-          }
-        }
-        if (config.type === "wms" || config.type === "tile") {
-          const layer2 = handler.getLayer();
-          const source = layer2.getSource();
-          if (source && typeof source.getFeatureInfoUrl === "function") {
-            const featureInfoParams = {
-              "INFO_FORMAT": infoFormat,
-              "FEATURE_COUNT": featureCount,
-              ...(featureInfoConfig == null ? void 0 : featureInfoConfig.params) || {}
-            };
-            const url = source.getFeatureInfoUrl(
-              coordinate,
-              resolution,
-              projection2,
-              featureInfoParams
-            );
-            if (url) {
-              const response = await fetch(url);
-              if (response.ok) {
-                const data = await response.json();
-                if (data.features && data.features.length > 0) {
-                  results.push({
-                    layerId,
-                    layerName: config.name,
-                    features: data.features
-                  });
-                }
-              }
-            }
-          }
-        } else if (config.type === "wmts") {
-          if (featureInfoConfig == null ? void 0 : featureInfoConfig.enabled) {
-          }
-        } else if (config.type === "vector") {
-          if (featureInfoConfig == null ? void 0 : featureInfoConfig.enabled) {
-            const layer2 = handler.getLayer();
-            const pixel = this.map.getPixelFromCoordinate(coordinate);
-            const features2 = [];
-            this.map.forEachFeatureAtPixel(pixel, (feature2) => {
-              features2.push({
-                properties: feature2.getProperties(),
-                geometry: feature2.getGeometry()
-              });
-            }, { layerFilter: (l2) => l2 === layer2 });
-            if (features2.length > 0) {
-              results.push({
-                layerId,
-                layerName: config.name,
-                features: features2
-              });
-            }
-          }
-        } else if (config.type === "heatmap") {
-          if (featureInfoConfig == null ? void 0 : featureInfoConfig.enabled) {
-            const layer2 = handler.getLayer();
-            const source = layer2.getSource();
-            if (source && typeof source.getFeatures === "function") {
-              const pixel = this.map.getPixelFromCoordinate(coordinate);
-              const features2 = [];
-              this.map.forEachFeatureAtPixel(pixel, (feature2) => {
-                features2.push({
-                  properties: feature2.getProperties(),
-                  geometry: feature2.getGeometry()
-                });
-              }, { layerFilter: (l2) => l2 === layer2 });
-              if (features2.length > 0) {
-                results.push({
-                  layerId,
-                  layerName: config.name,
-                  features: features2
-                });
-              }
-            }
-          }
-        } else if (["bing", "google", "arcgis", "mapbox", "xyz", "webgl", "canvas", "graticule"].includes(config.type)) {
-          if (featureInfoConfig == null ? void 0 : featureInfoConfig.enabled) {
-            console.log(`图层类型 ${config.type} 需要配置自定义接口来支持要素查询`);
-          }
-        }
-      } catch (error2) {
-        console.warn(`获取图层 ${layerId} 要素信息失败:`, error2);
-      }
-    }
-    return results;
-  }
   /**
    * 设置图层可见性（支持按需加载）
    */
@@ -464390,6 +465217,98 @@ class LayerManager {
       return false;
     }
   }
+  /**
+   * 根据坐标获取图层要素信息（用于tooltip）
+   */
+  async getFeatureInfoAtCoordinate(coordinate, options) {
+    try {
+      const results = [];
+      const targetLayers = (options == null ? void 0 : options.layers) || Array.from(this.layerHandlers.keys());
+      for (const layerId of targetLayers) {
+        const handler = this.layerHandlers.get(layerId);
+        const config = this.layerConfigs.get(layerId);
+        if (!handler || !config || !config.visible) {
+          continue;
+        }
+        try {
+          if (config.type === "TileSuperMapRest" || config.type === "tilesupermaprest" || config.type === "TILESUPERMAPREST") {
+            if ("getFeatureInfoAtCoordinate" in handler) {
+              const features2 = await handler.getFeatureInfoAtCoordinate(
+                coordinate,
+                {
+                  bufferDistance: 80,
+                  // 默认5米缓冲区
+                  maxFeatures: (options == null ? void 0 : options.featureCount) || 10,
+                  returnContent: true
+                }
+              );
+              if (features2 && features2.length > 0) {
+                results.push({
+                  layerId,
+                  layerName: config.name,
+                  layerType: config.type,
+                  features: features2
+                });
+              }
+            }
+          } else if (config.type === "wms" || config.type === "WMS") {
+            if ("getFeatureInfoAtCoordinate" in handler) {
+              const features2 = await handler.getFeatureInfoAtCoordinate(
+                coordinate,
+                {
+                  infoFormat: (options == null ? void 0 : options.infoFormat) || "application/json",
+                  featureCount: (options == null ? void 0 : options.featureCount) || 10
+                }
+              );
+              if (features2 && features2.length > 0) {
+                results.push({
+                  layerId,
+                  layerName: config.name,
+                  layerType: config.type,
+                  features: features2
+                });
+              }
+            }
+          } else if (config.type === "vector" || config.type === "geojson") {
+            const layer2 = handler.getLayer();
+            if (layer2 && "getSource" in layer2) {
+              const source = layer2.getSource();
+              if (source && "getFeaturesAtCoordinate" in source) {
+                const features2 = source.getFeaturesAtCoordinate(coordinate);
+                if (features2 && features2.length > 0) {
+                  const processedFeatures = features2.slice(0, (options == null ? void 0 : options.featureCount) || 10).map((feature2) => {
+                    const properties = feature2.getProperties ? feature2.getProperties() : {};
+                    const enhancedProperties = {
+                      ...properties,
+                      layerId,
+                      layerName: config.name,
+                      layerType: config.type
+                    };
+                    if (feature2.setProperties) {
+                      feature2.setProperties(enhancedProperties);
+                    }
+                    return feature2;
+                  });
+                  results.push({
+                    layerId,
+                    layerName: config.name,
+                    layerType: config.type,
+                    features: processedFeatures
+                  });
+                }
+              }
+            }
+          }
+        } catch (error2) {
+          console.warn(`图层 ${layerId} 要素查询失败:`, error2);
+        }
+      }
+      return results;
+    } catch (error2) {
+      console.error("获取要素信息失败:", error2);
+      return [];
+    }
+  }
   /**
    * 销毁图层管理器
    */
@@ -464904,21 +465823,24 @@ class MapManager {
       }
       if (this.layerManager) {
         try {
-          const wmsFeatures = await this.layerManager.getFeatureInfoAtCoordinate(lonLatCoordinate);
-          if (wmsFeatures.length > 0) {
-            const wmsLayerData = wmsFeatures[0];
-            if (wmsLayerData.features && wmsLayerData.features.length > 0) {
-              const feature2 = wmsLayerData.features[0];
-              const layer2 = {
-                layerId: wmsLayerData.layerId,
-                layerName: wmsLayerData.layerName
-              };
-              this.emit("feature-click", feature2, layer2, lonLatCoordinate);
-              return;
+          const featureInfoResults = await this.layerManager.getFeatureInfoAtCoordinate(
+            lonLatCoordinate,
+            {
+              featureCount: 10
             }
+          );
+          if (featureInfoResults && featureInfoResults.length > 0) {
+            const tooltipData = featureInfoResults.map((result) => ({
+              layerId: result.layerId,
+              layerName: result.layerName,
+              features: result.features,
+              coordinate: lonLatCoordinate
+            }));
+            this.emit("feature-info", tooltipData);
+            return;
           }
         } catch (error2) {
-          console.warn("查询WMS图层要素信息失败:", error2);
+          console.warn("查询图层要素信息失败:", error2);
         }
       }
       this.emit("map-click", {
@@ -465169,7 +466091,7 @@ class MapManager {
     if (!this.map)
       return;
     this.map.on("singleclick", async (evt) => {
-      var _a3, _b3, _c2, _d;
+      var _a3, _b3, _c2;
       const coordinate = evt.coordinate;
       const pixel = evt.pixel;
       const view = this.map.getView();
@@ -465201,24 +466123,7 @@ class MapManager {
         }
         (_b3 = callbacks.onFeatureClick) == null ? void 0 : _b3.call(callbacks, feature2, layer2, lonLatCoordinate, mapCoordinate);
       } else {
-        try {
-          const wmsFeatures = await this.layerManager.getFeatureInfoAtCoordinate(coordinate);
-          if (wmsFeatures.length > 0) {
-            const wmsLayerData = wmsFeatures[0];
-            if (wmsLayerData.features && wmsLayerData.features.length > 0) {
-              const feature2 = wmsLayerData.features[0];
-              const layer2 = {
-                layerId: wmsLayerData.layerId,
-                layerName: wmsLayerData.layerName
-              };
-              (_c2 = callbacks.onFeatureClick) == null ? void 0 : _c2.call(callbacks, feature2, layer2, lonLatCoordinate, mapCoordinate);
-              return;
-            }
-          }
-        } catch (error2) {
-          console.warn("WMS GetFeatureInfo request failed:", error2);
-        }
-        (_d = callbacks.onMapClick) == null ? void 0 : _d.call(callbacks, {
+        (_c2 = callbacks.onMapClick) == null ? void 0 : _c2.call(callbacks, {
           coordinate: lonLatCoordinate,
           mapCoordinate,
           pixel,
@@ -465348,7 +466253,7 @@ const _sfc_main$q = /* @__PURE__ */ defineComponent({
     loading: { type: Boolean, default: false },
     userMarkers: {}
   },
-  emits: ["map-ready", "map-click", "map-dblclick", "map-contextmenu", "map-move", "zoom-change"],
+  emits: ["map-ready", "map-click", "map-dblclick", "map-contextmenu", "map-move", "zoom-change", "feature-info"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
@@ -465435,6 +466340,9 @@ const _sfc_main$q = /* @__PURE__ */ defineComponent({
           emit("map-contextmenu", { coordinate, pixel });
         }
       });
+      mapManager.value.on("feature-info", (data) => {
+        emit("feature-info", data);
+      });
     };
     const updateMapConfig = (config) => {
       if (!map2.value)
@@ -465506,7 +466414,7 @@ const _export_sfc = (sfc, props) => {
   }
   return target;
 };
-const MapContainer = /* @__PURE__ */ _export_sfc(_sfc_main$q, [["__scopeId", "data-v-53c8deda"]]);
+const MapContainer = /* @__PURE__ */ _export_sfc(_sfc_main$q, [["__scopeId", "data-v-9900e920"]]);
 const _hoisted_1$n = ["href"];
 const _sfc_main$p = /* @__PURE__ */ defineComponent({
   __name: "index",
@@ -476245,19 +477153,25 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
           { "ol-popup-vertical": _ctx.config.vertical },
           _ctx.config.className
         ]),
-        style: normalizeStyle$1(popupStyle.value)
+        style: normalizeStyle$1(popupStyle.value),
+        onClick: _cache[0] || (_cache[0] = withModifiers(() => {
+        }, ["stop"])),
+        onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {
+        }, ["stop"])),
+        onMouseup: _cache[2] || (_cache[2] = withModifiers(() => {
+        }, ["stop"]))
       }, [
-        _cache[2] || (_cache[2] = createElementVNode("div", { class: "ol-popup-tip" }, null, -1)),
+        _cache[5] || (_cache[5] = createElementVNode("div", { class: "ol-popup-tip" }, null, -1)),
         _ctx.config.showCloseButton !== false ? (openBlock(), createBlock(unref(ElButton), {
           key: 0,
           class: "ol-popup-closer",
-          onClick: handleClose,
+          onClick: withModifiers(handleClose, ["stop"]),
           title: "关闭",
           text: "",
           circle: "",
           size: "small"
         }, {
-          default: withCtx(() => [..._cache[0] || (_cache[0] = [
+          default: withCtx(() => [..._cache[3] || (_cache[3] = [
             createTextVNode(" × ", -1)
           ])]),
           _: 1
@@ -476272,16 +477186,16 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
             coordinate: _ctx.coordinate,
             config: _ctx.config
           }, () => [
-            _cache[1] || (_cache[1] = createElementVNode("div", { class: "ol-popup-default" }, [
+            _cache[4] || (_cache[4] = createElementVNode("div", { class: "ol-popup-default" }, [
               createElementVNode("p", null, "请提供 popup 内容")
             ], -1))
           ], true)
         ], 512)
-      ], 6)) : createCommentVNode("", true);
+      ], 38)) : createCommentVNode("", true);
     };
   }
 });
-const BasePopup = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-ec278a8a"]]);
+const BasePopup = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-9a5b6333"]]);
 const _hoisted_1$3 = { class: "html-popup-content" };
 const _hoisted_2$3 = {
   key: 0,
@@ -476744,7 +477658,7 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
   setup(__props, { emit: __emit }) {
     const props = __props;
     const emit = __emit;
-    const currentView = ref(props.config.defaultView || "table");
+    const currentView = ref(props.config.defaultView || "list");
     const searchQuery = ref("");
     const sortField = ref("");
     const sortOrder = ref("asc");
@@ -477090,7 +478004,7 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const ArrayPopup = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-4a372183"]]);
+const ArrayPopup = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-140dd964"]]);
 class PopupManager {
   constructor(map2, config = {}) {
     __publicField(this, "map");
@@ -477776,7 +478690,127 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       emit("zoom-change", zoom, oldZoom);
     };
     const onFeatureInfo = (data) => {
-      emit("feature-info", data);
+      if (data && data.length > 0) {
+        const firstResult = data[0];
+        const { layerId, layerName, features: features2, coordinate } = firstResult;
+        if (features2 && features2.length > 0) {
+          const feature2 = features2[0];
+          const layerInfo = {
+            layerId,
+            layerName
+          };
+          emit("feature-click", feature2, layerInfo, coordinate);
+          if (popupManager.value) {
+            const allLayers = [...finalMapConfig.value.baseLayers || [], ...finalMapConfig.value.overlayLayers || [], ...finalMapConfig.value.vectorLayers || []];
+            const targetLayer = allLayers.find((l2) => l2.id === layerId || l2.name === layerName);
+            if (targetLayer && targetLayer.popup) {
+              const popupConfig = targetLayer.popup;
+              console.log("显示SuperMap图层popup:", { layerId, layerName, feature: feature2, coordinate });
+              let properties;
+              if (feature2 && typeof feature2.getProperties === "function") {
+                properties = feature2.getProperties();
+                console.log("OpenLayers Feature属性:", properties);
+              } else if (feature2 && feature2.properties) {
+                properties = feature2.properties;
+                console.log("GeoJSON Feature属性:", properties);
+              } else {
+                properties = feature2;
+                console.log("其他格式属性:", properties);
+              }
+              console.log("SuperMap要素属性数据:", properties);
+              console.log("popup配置字段:", popupConfig.fields);
+              let content2 = {};
+              let hasValidFields = false;
+              if (popupConfig.fields && Array.isArray(popupConfig.fields)) {
+                popupConfig.fields.forEach((field) => {
+                  if (typeof field === "string") {
+                    const value = properties[field];
+                    console.log(`字段 ${field} 的值:`, value);
+                    if (value !== void 0 && value !== null) {
+                      content2[field] = value;
+                      hasValidFields = true;
+                    } else {
+                      content2[field] = "--";
+                    }
+                  } else if (field.name) {
+                    const displayName = field.label || field.name;
+                    const value = properties[field.name];
+                    console.log(`字段 ${field.name} (${displayName}) 的值:`, value);
+                    if (value !== void 0 && value !== null) {
+                      content2[displayName] = value;
+                      hasValidFields = true;
+                    } else {
+                      content2[displayName] = "--";
+                    }
+                  }
+                });
+                if (!hasValidFields && properties && Object.keys(properties).length > 0) {
+                  console.log("配置的字段无效，显示所有属性:", properties);
+                  content2 = { ...properties };
+                }
+              } else {
+                content2 = properties;
+              }
+              console.log("最终popup内容:", content2);
+              const getPopupType = (config) => {
+                if (config.type) {
+                  return config.type;
+                }
+                if (config.fields && Array.isArray(config.fields)) {
+                  return "array";
+                }
+                if (config.htmlContent || config.content) {
+                  return "html";
+                }
+                if (config.images && Array.isArray(config.images)) {
+                  return "image";
+                }
+                return "array";
+              };
+              const popupType = getPopupType(popupConfig);
+              let finalConfig = {
+                title: popupConfig.title || layerName || "要素信息",
+                showCloseButton: true,
+                maxWidth: 300,
+                maxHeight: 400,
+                ...popupConfig
+              };
+              switch (popupType) {
+                case "array":
+                  finalConfig = {
+                    ...finalConfig,
+                    type: "array",
+                    fields: popupConfig.fields || Object.keys(properties).map((key) => ({ name: key, label: key, type: "text" })),
+                    data: [properties],
+                    vertical: true
+                  };
+                  break;
+                case "html":
+                  finalConfig = {
+                    ...finalConfig,
+                    type: "html",
+                    content: popupConfig.htmlContent || popupConfig.content || content2
+                  };
+                  break;
+                case "image":
+                  finalConfig = {
+                    ...finalConfig,
+                    type: "image",
+                    images: popupConfig.images || []
+                  };
+                  break;
+                default:
+                  finalConfig = {
+                    ...finalConfig,
+                    htmlContent: content2
+                  };
+                  break;
+              }
+              showPopup(popupType, finalConfig, coordinate);
+            }
+          }
+        }
+      }
     };
     const onFeatureClick = (feature2, layer2, clickCoordinate, mapCoordinate) => {
       let popupConfig = null;
@@ -478592,7 +479626,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const CustomOpenlayer = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-cb07ef9b"]]);
+const CustomOpenlayer = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-02822978"]]);
 var u8 = Uint8Array;
 var u16 = Uint16Array;
 var i32 = Int32Array;
@@ -486864,7 +487898,7 @@ function(t3) {
  */
 function(t3) {
   function e8() {
-    return (n.canvg ? Promise.resolve(n.canvg) : import("./index.es-a8e2a821.mjs")).catch(function(t4) {
+    return (n.canvg ? Promise.resolve(n.canvg) : import("./index.es-9e1aa406.mjs")).catch(function(t4) {
       return Promise.reject(new Error("Could not load canvg: " + t4));
     }).then(function(t4) {
       return t4.default ? t4.default : t4;