augustine-jkmap 1.0.5 → 1.0.6

package/dist/augustine-jkmap.umd.js

@@ -3517,62 +3517,62 @@ function judgmentMapDataType(type = '') {
  * @returns {{x: number, y: number, spatialReference?: any} | null}
  */
 function parseToPoint(input) {
-  if (!input) return null
+  if (!input) return null;
 
   // 字符串 "lng,lat"
-  if (typeof input === 'string') {
-    const parts = input.split(',').map((s) => parseFloat(s.trim()))
+  if (typeof input === "string") {
+    const parts = input.split(",").map((s) => parseFloat(s.trim()));
     if (parts.length === 2 && !isNaN(parts[0]) && !isNaN(parts[1])) {
-      return { x: parts[0], y: parts[1] }
+      return { x: parts[0], y: parts[1] };
     }
   }
 
   // 数组 [x, y]
   if (Array.isArray(input) && input.length >= 2) {
-    const x = parseFloat(input[0])
-    const y = parseFloat(input[1])
+    const x = parseFloat(input[0]);
+    const y = parseFloat(input[1]);
     if (!isNaN(x) && !isNaN(y)) {
-      return { x, y }
+      return { x, y };
     }
   }
 
   // 对象 {x, y} 或 {longitude, latitude}
-  if (typeof input === 'object') {
-    let x, y
-    if ('x' in input && 'y' in input) {
-      x = parseFloat(input.x)
-      y = parseFloat(input.y)
-    } else if ('longitude' in input && 'latitude' in input) {
-      x = parseFloat(input.longitude)
-      y = parseFloat(input.latitude)
-    } else if ('lng' in input && 'lat' in input) {
-      x = parseFloat(input.lng)
-      y = parseFloat(input.lat)
+  if (typeof input === "object") {
+    let x, y;
+    if ("x" in input && "y" in input) {
+      x = parseFloat(input.x);
+      y = parseFloat(input.y);
+    } else if ("longitude" in input && "latitude" in input) {
+      x = parseFloat(input.longitude);
+      y = parseFloat(input.latitude);
+    } else if ("lng" in input && "lat" in input) {
+      x = parseFloat(input.lng);
+      y = parseFloat(input.lat);
     }
     if (!isNaN(x) && !isNaN(y)) {
-      return { x, y, spatialReference: input.spatialReference }
+      return { x, y, spatialReference: input.spatialReference };
     }
   }
 
-  return null
+  return null;
 }
 /**
  * 尝试将 esri/geometry/Point 转为普通对象
  */
 function tryConvertEsriPoint(obj) {
   // 检查是否有 toJSON 方法（esri geometry 标准）
-  if (obj && typeof obj.toJSON === 'function') {
+  if (obj && typeof obj.toJSON === "function") {
     try {
-      const json = obj.toJSON()
+      const json = obj.toJSON();
       // 验证是否为点（有 x 和 y）
-      if (typeof json.x === 'number' && typeof json.y === 'number') {
-        return obj // 已是标准 ArcGIS JSON
+      if (typeof json.x === "number" && typeof json.y === "number") {
+        return obj; // 已是标准 ArcGIS JSON
       }
     } catch (error) {
-      throw new Error(`esri.Point toJSON 失败: ${error}`)
+      throw new Error(`esri.Point toJSON 失败: ${error}`);
     }
   }
-  return null
+  return null;
 }
 /**
  * 将任意变量尝试转换为 ArcGIS 点格式 { x, y }
@@ -3584,56 +3584,60 @@ function tryConvertEsriPoint(obj) {
 function toArcGISPoint(crPoint, strict = true) {
   let x,
     y,
-    result = null
+    result = null;
   try {
     // 1. 检查 ArcGIS API 是否加载
     if (!window || !window.jkEsri || !window.jkEsri.Point) {
-      console.warn('[createText] ArcGIS API 未加载，跳过创建')
-      throw new Error('[createText] ArcGIS API 未加载，跳过创建')
+      console.warn("[createText] ArcGIS API 未加载，跳过创建");
+      throw new Error("[createText] ArcGIS API 未加载，跳过创建");
     }
     // 1. null / undefined
     if (isEmpty(crPoint)) {
-      throw new Error('转换异常,无经纬度点位数据')
+      throw new Error("转换异常,无经纬度点位数据");
     }
     // 2. 尝试作为 esri.Point 处理（优先级高）
-    result = tryConvertEsriPoint(crPoint)
+    result = tryConvertEsriPoint(crPoint);
     if (result) {
       // 成功解析为 {x, y, ...}
-      return result
+      return result;
     } else {
-      const transform_point = parseToPoint(crPoint)
+      const transform_point = parseToPoint(crPoint);
 
-      if (isEmpty(transform_point) || isEmpty(transform_point.x) || isEmpty(transform_point.y)) {
-        throw new Error('转换异常,无经纬度点位数据')
+      if (
+        isEmpty(transform_point) ||
+        isEmpty(transform_point.x) ||
+        isEmpty(transform_point.y)
+      ) {
+        throw new Error("转换异常,无经纬度点位数据");
       }
-      x = transform_point.x
-      y = transform_point.y
+      x = transform_point.x;
+      y = transform_point.y;
     }
     // 5. 仍未成功解析
     if (isNaN(x) || isNaN(y)) {
-      throw new Error('转换异常,无经纬度点位数据')
+      throw new Error("转换异常,无经纬度点位数据");
     }
     // 6. 【可选】经纬度范围校验
     if (strict) {
       if (x < -180 || x > 180) {
-        throw new Error('转换异常,x < -180 || x > 180')
+        throw new Error("转换异常,x < -180 || x > 180");
       }
       if (y < -90 || y > 90) {
-        throw new Error('转换异常,y < -90 || y > 90')
+        throw new Error("转换异常,y < -90 || y > 90");
       }
     }
-    let wkid = crPoint.wkid ? crPoint.wkid : Number(x) > 1000 ? 102100 : 4326
+    let wkid = crPoint.wkid ? crPoint.wkid : Number(x) > 1000 ? 102100 : 4326;
     // 7. 返回标准 ArcGIS 点
     return new window.jkEsri.Point(
       Number(x),
       Number(y),
       new window.jkEsri.SpatialReference({
-        wkid
+        wkid,
       })
-    )
+    );
   } catch (error) {
-    console.warn('error', error)
-    throw new Error(`转换异常:${error}`)
+    console.warn("error", error);
+    throw new Error(`转换异常:${error}`);
   }
 }
 /**
@@ -3655,18 +3659,24 @@ function toArcGISPoint(crPoint, strict = true) {
 function mapJump(view, target, options = { zoom: 16 }) {
   // 前置校验：ArcGIS API是否加载
   if (!window.jkEsri) {
-    return Promise.reject(new Error('[mapJump] ArcGIS API 未加载 (window.jkEsri missing)'))
+    return Promise.reject(
+      new Error("[mapJump] ArcGIS API 未加载 (window.jkEsri missing)")
+    );
   }
   // 前置校验：view有效性
-  if (!view || typeof view.goTo !== 'function') {
-    return Promise.reject(new Error('[mapJump] 无效的 view 对象（缺少 goTo 方法）'))
+  if (!view || typeof view.goTo !== "function") {
+    return Promise.reject(
+      new Error("[mapJump] 无效的 view 对象（缺少 goTo 方法）")
+    );
   }
 
   // 视图类型判断
-  const isScene = view.declaredClass === 'esri.views.SceneView'
-  const isMap = view.declaredClass === 'esri.views.MapView'
+  const isScene = view.declaredClass === "esri.views.SceneView";
+  const isMap = view.declaredClass === "esri.views.MapView";
   if (!isScene && !isMap) {
-    return Promise.reject(new Error(`[mapJump] 不支持的 view 类型: ${view.declaredClass}`))
+    return Promise.reject(
+      new Error(`[mapJump] 不支持的 view 类型: ${view.declaredClass}`)
+    );
   }
 
   // 合并配置项（新增重试、动画默认优化）
@@ -3674,16 +3684,22 @@ function mapJump(view, target, options = { zoom: 16 }) {
     {
       padding: 20,
       animate: false, // 单点跳转默认关闭动画，减少中断（核心优化）
-      pointZoom: Math.max(1, Math.min(20, options?.pointZoom || 15)), // 限制缩放级别范围
-      pointScale: Math.max(100, Math.min(100000, options?.pointScale || 5000)), // 限制相机高度
+      pointZoom: Math.max(
+        1,
+        Math.min(20, options.pointZoom ? options.pointZoom : 15)
+      ), // 限制缩放级别范围
+      pointScale: Math.max(
+        100,
+        Math.min(100000, options.pointScale ? options.pointScale : 5000)
+      ), // 限制相机高度
       fallbackExtent: null,
-      retryTimes: 1 // 中断时重试1次
+      retryTimes: 1, // 中断时重试1次
     },
     options
-  )
+  );
 
   // 防抖标记：避免短时间多次调用
-  let isJumping = false
+  let isJumping = false;
   /**
    * 工具函数：等待视图就绪（核心！解决视图未加载完成导致的中断）
    * @returns {Promise<void>}
@@ -3691,11 +3707,11 @@ function mapJump(view, target, options = { zoom: 16 }) {
   function waitViewReady() {
     return new Promise((resolve) => {
       if (view.ready) {
-        resolve()
+        resolve();
       } else {
-        view.when(() => resolve())
+        view.when(() => resolve());
       }
-    })
+    });
   }
 
   /**
@@ -3704,19 +3720,19 @@ function mapJump(view, target, options = { zoom: 16 }) {
    * @returns {__esri.Geometry} 转换后的几何
    */
   function projectGeometry(geom) {
-    if (!geom || !geom.spatialReference) return geom
+    if (!geom || !geom.spatialReference) return geom;
 
     // 空间参考一致，无需转换
     if (geom.spatialReference.wkid === view.spatialReference.wkid) {
-      return geom
+      return geom;
     }
 
     try {
       // 使用ArcGIS投影工具转换空间参考
-      return window.jkEsri.geometry.project(geom, view.spatialReference)
+      return window.jkEsri.geometry.project(geom, view.spatialReference);
     } catch (e) {
-      console.warn('[projectGeometry] 空间参考转换失败，使用原几何:', e)
-      return geom
+      console.warn("[projectGeometry] 空间参考转换失败，使用原几何:", e);
+      return geom;
     }
   }
 
@@ -3726,9 +3742,9 @@ function mapJump(view, target, options = { zoom: 16 }) {
    * @returns {boolean}
    */
   function isPointGeometry(geometry) {
-    if (!geometry) return false
-    const type = geometry.type || (geometry.x && geometry.y ? 'point' : '')
-    return type === 'point' || type === 'multipoint'
+    if (!geometry) return false;
+    const type = geometry.type || (geometry.x && geometry.y ? "point" : "");
+    return type === "point" || type === "multipoint";
   }
 
   /**
@@ -3737,77 +3753,81 @@ function mapJump(view, target, options = { zoom: 16 }) {
    * @returns {__esri.Geometry | null}
    */
   function toEsriGeometry(geomJson) {
-    if (!geomJson) return null
+    if (!geomJson) return null;
 
     // 已是API实例，直接返回
-    if (geomJson.toJSON && typeof geomJson.toJSON === 'function') {
-      return geomJson
+    if (geomJson.toJSON && typeof geomJson.toJSON === "function") {
+      return geomJson;
     }
 
     // 提取几何类型（兼容纯JSON无type字段的Point）
-    let geomType = geomJson.type
+    let geomType = geomJson.type;
     if (!geomType && geomJson.x !== undefined && geomJson.y !== undefined) {
-      geomType = 'point'
+      geomType = "point";
     }
-    if (!geomType) return null
+    if (!geomType) return null;
 
     // 统一空间参考（优先用几何自身的，无则用视图的）
-    const sr = geomJson.spatialReference || view.spatialReference
+    const sr = geomJson.spatialReference || view.spatialReference;
 
     try {
       // 1. 点（核心：校验坐标合法性，避免NaN导致中断）
-      if (geomType === 'point') {
-        const x = Number(geomJson.x)
-        const y = Number(geomJson.y)
+      if (geomType === "point") {
+        const x = Number(geomJson.x);
+        const y = Number(geomJson.y);
         // 坐标合法性校验（关键！NaN会导致goTo中断）
         if (isNaN(x) || isNaN(y)) {
-          console.error('[toEsriGeometry] 点坐标非法:', geomJson)
-          return null
+          console.error("[toEsriGeometry] 点坐标非法:", geomJson);
+          return null;
         }
         return new window.jkEsri.Point({
           x,
           y,
           z: geomJson.z ? Number(geomJson.z) : undefined,
-          spatialReference: sr
-        })
-      } else if (geomType === 'multipoint') {
+          spatialReference: sr,
+        });
+      } else if (geomType === "multipoint") {
         return new window.jkEsri.MultiPoint({
-          points: geomJson.points?.map((pt) => pt.map(Number)) || [],
-          spatialReference: sr
-        })
+          points: geomJson.points.map((pt) => pt.map(Number)) || [],
+          spatialReference: sr,
+        });
       }
 
       // 2. 线/多线
-      else if (geomType === 'polyline' || geomType === 'multipolyline') {
+      else if (geomType === "polyline" || geomType === "multipolyline") {
         return new window.jkEsri.Polyline({
-          paths: geomJson.paths?.map((path) => path.map((pt) => pt.map(Number))) || [],
-          spatialReference: sr
-        })
+          paths:
+            geomJson.paths.map((path) => path.map((pt) => pt.map(Number))) ||
+            [],
+          spatialReference: sr,
+        });
       }
 
       // 3. 面/多面
-      else if (geomType === 'polygon' || geomType === 'multipolygon') {
+      else if (geomType === "polygon" || geomType === "multipolygon") {
         return new window.jkEsri.Polygon({
-          rings: geomJson.rings?.map((ring) => ring.map((pt) => pt.map(Number))) || [],
-          spatialReference: sr
-        })
+          rings:
+            geomJson.rings.map((ring) => ring.map((pt) => pt.map(Number))) ||
+            [],
+          spatialReference: sr,
+        });
       }
 
       // 4. 范围
-      else if (geomType === 'extent') {
+      else if (geomType === "extent") {
         return new window.jkEsri.Extent({
           xmin: Number(geomJson.xmin),
           ymin: Number(geomJson.ymin),
           xmax: Number(geomJson.xmax),
           ymax: Number(geomJson.ymax),
-          spatialReference: sr
-        })
+          spatialReference: sr,
+        });
       }
 
-      return null
+      return null;
     } catch (e) {
-      console.warn(`[toEsriGeometry] 转换${geomType}失败:`, e)
-      return null
+      console.warn(`[toEsriGeometry] 转换${geomType}失败:`, e);
+      return null;
     }
   }
 
@@ -3817,30 +3837,30 @@ function mapJump(view, target, options = { zoom: 16 }) {
    * @returns {__esri.Extent | null}
    */
   function getGeometryExtent(geom) {
-    if (!geom) return null
+    if (!geom) return null;
 
     // 步骤1：转换为API实例（解决纯JSON无extent问题）
-    const esriGeom = toEsriGeometry(geom)
-    if (!esriGeom) return null
+    const esriGeom = toEsriGeometry(geom);
+    if (!esriGeom) return null;
 
     // 步骤2：API实例自带extent，直接返回
     if (esriGeom.extent) {
-      return esriGeom.extent
+      return esriGeom.extent;
     }
 
     // 步骤3：极端降级 - 手动构建Point的范围（x/y相同）
-    if (esriGeom.type === 'point') {
+    if (esriGeom.type === "point") {
       return new window.jkEsri.Extent({
         xmin: esriGeom.x,
         ymin: esriGeom.y,
         xmax: esriGeom.x,
         ymax: esriGeom.y,
-        spatialReference: esriGeom.spatialReference
-      })
+        spatialReference: esriGeom.spatialReference,
+      });
     }
 
-    console.warn('[getGeometryExtent] 无法获取几何范围:', geom)
-    return null
+    console.warn("[getGeometryExtent] 无法获取几何范围:", geom);
+    return null;
   }
 
   /**
@@ -3849,42 +3869,45 @@ function mapJump(view, target, options = { zoom: 16 }) {
    * @returns {__esri.Extent | null}
    */
   function computeExtentFromGraphics(graphics) {
-    if (!graphics || graphics.length === 0) return null
+    if (!graphics || graphics.length === 0) return null;
 
-    const validExtents = []
+    const validExtents = [];
     for (const graphic of graphics) {
       // 跳过无几何的无效图形
       if (!graphic || !graphic.geometry) {
-        console.warn('[computeExtentFromGraphics] 跳过无几何的图形:', graphic)
-        continue
+        console.warn("[computeExtentFromGraphics] 跳过无几何的图形:", graphic);
+        continue;
       }
 
       // 获取单个图形的有效范围（自动转换纯JSON几何）
-      const extent = getGeometryExtent(graphic.geometry)
+      const extent = getGeometryExtent(graphic.geometry);
       if (extent) {
-        validExtents.push(extent)
+        validExtents.push(extent);
       } else {
-        console.warn('[computeExtentFromGraphics] 图形几何无有效范围:', graphic.geometry)
+        console.warn(
+          "[computeExtentFromGraphics] 图形几何无有效范围:",
+          graphic.geometry
+        );
       }
     }
 
     // 无有效范围
     if (validExtents.length === 0) {
-      console.error('[computeExtentFromGraphics] 所有图形均无有效范围！')
-      return null
+      console.error("[computeExtentFromGraphics] 所有图形均无有效范围！");
+      return null;
     }
 
     // 单个范围直接返回
     if (validExtents.length === 1) {
-      return validExtents[0]
+      return validExtents[0];
     }
 
     // 合并多个范围（点/线/面混合也能正确union）
-    let combinedExtent = validExtents[0]
+    let combinedExtent = validExtents[0];
     for (let i = 1; i < validExtents.length; i++) {
-      combinedExtent = combinedExtent.union(validExtents[i])
+      combinedExtent = combinedExtent.union(validExtents[i]);
     }
-    return combinedExtent
+    return combinedExtent;
   }
 
   /**
@@ -3893,29 +3916,29 @@ function mapJump(view, target, options = { zoom: 16 }) {
    * @returns {Object|null}
    */
   function parseToPoint(target) {
-    if (!target) return null
+    if (!target) return null;
 
     // {x,y}格式
     if (target.x !== undefined && target.y !== undefined) {
-      const x = Number(target.x)
-      const y = Number(target.y)
-      return !isNaN(x) && !isNaN(y) ? { x, y } : null
+      const x = Number(target.x);
+      const y = Number(target.y);
+      return !isNaN(x) && !isNaN(y) ? { x, y } : null;
     }
 
     // [x,y]数组格式
     if (Array.isArray(target) && target.length >= 2) {
-      const x = Number(target[0])
-      const y = Number(target[1])
-      return !isNaN(x) && !isNaN(y) ? { x, y } : null
+      const x = Number(target[0]);
+      const y = Number(target[1]);
+      return !isNaN(x) && !isNaN(y) ? { x, y } : null;
     }
 
     // "lng,lat"字符串格式
-    if (typeof target === 'string' && target.includes(',')) {
-      const [x, y] = target.split(',').map(Number)
-      return !isNaN(x) && !isNaN(y) ? { x, y } : null
+    if (typeof target === "string" && target.includes(",")) {
+      const [x, y] = target.split(",").map(Number);
+      return !isNaN(x) && !isNaN(y) ? { x, y } : null;
     }
 
-    return null
+    return null;
   }
 
   /**
@@ -3928,62 +3951,65 @@ function mapJump(view, target, options = { zoom: 16 }) {
   async function doGoToWithRetry(targetGeom, isPointType, retryLeft) {
     // 防抖：已有跳转中，直接中断
     if (isJumping) {
-      throw new Error('[mapJump] 前一次跳转未完成，中断本次操作')
+      throw new Error("[mapJump] 前一次跳转未完成，中断本次操作");
     }
 
     try {
-      isJumping = true
+      isJumping = true;
       // 步骤1：等待视图就绪
-      await waitViewReady()
+      await waitViewReady();
 
       // 步骤2：强制转换空间参考（解决4326/3857不匹配）
-      const projectedGeom = projectGeometry(targetGeom)
+      const projectedGeom = projectGeometry(targetGeom);
       if (!projectedGeom) {
-        throw new Error('[mapJump] 空间参考转换后几何无效')
+        throw new Error("[mapJump] 空间参考转换后几何无效");
       }
 
       // 步骤3：构建goTo配置（优化动画/缩放参数，减少中断）
       const goToOptions = {
         animate: opts.animate,
         // 新增：延长动画时间，避免快速中断（单点建议关闭动画）
-        duration: opts.animate ? 500 : 0
-      }
+        duration: opts.animate ? 500 : 0,
+      };
 
       // MapView配置：限制缩放级别在有效范围（1-20）
       if (isMap) {
         if (isPointType) {
-          goToOptions.zoom = Math.max(1, Math.min(20, opts.pointZoom))
+          goToOptions.zoom = Math.max(1, Math.min(20, opts.pointZoom));
         } else {
-          goToOptions.padding = opts.padding
+          goToOptions.padding = opts.padding;
         }
       }
       // SceneView配置：限制scale在合理范围
       else if (isScene) {
         if (isPointType) {
-          goToOptions.scale = Math.max(100, opts.pointScale)
+          goToOptions.scale = Math.max(100, opts.pointScale);
           // 新增：SceneView单点跳转强制设置target为相机位置，减少中断
           goToOptions.target = {
             position: projectedGeom,
-            scale: goToOptions.scale
-          }
+            scale: goToOptions.scale,
+          };
         }
       }
 
       // 步骤4：执行跳转（捕获interrupted错误）
       try {
-        await view.goTo(projectedGeom, goToOptions)
+        await view.goTo(projectedGeom, goToOptions);
       } catch (gotoErr) {
         // 捕获Goto was interrupted错误，重试
-        if (gotoErr.message.includes('interrupted') && retryLeft > 0) {
-          console.warn(`[mapJump] 跳转中断，剩余重试次数: ${retryLeft}`, gotoErr)
+        if (gotoErr.message.includes("interrupted") && retryLeft > 0) {
+          console.warn(
+            `[mapJump] 跳转中断，剩余重试次数: ${retryLeft}`,
+            gotoErr
+          );
           // 延迟50ms重试，避免连续中断
-          await new Promise((resolve) => setTimeout(resolve, 50))
-          return doGoToWithRetry(targetGeom, isPointType, retryLeft - 1)
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          return doGoToWithRetry(targetGeom, isPointType, retryLeft - 1);
         }
-        throw gotoErr
+        throw gotoErr;
       }
     } finally {
-      isJumping = false // 重置防抖标记
+      isJumping = false; // 重置防抖标记
     }
   }
 
@@ -3994,215 +4020,240 @@ function mapJump(view, target, options = { zoom: 16 }) {
    */
   function getWMXLayerExtent(layer) {
     // 优先读取图层内置范围
-    if (layer.fullExtent) return layer.fullExtent
-    if (layer.extent) return layer.extent
-    if (layer.tileInfo?.fullExtent) return layer.tileInfo.fullExtent
-    if (layer.initialExtent) return layer.initialExtent
+    if (layer.fullExtent) return layer.fullExtent;
+    if (layer.extent) return layer.extent;
+    if (layer.tileInfo.fullExtent) return layer.tileInfo.fullExtent;
+    if (layer.initialExtent) return layer.initialExtent;
 
     // 解析URL中的BBOX参数（WMS标准）
     if (layer.url) {
       try {
-        const urlObj = new URL(layer.url)
-        const bbox = urlObj.searchParams.get('BBOX') || urlObj.searchParams.get('bbox')
+        const urlObj = new URL(layer.url);
+        const bbox =
+          urlObj.searchParams.get("BBOX") || urlObj.searchParams.get("bbox");
         if (bbox) {
-          const [xmin, ymin, xmax, ymax] = bbox.split(',').map(Number)
+          const [xmin, ymin, xmax, ymax] = bbox.split(",").map(Number);
           if (!isNaN(xmin) && !isNaN(ymin) && !isNaN(xmax) && !isNaN(ymax)) {
             return new window.jkEsri.Extent({
               xmin,
               ymin,
               xmax,
               ymax,
-              spatialReference: layer.spatialReference || view.spatialReference
-            })
+              spatialReference: layer.spatialReference || view.spatialReference,
+            });
           }
         }
       } catch (e) {
-        console.warn('[getWMXLayerExtent] 解析URL BBOX失败:', e)
+        console.warn("[getWMXLayerExtent] 解析URL BBOX失败:", e);
       }
     }
 
     // 兜底范围
-    return opts.fallbackExtent
+    return opts.fallbackExtent;
   }
 
   // 主逻辑：Promise封装，统一处理所有目标类型
   return new Promise(async (resolve, reject) => {
-    let targetGeometry = null // 最终解析的几何实例
-    let isPointType = false // 是否为点类几何
+    let targetGeometry = null; // 最终解析的几何实例
+    let isPointType = false; // 是否为点类几何
 
     try {
       // 等待视图就绪（前置校验）
-      await waitViewReady()
+      await waitViewReady();
 
       // ========== 分支1：处理图层对象 ==========
       if (
         target &&
-        typeof target === 'object' &&
+        typeof target === "object" &&
         target.declaredClass &&
-        target.declaredClass.endsWith('Layer')
+        target.declaredClass.endsWith("Layer")
       ) {
-        const layer = target
+        const layer = target;
 
         // 1.1 图形图层（GraphicsLayer）
-        if (layer.declaredClass === 'esri.layers.GraphicsLayer') {
-          const graphics = layer.graphics.toArray()
+        if (layer.declaredClass === "esri.layers.GraphicsLayer") {
+          const graphics = layer.graphics.toArray();
           if (graphics.length === 0) {
-            reject(new Error('[mapJump] GraphicsLayer 无有效图形'))
-            return
+            reject(new Error("[mapJump] GraphicsLayer 无有效图形"));
+            return;
           }
 
           // 单个图形且为点类 → 按点跳转
           if (graphics.length === 1 && isPointGeometry(graphics[0].geometry)) {
-            await doGoToWithRetry(graphics[0].geometry, true, opts.retryTimes)
-            resolve()
-            return
+            await doGoToWithRetry(graphics[0].geometry, true, opts.retryTimes);
+            resolve();
+            return;
           }
 
           // 多个图形/线/面 → 计算合并范围
-          const layerExtent = computeExtentFromGraphics(graphics)
+          const layerExtent = computeExtentFromGraphics(graphics);
           if (layerExtent) {
-            await doGoToWithRetry(layerExtent, false, opts.retryTimes)
-            resolve()
+            await doGoToWithRetry(layerExtent, false, opts.retryTimes);
+            resolve();
           } else {
             // 兜底1：取第一个有效图形
-            const firstValid = graphics.find((g) => g.geometry && getGeometryExtent(g.geometry))
+            const firstValid = graphics.find(
+              (g) => g.geometry && getGeometryExtent(g.geometry)
+            );
             if (firstValid) {
               await doGoToWithRetry(
                 firstValid.geometry,
                 isPointGeometry(firstValid.geometry),
                 opts.retryTimes
-              )
-              resolve()
+              );
+              resolve();
             }
             // 兜底2：使用配置的兜底范围
             else if (opts.fallbackExtent) {
-              await doGoToWithRetry(opts.fallbackExtent, false, opts.retryTimes)
-              resolve()
+              await doGoToWithRetry(
+                opts.fallbackExtent,
+                false,
+                opts.retryTimes
+              );
+              resolve();
             }
             // 最终兜底：报错
             else {
-              reject(new Error('[mapJump] 无法从GraphicsLayer计算有效范围，且无兜底范围'))
+              reject(
+                new Error(
+                  "[mapJump] 无法从GraphicsLayer计算有效范围，且无兜底范围"
+                )
+              );
             }
           }
-          return
+          return;
         }
 
         // 1.2 WMS/WMTS图层
         if (
-          layer.declaredClass === 'esri.layers.WMSLayer' ||
-          layer.declaredClass === 'esri.layers.WMTSLayer'
+          layer.declaredClass === "esri.layers.WMSLayer" ||
+          layer.declaredClass === "esri.layers.WMTSLayer"
         ) {
           // 图层未加载则先加载
           if (!layer.loaded) {
-            await layer.load()
+            await layer.load();
           }
-          const extent = getWMXLayerExtent(layer)
+          const extent = getWMXLayerExtent(layer);
           if (extent) {
-            await doGoToWithRetry(extent, false, opts.retryTimes)
-            resolve()
+            await doGoToWithRetry(extent, false, opts.retryTimes);
+            resolve();
           } else {
-            reject(new Error(`WM${layer.declaredClass.includes('WMS') ? 'S' : 'TS'}图层无有效范围`))
+            reject(
+              new Error(
+                `WM${
+                  layer.declaredClass.includes("WMS") ? "S" : "TS"
+                }图层无有效范围`
+              )
+            );
           }
-          return
+          return;
         }
 
         // 1.3 服务图层（FeatureLayer/TileLayer等，支持queryExtent）
-        if (typeof layer.queryExtent === 'function') {
+        if (typeof layer.queryExtent === "function") {
           if (!layer.loaded) {
-            await layer.load()
+            await layer.load();
           }
-          const res = await layer.queryExtent()
-          if (res?.extent) {
-            await doGoToWithRetry(res.extent, false, opts.retryTimes)
-            resolve()
+          const res = await layer.queryExtent();
+          if (res.extent) {
+            await doGoToWithRetry(res.extent, false, opts.retryTimes);
+            resolve();
           } else {
-            reject(new Error('服务图层查询范围为空'))
+            reject(new Error("服务图层查询范围为空"));
           }
-          return
+          return;
         }
 
         // 1.4 普通图层（无queryExtent，用fullExtent）
         if (layer.fullExtent) {
-          await doGoToWithRetry(layer.fullExtent, false, opts.retryTimes)
-          resolve()
-          return
+          await doGoToWithRetry(layer.fullExtent, false, opts.retryTimes);
+          resolve();
+          return;
         }
 
         // 不支持的图层类型
-        reject(new Error(`[mapJump] 不支持的图层类型: ${layer.declaredClass}`))
-        return
+        reject(new Error(`[mapJump] 不支持的图层类型: ${layer.declaredClass}`));
+        return;
       }
 
       // ========== 分支2：处理图形数组（API实例/纯JSON） ==========
       if (Array.isArray(target) && target.length > 0) {
         // 判断是否为Graphic数组（含纯JSON）
-        const isGraphicArray = target.every((item) => item.geometry)
+        const isGraphicArray = target.every((item) => item.geometry);
         if (isGraphicArray) {
           // 单个图形且为点类 → 按点跳转
           if (target.length === 1 && isPointGeometry(target[0].geometry)) {
-            targetGeometry = toEsriGeometry(target[0].geometry)
+            targetGeometry = toEsriGeometry(target[0].geometry);
             if (!targetGeometry) {
-              reject(new Error('单个图形几何无效'))
-              return
+              reject(new Error("单个图形几何无效"));
+              return;
             }
-            await doGoToWithRetry(targetGeometry, true, opts.retryTimes)
-            resolve()
-            return
+            await doGoToWithRetry(targetGeometry, true, opts.retryTimes);
+            resolve();
+            return;
           }
 
           // 多个图形/线/面 → 计算合并范围
-          const graphicsExtent = computeExtentFromGraphics(target)
+          const graphicsExtent = computeExtentFromGraphics(target);
           if (graphicsExtent) {
-            await doGoToWithRetry(graphicsExtent, false, opts.retryTimes)
-            resolve()
+            await doGoToWithRetry(graphicsExtent, false, opts.retryTimes);
+            resolve();
           } else {
             // 兜底1：取第一个有效图形
-            const firstValid = target.find((item) => item.geometry && toEsriGeometry(item.geometry))
+            const firstValid = target.find(
+              (item) => item.geometry && toEsriGeometry(item.geometry)
+            );
             if (firstValid) {
-              targetGeometry = toEsriGeometry(firstValid.geometry)
+              targetGeometry = toEsriGeometry(firstValid.geometry);
               await doGoToWithRetry(
                 targetGeometry,
                 isPointGeometry(firstValid.geometry),
                 opts.retryTimes
-              )
-              resolve()
+              );
+              resolve();
             }
             // 兜底2：兜底范围
             else if (opts.fallbackExtent) {
-              await doGoToWithRetry(opts.fallbackExtent, false, opts.retryTimes)
-              resolve()
+              await doGoToWithRetry(
+                opts.fallbackExtent,
+                false,
+                opts.retryTimes
+              );
+              resolve();
             }
             // 最终兜底
             else {
-              reject(new Error('[mapJump] 无法从图形数组计算有效范围，且无兜底范围'))
+              reject(
+                new Error("[mapJump] 无法从图形数组计算有效范围，且无兜底范围")
+              );
             }
           }
-          return
+          return;
         }
       }
 
       // ========== 分支3：处理单个Graphic（API实例/纯JSON） ==========
       if (target && target.geometry) {
-        targetGeometry = toEsriGeometry(target.geometry)
-        isPointType = isPointGeometry(target.geometry)
+        targetGeometry = toEsriGeometry(target.geometry);
+        isPointType = isPointGeometry(target.geometry);
       }
 
       // ========== 分支4：处理几何对象（API实例/纯JSON） ==========
       else if (target && (target.type || (target.x && target.y))) {
-        targetGeometry = toEsriGeometry(target)
-        isPointType = isPointGeometry(target)
+        targetGeometry = toEsriGeometry(target);
+        isPointType = isPointGeometry(target);
       }
 
       // ========== 分支5：处理普通坐标格式 ==========
       else {
-        const pointObj = parseToPoint(target)
+        const pointObj = parseToPoint(target);
         if (pointObj) {
           targetGeometry = new window.jkEsri.Point({
             x: pointObj.x,
             y: pointObj.y,
-            spatialReference: view.spatialReference
-          })
-          isPointType = true
+            spatialReference: view.spatialReference,
+          });
+          isPointType = true;
         }
       }
 
@@ -4214,18 +4265,18 @@ function mapJump(view, target, options = { zoom: 16 }) {
           2. 几何对象：Point/MultiPoint/Polyline/MultiPolyline/Polygon/MultiPolygon/Extent（API实例/纯JSON）
           3. 图形对象：Graphic / 纯JSON Graphic / Graphic[] / 纯JSON Graphic[]
           4. 图层对象：Layer（FeatureLayer/WMSLayer/WMTSLayer等）`)
-        )
-        return
+        );
+        return;
       }
 
       // 执行跳转（带重试）
-      await doGoToWithRetry(targetGeometry, isPointType, opts.retryTimes)
-      resolve()
+      await doGoToWithRetry(targetGeometry, isPointType, opts.retryTimes);
+      resolve();
     } catch (e) {
       // 捕获所有异常
-      reject(new Error(`[mapJump] 执行失败: ${e.message}`))
+      reject(new Error(`[mapJump] 执行失败: ${e.message}`));
     }
-  })
+  });
 }
 
 
@@ -4240,10 +4291,10 @@ function mapJump(view, target, options = { zoom: 16 }) {
  * @returns
  */
 function judgeLayerType(type) {
-  if (!type) return
-  if (type.includes('oint')) return 'point'
-  if (type.includes('olygon')) return 'polygon'
-  if (type.includes('ine')) return 'polyline'
+  if (!type) return;
+  if (type.includes("oint")) return "point";
+  if (type.includes("olygon")) return "polygon";
+  if (type.includes("ine")) return "polyline";
 }
 /**
  * TextSymbol 符号
@@ -4259,16 +4310,20 @@ function judgeLayerType(type) {
  */
 function getTextSymbol(options) {
   try {
-    const text = options.mapText || '暂无描述'
-    const fontSize = isFinite(options.fontSize) ? Number(options.fontSize) : 10
-    const color = (typeof options.color === 'string' && options.color) || 'red'
-    const haloColor = (typeof options.haloColor === 'string' && options.haloColor) || 'black'
-    const haloSize = typeof options.haloSize !== 'undefined' ? String(options.haloSize) : '1px'
-    const xoffset = isFinite(options.xoffset) ? Number(options.xoffset) : 3
-    const yoffset = isFinite(options.yoffset) ? Number(options.yoffset) : 3
+    const text = options.mapText || "暂无描述";
+    const fontSize = isFinite(options.fontSize) ? Number(options.fontSize) : 10;
+    const color = (typeof options.color === "string" && options.color) || "red";
+    const haloColor =
+      (typeof options.haloColor === "string" && options.haloColor) || "black";
+    const haloSize =
+      typeof options.haloSize !== "undefined"
+        ? String(options.haloSize)
+        : "1px";
+    const xoffset = isFinite(options.xoffset) ? Number(options.xoffset) : 3;
+    const yoffset = isFinite(options.yoffset) ? Number(options.yoffset) : 3;
     return {
-      type: 'text',
-      text: String(text ?? ''),
+      type: "text",
+      text: String(text ?? ""),
       color: color,
       haloColor: haloColor,
       haloSize: haloSize,
@@ -4276,21 +4331,21 @@ function getTextSymbol(options) {
       yoffset: yoffset,
       font: {
         size: fontSize,
-        weight: 'bold'
-      }
-    }
+        weight: "bold",
+      },
+    };
   } catch (e) {
-    console.error('[getTextSymbol] 生成 symbol 失败，使用默认值:', e)
+    console.error("[getTextSymbol] 生成 symbol 失败，使用默认值:", e);
     return {
-      type: 'text',
-      text: '暂无标注',
-      color: 'red',
-      haloColor: 'black',
-      haloSize: '1px',
+      type: "text",
+      text: "暂无标注",
+      color: "red",
+      haloColor: "black",
+      haloSize: "1px",
       xoffset: 3,
       yoffset: 3,
-      font: { size: 10, weight: 'bold' }
-    }
+      font: { size: 10, weight: "bold" },
+    };
   }
 }
 /**
@@ -4308,24 +4363,28 @@ function getSimpleMarkerSymbol(options) {
   try {
     // 1. 检查 ArcGIS API 是否加载
     if (!window || !window.jkEsri || !window.jkEsri.SimpleMarkerSymbol) {
-      console.error('[getSimpleMarkerSymbol] ArcGIS API-SimpleMarkerSymbol 未加载，跳过创建')
-      return null
+      console.error(
+        "[getSimpleMarkerSymbol] ArcGIS API-SimpleMarkerSymbol 未加载，跳过创建"
+      );
+      return null;
     }
     // 关键：设置偏移（单位：屏幕像素）
-    let color = 'red',
+    let color = "red",
       size = 12,
-      lineColor = 'white',
+      lineColor = "white",
       lineWidth = 1,
-      style = 'circle',
-      angle = 0
+      style = "circle",
+      angle = 0;
     if (options) {
-      if (!isEmpty(options.color)) color = options.color
-      if (isFinite(options.size) && Number(options.size)) size = Number(options.size)
-      if (!isEmpty(options.lineColor)) lineColor = options.lineColor
-      if (!isEmpty(options.style)) style = options.style
+      if (!isEmpty(options.color)) color = options.color;
+      if (isFinite(options.size) && Number(options.size))
+        size = Number(options.size);
+      if (!isEmpty(options.lineColor)) lineColor = options.lineColor;
+      if (!isEmpty(options.style)) style = options.style;
       if (isFinite(options.lineWidth) && Number(options.lineWidth))
-        lineWidth = Number(options.lineWidth)
-      if (isFinite(options.angle) && Number(options.angle)) angle = Number(options.angle)
+        lineWidth = Number(options.lineWidth);
+      if (isFinite(options.angle) && Number(options.angle))
+        angle = Number(options.angle);
     }
     return new window.jkEsri.SimpleMarkerSymbol({
       color, // 填充色（支持 hex, rgb, named color）
@@ -4333,14 +4392,14 @@ function getSimpleMarkerSymbol(options) {
       outline: {
         // 边框
         color: lineColor,
-        width: lineWidth // 边框宽度（px）
+        width: lineWidth, // 边框宽度（px）
       },
       style, // 形状：'circle' | 'square' | 'cross' | 'diamond' | 'triangle' | 'x'
-      angle //仅'diamond' | 'triangle'有效
-    })
+      angle, //仅'diamond' | 'triangle'有效
+    });
   } catch (e) {
-    console.error('[getSimpleMarkerSymbol] 生成 symbol 失败，', e)
-    return null
+    console.error("[getSimpleMarkerSymbol] 生成 symbol 失败，", e);
+    return null;
   }
 }
 /**
@@ -4356,40 +4415,45 @@ function getSimpleMarkerSymbol(options) {
  */
 function getPictureSymbol(options) {
   if (isEmpty(options) || isEmpty(options.url)) {
-    return getSimpleMarkerSymbol(options)
+    return getSimpleMarkerSymbol(options);
   }
   try {
     if (isEmpty(options) || isEmpty(options.url)) {
-      console.error('[getPictureSymbol] 生成 symbol', options)
-      return null
+      console.error("[getPictureSymbol] 生成 symbol", options);
+      return null;
     }
     // 关键：设置偏移（单位：屏幕像素）
     let offset = {
         x: 0, // 水平偏移：正数向右，负数向左
-        y: 0 // 垂直偏移：正数向下，负数向上
+        y: 0, // 垂直偏移：正数向下，负数向上
       },
       width = 20,
       height = 20,
       size = 0,
-      url = options.url
+      url = options.url;
     if (options) {
-      if (isFinite(options.width) && Number(options.width)) width = Number(options.width)
-      if (isFinite(options.height) && Number(options.height)) height = Number(options.height)
-      if (isFinite(options.size) && Number(options.size)) size = Number(options.size)
-      if (isFinite(options.xoffset) && Number(options.xoffset)) offset.x = Number(options.xoffset)
-      if (isFinite(options.yoffset) && Number(options.yoffset)) offset.y = Number(options.yoffset)
+      if (isFinite(options.width) && Number(options.width))
+        width = Number(options.width);
+      if (isFinite(options.height) && Number(options.height))
+        height = Number(options.height);
+      if (isFinite(options.size) && Number(options.size))
+        size = Number(options.size);
+      if (isFinite(options.xoffset) && Number(options.xoffset))
+        offset.x = Number(options.xoffset);
+      if (isFinite(options.yoffset) && Number(options.yoffset))
+        offset.y = Number(options.yoffset);
     }
     return {
-      type: 'picture-marker',
+      type: "picture-marker",
       url, // 图片地址
       width,
       height,
       size,
-      offset
-    }
+      offset,
+    };
   } catch (e) {
-    console.error('[getPictureSymbol] 生成 symbol 失败', e)
-    return null
+    console.error("[getPictureSymbol] 生成 symbol 失败", e);
+    return null;
   }
 }
 
@@ -4402,31 +4466,31 @@ function getPictureSymbol(options) {
  * @returns symbol
  */
 function getLineSymbol(options) {
-  const { color = '#fff', width = 2, opacity = 100 } = options
+  const { color = "#fff", width = 2, opacity = 100 } = options;
   try {
     // 1. 检查 ArcGIS API 是否加载
     if (!window || !window.jkEsri || !window.jkEsri.Color) {
-      console.error('[getLineSymbol] ArcGIS API-Color 未加载，跳过创建')
-      return null
+      console.error("[getLineSymbol] ArcGIS API-Color 未加载，跳过创建");
+      return null;
     }
-    const esriColor = new window.jkEsri.Color(color)
-    esriColor.a = Math.min(1, Math.max(0, opacity / 100))
+    const esriColor = new window.jkEsri.Color(color);
+    esriColor.a = Math.min(1, Math.max(0, opacity / 100));
     return {
-      type: 'simple-line',
+      type: "simple-line",
       color: esriColor,
       width: width,
-      cap: 'round',
-      join: 'round'
-    }
+      cap: "round",
+      join: "round",
+    };
   } catch (e) {
-    console.error('getLineSymbol未传入symbol,使用默认:', e)
+    console.error("getLineSymbol未传入symbol,使用默认:", e);
     return {
-      type: 'simple-line',
-      color: new window.jkEsri.Color('#1f77b4').setAlpha(1),
+      type: "simple-line",
+      color: new window.jkEsri.Color("#1f77b4").setAlpha(1),
       width: 2,
-      cap: 'round',
-      join: 'round'
-    }
+      cap: "round",
+      join: "round",
+    };
   }
 }
 /**
@@ -4441,29 +4505,29 @@ function getLineSymbol(options) {
  * @returns symbol
  */
 function getFillSymbol(options) {
-  let color = '#fff',
-    lineColor = '#fff',
+  let color = "#fff",
+    lineColor = "#fff",
     width = 1,
     opacity = 10,
-    lineOpacity = 100
+    lineOpacity = 100;
   if (options) {
-    if (options.color) color = options.color
-    if (options.opacity || options.opacity == 0) opacity = options.opacity
+    if (options.color) color = options.color;
+    if (options.opacity || options.opacity == 0) opacity = options.opacity;
     if (options.outline) {
-      lineColor = options.outline?.color || '#fff'
-      width = options.outline?.width || 1
-      lineOpacity = options.outline?.opacity || 100
+      lineColor = options.outline.color || "#fff";
+      width = options.outline.width || 1;
+      lineOpacity = options.outline.opacity || 100;
     }
   }
-  const colors = new window.jkEsri.Color(color)
-  colors.a = opacity / 100
-  const outColor = new window.jkEsri.Color(lineColor)
-  outColor.a = lineOpacity / 100
+  const colors = new window.jkEsri.Color(color);
+  colors.a = opacity / 100;
+  const outColor = new window.jkEsri.Color(lineColor);
+  outColor.a = lineOpacity / 100;
   return {
-    type: 'simple-fill',
+    type: "simple-fill",
     color: colors,
-    outline: { color: outColor, width: width }
-  }
+    outline: { color: outColor, width: width },
+  };
 }
 /**
  *
@@ -4474,38 +4538,44 @@ function drawLayer_drawLayer(options) {
   try {
     // 1. 检查 ArcGIS API 是否加载
     if (!window || !window.jkEsri || !window.jkEsri.Graphic) {
-      console.error('[drawLayer] ArcGIS API 未加载，跳过创建')
-      return null
+      console.error("[drawLayer] ArcGIS API 未加载，跳过创建");
+      return null;
     }
     if (isEmpty(options) || !options.geometry) {
-      console.error(`[drawLayer] options.geometry格式不正确,${options}`)
-      return null
+      console.error(`[drawLayer] options.geometry格式不正确,${options}`);
+      return null;
     }
     // 4. 构造安全 attributes（仅保留基本类型）
-    const safeAttrs = options.attributes || options.properties || options || {}
+    const safeAttrs = options.attributes || options.properties || options || {};
     const json = {
       geometry: options.geometry,
-      attributes: safeAttrs
-    }
+      attributes: safeAttrs,
+    };
     let graphic = window.jkEsri.Graphic.fromJSON(json),
-      symbol = null
-    const geometry = options.geometry
-    if (geometry.x || geometry.longitude || (geometry.points && geometry.points.length > 0)) {
+      symbol = null;
+    const geometry = options.geometry;
+    if (
+      geometry.x ||
+      geometry.longitude ||
+      (geometry.points && geometry.points.length > 0)
+    ) {
       if (options.mapText) {
-        symbol = getTextSymbol(options)
+        symbol = getTextSymbol(options);
       } else {
-        symbol = options.url ? getPictureSymbol(options) : getSimpleMarkerSymbol(options)
+        symbol = options.url
+          ? getPictureSymbol(options)
+          : getSimpleMarkerSymbol(options);
       }
     } else if (geometry.paths && geometry.paths.length > 0) {
-      symbol = getLineSymbol(options)
+      symbol = getLineSymbol(options);
     } else if (geometry.rings && geometry.rings.length > 0) {
-      symbol = getFillSymbol(options)
+      symbol = getFillSymbol(options);
     }
-    graphic.symbol = symbol
-    return graphic
+    graphic.symbol = symbol;
+    return graphic;
   } catch (e) {
-    console.error('[drawLayer]失败，', e)
-    return null
+    console.error("[drawLayer]失败，", e);
+    return null;
   }
 }
 /**
@@ -4519,37 +4589,39 @@ function drawArcPoint(options) {
   try {
     // 1. 检查 ArcGIS API 是否加载
     if (!window || !window.jkEsri) {
-      console.error('[createArcPoint] ArcGIS API 未加载，跳过创建')
-      throw new Error('[createArcPoint] ArcGIS API 未加载，跳过创建')
+      console.error("[createArcPoint] ArcGIS API 未加载，跳过创建");
+      throw new Error("[createArcPoint] ArcGIS API 未加载，跳过创建");
     }
 
     // 2. 解析坐标
-    const point = toArcGISPoint(options)
+    const point = toArcGISPoint(options);
     if (!point || !isFinite(point.x) || !isFinite(point.y)) {
-      console.error('[createText] 坐标无效，跳过创建:', options)
-      throw new Error('[createText] 坐标无效，跳过创建')
+      console.error("[createText] 坐标无效，跳过创建:", options);
+      throw new Error("[createText] 坐标无效，跳过创建");
     }
-    const geometry = point
+    const geometry = point;
     // 4. 构造安全 attributes（仅保留基本类型）
 
     // 5. 创建 symbol
-    let symbol = null
+    let symbol = null;
     if (options.mapText) {
-      symbol = getTextSymbol(options)
+      symbol = getTextSymbol(options);
     } else {
-      symbol = options.url ? getPictureSymbol(options) : getSimpleMarkerSymbol(options)
+      symbol = options.url
+        ? getPictureSymbol(options)
+        : getSimpleMarkerSymbol(options);
     }
     // 6. 创建 Graphic
     const graphic = new window.jkEsri.Graphic({
       geometry,
       symbol: symbol,
-      attributes: options
-    })
-    return graphic
+      attributes: options,
+    });
+    return graphic;
   } catch (error) {
     // 任何异常都捕获，不中断流程
-    console.error('[createText] 创建文本标注失败，已跳过:', error)
-    return null
+    console.error("[createText] 创建文本标注失败，已跳过:", error);
+    return null;
   }
 }
 /**
@@ -4563,32 +4635,37 @@ function createArcPoint(options) {
   try {
     // 1. 检查 ArcGIS API 是否加载
     if (!window || !window.jkEsri) {
-      console.error('[createArcPoint] ArcGIS API 未加载，跳过创建')
-      return null
+      console.error("[createArcPoint] ArcGIS API 未加载，跳过创建");
+      return null;
     }
-    if (isEmpty(options) || typeof options != 'object') {
-      console.error('[createArcPoint] 数据格式不对，跳过创建', options)
-      return null
+    if (isEmpty(options) || typeof options != "object") {
+      console.error("[createArcPoint] 数据格式不对，跳过创建", options);
+      return null;
     }
     // 情况 A: GeoJSON MultiPoint
-    if (options.type === 'MultiPoint' && Array.isArray(options.coordinates)) {
-      let graphics = []
+    if (options.type === "MultiPoint" && Array.isArray(options.coordinates)) {
+      let graphics = [];
       options.coordinates.map((coord) => {
-        if (Array.isArray(coord) && coord.length >= 2 && isFinite(coord[0]) && isFinite(coord[1])) {
+        if (
+          Array.isArray(coord) &&
+          coord.length >= 2 &&
+          isFinite(coord[0]) &&
+          isFinite(coord[1])
+        ) {
           let pointData = {
             ...options,
             longitude: coord[0],
-            latitude: coord[1]
-          }
-          graphics.push(drawArcPoint(pointData))
+            latitude: coord[1],
+          };
+          graphics.push(drawArcPoint(pointData));
         }
-      })
-      if (graphics && graphics.length > 0) return graphics
-    } else return drawArcPoint(options)
+      });
+      if (graphics && graphics.length > 0) return graphics;
+    } else return drawArcPoint(options);
   } catch (error) {
     // 任何异常都捕获，不中断流程
-    console.error('[createArcPoint] 创建文本标注失败，已跳过:', error)
-    return null
+    console.error("[createArcPoint] 创建文本标注失败，已跳过:", error);
+    return null;
   }
 }
 // ==================== 内部解析函数 ====================
@@ -4598,81 +4675,81 @@ function createArcPoint(options) {
  */
 function parseLineItem(item, defaultWKID, index) {
   try {
-    let geometry = null
-    let attributes = {}
+    let geometry = null;
+    let attributes = {};
 
     // 情况 1: 已是 Graphic 或 Feature 格式
     if (item.geometry) {
-      const geom = item.geometry
-      if (geom.type === 'polyline' && Array.isArray(geom.paths)) {
+      const geom = item.geometry;
+      if (geom.type === "polyline" && Array.isArray(geom.paths)) {
         geometry = new window.jkEsri.Polyline({
           paths: geom.paths,
-          spatialReference: geom.spatialReference || { wkid: defaultWKID }
-        })
+          spatialReference: geom.spatialReference || { wkid: defaultWKID },
+        });
       } else if (geom.x !== undefined || geom.rings !== undefined) {
         // 非线几何，跳过
-        return null
+        return null;
       }
-      attributes = { ...item.attributes, ...item } // 合并属性
+      attributes = { ...item.attributes, ...item }; // 合并属性
     }
     // 情况 2: WKT 字符串
-    else if (typeof item === 'string') {
+    else if (typeof item === "string") {
       if (isWKTMultiLineString(item) || isWKTPolyline(item)) {
-        const paths = parseWKTToPaths(item)
+        const paths = parseWKTToPaths(item);
         if (paths) {
           geometry = new window.jkEsri.Polyline({
             paths,
-            spatialReference: { wkid: defaultWKID }
-          })
+            spatialReference: { wkid: defaultWKID },
+          });
         }
       }
-      attributes = { wkt: item }
+      attributes = { wkt: item };
     }
     // 情况 3: GeoJSON
     else if (item.type) {
-      if (item.type === 'Feature') {
-        return parseLineItem(item.geometry || item, defaultWKID, index) // 递归处理 geometry
-      } else if (['LineString', 'MultiLineString'].includes(item.type)) {
-        const paths = geoJSONToArcGISPaths(item)
+      if (item.type === "Feature") {
+        return parseLineItem(item.geometry || item, defaultWKID, index); // 递归处理 geometry
+      } else if (["LineString", "MultiLineString"].includes(item.type)) {
+        const paths = geoJSONToArcGISPaths(item);
         if (paths) {
           geometry = new window.jkEsri.Polyline({
             paths,
-            spatialReference: { wkid: defaultWKID }
-          })
+            spatialReference: { wkid: defaultWKID },
+          });
         }
-        attributes = { ...item.properties }
+        attributes = { ...item.properties };
       }
     }
     // 情况 4: 纯坐标数组
     else if (Array.isArray(item)) {
-      const paths = normalizePaths(item)
+      const paths = normalizePaths(item);
       if (paths) {
         geometry = new window.jkEsri.Polyline({
           paths,
-          spatialReference: { wkid: defaultWKID }
-        })
+          spatialReference: { wkid: defaultWKID },
+        });
       }
-      attributes = { input: 'array' }
+      attributes = { input: "array" };
     }
 
     if (!geometry) {
-      console.error(`Invalid line data at index ${index}:`, item)
-      return null
+      console.error(`Invalid line data at index ${index}:`, item);
+      return null;
     }
 
     // 添加默认属性
     attributes = {
       sourceIndex: index,
-      ...attributes
-    }
+      ...attributes,
+    };
 
     return new window.jkEsri.Graphic({
       geometry,
-      attributes
-    })
+      attributes,
+    });
   } catch (e) {
-    console.error(`Failed to parse line item at index ${index}:`, e)
-    return null
+    console.error(`Failed to parse line item at index ${index}:`, e);
+    return null;
   }
 }
 
@@ -4683,7 +4760,10 @@ function parseLineItem(item, defaultWKID, index) {
  * @returns
  */
 function isWKTMultiLineString(str) {
-  return typeof str === 'string' && str.trim().toUpperCase().startsWith('MULTILINESTRING')
+  return (
+    typeof str === "string" &&
+    str.trim().toUpperCase().startsWith("MULTILINESTRING")
+  );
 }
 /**
  * 判断LINESTRING
@@ -4691,7 +4771,9 @@ function isWKTMultiLineString(str) {
  * @returns
  */
 function isWKTPolyline(str) {
-  return typeof str === 'string' && str.trim().toUpperCase().startsWith('LINESTRING')
+  return (
+    typeof str === "string" && str.trim().toUpperCase().startsWith("LINESTRING")
+  );
 }
 /**
  * 线转化
@@ -4700,25 +4782,27 @@ function isWKTPolyline(str) {
  */
 function parseWKTToPaths(wkt) {
   try {
-    const upper = wkt.trim().toUpperCase()
-    let coordsPart
-    if (upper.startsWith('MULTILINESTRING')) {
-      coordsPart = wkt.match(/MULTILINESTRING\s*\(\s*(.+)\s*\)/i)?.[1]
-      if (!coordsPart) return null
-      const lines = coordsPart.split(/\)\s*,\s*\(/)
+    const upper = wkt.trim().toUpperCase();
+    let coordsPart;
+    if (upper.startsWith("MULTILINESTRING")) {
+      coordsPart = wkt.match(/MULTILINESTRING\s*\(\s*(.+)\s*\)/i)?.[1];
+      if (!coordsPart) return null;
+      const lines = coordsPart.split(/\)\s*,\s*\(/);
       return lines.map((line) => {
-        line = line.replace(/^\(/, '').replace(/\)$/, '')
-        return line.split(',').map((pt) => pt.trim().split(/\s+/).map(Number))
-      })
-    } else if (upper.startsWith('LINESTRING')) {
-      coordsPart = wkt.match(/LINESTRING\s*\(\s*(.+)\s*\)/i)?.[1]
-      if (!coordsPart) return null
-      return [coordsPart.split(',').map((pt) => pt.trim().split(/\s+/).map(Number))]
-    }
-    return null
+        line = line.replace(/^\(/, "").replace(/\)$/, "");
+        return line.split(",").map((pt) => pt.trim().split(/\s+/).map(Number));
+      });
+    } else if (upper.startsWith("LINESTRING")) {
+      coordsPart = wkt.match(/LINESTRING\s*\(\s*(.+)\s*\)/i)?.[1];
+      if (!coordsPart) return null;
+      return [
+        coordsPart.split(",").map((pt) => pt.trim().split(/\s+/).map(Number)),
+      ];
+    }
+    return null;
   } catch (e) {
-    console.error('WKT parse error:', e)
-    return null
+    console.error("WKT parse error:", e);
+    return null;
   }
 }
 /**
@@ -4727,13 +4811,13 @@ function parseWKTToPaths(wkt) {
  * @returns
  */
 function geoJSONToArcGISPaths(geojson) {
-  if (!geojson.coordinates) return null
-  if (geojson.type === 'LineString') {
-    return [geojson.coordinates]
-  } else if (geojson.type === 'MultiLineString') {
-    return geojson.coordinates
+  if (!geojson.coordinates) return null;
+  if (geojson.type === "LineString") {
+    return [geojson.coordinates];
+  } else if (geojson.type === "MultiLineString") {
+    return geojson.coordinates;
   }
-  return null
+  return null;
 }
 /**
  * 格式化路径
@@ -4741,17 +4825,17 @@ function geoJSONToArcGISPaths(geojson) {
  * @returns
  */
 function normalizePaths(input) {
-  if (!Array.isArray(input) || input.length === 0) return null
+  if (!Array.isArray(input) || input.length === 0) return null;
 
   // 多段线：[[[x,y],...], [[x,y],...]]
   if (Array.isArray(input[0]) && Array.isArray(input[0][0])) {
-    return input
+    return input;
   }
   // 单段线：[[x,y], [x,y]]
-  if (Array.isArray(input[0]) && typeof input[0][0] === 'number') {
-    return [input]
+  if (Array.isArray(input[0]) && typeof input[0][0] === "number") {
+    return [input];
   }
-  return null
+  return null;
 }
 
 /**
@@ -4764,77 +4848,77 @@ function normalizePaths(input) {
  */
 async function createLineFeatureLayer(lineDataList = [], options = {}) {
   if (!Array.isArray(lineDataList) || lineDataList.length === 0) {
-    console.error('No line data provided')
-    return null
+    console.error("No line data provided");
+    return null;
   }
 
-  const { defaultWKID = 4326, layerId = 'lineFeatureId' } = options
+  const { defaultWKID = 4326, layerId = "lineFeatureId" } = options;
 
   try {
     // 1. 解析所有线数据为统一格式：{ geometry: Polyline, attributes: Object }
     const features = lineDataList
       .map((item, index) => parseLineItem(item, defaultWKID, index))
-      .filter(Boolean) // 过滤无效项
+      .filter(Boolean); // 过滤无效项
 
     if (features.length === 0) {
-      console.error('No valid line features parsed')
-      return null
+      console.error("No valid line features parsed");
+      return null;
     }
 
     // 2. 推断空间参考（优先使用第一个有效 geometry 的 WKID）
-    const firstGeom = features[0].geometry
+    const firstGeom = features[0].geometry;
     const spatialReference = firstGeom.spatialReference || {
-      wkid: defaultWKID
-    }
+      wkid: defaultWKID,
+    };
 
     // 3. 创建 FeatureLayer 所需的 fields（自动推断属性字段）
-    const allAttrs = features.map((f) => f.attributes).filter(Boolean)
-    const fieldMap = new Set(['OBJECTID']) // 必须包含 OBJECTID
+    const allAttrs = features.map((f) => f.attributes).filter(Boolean);
+    const fieldMap = new Set(["OBJECTID"]); // 必须包含 OBJECTID
 
     allAttrs.forEach((attrs) => {
-      if (attrs && typeof attrs === 'object') {
-        Object.keys(attrs).forEach((key) => fieldMap.add(key))
+      if (attrs && typeof attrs === "object") {
+        Object.keys(attrs).forEach((key) => fieldMap.add(key));
       }
-    })
+    });
 
     const fields = Array.from(fieldMap).map((name) => ({
       name,
-      type: 'string', // 简化处理，实际可按值类型判断
-      alias: name
-    }))
+      type: "string", // 简化处理，实际可按值类型判断
+      alias: name,
+    }));
 
     // 4. 确保每个 feature 有 OBJECTID
     features.forEach((feature, i) => {
-      if (!feature.attributes) feature.attributes = {}
+      if (!feature.attributes) feature.attributes = {};
       if (feature.attributes.OBJECTID == null) {
-        feature.attributes.OBJECTID = i + 1
+        feature.attributes.OBJECTID = i + 1;
       }
-    })
+    });
 
     // 5. 创建 FeatureLayer
     const layer = new window.jkEsri.FeatureLayer({
       source: features,
       fields: fields,
-      objectIdField: 'OBJECTID',
-      geometryType: 'polyline',
+      objectIdField: "OBJECTID",
+      geometryType: "polyline",
       spatialReference: spatialReference,
       renderer: {
-        type: 'simple',
+        type: "simple",
         symbol: {
-          type: 'simple-line',
-          color: '#1f77b4',
+          type: "simple-line",
+          color: "#1f77b4",
           width: 2,
-          cap: 'round',
-          join: 'round'
-        }
+          cap: "round",
+          join: "round",
+        },
       },
-      title: 'Dynamic Line Layer',
-      id: layerId
-    })
-    return layer
+      title: "Dynamic Line Layer",
+      id: layerId,
+    });
+    return layer;
   } catch (error) {
-    console.error('Failed to create FeatureLayer:', error)
-    return null
+    console.error("Failed to create FeatureLayer:", error);
+    return null;
   }
 }
 
@@ -4842,24 +4926,26 @@ async function createLineFeatureLayer(lineDataList = [], options = {}) {
  * 将任意线数据项解析为 Graphic
  */
 function parseLineToGraphic(item, defaultWKID, defaultSymbol, index) {
-  let geometry = null
-  let attributes = {}
+  let geometry = null;
+  let attributes = {};
 
   try {
     // 情况 1: 已是 Graphic 对象
     if (item instanceof window.jkEsri.Graphic) {
-      const geom = item.geometry
-      if (geom && geom.type === 'polyline') {
-        return item // 直接复用
+      const geom = item.geometry;
+      if (geom && geom.type === "polyline") {
+        return item; // 直接复用
       } else {
-        console.error(`Item at index ${index} is a Graphic but not polyline, skipped`)
-        return null
+        console.error(
+          `Item at index ${index} is a Graphic but not polyline, skipped`
+        );
+        return null;
       }
     }
 
     // 情况 2: 包含 geometry 的对象（如 Feature 格式）
-    if (item && typeof item === 'object' && item.geometry) {
-      const geom = item.geometry
+    if (item && typeof item === "object" && item.geometry) {
+      const geom = item.geometry;
       if (
         Array.isArray(geom.paths) ||
         Array.isArray(geom.coordinates) ||
@@ -4867,14 +4953,14 @@ function parseLineToGraphic(item, defaultWKID, defaultSymbol, index) {
       ) {
         geometry = new window.jkEsri.Polyline({
           paths: geom.paths || geom.coordinates || geom.rings,
-          spatialReference: geom.spatialReference || { wkid: defaultWKID }
-        })
+          spatialReference: geom.spatialReference || { wkid: defaultWKID },
+        });
       }
-      attributes = { ...item.attributes, ...item }
+      attributes = { ...item.attributes, ...item };
     }
     // 情况 3: GeoJSON
-    if (item && typeof item === 'object' && item.type) {
-      if (judgeLayerType(item.type) == 'polyline') {
+    if (item && typeof item === "object" && item.type) {
+      if (judgeLayerType(item.type) == "polyline") {
         if (
           Array.isArray(item.paths) ||
           Array.isArray(item.coordinates) ||
@@ -4882,72 +4968,77 @@ function parseLineToGraphic(item, defaultWKID, defaultSymbol, index) {
         ) {
           geometry = new window.jkEsri.Polyline({
             paths: item.paths || item.coordinates || item.rings,
-            spatialReference: item.spatialReference || { wkid: defaultWKID }
-          })
+            spatialReference: item.spatialReference || { wkid: defaultWKID },
+          });
         }
-        attributes = { ...item.attributes, ...item }
-      } else if (['LineString', 'MultiLineString'].includes(item.type)) {
-        const paths = geoJSONToArcGISPaths(item)
+        attributes = { ...item.attributes, ...item };
+      } else if (["LineString", "MultiLineString"].includes(item.type)) {
+        const paths = geoJSONToArcGISPaths(item);
         if (paths) {
           geometry = new window.jkEsri.Polyline({
             paths,
-            spatialReference: { wkid: defaultWKID }
-          })
+            spatialReference: { wkid: defaultWKID },
+          });
         }
-        attributes = { ...item.properties, sourceIndex: index }
-      } else if (item.type === 'Feature') {
-        return parseLineToGraphic(item.geometry || item, defaultWKID, defaultSymbol, index)
+        attributes = { ...item.properties, sourceIndex: index };
+      } else if (item.type === "Feature") {
+        return parseLineToGraphic(
+          item.geometry || item,
+          defaultWKID,
+          defaultSymbol,
+          index
+        );
       }
     }
     // 情况 4: WKT 字符串
-    if (typeof item === 'string') {
+    if (typeof item === "string") {
       if (isWKTMultiLineString(item) || isWKTPolyline(item)) {
-        const paths = parseWKTToPaths(item)
+        const paths = parseWKTToPaths(item);
         if (paths) {
           geometry = new window.jkEsri.Polyline({
             paths,
-            spatialReference: { wkid: defaultWKID }
-          })
+            spatialReference: { wkid: defaultWKID },
+          });
         }
       }
-      attributes = { wkt: item, sourceIndex: index }
+      attributes = { wkt: item, sourceIndex: index };
     }
     // 情况 5: 纯坐标数组
     if (Array.isArray(item)) {
-      const paths = normalizePaths(item)
+      const paths = normalizePaths(item);
       if (paths) {
         geometry = new window.jkEsri.Polyline({
           paths,
-          spatialReference: { wkid: defaultWKID }
-        })
+          spatialReference: { wkid: defaultWKID },
+        });
       }
-      attributes = { inputType: 'array', sourceIndex: index }
+      attributes = { inputType: "array", sourceIndex: index };
     }
 
     if (!geometry) {
-      console.error(`Invalid line data at index ${index}:`, item)
-      return null
+      console.error(`Invalid line data at index ${index}:`, item);
+      return null;
     }
 
     // 合并符号配置：优先使用 item 中的 symbol 配置
-    const symbolConfig = { ...defaultSymbol }
-    if (item && typeof item === 'object') {
-      if (item.color !== undefined) symbolConfig.color = item.color
-      if (item.width !== undefined) symbolConfig.width = item.width
-      if (item.borderWidth !== undefined) symbolConfig.width = item.borderWidth
-      if (item.opacity !== undefined) symbolConfig.opacity = item.opacity
+    const symbolConfig = { ...defaultSymbol };
+    if (item && typeof item === "object") {
+      if (item.color !== undefined) symbolConfig.color = item.color;
+      if (item.width !== undefined) symbolConfig.width = item.width;
+      if (item.borderWidth !== undefined) symbolConfig.width = item.borderWidth;
+      if (item.opacity !== undefined) symbolConfig.opacity = item.opacity;
     }
 
-    const symbol = getLineSymbol(symbolConfig)
+    const symbol = getLineSymbol(symbolConfig);
 
     return new window.jkEsri.Graphic({
       geometry,
       symbol,
-      attributes: { ...attributes, sourceIndex: index }
-    })
+      attributes: { ...attributes, sourceIndex: index },
+    });
   } catch (e) {
-    console.error(`Failed to parse line item at index ${index}:`, e)
-    return null
+    console.error(`Failed to parse line item at index ${index}:`, e);
+    return null;
   }
 }
 /**
@@ -4960,50 +5051,54 @@ function parseLineToGraphic(item, defaultWKID, defaultSymbol, index) {
  * @param {Promise<GraphicsLayer>} [mapLayer] - 地图图层
  * @returns {Promise<GraphicsLayer>} 返回 GraphicsLayer 实例
  */
-async function createLineGraphicsLayer(lineDataList = [], options = {}, mapLayer = null) {
+async function createLineGraphicsLayer(
+  lineDataList = [],
+  options = {},
+  mapLayer = null
+) {
   if (!Array.isArray(lineDataList) || lineDataList.length === 0) {
-    console.error('createLineGraphicsLayer: No line data provided')
-    return null
+    console.error("createLineGraphicsLayer: No line data provided");
+    return null;
   }
   const {
     defaultWKID = 4326,
-    layerId = 'lineGraphicsLayer',
+    layerId = "lineGraphicsLayer",
     defaultSymbol = {
-      color: '#1f77b4',
+      color: "#1f77b4",
       width: 2,
-      opacity: 100 // 0-100
-    }
-  } = options
+      opacity: 100, // 0-100
+    },
+  } = options;
 
   try {
-    const graphics = []
+    const graphics = [];
     for (let i = 0; i < lineDataList.length; i++) {
-      const item = lineDataList[i]
-      const graphic = parseLineToGraphic(item, defaultWKID, defaultSymbol, i)
+      const item = lineDataList[i];
+      const graphic = parseLineToGraphic(item, defaultWKID, defaultSymbol, i);
       if (graphic) {
-        graphics.push(graphic)
+        graphics.push(graphic);
       }
     }
 
     if (graphics.length === 0) {
-      console.error('createLineGraphicsLayer: No valid graphics created')
-      return null
+      console.error("createLineGraphicsLayer: No valid graphics created");
+      return null;
     }
-    let layer = mapLayer
+    let layer = mapLayer;
     if (!layer)
       layer = new window.jkEsri.GraphicsLayer({
         id: layerId,
-        title: 'Dynamic Line Graphics Layer'
-      })
+        title: "Dynamic Line Graphics Layer",
+      });
 
-    layer.addMany(graphics)
+    layer.addMany(graphics);
     return {
       layer,
-      graphics
-    }
+      graphics,
+    };
   } catch (error) {
-    console.error('createLineGraphicsLayer failed:', error)
-    return null
+    console.error("createLineGraphicsLayer failed:", error);
+    return null;
   }
 }
 /**
@@ -5017,88 +5112,94 @@ async function createLineGraphicsLayer(lineDataList = [], options = {}, mapLayer
  * @param {any} options.mapLayer - 地图图层
  * @returns {any} {layer,graphics}
  */
-async function createMaskLayer(polygonDataList = [], options, context = null, mapLayer) {
+async function createMaskLayer(
+  polygonDataList = [],
+  options,
+  context = null,
+  mapLayer
+) {
   const {
-    layerId = 'createMaskLayer',
-    outerExtent = null // { xmin, ymin, xmax, ymax, spatialReference }
-  } = options || {}
+    layerId = "createMaskLayer",
+    outerExtent = null, // { xmin, ymin, xmax, ymax, spatialReference }
+  } = options || {};
 
   if (!Array.isArray(polygonDataList) || polygonDataList.length === 0) {
-    console.warn('createMaskLayer: 范围是空的')
-    return null
+    console.warn("createMaskLayer: 范围是空的");
+    return null;
   }
 
-  if (typeof window.jkEsri === 'undefined') {
-    console.error('ArcGIS API for JavaScript is not loaded')
-    return null
+  if (typeof window.jkEsri === "undefined") {
+    console.error("ArcGIS API for JavaScript is not loaded");
+    return null;
   }
 
-  const { Polygon, SpatialReference, GraphicsLayer, Graphic, geometryEngine } = window.jkEsri
+  const { Polygon, SpatialReference, GraphicsLayer, Graphic, geometryEngine } =
+    window.jkEsri;
 
   // ========== 步骤 1：确定空间参考（spatialReference）==========
-  let view = null
-  let spatialReference = null
-  let is3D = false
-
-  if (context && typeof context === 'object') {
-    if (context.type === '2d' || context.type === '3d') {
-      view = context
-      is3D = context.type === '3d'
-      spatialReference = view.spatialReference
+  let view = null;
+  let spatialReference = null;
+  let is3D = false;
+
+  if (context && typeof context === "object") {
+    if (context.type === "2d" || context.type === "3d") {
+      view = context;
+      is3D = context.type === "3d";
+      spatialReference = view.spatialReference;
       if (!spatialReference) {
-        console.error('View spatialReference is not ready')
-        return null
+        console.error("View spatialReference is not ready");
+        return null;
       }
-    } else if (context.declaredClass === 'esri.layers.GraphicsLayer') {
-      spatialReference = new SpatialReference({ wkid: 4326 })
+    } else if (context.declaredClass === "esri.layers.GraphicsLayer") {
+      spatialReference = new SpatialReference({ wkid: 4326 });
     } else {
-      console.warn('Unknown context type, assuming WKID 4326')
-      spatialReference = new SpatialReference({ wkid: 4326 })
+      console.warn("Unknown context type, assuming WKID 4326");
+      spatialReference = new SpatialReference({ wkid: 4326 });
     }
   } else {
-    spatialReference = new SpatialReference({ wkid: 4326 })
+    spatialReference = new SpatialReference({ wkid: 4326 });
   }
 
-  const sr = spatialReference
-  const wkid = sr.wkid
+  const sr = spatialReference;
+  const wkid = sr.wkid;
 
   // ========== 辅助函数 ==========
   /**
    * 提取 rings 数据
    */
   function extractRawRings(item, index) {
-    if (!item) return null
-    if (Array.isArray(item)) return item
-    if (item.rings) return item.rings
-    if (item.geometry?.rings) return item.geometry.rings
-    console.warn(`Item ${index} has no valid rings`)
-    return null
+    if (!item) return null;
+    if (Array.isArray(item)) return item;
+    if (item.rings) return item.rings;
+    if (item.geometry.rings) return item.geometry.rings;
+    console.warn(`Item ${index} has no valid rings`);
+    return null;
   }
 
   /**
    * 判断环是否为顺时针（CW）
    */
   function isRingClockwise(ring) {
-    let sum = 0
+    let sum = 0;
     for (let i = 0; i < ring.length; i++) {
-      const [x1, y1] = ring[i]
-      const [x2, y2] = ring[(i + 1) % ring.length]
-      sum += (x2 - x1) * (y2 + y1)
+      const [x1, y1] = ring[i];
+      const [x2, y2] = ring[(i + 1) % ring.length];
+      sum += (x2 - x1) * (y2 + y1);
     }
-    return sum > 0 // true = CW
+    return sum > 0; // true = CW
   }
 
   /**
    * 确保环闭合
    */
   function ensureClosed(ring) {
-    if (ring.length < 3) return null
-    const first = ring[0]
-    const last = ring[ring.length - 1]
+    if (ring.length < 3) return null;
+    const first = ring[0];
+    const last = ring[ring.length - 1];
     if (first[0] !== last[0] || first[1] !== last[1]) {
-      return [...ring, [first[0], first[1]]]
+      return [...ring, [first[0], first[1]]];
     }
-    return ring
+    return ring;
   }
 
   // ========== 核心：3D 反遮罩几何裁剪 ==========
@@ -5112,38 +5213,38 @@ async function createMaskLayer(polygonDataList = [], options, context = null, ma
   function compute3DDifference(outerRing, holes, sr) {
     const outerPoly = new Polygon({
       rings: [outerRing],
-      spatialReference: sr
-    })
+      spatialReference: sr,
+    });
 
-    if (holes.length === 0) return outerPoly
+    if (holes.length === 0) return outerPoly;
 
     // 合并所有 holes
-    let unionHole = null
+    let unionHole = null;
     for (const hole of holes) {
       const holePoly = new Polygon({
         rings: [hole],
-        spatialReference: sr
-      })
+        spatialReference: sr,
+      });
       if (!unionHole) {
-        unionHole = holePoly
+        unionHole = holePoly;
       } else {
         try {
-          unionHole = geometryEngine.union(unionHole, holePoly)
+          unionHole = geometryEngine.union(unionHole, holePoly);
         } catch (e) {
-          console.warn('Union hole failed, skipping:', e)
+          console.warn("Union hole failed, skipping:", e);
         }
       }
     }
 
-    if (!unionHole) return outerPoly
+    if (!unionHole) return outerPoly;
 
     // 执行差集
     try {
-      const result = geometryEngine.difference(outerPoly, unionHole)
-      return result || outerPoly
+      const result = geometryEngine.difference(outerPoly, unionHole);
+      return result || outerPoly;
     } catch (e) {
-      console.error('Geometry difference failed:', e)
-      return outerPoly
+      console.error("Geometry difference failed:", e);
+      return outerPoly;
     }
   }
 
@@ -5151,15 +5252,15 @@ async function createMaskLayer(polygonDataList = [], options, context = null, ma
   try {
     // ========== 反遮罩模式 ==========
     // 构建 outerRing
-    let outerRing
-    if (outerExtent && outerExtent.spatialReference?.wkid === wkid) {
+    let outerRing;
+    if (outerExtent && outerExtent.spatialReference.wkid === wkid) {
       outerRing = [
         [outerExtent.xmin, outerExtent.ymin],
         [outerExtent.xmax, outerExtent.ymin],
         [outerExtent.xmax, outerExtent.ymax],
         [outerExtent.xmin, outerExtent.ymax],
-        [outerExtent.xmin, outerExtent.ymin]
-      ]
+        [outerExtent.xmin, outerExtent.ymin],
+      ];
     } else {
       if (wkid === 4326) {
         outerRing = [
@@ -5167,17 +5268,17 @@ async function createMaskLayer(polygonDataList = [], options, context = null, ma
           [180, -90],
           [180, 90],
           [-180, 90],
-          [-180, -90]
-        ]
+          [-180, -90],
+        ];
       } else if (wkid === 3857) {
-        const halfWorld = 20037508.342789244
+        const halfWorld = 20037508.342789244;
         outerRing = [
           [-halfWorld, -halfWorld],
           [halfWorld, -halfWorld],
           [halfWorld, halfWorld],
           [-halfWorld, halfWorld],
-          [-halfWorld, -halfWorld]
-        ]
+          [-halfWorld, -halfWorld],
+        ];
       } else {
         // 默认中国范围（WKID 4490 近似）
         outerRing = [
@@ -5185,75 +5286,76 @@ async function createMaskLayer(polygonDataList = [], options, context = null, ma
           [121.0131, 19.9696],
           [121.0131, 26.933],
           [105.0019, 26.933],
-          [105.0019, 19.9696]
-        ]
+          [105.0019, 19.9696],
+        ];
       }
     }
 
     // 提取 holes（支持多个环）
-    const holes = []
+    const holes = [];
     for (let i = 0; i < polygonDataList.length; i++) {
-      const item = polygonDataList[i]
-      const rawRings = extractRawRings(item, i)
-      if (!rawRings || !Array.isArray(rawRings[0]) || rawRings[0].length < 3) continue
+      const item = polygonDataList[i];
+      const rawRings = extractRawRings(item, i);
+      if (!rawRings || !Array.isArray(rawRings[0]) || rawRings[0].length < 3)
+        continue;
 
       rawRings.forEach((ring, idx) => {
-        idx
-        ring = ensureClosed(ring)
-        if (!ring) return
+        idx;
+        ring = ensureClosed(ring);
+        if (!ring) return;
 
         // 2D 要求 hole 为 CW；3D 不关心（后续会裁剪）
         if (!is3D && !isRingClockwise(ring)) {
-          ring = ring.slice().reverse()
+          ring = ring.slice().reverse();
         }
 
-        holes.push(ring)
-      })
+        holes.push(ring);
+      });
     }
 
-    let finalGeometry
+    let finalGeometry;
 
     if (is3D) {
       // ✅ 3D：使用 geometryEngine 裁剪
-      finalGeometry = await compute3DDifference(outerRing, holes, sr)
+      finalGeometry = await compute3DDifference(outerRing, holes, sr);
     } else {
       // ✅ 2D：使用多环 Polygon（holes 必须 CW）
       if (holes.length === 0) {
         finalGeometry = new Polygon({
           rings: [outerRing],
-          spatialReference: sr
-        })
+          spatialReference: sr,
+        });
       } else {
         finalGeometry = new Polygon({
           rings: [outerRing, ...holes],
-          spatialReference: sr
-        })
+          spatialReference: sr,
+        });
       }
     }
 
     const maskSymbol = {
-      type: 'simple-fill',
+      type: "simple-fill",
       color: [0, 0, 0, 0.8],
-      outline: null
-    }
+      outline: null,
+    };
     const maskGraphic = new Graphic({
       geometry: finalGeometry,
-      symbol: maskSymbol
-    })
+      symbol: maskSymbol,
+    });
 
-    let layer = mapLayer
+    let layer = mapLayer;
     if (!layer) {
-      layer = new GraphicsLayer({ id: layerId })
-      if (view) view.map.add(layer)
+      layer = new GraphicsLayer({ id: layerId });
+      if (view) view.map.add(layer);
     } else {
-      layer.removeAll()
+      layer.removeAll();
     }
-    layer.add(maskGraphic)
+    layer.add(maskGraphic);
 
-    return { layer, graphics: [maskGraphic] }
+    return { layer, graphics: [maskGraphic] };
   } catch (error) {
-    console.error('createMaskLayer failed:', error)
-    return null
+    console.error("createMaskLayer failed:", error);
+    return null;
   }
 }
 /**
@@ -5276,134 +5378,135 @@ async function createPolygonGraphicsLayer(
   mapLayer
 ) {
   const {
-    layerId = 'polygonGraphicsLayer',
+    layerId = "polygonGraphicsLayer",
     defaultSymbol = {
       color: [255, 255, 255, 0.1],
-      outline: { color: '#0070ff', width: 1 }
+      outline: { color: "#0070ff", width: 1 },
     },
-    enableHoles = true
-  } = options
+    enableHoles = true,
+  } = options;
   if (!Array.isArray(polygonDataList) || polygonDataList.length === 0) {
-    console.warn('createPolygonGraphicsLayer: 范围是空的')
-    return null
+    console.warn("createPolygonGraphicsLayer: 范围是空的");
+    return null;
   }
 
-  if (typeof window.jkEsri === 'undefined') {
-    console.error('ArcGIS API for JavaScript is not loaded')
-    return null
+  if (typeof window.jkEsri === "undefined") {
+    console.error("ArcGIS API for JavaScript is not loaded");
+    return null;
   }
 
-  const { Polygon, SpatialReference, GraphicsLayer, Graphic } = window.jkEsri
+  const { Polygon, SpatialReference, GraphicsLayer, Graphic } = window.jkEsri;
   // ========== 步骤 1：确定空间参考（spatialReference）==========
-  let view = null
-  let spatialReference = null
+  let view = null;
+  let spatialReference = null;
 
-  if (context && typeof context === 'object') {
-    if (context.type === '2d' || context.type === '3d') {
-      view = context
-      spatialReference = view.spatialReference
+  if (context && typeof context === "object") {
+    if (context.type === "2d" || context.type === "3d") {
+      view = context;
+      spatialReference = view.spatialReference;
       if (!spatialReference) {
-        console.error('View spatialReference is not ready')
-        return null
+        console.error("View spatialReference is not ready");
+        return null;
       }
-    } else if (context.declaredClass === 'esri.layers.GraphicsLayer') {
-      spatialReference = new SpatialReference({ wkid: 4326 })
+    } else if (context.declaredClass === "esri.layers.GraphicsLayer") {
+      spatialReference = new SpatialReference({ wkid: 4326 });
     } else {
-      console.warn('Unknown context type, assuming WKID 4326')
-      spatialReference = new SpatialReference({ wkid: 4326 })
+      console.warn("Unknown context type, assuming WKID 4326");
+      spatialReference = new SpatialReference({ wkid: 4326 });
     }
   } else {
-    spatialReference = new SpatialReference({ wkid: 4326 })
+    spatialReference = new SpatialReference({ wkid: 4326 });
   }
 
-  const sr = spatialReference
+  const sr = spatialReference;
 
   // ========== 辅助函数 ==========
   /**
    * 提取 rings 数据
    */
   function extractRawRings(item, index) {
-    if (!item) return null
-    if (Array.isArray(item)) return item
-    if (item.rings) return item.rings
-    if (item.geometry?.rings) return item.geometry.rings
-    console.warn(`Item ${index} has no valid rings`)
-    return null
+    if (!item) return null;
+    if (Array.isArray(item)) return item;
+    if (item.rings) return item.rings;
+    if (item.geometry.rings) return item.geometry.rings;
+    console.warn(`Item ${index} has no valid rings`);
+    return null;
   }
 
   /**
    * 确保环闭合
    */
   function ensureClosed(ring) {
-    if (ring.length < 3) return null
-    const first = ring[0]
-    const last = ring[ring.length - 1]
+    if (ring.length < 3) return null;
+    const first = ring[0];
+    const last = ring[ring.length - 1];
     if (first[0] !== last[0] || first[1] !== last[1]) {
-      return [...ring, [first[0], first[1]]]
+      return [...ring, [first[0], first[1]]];
     }
-    return ring
+    return ring;
   }
   // ========== 主逻辑 ==========
   try {
     // ========== 正向显示模式（2D/3D 通用）==========
-    const graphics = []
+    const graphics = [];
     for (let i = 0; i < polygonDataList.length; i++) {
-      const item = polygonDataList[i]
-      const rawRings = extractRawRings(item, i)
-      if (!rawRings) continue
-      const symbolConfig = { ...defaultSymbol }
-      if (item && typeof item === 'object') {
-        if (Array.isArray(item.color)) symbolConfig.color = item.color
-        if (typeof item.opacity === 'number') {
-          const alpha = Math.min(1, Math.max(0, item.opacity))
+      const item = polygonDataList[i];
+      const rawRings = extractRawRings(item, i);
+      if (!rawRings) continue;
+      const symbolConfig = { ...defaultSymbol };
+      if (item && typeof item === "object") {
+        if (Array.isArray(item.color)) symbolConfig.color = item.color;
+        if (typeof item.opacity === "number") {
+          const alpha = Math.min(1, Math.max(0, item.opacity));
           const baseColor = Array.isArray(symbolConfig.color)
             ? symbolConfig.color.slice(0, 3)
-            : [255, 255, 255]
-          symbolConfig.color = [...baseColor, alpha]
+            : [255, 255, 255];
+          symbolConfig.color = [...baseColor, alpha];
         }
-        if (item.outlineColor) symbolConfig.outline.color = item.outlineColor
-        if (typeof item.outlineWidth === 'number') symbolConfig.outline.width = item.outlineWidth
+        if (item.outlineColor) symbolConfig.outline.color = item.outlineColor;
+        if (typeof item.outlineWidth === "number")
+          symbolConfig.outline.width = item.outlineWidth;
       }
       const symbol = {
-        type: 'simple-fill',
+        type: "simple-fill",
         color: symbolConfig.color,
-        outline: symbolConfig.outline
-      }
-      const attributes = { ...(item || {}), sourceIndex: i }
+        outline: symbolConfig.outline,
+      };
+      const attributes = { ...(item || {}), sourceIndex: i };
       if (enableHoles) {
         const poly = new Polygon({
           rings: rawRings,
-          spatialReference: sr
-        })
-        graphics.push(new Graphic({ geometry: poly, symbol, attributes }))
+          spatialReference: sr,
+        });
+        graphics.push(new Graphic({ geometry: poly, symbol, attributes }));
       } else {
-        const outerRing = ensureClosed(rawRings[0])
+        const outerRing = ensureClosed(rawRings[0]);
         if (outerRing) {
           const poly = new Polygon({
             rings: [outerRing],
-            spatialReference: sr
-          })
-          graphics.push(new Graphic({ geometry: poly, symbol, attributes }))
+            spatialReference: sr,
+          });
+          graphics.push(new Graphic({ geometry: poly, symbol, attributes }));
         }
       }
     }
 
     if (graphics.length === 0) {
-      console.warn('No valid graphics created')
-      return null
+      console.warn("No valid graphics created");
+      return null;
     }
-    let layer = mapLayer
+    let layer = mapLayer;
     if (!layer) {
-      layer = new GraphicsLayer({ id: layerId, title: 'Polygon Layer' })
-      if (view) view.map.add(layer)
+      layer = new GraphicsLayer({ id: layerId, title: "Polygon Layer" });
+      if (view) view.map.add(layer);
     } else {
-      layer.removeAll()
+      layer.removeAll();
     }
-    layer.addMany(graphics)
-    return { layer, graphics }
+    layer.addMany(graphics);
+    return { layer, graphics };
   } catch (error) {
-    console.error('createPolygonGraphicsLayer failed:', error)
-    return null
+    console.error("createPolygonGraphicsLayer failed:", error);
+    return null;
   }
 }
 
@@ -12276,181 +12379,192 @@ var arcgisMap = null,
   currentAbortController,
   isClickLocked = false,
   mapLocationMixin_pointLayer = null,
-  searchViewModel = null
+  searchViewModel = null;
 let markerData = {
   url: ico_location_namespaceObject,
   width: 20,
-  height: 18
-}
+  height: 18,
+};
 const mapLocationMixin = {
   components: { loadingBox: loading, searchMap: search_map, svgIcon: svgIcon },
   props: {
     mapParams: {
       type: Object,
-      default: map_config
+      default: map_config,
     },
     defaultCenter: {
       type: Array,
       default: () => {
-        return []
-      }
+        return [];
+      },
     },
     isSearch: {
       type: Boolean,
-      default: true
+      default: true,
     },
     disabled: {
       type: Boolean,
-      default: false
-    }
+      default: false,
+    },
   },
   computed: {
     isShowPoint() {
-      return !this.disabled && this.isSearch
+      return !this.disabled && this.isSearch;
     },
-    mapCenter() {}
+    mapCenter() {},
   },
   data() {
     return {
-      mapId: 'map' + Math.round(Math.random() * 10000),
+      mapId: "map" + Math.round(Math.random() * 10000),
       isLoading: true, //地图加载loading
       center: [],
-      address: '',
+      address: "",
       pointCenter: [113.536308532987, 23.3450945634734],
       pointData: {
-        longitude: '',
-        latitude: '',
-        address: ''
-      }
-    }
+        longitude: "",
+        latitude: "",
+        address: "",
+      },
+    };
   },
   methods: {
     /**
      * 返回地图容器
      */
     getMap() {
-      return arcgisMap
+      return arcgisMap;
     },
     /**
      * 返回地图容器
      */
     getView() {
-      return arcgisView
+      return arcgisView;
     },
     setupMapEvents(view) {
       // 点击
-      this._clickHandler = view.on('click', this.debounce(this.handleMapClick, 300))
+      this._clickHandler = view.on(
+        "click",
+        this.debounce(this.handleMapClick, 300)
+      );
       // 悬浮
-      this._hoverHandler = view.on('pointer-move', this.debounce(this.handleMapHover, 80))
+      this._hoverHandler = view.on(
+        "pointer-move",
+        this.debounce(this.handleMapHover, 80)
+      );
     },
 
     handleMapClick(e) {
       // 处理点击逻辑
-      if (isClickLocked) return
+      if (isClickLocked) return;
       // 取消上一次未完成的 hitTest
       if (currentAbortController) {
-        currentAbortController.abort()
+        currentAbortController.abort();
       }
-      currentAbortController = new AbortController()
-      isClickLocked = true
+      currentAbortController = new AbortController();
+      isClickLocked = true;
       const eventData = {
         mapPoint: e.mapPoint,
-        type: 'click'
-      }
-      const hitTestPromise = arcgisView.hitTest(e) // 注意：ArcGIS hitTest 不支持 signal，此为未来兼容
+        type: "click",
+      };
+      const hitTestPromise = arcgisView.hitTest(e); // 注意：ArcGIS hitTest 不支持 signal，此为未来兼容
       hitTestPromise
         .then((hitResult) => {
-          if (currentAbortController.signal.aborted) return // 已取消
-          eventData.event = hitResult
+          if (currentAbortController.signal.aborted) return; // 已取消
+          eventData.event = hitResult;
           if (this.isShowPoint && searchViewModel) {
-            let point = e.mapPoint
+            let point = e.mapPoint;
             if (point) {
-              this.pointData.longitude = point.x
-              this.pointData.latitude = point.y
-              mapLocationMixin_pointLayer.graphics._items[0].geometry.longitude = point.x
-              mapLocationMixin_pointLayer.graphics._items[0].geometry.latitude = point.y
-              this.pointData.address = ''
-              searchViewModel.update(mapLocationMixin_pointLayer.graphics._items[0])
+              this.pointData.longitude = point.x;
+              this.pointData.latitude = point.y;
+              mapLocationMixin_pointLayer.graphics._items[0].geometry.longitude = point.x;
+              mapLocationMixin_pointLayer.graphics._items[0].geometry.latitude = point.y;
+              this.pointData.address = "";
+              searchViewModel.update(mapLocationMixin_pointLayer.graphics._items[0]);
             }
           }
-          this.$emit('mapEventClick', eventData)
+          this.$emit("mapEventClick", eventData);
         })
         .catch((err) => {
-          if (err.name === 'AbortError') return
-          console.warn('hitTest error', err)
+          if (err.name === "AbortError") return;
+          console.warn("hitTest error", err);
         })
         .finally(() => {
           setTimeout(() => {
-            isClickLocked = false
-            currentAbortController = null
-          }, 300)
-        })
+            isClickLocked = false;
+            currentAbortController = null;
+          }, 300);
+        });
     },
 
     async handleMapHover(event) {
       // 处理 hover 逻辑
-      const hitData = await arcgisView.hitTest(event)
+      const hitData = await arcgisView.hitTest(event);
       if (hitData && hitData.results && hitData.screenPoint) {
-        arcgisView.container.style.cursor = 'pointer'
+        arcgisView.container.style.cursor = "pointer";
 
-        this.$emit('mapEventMouse', hitData)
-      } else arcgisView.container.style.cursor = 'default'
+        this.$emit("mapEventMouse", hitData);
+      } else arcgisView.container.style.cursor = "default";
     },
 
     debounce(fn, delay) {
-      let timer
+      let timer;
       return (...args) => {
-        clearTimeout(timer)
-        timer = setTimeout(() => fn.apply(this, args), delay)
-      }
+        clearTimeout(timer);
+        timer = setTimeout(() => fn.apply(this, args), delay);
+      };
     },
 
     cleanupMapEvents() {
-      this._clickHandler?.remove()
-      this._hoverHandler?.remove()
+      this._clickHandler.remove();
+      this._hoverHandler.remove();
     },
     /**
      * 地图加载完成
      */
     loadEdMap(data) {
-      arcgisMap = data.map
-      arcgisView = data.view
-      initMapPack(data)
-      mapLocationMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: 'pointLayer' })
-      arcgisMap.add(mapLocationMixin_pointLayer, 10)
+      arcgisMap = data.map;
+      arcgisView = data.view;
+      initMapPack(data);
+      mapLocationMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: "pointLayer" });
+      arcgisMap.add(mapLocationMixin_pointLayer, 10);
       if (this.isShowPoint) {
-        this.setSearchVm()
+        this.setSearchVm();
       } else {
-        this.moveCenterPoint()
+        this.moveCenterPoint();
       }
-      this.setupMapEvents(data.view)
+      this.setupMapEvents(data.view);
       if (this.center && this.center.length == 2) {
         (0,utils_namespaceObject.goToPoint)({
           longitude: this.center[0],
-          latitude: this.center[1]
-        })
+          latitude: this.center[1],
+        });
       }
-      this.$emit('loadEdMap', data)
+      this.$emit("loadEdMap", data);
     },
     moveCenterPoint() {
-      if (this.center && this.center.length == 2 && this.center[0] && this.center[1]) {
+      if (
+        this.center &&
+        this.center.length == 2 &&
+        this.center[0] &&
+        this.center[1]
+      ) {
         this.refreshPoint({
           longitude: this.center[0],
-          latitude: this.center[1]
-        })
+          latitude: this.center[1],
+        });
       } else if (this.address) {
         getGeocoderAddress(this.address)
           .then((resData) => {
             if (resData && resData.lon && resData.lat) {
               this.refreshPoint({
-                longitude: resData.lon || '',
-                latitude: resData.lat
-              })
+                longitude: resData.lon || "",
+                latitude: resData.lat,
+              });
             }
           })
           .catch((err) => {
-            console.log('err', err)
-          })
+            console.log("err", err);
+          });
       } else if (
         this.defaultCenter &&
         this.defaultCenter.length == 2 &&
@@ -12459,13 +12573,13 @@ const mapLocationMixin = {
       ) {
         this.refreshPoint({
           longitude: this.defaultCenter[0],
-          latitude: this.defaultCenter[1]
-        })
+          latitude: this.defaultCenter[1],
+        });
       } else
         this.refreshPoint({
           longitude: this.pointCenter[0],
-          latitude: this.pointCenter[1]
-        })
+          latitude: this.pointCenter[1],
+        });
     },
     /**
      * 设置搜索的可编辑图层
@@ -12473,78 +12587,83 @@ const mapLocationMixin = {
     setSearchVm() {
       if (!this.disabled) {
         let pointSymbol = {
-          type: 'picture-marker', // autocasts as new PictureFillSymbol()
+          type: "picture-marker", // autocasts as new PictureFillSymbol()
           ...markerData,
-          img: markerData.url
-        }
+          img: markerData.url,
+        };
         searchViewModel = new window.jkEsri.SketchViewModel({
           view: arcgisView, // view 是你的地图视图
           layer: mapLocationMixin_pointLayer,
           pointSymbol: pointSymbol,
           polylineSymbol: {
-            type: 'simple-line',
-            color: '#8A2BE2',
-            width: '4',
-            style: 'dash',
+            type: "simple-line",
+            color: "#8A2BE2",
+            width: "4",
+            style: "dash",
             spatialReference: {
-              wkid: 4326
-            }
+              wkid: 4326,
+            },
           },
           polygonSymbol: {
-            type: 'simple-fill',
-            color: 'rgba(0, 45, 99,0.4)',
-            style: 'solid',
+            type: "simple-fill",
+            color: "rgba(0, 45, 99,0.4)",
+            style: "solid",
             outline: {
-              color: 'white',
-              width: 2
+              color: "white",
+              width: 2,
             },
             spatialReference: {
-              wkid: 4326
-            }
+              wkid: 4326,
+            },
           },
           spatialReference: {
-            wkid: 4326
-          }
-        })
-        this.moveCenterPoint()
-        searchViewModel.on('update', (event) => {
-          if (event && event.graphics && event.graphics.length > 0 && event.graphics[0].geometry) {
-            let geometry = event.graphics[0].geometry
+            wkid: 4326,
+          },
+        });
+        this.moveCenterPoint();
+        searchViewModel.on("update", (event) => {
+          if (
+            event &&
+            event.graphics &&
+            event.graphics.length > 0 &&
+            event.graphics[0].geometry
+          ) {
+            let geometry = event.graphics[0].geometry;
             event.graphics[0].symbol = getPictureSymbol({
-              ...markerData
-            })
+              ...markerData,
+            });
             if (this.isSearch) {
-              this.pointData.longitude = geometry.longitude
-              this.pointData.latitude = geometry.latitude
-              this.pointData.address = ''
+              this.pointData.longitude = geometry.longitude;
+              this.pointData.latitude = geometry.latitude;
+              this.pointData.address = "";
             }
-            event.graphic = event.graphics[0]
+            event.graphic = event.graphics[0];
           }
-        })
-      } else this.moveCenterPoint()
+        });
+      } else this.moveCenterPoint();
     },
 
     clearSearchMap() {
-      console.log('')
+      console.log("");
     },
     clearSketch() {
-      mapLocationMixin_pointLayer && mapLocationMixin_pointLayer.removeAll()
+      mapLocationMixin_pointLayer && mapLocationMixin_pointLayer.removeAll();
       if (this.$refs.searchRef && this.$refs.searchRef.clearSearch)
-        this.$refs.searchRef.clearSearch()
+        this.$refs.searchRef.clearSearch();
     },
     /**
      * 搜索绘图
      * @param data
      */
     refreshPoint(data) {
-      mapLocationMixin_pointLayer && mapLocationMixin_pointLayer.removeAll()
-      this.pointData = { ...data, ...markerData }
-      mapLocationMixin_pointLayer.add(drawArcPoint(this.pointData))
+      mapLocationMixin_pointLayer && mapLocationMixin_pointLayer.removeAll();
+      this.pointData = { ...data, ...markerData };
+      mapLocationMixin_pointLayer.add(drawArcPoint(this.pointData));
       if (this.isShowPoint)
         setTimeout(() => {
-          searchViewModel.update(mapLocationMixin_pointLayer.graphics._items[0])
-        }, 200)
-      ;(0,utils_namespaceObject.goToPoint)(data)
+          searchViewModel.update(mapLocationMixin_pointLayer.graphics._items[0]);
+        }, 200);
+      (0,utils_namespaceObject.goToPoint)(data);
     },
     /**
      * 初始化点
@@ -12553,12 +12672,12 @@ const mapLocationMixin = {
      * @param {String} options.address 中文地址
      */
     initPoint(options) {
-      this.center = []
-      this.address = ''
-      this.pointData.address = ''
+      this.center = [];
+      this.address = "";
+      this.pointData.address = "";
       if (options) {
         if (options.address) {
-          this.address = data.address
+          this.address = data.address;
         }
         if (
           options.center &&
@@ -12566,12 +12685,12 @@ const mapLocationMixin = {
           options.center[0] &&
           options.center[1]
         ) {
-          this.center = data.center
+          this.center = data.center;
         }
         if (arcgisMap && arcgisView) {
           setTimeout(() => {
-            this.moveCenterPoint()
-          }, 200)
+            this.moveCenterPoint();
+          }, 200);
         }
       }
     },
@@ -12579,33 +12698,35 @@ const mapLocationMixin = {
      * 搜索回调
      */
     async returnPoint() {
-      let datas = this.pointData
+      let datas = this.pointData;
       if (datas && datas.longitude && datas.latitude) {
         if (!datas.address) {
           let resData = await getGeocoderLg({
             longitude: this.pointData.longitude,
-            latitude: this.pointData.latitude
-          })
+            latitude: this.pointData.latitude,
+          });
           if (resData && resData.addressComponent) {
-            let address = ''
-            address = resData.addressComponent.address ? resData.addressComponent.address : ''
+            let address = "";
+            address = resData.addressComponent.address
+              ? resData.addressComponent.address
+              : "";
             datas = {
               ...this.pointData,
               ...resData.addressComponent,
-              address
-            }
+              address,
+            };
           }
         }
-        return datas
-      } else return datas
-    }
+        return datas;
+      } else return datas;
+    },
   },
   beforeUnmount() {
-    this.clearSketch()
-    this._clickHandler?.remove()
-    this._hoverHandler?.remove()
-  }
-}
+    this.clearSketch();
+    this._clickHandler.remove();
+    this._hoverHandler.remove();
+  },
+};
 
 ;// ./src/lib/eventManager.js
 /**
@@ -12749,8 +12870,8 @@ function createEventManager(originalFn, options = {}) {
 
 
 
-let MapWrapper_esri = {} // 全局 esri 缓存（可选，用于调试）
-;
+let MapWrapper_esri = {}; // 全局 esri 缓存（可选，用于调试）
+
 
 class MapWrapper {
   /**
@@ -12760,19 +12881,19 @@ class MapWrapper {
    * @returns
    */
   constructor(id, params = {}) {
-    this.id = id
-    let param = { ...map_config, ...params }
-    this.param = param
-    this.__config = param.config || {}
-    this.layersType = param.layersType
+    this.id = id;
+    let param = { ...map_config, ...params };
+    this.param = param;
+    this.__config = param.config || {};
+    this.layersType = param.layersType;
     // 存储原始参数，供 TDTinstance 使用
-    this.mapParams = { ...param }
+    this.mapParams = { ...param };
 
     // ✅ 使用 createEventManager 替代 eventBox
-    this.onloadMap = createEventManager()
+    this.onloadMap = createEventManager();
 
-    this.createMap(id, param)
-    return this
+    this.createMap(id, param);
+    return this;
   }
   /**
    * 创建地图
@@ -12780,7 +12901,7 @@ class MapWrapper {
    * @param {*} param
    */
   createMap(id, param) {
-    this.init(param)
+    this.init(param);
   }
   /**
    * 加载js和css
@@ -12789,27 +12910,27 @@ class MapWrapper {
   init(param) {
     if (!window.jkEsri) {
       if (param.initCss) {
-        (0,esri_loader.loadCss)(param.initCss)
+        (0,esri_loader.loadCss)(param.initCss);
       }
       const modules = param.modules || [
-        'esri/Map',
-        'esri/views/MapView',
-        'esri/layers/WebTileLayer',
-        'esri/geometry/Extent',
-        'esri/geometry/SpatialReference',
-        'esri/geometry/support/webMercatorUtils',
-        'esri/geometry/geometryEngine'
-      ]
+        "esri/Map",
+        "esri/views/MapView",
+        "esri/layers/WebTileLayer",
+        "esri/geometry/Extent",
+        "esri/geometry/SpatialReference",
+        "esri/geometry/support/webMercatorUtils",
+        "esri/geometry/geometryEngine",
+      ];
       // 更新 mapParams.modules 用于 TDTinstance 解析
-      this.mapParams.modules = modules
-      ;(0,esri_loader.loadModules)(modules, { url: param.initJs })
+      this.mapParams.modules = modules;
+      (0,esri_loader.loadModules)(modules, { url: param.initJs })
         .then(this.TDTinstance.bind(this, this.mapParams))
         .then(this.initMap.bind(this))
         .catch((err) => {
-          console.error('地图模块加载失败:', err)
-          throw err
-        })
-    } else this.initMap()
+          console.error("地图模块加载失败:", err);
+          throw err;
+        });
+    } else this.initMap();
   }
 
   /**
@@ -12818,69 +12939,74 @@ class MapWrapper {
    * @param {Array} args - loadModules 返回的模块实例数组
    */
   TDTinstance(mapSet, args) {
-    MapWrapper_esri = {} // 重置
+    MapWrapper_esri = {}; // 重置
     for (const k in args) {
-      if (!args.hasOwnProperty(k)) continue
+      if (!args.hasOwnProperty(k)) continue;
 
       // 获取模块短名称（如 'esri/Map' → 'Map'）
-      const name = mapSet.modules[k].split('/').pop()
+      const name = mapSet.modules[k].split("/").pop();
 
       // 特殊处理 webMercatorUtils
-      if (name === 'webMercatorUtils') {
-        MapWrapper_esri.webMercatorToGeographic = args[k].webMercatorToGeographic
-        MapWrapper_esri.geographicToWebMercator = args[k].geographicToWebMercator
+      if (name === "webMercatorUtils") {
+        MapWrapper_esri.webMercatorToGeographic = args[k].webMercatorToGeographic;
+        MapWrapper_esri.geographicToWebMercator = args[k].geographicToWebMercator;
       }
 
       // 特殊处理 geometryEngine（直接挂载整个对象）
-      if (name === 'geometryEngine') {
-        MapWrapper_esri.geometryEngine = args[k]
+      if (name === "geometryEngine") {
+        MapWrapper_esri.geometryEngine = args[k];
       }
 
       // 通用挂载：esri.Map, esri.MapView 等
-      MapWrapper_esri[name] = args[k]
+      MapWrapper_esri[name] = args[k];
     }
 
     // 暴露到 window（便于调试，生产环境可移除）
-    window.jkEsri = MapWrapper_esri
+    window.jkEsri = MapWrapper_esri;
 
     // 同时保存到实例，避免全局依赖
-    this.esri = MapWrapper_esri
+    this.esri = MapWrapper_esri;
   }
   /**
    * 初始化地图
    * @returns
    */
   initMap() {
-    let layer = null
-    if ((this.layersType == 'dynamic' || this.layersType == 'TileLayer') && this.param.baseMapUrl) {
+    let layer = null;
+    if (
+      (this.layersType == "dynamic" || this.layersType == "TileLayer") &&
+      this.param.baseMapUrl
+    ) {
       var layerApi =
-        this.layersType == 'dynamic' ? window.jkEsri.MapImageLayer : window.jkEsri.TileLayer
+        this.layersType == "dynamic"
+          ? window.jkEsri.MapImageLayer
+          : window.jkEsri.TileLayer;
       layer = new layerApi({
         url: this.param.baseMapUrl,
         title: this.layersType,
         opacity: 1,
-        visible: true
-      })
+        visible: true,
+      });
       createBase(this.id, layer, this.param).then((res) => {
-        this.onloadMap(res)
-      })
+        this.onloadMap(res);
+      });
     } else
       createMapView(this.id, this.param).then((res) => {
-        this.onloadMap(res)
-      })
+        this.onloadMap(res);
+      });
   }
 
   /**
    * 销毁
    */
   destroy() {
-    this.onloadMap?.destroy?.()
+    this.onloadMap.destroy();
     if (this.view) {
-      this.view.container = null
-      this.view = null
+      this.view.container = null;
+      this.view = null;
     }
-    this.map = null
-    this.esri = null
+    this.map = null;
+    this.esri = null;
   }
 }
 
@@ -12959,13 +13085,13 @@ let mapMixin_arcgisMap = null,
   drawingText = null,
   layerDraw = null,
   layerDrawText = null,
-  drawEnd = 0
+  drawEnd = 0;
 
 const mapMixin_markerData = {
   url: ico_location_namespaceObject,
   width: 20,
-  height: 18
-}
+  height: 18,
+};
 
 const mapMixin = {
   components: { searchMap: search_map, svgIcon: svgIcon, loadingBox: loading },
@@ -12973,255 +13099,277 @@ const mapMixin = {
     mapParams: {
       type: Object,
       default: () => {
-        return {}
-      }
+        return {};
+      },
     },
     module: {
       type: Array,
       default: () => {
-        return ['search', 'edit', 'screen'] //edit:编辑,screen:全屏,search:搜索-'search', 'edit', 'screen'
-      }
+        return ["search", "edit", "screen"]; //edit:编辑,screen:全屏,search:搜索-'search', 'edit', 'screen'
+      },
     },
     isUseMore: {
       type: Boolean,
-      default: false
+      default: false,
     },
     center: {
       type: Array,
-      default: () => [115.837683, 23.43353]
+      default: () => [115.837683, 23.43353],
     },
     type: {
       type: Array,
-      default: () => ['point', 'polyline', 'polygon'] //'point', 'polyline', 'polygon'
-    }
+      default: () => ["point", "polyline", "polygon"], //'point', 'polyline', 'polygon'
+    },
   },
   computed: {
     isShowPoint() {
-      return this.type && this.type.includes('point')
+      return this.type && this.type.includes("point");
     },
     isSearch() {
-      return this.module && this.module.length > 0 && this.module.indexOf('search') > -1
+      return (
+        this.module &&
+        this.module.length > 0 &&
+        this.module.indexOf("search") > -1
+      );
     },
     isUseSketch() {
-      return this.module && this.module.length > 0 && this.module.indexOf('edit') > -1
+      return (
+        this.module &&
+        this.module.length > 0 &&
+        this.module.indexOf("edit") > -1
+      );
     },
     isShowBtnBox() {
       return (
         this.module &&
         this.module.length > 0 &&
-        (this.module.indexOf('edit') > -1 || this.module.indexOf('screen') > -1)
-      )
-    }
+        (this.module.indexOf("edit") > -1 || this.module.indexOf("screen") > -1)
+      );
+    },
   },
   data() {
     return {
-      mapId: 'map' + Math.round(Math.random() * 10000),
+      mapId: "map" + Math.round(Math.random() * 10000),
       isLoading: true,
       pointData: null,
       isPerv: false,
       isNextList: [],
-      drawIngArea: 0
-    }
+      drawIngArea: 0,
+    };
   },
   methods: {
     getMap() {
-      return mapMixin_arcgisMap
+      return mapMixin_arcgisMap;
     },
     getView() {
-      return mapMixin_arcgisView
+      return mapMixin_arcgisView;
     },
     setupMapEvents(view) {
-      this._clickHandler = view.on('click', this.debounce(this.handleMapClick, 300))
-      this._hoverHandler = view.on('pointer-move', this.debounce(this.handleMapHover, 80))
+      this._clickHandler = view.on(
+        "click",
+        this.debounce(this.handleMapClick, 300)
+      );
+      this._hoverHandler = view.on(
+        "pointer-move",
+        this.debounce(this.handleMapHover, 80)
+      );
     },
     async handleMapClick(e) {
-      if (mapMixin_isClickLocked) return
+      if (mapMixin_isClickLocked) return;
       if (mapMixin_currentAbortController) {
-        mapMixin_currentAbortController.abort()
+        mapMixin_currentAbortController.abort();
       }
-      mapMixin_currentAbortController = new AbortController()
-      mapMixin_isClickLocked = true
+      mapMixin_currentAbortController = new AbortController();
+      mapMixin_isClickLocked = true;
       const eventData = {
         mapPoint: e.mapPoint,
-        type: 'click'
-      }
+        type: "click",
+      };
       try {
-        const hitResult = await mapMixin_arcgisView.hitTest(e)
-        if (mapMixin_currentAbortController.signal.aborted) return
-        this.$emit('mapEventClick', { ...eventData, ...hitResult })
+        const hitResult = await mapMixin_arcgisView.hitTest(e);
+        if (mapMixin_currentAbortController.signal.aborted) return;
+        this.$emit("mapEventClick", { ...eventData, ...hitResult });
       } catch (err) {
-        if (err.name !== 'AbortError') {
-          console.warn('hitTest error', err)
+        if (err.name !== "AbortError") {
+          console.warn("hitTest error", err);
         }
       } finally {
         setTimeout(() => {
-          mapMixin_isClickLocked = false
-          mapMixin_currentAbortController = null
-        }, 300)
+          mapMixin_isClickLocked = false;
+          mapMixin_currentAbortController = null;
+        }, 300);
       }
     },
 
     async handleMapHover(event) {
-      const hitData = await mapMixin_arcgisView.hitTest(event)
+      const hitData = await mapMixin_arcgisView.hitTest(event);
       hitData.results = hitData.results.filter(
-        (item) => item.layer && item.layer.id && item.layer.id.indexOf('map-mask') == -1
-      )
-      if (hitData && hitData.results && hitData.results.length > 0 && hitData.screenPoint) {
+        (item) =>
+          item.layer && item.layer.id && item.layer.id.indexOf("map-mask") == -1
+      );
+      if (
+        hitData &&
+        hitData.results &&
+        hitData.results.length > 0 &&
+        hitData.screenPoint
+      ) {
         // arcgisView.container.style.cursor = 'pointer'
-        this.$emit('mapEventMouse', hitData)
+        this.$emit("mapEventMouse", hitData);
       } else {
-        mapMixin_arcgisView.container.style.cursor = 'default'
+        mapMixin_arcgisView.container.style.cursor = "default";
       }
     },
 
     debounce(fn, delay) {
-      let timer
+      let timer;
       return (...args) => {
-        clearTimeout(timer)
-        timer = setTimeout(() => fn.apply(this, args), delay)
-      }
+        clearTimeout(timer);
+        timer = setTimeout(() => fn.apply(this, args), delay);
+      };
     },
 
     cleanupMapEvents() {
-      this._clickHandler?.remove()
-      this._hoverHandler?.remove()
+      this._clickHandler.remove();
+      this._hoverHandler.remove();
     },
 
     loadEdMap(data) {
-      mapMixin_arcgisMap = data.map
-      mapMixin_arcgisView = data.view
-      initMapPack(data)
-      this.setupMapEvents(data.view)
+      mapMixin_arcgisMap = data.map;
+      mapMixin_arcgisView = data.view;
+      initMapPack(data);
+      this.setupMapEvents(data.view);
       if (this.isSearch) {
-        mapMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: 'pointLayer' })
-        mapMixin_arcgisMap.add(mapMixin_pointLayer, 10)
+        mapMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: "pointLayer" });
+        mapMixin_arcgisMap.add(mapMixin_pointLayer, 10);
       }
       if (this.isUseSketch) {
-        this.loadSketch()
+        this.loadSketch();
       }
       if (this.center && this.center.length === 2) {
         goToMap({
           longitude: this.center[0],
-          latitude: this.center[1]
-        })
+          latitude: this.center[1],
+        });
       }
-      this.$emit('loadEdMap', data)
+      this.$emit("loadEdMap", data);
     },
 
     clearSearchMap() {
-      mapMixin_pointLayer?.removeAll()
+      mapMixin_pointLayer.removeAll();
     },
 
     refreshPoint(data) {
-      mapMixin_pointLayer?.removeAll()
+      mapMixin_pointLayer.removeAll();
       this.pointData = {
         ...data,
-        ...mapMixin_markerData
-      }
-      mapMixin_pointLayer.add(drawArcPoint(this.pointData))
-      goToMap(data)
+        ...mapMixin_markerData,
+      };
+      mapMixin_pointLayer.add(drawArcPoint(this.pointData));
+      goToMap(data);
     },
     uuidGenerator() {
-      const originStr = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
-      const originChar = 'ABCDEFGHJKMNPQRSTWXYZ0123456789'
-      const len = originChar.length
-      return originStr.replace(/x/g, () => originChar.charAt(Math.floor(Math.random() * len)))
+      const originStr = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+      const originChar = "ABCDEFGHJKMNPQRSTWXYZ0123456789";
+      const len = originChar.length;
+      return originStr.replace(/x/g, () =>
+        originChar.charAt(Math.floor(Math.random() * len))
+      );
     },
 
     drawLayerType(type) {
-      editGraphic = null
-      sketchDemo.create(type)
-      sketchDemo.on('create', (event) => {
-        this.isPerv = true
-
-        if (event.graphic) this.drawLayerNames(event.graphic)
-        if (event.state === 'complete') {
-          if (!this.isUseMore) sketchDemo.cancel()
-          this.isPerv = false
-          this.isNextList = []
-          this.drawIngArea = 0
-          editGraphic = null
-          drawEnd = 1
+      editGraphic = null;
+      sketchDemo.create(type);
+      sketchDemo.on("create", (event) => {
+        this.isPerv = true;
+
+        if (event.graphic) this.drawLayerNames(event.graphic);
+        if (event.state === "complete") {
+          if (!this.isUseMore) sketchDemo.cancel();
+          this.isPerv = false;
+          this.isNextList = [];
+          this.drawIngArea = 0;
+          editGraphic = null;
+          drawEnd = 1;
 
           if (event.graphic && !event.graphic.attributes) {
             const baseAttr = {
               typeId: this.uuidGenerator(),
-              name: '',
-              describe: '',
-              area: 0
-            }
-            if (event.graphic.symbol.type === 'simple-fill') {
+              name: "",
+              describe: "",
+              area: 0,
+            };
+            if (event.graphic.symbol.type === "simple-fill") {
               event.graphic.attributes = {
                 ...baseAttr,
-                type: 'polygon'
-              }
-            } else if (event.graphic.symbol.type === 'simple-line') {
+                type: "polygon",
+              };
+            } else if (event.graphic.symbol.type === "simple-line") {
               event.graphic.attributes = {
                 ...baseAttr,
-                type: 'polyline'
-              }
+                type: "polyline",
+              };
             } else {
               event.graphic.attributes = {
                 ...baseAttr,
-                type: 'point'
-              }
+                type: "point",
+              };
             }
-          } else if (event.graphics?.[0]) {
-            const g = event.graphics[0]
-            if (['simple-marker', 'picture-marker'].includes(g.symbol.type)) {
+          } else if (event.graphics[0]) {
+            const g = event.graphics[0];
+            if (["simple-marker", "picture-marker"].includes(g.symbol.type)) {
               g.symbol = getPictureSymbol({
-                url: g.attributes?.url || ico_location_namespaceObject,
-                width: g.attributes?.width || 20,
-                height: g.attributes?.height || 18
-              })
+                url: g.attributes.url || ico_location_namespaceObject,
+                width: g.attributes.width || 20,
+                height: g.attributes.height || 18,
+              });
             }
           }
-          this.drawcomplete(event)
+          this.drawcomplete(event);
         }
-      })
+      });
     },
     undo() {
-      if (!this.isPerv) return
-      sketchDemo.undo()
-      this.isNextList.push('1')
-      if (editGraphic) this.drawLayerNames(editGraphic)
+      if (!this.isPerv) return;
+      sketchDemo.undo();
+      this.isNextList.push("1");
+      if (editGraphic) this.drawLayerNames(editGraphic);
     },
     redo() {
-      if (this.isNextList.length === 0) return
-      this.isPerv = true
-      sketchDemo.redo()
-      if (editGraphic) this.drawLayerNames(editGraphic)
-      this.isNextList.pop()
+      if (this.isNextList.length === 0) return;
+      this.isPerv = true;
+      sketchDemo.redo();
+      if (editGraphic) this.drawLayerNames(editGraphic);
+      this.isNextList.pop();
     },
 
     closeLayer() {
-      if (sketchDemo?.viewModel) sketchDemo.viewModel.cancel()
-      this.isPerv = false
-      this.isNextList = []
+      if (sketchDemo.viewModel) sketchDemo.viewModel.cancel();
+      this.isPerv = false;
+      this.isNextList = [];
     },
 
     delDraw() {
-      this.clearSketch()
+      this.clearSketch();
     },
 
     changeFull() {
-      this.$emit('changeFull')
+      this.$emit("changeFull");
     },
 
     completeSketch() {
-      editGraphic = null
-      sketchDemo?.viewModel?.complete()
+      editGraphic = null;
+      sketchDemo.viewModel.complete();
     },
 
     clearSketch() {
-      this.closeLayer()
-      editGraphic = null
-      sketchLayer?.removeAll()
-      sketchTextLayer?.removeAll()
-      layerDraw?.removeAll()
-      layerDrawText?.removeAll()
-      drawingText?.removeAll()
-      mapMixin_pointLayer?.removeAll()
+      this.closeLayer();
+      editGraphic = null;
+      sketchLayer.removeAll();
+      sketchTextLayer.removeAll();
+      layerDraw.removeAll();
+      layerDrawText.removeAll();
+      drawingText.removeAll();
+      mapMixin_pointLayer.removeAll();
 
       if (
         (this.isShowPoint || this.isSearch) &&
@@ -13229,234 +13377,238 @@ const mapMixin = {
         this.$refs.searchRef.clearSearch
       ) {
         this.$nextTick(() => {
-          this.$refs.searchRef.clearSearch()
-        })
+          this.$refs.searchRef.clearSearch();
+        });
       }
     },
 
     addGeometryLayer(graphic) {
-      sketchLayer?.add(graphic)
+      sketchLayer.add(graphic);
     },
 
     loadSketch() {
-      mapMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: 'pointLayer' })
-      layerDraw = new window.jkEsri.GraphicsLayer({ id: 'layerDraw' })
-      layerDrawText = new window.jkEsri.GraphicsLayer({ id: 'layerDrawText' })
-      sketchLayer = new window.jkEsri.GraphicsLayer({ id: 'sketchLayer' })
+      mapMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: "pointLayer" });
+      layerDraw = new window.jkEsri.GraphicsLayer({ id: "layerDraw" });
+      layerDrawText = new window.jkEsri.GraphicsLayer({ id: "layerDrawText" });
+      sketchLayer = new window.jkEsri.GraphicsLayer({ id: "sketchLayer" });
       sketchTextLayer = new window.jkEsri.GraphicsLayer({
-        id: 'sketchTextLayer'
-      })
-      drawingText = new window.jkEsri.GraphicsLayer({ id: 'drawingText' })
-      mapMixin_arcgisMap.add(mapMixin_pointLayer, 10)
-      mapMixin_arcgisMap.add(layerDraw, 1)
-      mapMixin_arcgisMap.add(layerDrawText, 2)
-      mapMixin_arcgisMap.add(sketchLayer, 4)
-      mapMixin_arcgisMap.add(sketchTextLayer, 5)
-      mapMixin_arcgisMap.add(drawingText, 5)
+        id: "sketchTextLayer",
+      });
+      drawingText = new window.jkEsri.GraphicsLayer({ id: "drawingText" });
+      mapMixin_arcgisMap.add(mapMixin_pointLayer, 10);
+      mapMixin_arcgisMap.add(layerDraw, 1);
+      mapMixin_arcgisMap.add(layerDrawText, 2);
+      mapMixin_arcgisMap.add(sketchLayer, 4);
+      mapMixin_arcgisMap.add(sketchTextLayer, 5);
+      mapMixin_arcgisMap.add(drawingText, 5);
       sketchDemo = new window.jkEsri.SketchViewModel({
         layer: sketchLayer,
         view: mapMixin_arcgisView,
         polylineSymbol: {
-          type: 'simple-line',
-          color: '#fff',
-          width: '4',
-          style: 'dash'
+          type: "simple-line",
+          color: "#fff",
+          width: "4",
+          style: "dash",
         },
         polygonSymbol: {
-          type: 'simple-fill',
-          color: 'rgba(0, 45, 99,0.01)',
-          style: 'solid',
+          type: "simple-fill",
+          color: "rgba(0, 45, 99,0.01)",
+          style: "solid",
           outline: {
-            color: 'white',
-            width: 2
-          }
-        }
-      })
-      sketchDemo.on('delete', (event) => {
-        if (event.graphics?.length > 0) event.graphic = event.graphics[0]
-        this.drawIngArea = 0
-        editGraphic = null
-        this.drawcomplete(event)
-      })
-      sketchDemo.on('update', (event) => {
-        if (event.graphics?.[0]) {
-          this.drawLayerNames(event.graphics[0])
+            color: "white",
+            width: 2,
+          },
+        },
+      });
+      sketchDemo.on("delete", (event) => {
+        if (event.graphics.length > 0) event.graphic = event.graphics[0];
+        this.drawIngArea = 0;
+        editGraphic = null;
+        this.drawcomplete(event);
+      });
+      sketchDemo.on("update", (event) => {
+        if (event.graphics[0]) {
+          this.drawLayerNames(event.graphics[0]);
         }
-        if (event.state === 'start') {
-          drawEnd = 0
-          event.graphic = event.graphics[0]
+        if (event.state === "start") {
+          drawEnd = 0;
+          event.graphic = event.graphics[0];
           if (event.graphic && !event.graphic.attributes) {
             const baseAttr = {
               typeId: this.uuidGenerator(),
-              name: '',
-              describe: '',
+              name: "",
+              describe: "",
               area: 0,
-              rings: []
-            }
-            if (event.graphic.symbol.type === 'simple-fill') {
+              rings: [],
+            };
+            if (event.graphic.symbol.type === "simple-fill") {
               event.graphic.attributes = {
                 ...baseAttr,
-                type: 'polygon',
-                color: '#cef5ff',
+                type: "polygon",
+                color: "#cef5ff",
                 opacity: 20,
                 outline: {
                   opacity: 100,
-                  color: '#0ccfff',
+                  color: "#0ccfff",
                   width: 2,
-                  style: 'solid'
-                }
-              }
-            } else if (event.graphic.symbol.type === 'simple-line') {
+                  style: "solid",
+                },
+              };
+            } else if (event.graphic.symbol.type === "simple-line") {
               event.graphic.attributes = {
                 ...baseAttr,
-                type: 'polyline',
+                type: "polyline",
                 outline: {
                   opacity: 100,
-                  color: '#0ccfff',
+                  color: "#0ccfff",
                   width: 2,
-                  style: 'solid'
-                }
-              }
+                  style: "solid",
+                },
+              };
             } else {
               event.graphic.attributes = {
                 ...baseAttr,
-                type: 'point'
-              }
+                type: "point",
+              };
             }
           }
-        } else if (event.state === 'active') {
-          this.isPerv = true
-        } else if (event.state === 'complete') {
-          this.isPerv = false
-          this.isNextList = []
-          drawEnd = 1
-          this.drawIngArea = 0
-          editGraphic = null
-          event.graphic = event.graphics[0]
-          this.drawcomplete(event)
+        } else if (event.state === "active") {
+          this.isPerv = true;
+        } else if (event.state === "complete") {
+          this.isPerv = false;
+          this.isNextList = [];
+          drawEnd = 1;
+          this.drawIngArea = 0;
+          editGraphic = null;
+          event.graphic = event.graphics[0];
+          this.drawcomplete(event);
         }
-      })
+      });
     },
 
     drawLayerNames(event) {
-      if (event?.geometry?.type === 'polygon' && event.geometry.rings?.length > 0) {
-        this.drawIngArea = 0
-        editGraphic = event
-        const lastRing = event.geometry.rings[event.geometry.rings.length - 1]
-        const isDraw = lastRing.length > 2
-        const draw_Area = getArea(event.geometry)
+      if (
+        event.geometry.type === "polygon" &&
+        event.geometry.rings.length > 0
+      ) {
+        this.drawIngArea = 0;
+        editGraphic = event;
+        const lastRing = event.geometry.rings[event.geometry.rings.length - 1];
+        const isDraw = lastRing.length > 2;
+        const draw_Area = getArea(event.geometry);
         if (isDraw && draw_Area && Number(draw_Area) > 0) {
-          this.drawIngArea = Number(draw_Area).toFixed(2)
+          this.drawIngArea = Number(draw_Area).toFixed(2);
         }
-        if (event.attributes?.uuid && sketchTextLayer?.graphics?.items) {
+        if (event.attributes.uuid && sketchTextLayer.graphics.items) {
           const textItem = sketchTextLayer.graphics.items.find(
-            (item) => item.attributes?.uuid === event.attributes.uuid
-          )
+            (item) => item.attributes.uuid === event.attributes.uuid
+          );
           if (textItem) {
-            textItem.geometry = event.geometry.centroid
+            textItem.geometry = event.geometry.centroid;
           }
         }
       }
     },
 
     async retuanGraphics() {
-      let area = 0
+      let area = 0;
       let form = {
         drawEnd,
-        area: '',
-        mArea: '',
-        hectareArea: '',
-        latitude: '',
-        longitude: '',
-        ringsList: []
-      }
+        area: "",
+        mArea: "",
+        hectareArea: "",
+        latitude: "",
+        longitude: "",
+        ringsList: [],
+      };
 
-      if (sketchLayer?.graphics?.items?.length > 0) {
+      if (sketchLayer.graphics.items.length > 0) {
         for (const item of sketchLayer.graphics.items) {
-          const geomType = this.judgeLayerType(item.geometry.type)
-          let geometry = arcGISTranformGeoJson(item)
-          if (geomType === 'point') {
-            form.longitude = item.geometry.longitude
-            form.latitude = item.geometry.latitude
+          const geomType = this.judgeLayerType(item.geometry.type);
+          let geometry = arcGISTranformGeoJson(item);
+          if (geomType === "point") {
+            form.longitude = item.geometry.longitude;
+            form.latitude = item.geometry.latitude;
             form.ringsList.push({
-              type: 'Point',
-              geometry
-            })
-          } else if (geomType === 'polyline') {
+              type: "Point",
+              geometry,
+            });
+          } else if (geomType === "polyline") {
             form.ringsList.push({
-              type: 'Polyline',
+              type: "Polyline",
               geometry,
-              latitude: '',
-              longitude: '',
-              area: 0
-            })
-          } else if (geomType === 'polygon') {
-            const itemArea = getArea(item.geometry)
-
-            let polygonArea = 0
-            if (itemArea && Number(itemArea)) polygonArea = Math.abs(Number(itemArea).toFixed(2))
-            area += polygonArea
-            form.longitude = item.geometry.centroid.longitude
-            form.latitude = item.geometry.centroid.latitude
+              latitude: "",
+              longitude: "",
+              area: 0,
+            });
+          } else if (geomType === "polygon") {
+            const itemArea = getArea(item.geometry);
+
+            let polygonArea = 0;
+            if (itemArea && Number(itemArea))
+              polygonArea = Math.abs(Number(itemArea).toFixed(2));
+            area += polygonArea;
+            form.longitude = item.geometry.centroid.longitude;
+            form.latitude = item.geometry.centroid.latitude;
             form.ringsList.push({
-              type: 'polygon',
+              type: "polygon",
               geometry,
               longitude: item.geometry.centroid.longitude,
               latitude: item.geometry.centroid.latitude,
-              area: polygonArea
-            })
+              area: polygonArea,
+            });
           }
         }
       }
       if (area > 0) {
-        form.area = area
-        form.mArea = Number(area) * 0.0015 // 亩
-        form.hectareArea = Number(area) * 0.0001 // 公顷
+        form.area = area;
+        form.mArea = Number(area) * 0.0015; // 亩
+        form.hectareArea = Number(area) * 0.0001; // 公顷
       }
-      console.log('formatMapData00', form, sketchLayer.graphics.items)
-      return form
+      console.log("formatMapData00", form, sketchLayer.graphics.items);
+      return form;
     },
     async drawcomplete(event) {
-      if (event.type == 'delete') {
-        if (event.graphic?.attributes?.uuid && sketchTextLayer?.graphics?.items) {
+      if (event.type == "delete") {
+        if (event.graphic.attributes.uuid && sketchTextLayer.graphics.items) {
           const idx = sketchTextLayer.graphics.items.findIndex(
-            (item) => item.attributes?.uuid === event.graphic.attributes.uuid
-          )
+            (item) => item.attributes.uuid === event.graphic.attributes.uuid
+          );
           if (idx >= 0) {
-            sketchTextLayer.remove(sketchTextLayer.graphics.items[idx])
+            sketchTextLayer.remove(sketchTextLayer.graphics.items[idx]);
           }
         }
       }
-      const form = await this.retuanGraphics()
-      this.$emit('drawcomplete', form)
+      const form = await this.retuanGraphics();
+      this.$emit("drawcomplete", form);
     },
 
     judgeLayerType(type) {
-      if (!type) return
-      if (type.includes('oint')) return 'point'
-      if (type.includes('olygon')) return 'polygon'
-      if (type.includes('ine')) return 'polyline'
+      if (!type) return;
+      if (type.includes("oint")) return "point";
+      if (type.includes("olygon")) return "polygon";
+      if (type.includes("ine")) return "polyline";
     },
-    batchDraw(layers, type = 'edit') {
-      let layer = type == 'edit' ? sketchLayer : layerDraw
-      let graphics = []
-      if (layers?.length > 0) {
+    batchDraw(layers, type = "edit") {
+      let layer = type == "edit" ? sketchLayer : layerDraw;
+      let graphics = [];
+      if (layers.length > 0) {
         for (const item of layers) {
-          let graphic = drawLayer_drawLayer(item, item.drawType)
-          if (graphics) graphics.push(graphic)
+          let graphic = drawLayer_drawLayer(item, item.drawType);
+          if (graphics) graphics.push(graphic);
         }
         if (graphics.length > 0) {
-          layer.addMany(graphics)
+          layer.addMany(graphics);
         }
-        goToMap(layer)
+        goToMap(layer);
       }
-    }
+    },
   },
   beforeUnmount() {
-    this.clearSketch()
-    this.cleanupMapEvents()
-  }
-}
+    this.clearSketch();
+    this.cleanupMapEvents();
+  },
+};
 
 ;// ./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/vue2/augustineMap.vue?vue&type=script&lang=js
 
@@ -13520,161 +13672,175 @@ var mapListMixin_arcgisMap = null,
   mapListMixin_arcgisView = null,
   mapListMixin_currentAbortController,
   mapListMixin_isClickLocked = false,
-  mapListMixin_pointLayer = null
+  mapListMixin_pointLayer = null;
 const mapListMixin = {
   components: { loadingBox: loading },
   props: {
     mapParams: {
       type: Object,
-      default: map_config
+      default: map_config,
     },
 
     load: {
       type: Function,
-      default: null
+      default: null,
     },
     defaultCenter: {
       type: Array,
       default: () => {
-        return []
-      }
+        return [];
+      },
     },
     disabled: {
       type: Boolean,
-      default: false
-    }
+      default: false,
+    },
   },
   computed: {
-    mapCenter() {}
+    mapCenter() {},
   },
   data() {
     return {
-      mapId: 'map' + Math.round(Math.random() * 10000),
+      mapId: "map" + Math.round(Math.random() * 10000),
       isLoading: true, //地图加载loading
       center: [],
-      address: '',
+      address: "",
       pointCenter: [113.536308532987, 23.3450945634734],
-      pointsList: []
-    }
+      pointsList: [],
+    };
   },
   methods: {
     /**
      * 返回地图容器
      */
     getMap() {
-      return mapListMixin_arcgisMap
+      return mapListMixin_arcgisMap;
     },
     /**
      * 返回地图容器
      */
     getView() {
-      return mapListMixin_arcgisView
+      return mapListMixin_arcgisView;
     },
     setupMapEvents(view) {
       // 点击
-      this._clickHandler = view.on('click', this.debounce(this.handleMapClick, 300))
+      this._clickHandler = view.on(
+        "click",
+        this.debounce(this.handleMapClick, 300)
+      );
       // 悬浮
-      this._hoverHandler = view.on('pointer-move', this.debounce(this.handleMapHover, 80))
+      this._hoverHandler = view.on(
+        "pointer-move",
+        this.debounce(this.handleMapHover, 80)
+      );
     },
     changeGraphic(data) {
       if (mapListMixin_pointLayer && mapListMixin_pointLayer.graphics && mapListMixin_pointLayer.graphics._items) {
         mapListMixin_pointLayer.graphics._items.map((item) => {
           let url = item.attributes.url,
             width = item.attributes.width,
-            height = item.attributes.height
-          if (data && item && item.attributes && item.attributes.name == data.name) {
-            url = data.activeUrl ? data.activeUrl : data.url
-            width = data.width + 5
-            height = (data.height * width) / data.width
+            height = item.attributes.height;
+          if (
+            data &&
+            item &&
+            item.attributes &&
+            item.attributes.name == data.name
+          ) {
+            url = data.activeUrl ? data.activeUrl : data.url;
+            width = data.width + 5;
+            height = (data.height * width) / data.width;
           }
           item.symbol = getPictureSymbol({
             url: url,
             width: width,
-            height: height
-          })
-          return item
-        })
+            height: height,
+          });
+          return item;
+        });
       }
     },
     handleMapClick(e) {
       // 处理点击逻辑
-      if (mapListMixin_isClickLocked) return
+      if (mapListMixin_isClickLocked) return;
       // 取消上一次未完成的 hitTest
       if (mapListMixin_currentAbortController) {
-        mapListMixin_currentAbortController.abort()
+        mapListMixin_currentAbortController.abort();
       }
-      mapListMixin_currentAbortController = new AbortController()
-      mapListMixin_isClickLocked = true
+      mapListMixin_currentAbortController = new AbortController();
+      mapListMixin_isClickLocked = true;
       const eventData = {
         mapPoint: e.mapPoint,
-        type: 'click'
-      }
-      const hitTestPromise = mapListMixin_arcgisView.hitTest(e) // 注意：ArcGIS hitTest 不支持 signal，此为未来兼容
+        type: "click",
+      };
+      const hitTestPromise = mapListMixin_arcgisView.hitTest(e); // 注意：ArcGIS hitTest 不支持 signal，此为未来兼容
       hitTestPromise
         .then((hitResult) => {
-          if (mapListMixin_currentAbortController.signal.aborted) return // 已取消
-          eventData.event = hitResult
+          if (mapListMixin_currentAbortController.signal.aborted) return; // 已取消
+          eventData.event = hitResult;
           if (hitResult && hitResult.results && hitResult.results.length > 0) {
             const graphics = hitResult.results.filter(
-              (item) => item.layer && item.layer.id && item.layer.id.indexOf('pointLayer') > -1
-            )
+              (item) =>
+                item.layer &&
+                item.layer.id &&
+                item.layer.id.indexOf("pointLayer") > -1
+            );
             if (graphics && graphics.length > 0) {
               const graphic = graphics[0].graphic,
-                attributes = graphic.attributes
-              this.changeGraphic(attributes)
+                attributes = graphic.attributes;
+              this.changeGraphic(attributes);
             }
-            console.log('eventData', hitResult.results, graphics)
+            console.log("eventData", hitResult.results, graphics);
           } else {
-            this.changeGraphic(null)
+            this.changeGraphic(null);
           }
-          this.$emit('mapEventClick', eventData)
+          this.$emit("mapEventClick", eventData);
         })
         .catch((err) => {
-          if (err.name === 'AbortError') return
-          console.warn('hitTest error', err)
+          if (err.name === "AbortError") return;
+          console.warn("hitTest error", err);
         })
         .finally(() => {
           setTimeout(() => {
-            mapListMixin_isClickLocked = false
-            mapListMixin_currentAbortController = null
-          }, 300)
-        })
+            mapListMixin_isClickLocked = false;
+            mapListMixin_currentAbortController = null;
+          }, 300);
+        });
     },
 
     async handleMapHover(event) {
       // 处理 hover 逻辑
-      const hitData = await mapListMixin_arcgisView.hitTest(event)
+      const hitData = await mapListMixin_arcgisView.hitTest(event);
       if (hitData && hitData.results && hitData.screenPoint) {
-        mapListMixin_arcgisView.container.style.cursor = 'pointer'
-        this.$emit('mapEventMouse', hitData)
-      } else mapListMixin_arcgisView.container.style.cursor = 'default'
+        mapListMixin_arcgisView.container.style.cursor = "pointer";
+        this.$emit("mapEventMouse", hitData);
+      } else mapListMixin_arcgisView.container.style.cursor = "default";
     },
 
     debounce(fn, delay) {
-      let timer
+      let timer;
       return (...args) => {
-        clearTimeout(timer)
-        timer = setTimeout(() => fn.apply(this, args), delay)
-      }
+        clearTimeout(timer);
+        timer = setTimeout(() => fn.apply(this, args), delay);
+      };
     },
 
     cleanupMapEvents() {
-      this._clickHandler?.remove()
-      this._hoverHandler?.remove()
+      this._clickHandler.remove();
+      this._hoverHandler.remove();
     },
     /**
      * 地图加载完成
      */
     loadEdMap(data) {
-      mapListMixin_arcgisMap = data.map
-      mapListMixin_arcgisView = data.view
+      mapListMixin_arcgisMap = data.map;
+      mapListMixin_arcgisView = data.view;
       setTimeout(() => {
-        mapListMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: 'pointLayer' })
-        mapListMixin_arcgisMap.add(mapListMixin_pointLayer, 10)
-        this.drawPoints()
-        this.setupMapEvents(data.view)
-        this.$emit('loadEdMap', data)
-      }, 500)
+        mapListMixin_pointLayer = new window.jkEsri.GraphicsLayer({ id: "pointLayer" });
+        mapListMixin_arcgisMap.add(mapListMixin_pointLayer, 10);
+        this.drawPoints();
+        this.setupMapEvents(data.view);
+        this.$emit("loadEdMap", data);
+      }, 500);
     },
     moveCenterPoint() {
       if (
@@ -13683,16 +13849,16 @@ const mapListMixin = {
         this.defaultCenter[0] &&
         this.defaultCenter[1]
       ) {
-        goToMap(this.defaultCenter)
-      } else goToMap(this.pointCenter)
+        goToMap(this.defaultCenter);
+      } else goToMap(this.pointCenter);
     },
     drawPoints() {
       if (this.pointsList && this.pointsList.length > 0) {
         const validGraphics = this.pointsList
           .map((item) => createArcPoint(item))
-          .filter((g) => g !== null) // 过滤掉失败项
-        mapListMixin_pointLayer.addMany(validGraphics)
-        goToMap(mapListMixin_pointLayer.graphics.items)
+          .filter((g) => g !== null); // 过滤掉失败项
+        mapListMixin_pointLayer.addMany(validGraphics);
+        goToMap(mapListMixin_pointLayer.graphics.items);
       }
     },
     /**
@@ -13700,18 +13866,18 @@ const mapListMixin = {
      * @param {*} data
      */
     initPoint(data = []) {
-      this.pointsList = data || []
+      this.pointsList = data || [];
       if (mapListMixin_arcgisMap && mapListMixin_arcgisView) {
-        if (mapListMixin_pointLayer) mapListMixin_pointLayer.removeAll()
-        this.drawPoints()
+        if (mapListMixin_pointLayer) mapListMixin_pointLayer.removeAll();
+        this.drawPoints();
       }
-    }
+    },
   },
   beforeUnmount() {
-    this._clickHandler?.remove()
-    this._hoverHandler?.remove()
-  }
-}
+    this._clickHandler.remove();
+    this._hoverHandler.remove();
+  },
+};
 
 ;// ./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/vue2/mapList.vue?vue&type=script&lang=js