@jorgmoritz/gis-manager 0.1.52 → 0.1.54

package/dist/index.cjs

@@ -13,7 +13,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // package.json
 var package_default = {
   name: "@jorgmoritz/gis-manager",
-  version: "0.1.52"};
+  version: "0.1.54"};
 
 // src/utils/version.ts
 var version = package_default.version;
@@ -2702,6 +2702,8 @@ var StateManager = class {
     __publicField(this, "editing", false);
     __publicField(this, "editingTarget");
     __publicField(this, "previousView");
+    // MassPolygonManager 注册表（用于编辑模式隔离）
+    __publicField(this, "massPolygonManagers", /* @__PURE__ */ new Set());
     // Emitters
     __publicField(this, "onSelectionChange", new Emitter());
     __publicField(this, "onEditingChange", new Emitter());
@@ -2752,6 +2754,26 @@ var StateManager = class {
   getPreviousCameraView() {
     return this.previousView;
   }
+  // MassPolygonManager 注册管理
+  /**
+   * 注册 MassPolygonManager 实例
+   * 用于编辑模式下统一管理所有图层的交互状态
+   */
+  registerMassPolygonManager(manager) {
+    this.massPolygonManagers.add(manager);
+  }
+  /**
+   * 注销 MassPolygonManager 实例
+   */
+  unregisterMassPolygonManager(manager) {
+    this.massPolygonManagers.delete(manager);
+  }
+  /**
+   * 获取所有已注册的 MassPolygonManager 实例
+   */
+  getAllMassPolygonManagers() {
+    return Array.from(this.massPolygonManagers);
+  }
 };
 var globalState = new StateManager();
 
@@ -3315,8 +3337,14 @@ var CameraFOVController = class {
     if (this.sliderEl) {
       this.sliderEl.removeEventListener("input", this.handleSliderChange);
     }
-    if (this.containerEl && !this.opts.container) {
-      this.containerEl.remove();
+    if (this.containerEl) {
+      if (!this.opts.container) {
+        this.containerEl.remove();
+      } else {
+        while (this.containerEl.firstChild) {
+          this.containerEl.removeChild(this.containerEl.firstChild);
+        }
+      }
     }
     this.onFOVChange.clear();
   }
@@ -9983,7 +10011,7 @@ var PolygonEditor = class {
     this.editHandles = positions.map(
       (p, i) => layer.entities.add({
         position: p,
-        point: { pixelSize: 7, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 1 },
+        point: { pixelSize: 12, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 2 },
         properties: { _vertexIndex: i }
       })
     );
@@ -10065,29 +10093,120 @@ var PolygonEditor = class {
         return void 0;
       }
     };
-    const highlightHandle = (index) => {
+    let hoveredIndex = void 0;
+    const getHighlightColors = () => {
+      if (layer.name === "inverter") {
+        return {
+          hoverColor: C.Color.fromCssColorString("rgba(150, 255, 150, 1)"),
+          // 浅绿色
+          hoverOutline: C.Color.fromCssColorString("rgba(0, 150, 0, 1)"),
+          // 深绿色
+          selectColor: C.Color.fromCssColorString("rgba(100, 255, 100, 1)"),
+          // 亮绿色
+          selectOutline: C.Color.fromCssColorString("rgba(0, 100, 0, 1)")
+          // 深绿色
+        };
+      } else {
+        return {
+          hoverColor: C.Color.fromCssColorString("rgba(255, 150, 150, 1)"),
+          // 浅红色
+          hoverOutline: C.Color.fromCssColorString("rgba(200, 0, 0, 1)"),
+          // 深红色
+          selectColor: C.Color.fromCssColorString("rgba(255, 100, 100, 1)"),
+          // 亮红色
+          selectOutline: C.Color.fromCssColorString("rgba(150, 0, 0, 1)")
+          // 深红色
+        };
+      }
+    };
+    const highlightColors = getHighlightColors();
+    const hoverHandle = (index) => {
+      const handle = this.editHandles[index];
+      if (handle && handle.point) {
+        handle.point.pixelSize = 18;
+        handle.point.color = highlightColors.hoverColor;
+        handle.point.outlineColor = highlightColors.hoverOutline;
+        handle.point.outlineWidth = 3;
+      }
+    };
+    const unhoverHandle = (index) => {
       const handle = this.editHandles[index];
       if (handle && handle.point) {
-        handle.point.pixelSize = 10;
-        handle.point.color = C.Color.YELLOW;
-        handle.point.outlineColor = C.Color.RED;
+        handle.point.pixelSize = 12;
+        handle.point.color = point_color;
+        handle.point.outlineColor = C.Color.BLACK;
         handle.point.outlineWidth = 2;
       }
     };
+    const highlightHandle = (index) => {
+      const handle = this.editHandles[index];
+      if (handle && handle.point) {
+        handle.point.pixelSize = 16;
+        handle.point.color = highlightColors.selectColor;
+        handle.point.outlineColor = highlightColors.selectOutline;
+        handle.point.outlineWidth = 3;
+      }
+    };
     const unhighlightHandle = (index) => {
       const handle = this.editHandles[index];
       if (handle && handle.point) {
-        handle.point.pixelSize = 7;
+        handle.point.pixelSize = 12;
         handle.point.color = point_color;
         handle.point.outlineColor = C.Color.BLACK;
-        handle.point.outlineWidth = 1;
+        handle.point.outlineWidth = 2;
+      }
+    };
+    const VERTEX_PICK_RADIUS = 30;
+    const findNearestVertexByScreenDistance = (screenPos) => {
+      if (!screenPos || typeof screenPos.x !== "number" || typeof screenPos.y !== "number") {
+        return void 0;
+      }
+      const scene = this.viewer.scene;
+      const ST = this.CesiumNS.SceneTransforms;
+      let nearestIdx;
+      let nearestDist = VERTEX_PICK_RADIUS;
+      for (let i = 0; i < positions.length; i++) {
+        const worldPos = positions[i];
+        if (!worldPos) continue;
+        let screenCoord;
+        try {
+          screenCoord = ST.wgs84ToWindowCoordinates?.(scene, worldPos);
+        } catch {
+        }
+        if (!screenCoord) {
+          try {
+            screenCoord = ST.worldToWindowCoordinates?.(scene, worldPos);
+          } catch {
+          }
+        }
+        if (!screenCoord && scene.cartesianToCanvasCoordinates) {
+          try {
+            const canvasCoord = scene.cartesianToCanvasCoordinates(worldPos);
+            if (canvasCoord) {
+              screenCoord = { x: canvasCoord.x, y: canvasCoord.y };
+            }
+          } catch {
+          }
+        }
+        if (!screenCoord) continue;
+        const dx = screenPos.x - screenCoord.x;
+        const dy = screenPos.y - screenCoord.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < nearestDist) {
+          nearestDist = dist;
+          nearestIdx = i;
+        }
       }
+      return nearestIdx;
     };
     this.handler && this.handler.setInputAction(
       (movement) => {
+        const screenPos = movement.position;
+        const nearestVertexIdx = findNearestVertexByScreenDistance(screenPos);
         const picked = this.viewer.scene.pick?.(movement.position);
         const entity = picked?.id;
-        const idx = entity?.properties?._vertexIndex?.getValue?.() ?? entity?.properties?._vertexIndex;
+        const pickedIdx = entity?.properties?._vertexIndex?.getValue?.() ?? entity?.properties?._vertexIndex;
+        const idx = nearestVertexIdx ?? (typeof pickedIdx === "number" ? pickedIdx : void 0);
         if (this.draggingIndex === void 0) {
           if (typeof idx === "number") {
             this.draggingIndex = idx;
@@ -10121,7 +10240,7 @@ var PolygonEditor = class {
             positions.splice(insertIndex, 0, insertPoint);
             const newHandle = layer.entities.add({
               position: insertPoint,
-              point: { pixelSize: 7, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 1 },
+              point: { pixelSize: 12, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 2 },
               properties: { _vertexIndex: insertIndex }
             });
             this.editHandles.splice(insertIndex, 0, newHandle);
@@ -10180,10 +10299,46 @@ var PolygonEditor = class {
             }
             this.insertPreviewHandle = void 0;
           }
+          if (hoveredIndex !== void 0) {
+            unhoverHandle(hoveredIndex);
+            hoveredIndex = void 0;
+          }
           return;
         }
+        const winPos = movement?.endPosition ?? movement?.position ?? movement;
+        if (winPos) {
+          const nearestVertexIdx = findNearestVertexByScreenDistance(winPos);
+          if (nearestVertexIdx !== void 0) {
+            if (hoveredIndex !== nearestVertexIdx) {
+              if (hoveredIndex !== void 0) {
+                unhoverHandle(hoveredIndex);
+              }
+              hoveredIndex = nearestVertexIdx;
+              hoverHandle(hoveredIndex);
+            }
+            if (this.segmentHighlight) {
+              try {
+                layer.entities.remove(this.segmentHighlight);
+              } catch {
+              }
+              this.segmentHighlight = void 0;
+            }
+            if (this.insertPreviewHandle) {
+              try {
+                layer.entities.remove(this.insertPreviewHandle);
+              } catch {
+              }
+              this.insertPreviewHandle = void 0;
+            }
+            return;
+          } else {
+            if (hoveredIndex !== void 0) {
+              unhoverHandle(hoveredIndex);
+              hoveredIndex = void 0;
+            }
+          }
+        }
         try {
-          const winPos = movement?.endPosition ?? movement?.position ?? movement;
           if (!winPos) return;
           const ST = this.CesiumNS.SceneTransforms;
           const threshold = 8;
@@ -12189,6 +12344,8 @@ var CZMLManager = class {
     __publicField(this, "currentSelectedEntity", null);
     __publicField(this, "activePolygonSession", null);
     __publicField(this, "polygonSessionCleanup");
+    // 编辑模式标志
+    __publicField(this, "editingMode", false);
     __publicField(this, "_polygonEditor");
     // Path manager composition
     __publicField(this, "_pathMgr");
@@ -12478,10 +12635,17 @@ var CZMLManager = class {
       bringDataSourceToTop(this.viewer, "other");
     }
     const session = this.polygonEditor.startDrawing(type, layer, (entity) => {
+      this.exitEditingMode();
       this.cancelActivePolygonDrawing();
       onComplete?.(entity);
     });
     if (session && typeof session.stop === "function") {
+      this.enterEditingMode();
+      const originalStop = session.stop;
+      session.stop = () => {
+        this.exitEditingMode();
+        originalStop();
+      };
       this.activePolygonSession = session;
     } else {
       this.activePolygonSession = null;
@@ -12583,6 +12747,39 @@ var CZMLManager = class {
     bringDataSourceToTop(this.viewer, "other");
     return this.polygonEditor.startPointDrawing?.(layer, iconSvg, onComplete);
   }
+  /**
+   * 进入编辑模式：禁用所有 MassPolygonManager 的交互
+   * 防止编辑多边形时其他图层响应鼠标事件
+   */
+  enterEditingMode() {
+    if (this.editingMode) return;
+    this.editingMode = true;
+    const managers = globalState.getAllMassPolygonManagers?.();
+    if (managers) {
+      for (const manager of managers) {
+        manager.disableInteraction();
+      }
+    }
+  }
+  /**
+   * 退出编辑模式：恢复所有 MassPolygonManager 的交互
+   */
+  exitEditingMode() {
+    if (!this.editingMode) return;
+    this.editingMode = false;
+    const managers = globalState.getAllMassPolygonManagers?.();
+    if (managers) {
+      for (const manager of managers) {
+        manager.enableInteraction();
+      }
+    }
+  }
+  /**
+   * 检查是否处于编辑模式
+   */
+  isInEditingMode() {
+    return this.editingMode;
+  }
   // New: start editing an existing polygon entity's vertices
   // Accepts: an Entity, or an id string, or undefined to use the last selected entity from state
   startPolygonEditing(entityOrId, onComplete) {
@@ -12624,7 +12821,20 @@ var CZMLManager = class {
     } else if (dataSource.name === "other") {
       bringDataSourceToTop(this.viewer, "other");
     }
-    return this.polygonEditor.startEditing(entity, dataSource, onComplete);
+    this.enterEditingMode();
+    const wrappedOnComplete = (editedEntity) => {
+      this.exitEditingMode();
+      onComplete?.(editedEntity);
+    };
+    const session = this.polygonEditor.startEditing(entity, dataSource, wrappedOnComplete);
+    if (session) {
+      const originalStop = session.stop;
+      session.stop = () => {
+        this.exitEditingMode();
+        originalStop();
+      };
+    }
+    return session;
   }
   ensurePolygonSessionHooks() {
     if (this.polygonSessionCleanup || typeof window === "undefined" || typeof document === "undefined") {
@@ -14163,6 +14373,8 @@ var MassPolygonManager = class {
     __publicField(this, "hoverHandler");
     __publicField(this, "clickHandler");
     __publicField(this, "rightClickHandler");
+    // 交互禁用标志（编辑模式时禁用）
+    __publicField(this, "interactionDisabled", false);
     // 悬停状态
     __publicField(this, "highlightedId");
     __publicField(this, "originalHighlightFillColor");
@@ -14251,12 +14463,35 @@ var MassPolygonManager = class {
   getLayerCollection() {
     return this.layerCollection;
   }
+  /**
+   * 禁用所有交互（hover/click/rightClick）
+   * 用于编辑模式下隔离其他图层的交互
+   */
+  disableInteraction() {
+    this.interactionDisabled = true;
+    this.clearHighlight();
+    this.hideLabel();
+  }
+  /**
+   * 启用所有交互
+   * 用于退出编辑模式后恢复交互
+   */
+  enableInteraction() {
+    this.interactionDisabled = false;
+  }
+  /**
+   * 检查交互是否被禁用
+   */
+  isInteractionDisabled() {
+    return this.interactionDisabled;
+  }
   /**
    * 批量创建多边形
    */
   create(polygons, options) {
     const C = this.CesiumNS;
     this.clear();
+    globalState.registerMassPolygonManager(this);
     this.currentOptions = options ?? {};
     this.layerName = options?.layerName;
     if (options?.style) {
@@ -14450,6 +14685,7 @@ var MassPolygonManager = class {
     this.hoverHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.hoverHandler.setInputAction(
       (movement) => {
+        if (this.interactionDisabled) return;
         const now = Date.now();
         if (now - this.lastPickTime < this.pickThrottleMs) return;
         this.lastPickTime = now;
@@ -14491,6 +14727,7 @@ var MassPolygonManager = class {
     this.clickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.clickHandler.setInputAction(
       (movement) => {
+        if (this.interactionDisabled) return;
         let polygonId = null;
         if (this.isClampToGround) {
           polygonId = this.pickPolygonByPosition(movement.position);
@@ -14533,6 +14770,7 @@ var MassPolygonManager = class {
     this.rightClickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.rightClickHandler.setInputAction(
       (movement) => {
+        if (this.interactionDisabled) return;
         let polygonId = null;
         if (this.isClampToGround) {
           polygonId = this.pickPolygonByPosition(movement.position);
@@ -15313,6 +15551,7 @@ var MassPolygonManager = class {
    * 清除所有多边形
    */
   clear() {
+    globalState.unregisterMassPolygonManager(this);
     if (this.hoverHandler) {
       this.hoverHandler.destroy();
       this.hoverHandler = void 0;
@@ -15332,6 +15571,7 @@ var MassPolygonManager = class {
     this.originalSelectFillColor = void 0;
     this.originalSelectOutlineColor = void 0;
     this.hoverLabel = void 0;
+    this.interactionDisabled = false;
     this.highlightPrimitive = void 0;
     this.selectPrimitive = void 0;
     if (this.layerCollection && this.viewer?.scene?.primitives) {