vue-openlayers-plugin 1.0.31 → 1.0.33

package/lib/index.umd.js

@@ -41707,7 +41707,7 @@ var __publicField = (obj, key, value) => {
       item
     );
   }
-  function proj4$2(fromProjOrToProj, toProjOrCoord, coord) {
+  function proj4$3(fromProjOrToProj, toProjOrCoord, coord) {
     var fromProj;
     var toProj;
     var single = false;
@@ -45707,7 +45707,7 @@ var __publicField = (obj, key, value) => {
     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"),
@@ -45720,6 +45720,10 @@ var __publicField = (obj, key, value) => {
     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;
@@ -45806,11 +45810,9 @@ var __publicField = (obj, key, value) => {
           "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;
@@ -45832,9 +45834,6 @@ var __publicField = (obj, key, value) => {
             pixel,
             originalEvent: event.originalEvent
           });
-          if (this.config.enableFeatureInfo) {
-            this.handleFeatureInfoQuery(coordinate, pixel);
-          }
         });
       }
       if (enabledEvents.includes("map:dblclick")) {
@@ -45911,23 +45910,6 @@ var __publicField = (obj, key, value) => {
       this.map.on(eventType, handler);
       this.listeners.set(key2, () => 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);
-      }
-    }
     /**
      * 防抖处理
      */
@@ -45982,12 +45964,6 @@ var __publicField = (obj, key, value) => {
     getMittEmitter() {
       return this.mittEmitter;
     }
-    /**
-     * 手动触发要素信息查询
-     */
-    async queryFeatureInfo(coordinate, pixel) {
-      return await this.layerManager.getFeatureInfoAtCoordinate(coordinate, {});
-    }
     /**
      * 更新配置
      */
@@ -69574,23 +69550,218 @@ ${this.attributes_.map(
         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(data2) {
+      try {
+        return btoa(encodeURIComponent(data2));
+      } catch {
+        return data2;
+      }
+    }
+    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 key2 in localStorage) {
+          if (localStorage.hasOwnProperty(key2)) {
+            used += localStorage[key2].length + key2.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(key2, 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(key2, 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(key2, compressedValue);
+              return true;
+            } catch {
+              console.error("清理后仍无法存储，数据过大或配额不足");
+              return false;
+            }
+          } else {
+            console.error("清理过程中存储失败，跳过重试");
+            return false;
+          }
+        }
+        console.error("存储失败:", error2);
+        return false;
+      }
+    }
+    /**
+     * 安全获取数据（带解压缩）
+     */
+    safeGetItem(key2) {
+      try {
+        const item = localStorage.getItem(key2);
+        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);
       }
@@ -69600,7 +69771,7 @@ ${this.attributes_.map(
      */
     getMeasurements() {
       try {
-        const data2 = localStorage.getItem(this.storageKeys.MEASUREMENTS);
+        const data2 = this.safeGetItem(this.storageKeys.MEASUREMENTS);
         return data2 ? JSON.parse(data2) : [];
       } catch (error2) {
         console.error("获取测量结果失败:", error2);
@@ -69633,18 +69804,31 @@ ${this.attributes_.map(
      */
     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);
       }
@@ -69654,7 +69838,7 @@ ${this.attributes_.map(
      */
     getLayerConfigs() {
       try {
-        const data2 = localStorage.getItem(this.storageKeys.LAYER_CONFIGS);
+        const data2 = this.safeGetItem(this.storageKeys.LAYER_CONFIGS);
         return data2 ? JSON.parse(data2) : [];
       } catch (error2) {
         console.error("获取图层配置失败:", error2);
@@ -69667,7 +69851,10 @@ ${this.attributes_.map(
     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);
       }
@@ -69677,7 +69864,7 @@ ${this.attributes_.map(
      */
     getMapState() {
       try {
-        const data2 = localStorage.getItem(this.storageKeys.MAP_STATE);
+        const data2 = this.safeGetItem(this.storageKeys.MAP_STATE);
         return data2 ? JSON.parse(data2) : null;
       } catch (error2) {
         console.error("获取地图状态失败:", error2);
@@ -69705,10 +69892,101 @@ ${this.attributes_.map(
       });
       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(data2) {
+      try {
+        if (data2.measurements) {
+          this.saveMeasurements(data2.measurements);
+        }
+        if (data2.layerConfigs) {
+          this.saveLayerConfigs(data2.layerConfigs);
+        }
+        if (data2.mapState) {
+          const { center: center2, zoom, rotation } = data2.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");
@@ -69808,7 +70086,7 @@ ${this.attributes_.map(
     }
     // 清除特定要素的测量结果标注
     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((node2) => {
         const nodeFeatureId = node2.get("parentFeatureId");
         return nodeFeatureId === featureId2;
@@ -69935,7 +70213,7 @@ ${this.attributes_.map(
       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,
@@ -69952,7 +70230,7 @@ ${this.attributes_.map(
         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,
@@ -81658,7 +81936,7 @@ ${this.attributes_.map(
           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;
             }
           });
@@ -81688,17 +81966,20 @@ ${this.attributes_.map(
      * 清除图层样式
      */
     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] = "";
             }
           });
@@ -81967,18 +82248,121 @@ ${this.attributes_.map(
     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 data2 = await response.json();
+        const features2 = this.parseFeatureInfoResponse(data2);
+        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: (key2) => properties[key2],
+            setProperties: (props) => {
+              Object.assign(properties, props);
+            }
+          };
+        });
+      } catch (error2) {
+        console.error("WMS GetFeatureInfo查询失败:", error2);
+        return [];
       }
-      return void 0;
+    }
+    /**
+     * 解析GetFeatureInfo响应数据
+     */
+    parseFeatureInfoResponse(data2) {
+      const features2 = [];
+      try {
+        if (data2.type === "FeatureCollection" && data2.features) {
+          return data2.features;
+        }
+        if (data2.type === "Feature") {
+          return [data2];
+        }
+        if (Array.isArray(data2)) {
+          return data2;
+        }
+        if (typeof data2 === "object" && data2 !== null) {
+          for (const key2 in data2) {
+            if (Array.isArray(data2[key2])) {
+              return data2[key2];
+            }
+          }
+          return [{
+            type: "Feature",
+            properties: data2,
+            geometry: null
+          }];
+        }
+      } catch (error2) {
+        console.error("解析WMS响应数据失败:", error2);
+      }
+      return features2;
     }
   }
   class WMTSLayerHandler extends BaseLayer$2 {
@@ -82990,8 +83374,7 @@ ${this.attributes_.map(
       view.fit(extent3, {
         padding: fitOptions.padding,
         maxZoom: fitOptions.maxZoom,
-        duration: fitOptions.duration,
-        minZoom: fitOptions.minZoom
+        duration: fitOptions.duration
       });
       console.log(`已定位到 ${features2.length} 个 GeoJSON 要素`);
     }
@@ -83319,7 +83702,7 @@ ${this.attributes_.map(
   }
   class GMLLayerHandler extends BaseLayer$2 {
     constructor(config, map2) {
-      super(config, map2);
+      super(config);
       __publicField(this, "vectorSource", null);
       __publicField(this, "gmlFormat", null);
       this.initializeGMLFormat();
@@ -83334,21 +83717,18 @@ ${this.attributes_.map(
         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;
@@ -84203,7 +84583,7 @@ ${this.attributes_.map(
      * 更新图层配置
      */
     updateLayerConfig(config) {
-      super.updateLayerConfig(config);
+      super.updateConfig(config);
       if (config.clusterDistance !== void 0) {
         this.setDistance(config.clusterDistance);
       }
@@ -463483,8 +463863,8 @@ ${this.attributes_.map(
       __publicField(this, "maxStyleApplyAttempts", 5);
     }
     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() {
@@ -463627,8 +464007,11 @@ ${this.attributes_.map(
         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}`);
@@ -463790,7 +464173,12 @@ ${this.attributes_.map(
       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 key2 of recreateConfigs) {
           if (newConfig[key2] !== void 0 && newConfig[key2] !== this.config[key2]) {
             needsRecreate = true;
@@ -463826,6 +464214,539 @@ ${this.attributes_.map(
         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$c([lon2, lat2]);
+      let smGeom = Util.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 FeatureService(serviceUrl).getFeaturesByGeometry(
+          queryParams,
+          (result) => {
+            var _a3, _b3, _c2;
+            if (result.error) {
+              console.error("iServer 错误:", result.error);
+              reject2(result.error);
+              return;
+            }
+            const features2 = ((_b3 = (_a3 = result.result) == null ? void 0 : _a3.features) == null ? void 0 : _b3.features) || [];
+            if (vectorLayer) {
+              (_c2 = vectorLayer.getSource()) == null ? void 0 : _c2.clear();
+              features2.forEach((f2) => {
+                var _a4;
+                const olFeat = new ol$1.Feature(Util.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$c([lon2, lat2]);
+        let smGeom = Util.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 FeatureService(serviceUrl).getFeaturesByBuffer(
+            bufferParams,
+            (serviceResult) => {
+              var _a3, _b3, _c2, _d, _e2;
+              console.log("serviceResult:", serviceResult);
+              if (serviceResult.error) {
+                console.error("iServer error:", serviceResult.error);
+                reject2(new Error("iServer 返回错误，详见控制台"));
+                return;
+              }
+              const feats = ((_c2 = (_b3 = (_a3 = serviceResult.result) == null ? void 0 : _a3.features) == null ? void 0 : _b3.features) == null ? void 0 : _c2.map(
+                (f2) => new ol$1.Feature(Util.toSuperMapGeometry(f2.geometry))
+              )) ?? [];
+              if (vectorLayer) {
+                (_d = vectorLayer.getSource()) == null ? void 0 : _d.clear();
+                if (feats.length) {
+                  (_e2 = vectorLayer.getSource()) == null ? void 0 : _e2.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) => {
+          const properties = feature2.getProperties() || {};
+          feature2.setProperties({
+            ...properties,
+            layerId: this.config.id,
+            layerName: this.config.name,
+            layerType: "supermap-rest"
+          });
+          return feature2;
+        });
+      } catch (error2) {
+        console.error("获取要素信息失败:", error2);
+        return [];
+      }
+    }
   }
   class CanvasLayerHandler extends BaseLayer$2 {
     constructor() {
@@ -463978,7 +464899,7 @@ ${this.attributes_.map(
      * 更新图层配置
      */
     updateLayerConfig(config) {
-      super.updateLayerConfig(config);
+      super.updateConfig(config);
       if (config.canvasConfig) {
         this.updateCanvasConfig(config.canvasConfig);
       }
@@ -464697,176 +465618,6 @@ ${this.attributes_.map(
     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 method2 = 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((key2) => {
-                    if (key2 !== "coordinate" && key2 !== "layer") {
-                      requestParams[key2] = customApi.params[key2];
-                    }
-                  });
-                }
-                const requestOptions = {
-                  method: method2,
-                  headers: {
-                    "Content-Type": "application/json"
-                  }
-                };
-                let finalUrl = requestUrl;
-                if (method2.toUpperCase() === "POST") {
-                  requestOptions.body = JSON.stringify(requestParams);
-                } else {
-                  const urlParams = new URLSearchParams();
-                  Object.keys(requestParams).forEach((key2) => {
-                    if (Array.isArray(requestParams[key2])) {
-                      urlParams.append(key2, requestParams[key2].join(","));
-                    } else {
-                      urlParams.append(key2, String(requestParams[key2]));
-                    }
-                  });
-                  finalUrl = `${requestUrl}?${urlParams.toString()}`;
-                }
-                const response = await fetch(finalUrl, requestOptions);
-                if (response.ok) {
-                  let data2 = await response.json();
-                  if (customApi.responseHandler) {
-                    try {
-                      const handlerFunc = new Function("data", `return (${customApi.responseHandler})(data)`);
-                      data2 = handlerFunc(data2);
-                    } catch (error2) {
-                      console.warn("自定义响应处理函数执行失败:", error2);
-                    }
-                  }
-                  const features2 = Array.isArray(data2) ? data2 : data2.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 data2 = await response.json();
-                  if (data2.features && data2.features.length > 0) {
-                    results.push({
-                      layerId,
-                      layerName: config.name,
-                      features: data2.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;
-    }
     /**
      * 设置图层可见性（支持按需加载）
      */
@@ -465166,6 +465917,98 @@ ${this.attributes_.map(
         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 [];
+      }
+    }
     /**
      * 销毁图层管理器
      */
@@ -465680,21 +466523,24 @@ ${this.attributes_.map(
         }
         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", {
@@ -465945,7 +466791,7 @@ ${this.attributes_.map(
       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();
@@ -465977,24 +466823,7 @@ ${this.attributes_.map(
           }
           (_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,
@@ -466124,7 +466953,7 @@ ${this.attributes_.map(
       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;
@@ -466211,6 +467040,9 @@ ${this.attributes_.map(
             emit("map-contextmenu", { coordinate, pixel });
           }
         });
+        mapManager.value.on("feature-info", (data2) => {
+          emit("feature-info", data2);
+        });
       };
       const updateMapConfig = (config) => {
         if (!map2.value)
@@ -466275,7 +467107,7 @@ ${this.attributes_.map(
       };
     }
   });
-  const MapContainer_vue_vue_type_style_index_0_scoped_53c8deda_lang = "";
+  const MapContainer_vue_vue_type_style_index_0_scoped_9900e920_lang = "";
   const _export_sfc = (sfc, props) => {
     const target = sfc.__vccOpts || sfc;
     for (const [key2, val] of props) {
@@ -466283,7 +467115,7 @@ ${this.attributes_.map(
     }
     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__ */ vue.defineComponent({
     __name: "index",
@@ -476240,6 +477072,10 @@ ${this.attributes_.map(
       };
       const initializeLayerManager = () => {
         if (layerManager.value) {
+          if (map2.value && layerManager.value) {
+            layerTreeManager.initialize(map2.value, layerManager.value);
+            layerConfigManager.initialize(layerManager.value);
+          }
           vue.nextTick(() => {
             if (layerManager.value) {
               layerManager.value.setLayersZIndexByOrder(1, 1);
@@ -476560,10 +477396,6 @@ ${this.attributes_.map(
         });
       };
       vue.onMounted(() => {
-        if (map2.value && layerManager.value) {
-          layerTreeManager.initialize(map2.value, layerManager.value);
-          layerConfigManager.initialize(layerManager.value);
-        }
         layerEventBus.on("basemap-changed", handleBasemapChanged);
         layerEventBus.on("basemap-switch-request", handleBasemapSwitchRequest);
       });
@@ -476704,8 +477536,8 @@ ${this.attributes_.map(
       };
     }
   });
-  const LayerPanel_vue_vue_type_style_index_0_scoped_2456ec00_lang = "";
-  const LayerPanel = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-2456ec00"]]);
+  const LayerPanel_vue_vue_type_style_index_0_scoped_6929b38c_lang = "";
+  const LayerPanel = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-6929b38c"]]);
   const _hoisted_1$4 = {
     key: 2,
     class: "tooltip-content"
@@ -476978,6 +477810,12 @@ ${this.attributes_.map(
         if (props.config.maxHeight) {
           style.maxHeight = typeof props.config.maxHeight === "number" ? `${props.config.maxHeight}px` : props.config.maxHeight;
         }
+        if (props.config.vertical) {
+          style.display = "flex";
+          style.flexDirection = "column";
+          style.minWidth = "200px";
+          style.maxWidth = style.maxWidth || "300px";
+        }
         return style;
       });
       const handleClose = () => {
@@ -477033,21 +477871,28 @@ ${this.attributes_.map(
           class: vue.normalizeClass([
             "ol-popup",
             `ol-popup-${position2.value}`,
+            { "ol-popup-vertical": _ctx.config.vertical },
             _ctx.config.className
           ]),
-          style: vue.normalizeStyle(popupStyle.value)
+          style: vue.normalizeStyle(popupStyle.value),
+          onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+          }, ["stop"])),
+          onMousedown: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+          }, ["stop"])),
+          onMouseup: _cache[2] || (_cache[2] = vue.withModifiers(() => {
+          }, ["stop"]))
         }, [
-          _cache[2] || (_cache[2] = vue.createElementVNode("div", { class: "ol-popup-tip" }, null, -1)),
+          _cache[5] || (_cache[5] = vue.createElementVNode("div", { class: "ol-popup-tip" }, null, -1)),
           _ctx.config.showCloseButton !== false ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), {
             key: 0,
             class: "ol-popup-closer",
-            onClick: handleClose,
+            onClick: vue.withModifiers(handleClose, ["stop"]),
             title: "关闭",
             text: "",
             circle: "",
             size: "small"
           }, {
-            default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
+            default: vue.withCtx(() => [..._cache[3] || (_cache[3] = [
               vue.createTextVNode(" × ", -1)
             ])]),
             _: 1
@@ -477062,17 +477907,17 @@ ${this.attributes_.map(
               coordinate: _ctx.coordinate,
               config: _ctx.config
             }, () => [
-              _cache[1] || (_cache[1] = vue.createElementVNode("div", { class: "ol-popup-default" }, [
+              _cache[4] || (_cache[4] = vue.createElementVNode("div", { class: "ol-popup-default" }, [
                 vue.createElementVNode("p", null, "请提供 popup 内容")
               ], -1))
             ], true)
           ], 512)
-        ], 6)) : vue.createCommentVNode("", true);
+        ], 38)) : vue.createCommentVNode("", true);
       };
     }
   });
-  const BasePopup_vue_vue_type_style_index_0_scoped_90f1b0a2_lang = "";
-  const BasePopup = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-90f1b0a2"]]);
+  const BasePopup_vue_vue_type_style_index_0_scoped_9a5b6333_lang = "";
+  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,
@@ -477883,8 +478728,8 @@ ${this.attributes_.map(
       };
     }
   });
-  const ArrayPopup_vue_vue_type_style_index_0_scoped_620d344e_lang = "";
-  const ArrayPopup = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-620d344e"]]);
+  const ArrayPopup_vue_vue_type_style_index_0_scoped_4a372183_lang = "";
+  const ArrayPopup = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-4a372183"]]);
   class PopupManager {
     constructor(map2, config = {}) {
       __publicField(this, "map");
@@ -477896,6 +478741,11 @@ ${this.attributes_.map(
         maxPopups: 5,
         autoClose: true,
         closeOnMapClick: true,
+        defaultConfig: {
+          vertical: true,
+          maxHeight: 300,
+          ...config.defaultConfig
+        },
         ...config
       };
       if (this.config.closeOnMapClick) {
@@ -478020,7 +478870,7 @@ ${this.attributes_.map(
         switch (type) {
           case "html":
             app = vue.createApp(HtmlPopup, {
-              config,
+              config: { ...this.config.defaultConfig, ...config },
               coordinate,
               feature: feature2,
               visible: true,
@@ -478029,7 +478879,7 @@ ${this.attributes_.map(
             break;
           case "image":
             app = vue.createApp(ImagePopup, {
-              config,
+              config: { ...this.config.defaultConfig, ...config },
               coordinate,
               feature: feature2,
               visible: true,
@@ -478038,7 +478888,7 @@ ${this.attributes_.map(
             break;
           case "array":
             app = vue.createApp(ArrayPopup, {
-              config,
+              config: { ...this.config.defaultConfig, ...config },
               coordinate,
               feature: feature2,
               visible: true,
@@ -478565,9 +479415,113 @@ ${this.attributes_.map(
         emit("zoom-change", zoom, oldZoom);
       };
       const onFeatureInfo = (data2) => {
-        emit("feature-info", data2);
+        if (data2 && data2.length > 0) {
+          const firstResult = data2[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 = feature2.properties || feature2;
+                let content2 = {};
+                if (popupConfig.fields && Array.isArray(popupConfig.fields)) {
+                  popupConfig.fields.forEach((field) => {
+                    if (typeof field === "string") {
+                      content2[field] = properties[field] || "--";
+                    } else if (field.name) {
+                      const displayName = field.label || field.name;
+                      content2[displayName] = properties[field.name] || "--";
+                    }
+                  });
+                } else {
+                  content2 = properties;
+                }
+                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((key2) => ({ name: key2, label: key2, 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;
+        const allLayers = [...finalMapConfig.value.baseLayers || [], ...finalMapConfig.value.overlayLayers || [], ...finalMapConfig.value.vectorLayers || []];
+        console.log("点击事件调试信息:");
+        console.log("layer对象:", layer2);
+        console.log("所有图层配置:", allLayers.map((l2) => ({ id: l2.id, name: l2.name, hasPopup: !!l2.popup })));
+        const targetLayer = allLayers.find((l2) => l2.id === layer2.values_.layerId || l2.name === layer2.layerName);
+        console.log("匹配到的图层:", targetLayer);
+        if (targetLayer && targetLayer.popup) {
+          popupConfig = targetLayer.popup;
+          console.log("找到popup配置:", popupConfig);
+        }
+        if (!popupConfig) {
+          console.log("没有找到popup配置，跳过显示");
+          emit("feature-click", feature2, layer2, clickCoordinate);
+          return;
+        }
         if (feature2 && layer2 && popupManager.value && clickCoordinate) {
           const coordinate = mapCoordinate || clickCoordinate;
           if (coordinate) {
@@ -478579,22 +479533,20 @@ ${this.attributes_.map(
             } else {
               properties = feature2;
             }
-            let popupConfig = null;
-            const allLayers = [...finalMapConfig.value.baseLayers || [], ...finalMapConfig.value.overlayLayers || [], ...finalMapConfig.value.vectorLayers || []];
-            const targetLayer = allLayers.find((l2) => l2.id === layer2.layerId || l2.name === layer2.layerName);
-            if (targetLayer && targetLayer.popup) {
-              popupConfig = targetLayer.popup;
-            }
+            const popupType = (popupConfig == null ? void 0 : popupConfig.type) || "array";
             if (popupConfig && popupConfig.fields) {
               popupManager.value.replacePopup(
-                "array",
+                popupType,
                 {
-                  type: "array",
+                  type: popupType,
                   title: (targetLayer == null ? void 0 : targetLayer.name) || layer2.layerName || "要素信息",
                   fields: popupConfig.fields,
                   data: [properties],
                   showCloseButton: true,
-                  maxWidth: 400
+                  maxWidth: 300,
+                  maxHeight: 400,
+                  vertical: true,
+                  ...popupConfig
                 },
                 coordinate,
                 feature2
@@ -478603,14 +479555,17 @@ ${this.attributes_.map(
               const fields = Object.keys(properties).filter((key2) => key2 !== "geometry").map((key2) => ({ name: key2, label: key2, type: "text" }));
               if (fields.length > 0) {
                 popupManager.value.replacePopup(
-                  "array",
+                  popupType,
                   {
-                    type: "array",
+                    type: popupType,
                     title: layer2.layerName || "要素信息",
                     fields,
                     data: [properties],
                     showCloseButton: true,
-                    maxWidth: 400
+                    maxWidth: 300,
+                    maxHeight: 400,
+                    vertical: true,
+                    ...popupConfig
                   },
                   coordinate,
                   feature2
@@ -479364,8 +480319,8 @@ ${this.attributes_.map(
       };
     }
   });
-  const index_vue_vue_type_style_index_0_scoped_7dc7f994_lang = "";
-  const CustomOpenlayer = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7dc7f994"]]);
+  const index_vue_vue_type_style_index_0_scoped_78070f98_lang = "";
+  const CustomOpenlayer = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-78070f98"]]);
   const base = "";
   var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
   var fleb = new u8([