@jorgmoritz/gis-manager 0.1.47 → 0.1.49

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.46"};
+  version: "0.1.48"};
 
 // src/utils/version.ts
 var version = package_default.version;
@@ -3176,12 +3176,13 @@ var FrustumPyramid = class {
    * - 用 apex 的地表法线作为世界 up，重建无滚转的 right/up，从而避免 pitch 时的视觉侧倾
    * - 基于 fov 与 aspectRatio 求得底面半宽半高，沿 forward 推进 length 得到 baseCenter
    */
-  computeFrustumGeometry(apex, headingDeg, pitchDeg, rollDeg, fovDeg, length) {
+  computeFrustumGeometry(apex, headingDeg, pitchDeg, _rollDeg, fovDeg, length) {
     const C = this.CesiumNS;
     const fov = Math.max(1, Math.min(120, fovDeg ?? this.opts.fov ?? DEFAULT_FOV));
     const aspectRatio = this.opts.aspectRatio ?? 4 / 3;
     const halfFovH = C.Math.toRadians(fov / 2);
-    const halfWidth = Math.tan(halfFovH) * length;
+    const baseScale = 0.4;
+    const halfWidth = Math.tan(halfFovH) * length * baseScale;
     const halfHeight = halfWidth / aspectRatio;
     const enu = C.Transforms.eastNorthUpToFixedFrame(apex);
     const eastCol = C.Matrix4.getColumn(enu, 0, new C.Cartesian4());
@@ -4271,7 +4272,7 @@ var VertexLabelManager = class {
       startColor: options?.startColor ?? "#FF6B6B",
       outlineColor: options?.outlineColor ?? "#FFFFFF",
       textColor: options?.textColor ?? "#FFFFFF",
-      pixelOffsetY: options?.pixelOffsetY ?? -10
+      pixelOffsetY: options?.pixelOffsetY ?? 0
     };
   }
   /**
@@ -4328,7 +4329,7 @@ var VertexLabelManager = class {
       const blob = new Blob([svg], { type: "image/svg+xml" });
       const url = URL.createObjectURL(blob);
       const C = this.CesiumNS;
-      const firstWaypointIndex = this.hiddenClimbIndex === 1 ? 2 : 1;
+      const firstWaypointIndex = this.hiddenClimbIndex === 1 ? 2 : 0;
       return this.layer.entities.add({
         position,
         billboard: {
@@ -7887,7 +7888,7 @@ function renderFlightPath(CesiumNS, viewer, options) {
     description: entityDescription,
     polyline: {
       positions: positions.slice(),
-      width: options.style?.width ?? 3,
+      width: options.style?.width ?? 5,
       material: options.style?.material ?? options.style?.color ?? C.Color.fromCssColorString("#00E676"),
       clampToGround: false
     },
@@ -9158,7 +9159,7 @@ var PolygonEditor = class {
     this.editHandles = positions.map(
       (p, i) => layer.entities.add({
         position: p,
-        point: { pixelSize: 7, color: point_color },
+        point: { pixelSize: 7, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 1 },
         properties: { _vertexIndex: i }
       })
     );
@@ -9240,6 +9241,24 @@ var PolygonEditor = class {
         return void 0;
       }
     };
+    const highlightHandle = (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.outlineWidth = 2;
+      }
+    };
+    const unhighlightHandle = (index) => {
+      const handle = this.editHandles[index];
+      if (handle && handle.point) {
+        handle.point.pixelSize = 7;
+        handle.point.color = point_color;
+        handle.point.outlineColor = C.Color.BLACK;
+        handle.point.outlineWidth = 1;
+      }
+    };
     this.handler && this.handler.setInputAction(
       (movement) => {
         const picked = this.viewer.scene.pick?.(movement.position);
@@ -9249,6 +9268,7 @@ var PolygonEditor = class {
           if (typeof idx === "number") {
             this.draggingIndex = idx;
             this.originalPositionOnDrag = positions[idx];
+            highlightHandle(idx);
             if (this.segmentHighlight) {
               try {
                 layer.entities.remove(this.segmentHighlight);
@@ -9277,7 +9297,7 @@ var PolygonEditor = class {
             positions.splice(insertIndex, 0, insertPoint);
             const newHandle = layer.entities.add({
               position: insertPoint,
-              point: { pixelSize: 7, color: point_color },
+              point: { pixelSize: 7, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 1 },
               properties: { _vertexIndex: insertIndex }
             });
             this.editHandles.splice(insertIndex, 0, newHandle);
@@ -9289,6 +9309,7 @@ var PolygonEditor = class {
             });
             this.draggingIndex = insertIndex;
             this.originalPositionOnDrag = insertPoint;
+            highlightHandle(insertIndex);
             if (this.segmentHighlight) {
               try {
                 layer.entities.remove(this.segmentHighlight);
@@ -9305,6 +9326,7 @@ var PolygonEditor = class {
             }
           }
         } else {
+          unhighlightHandle(this.draggingIndex);
           this.draggingIndex = void 0;
           this.originalPositionOnDrag = void 0;
         }
@@ -9442,7 +9464,10 @@ var PolygonEditor = class {
       if (this.draggingIndex !== void 0 && this.originalPositionOnDrag) {
         positions[this.draggingIndex] = this.originalPositionOnDrag;
         const handle = this.editHandles[this.draggingIndex];
-        if (handle) handle.position = this.originalPositionOnDrag;
+        if (handle) {
+          handle.position = this.originalPositionOnDrag;
+          unhighlightHandle(this.draggingIndex);
+        }
         this.draggingIndex = void 0;
         this.originalPositionOnDrag = void 0;
       }
@@ -11248,6 +11273,89 @@ var PolygonEditor = class {
   }
 };
 
+// src/utils/LayerOrderManager.ts
+function bringDataSourceToTop(viewer, layerName) {
+  const layers = viewer.dataSources.getByName(layerName);
+  if (layers.length === 0) {
+    return false;
+  }
+  const layer = layers[0];
+  const currentIndex = viewer.dataSources.indexOf(layer);
+  const lastIndex = viewer.dataSources.length - 1;
+  if (currentIndex === lastIndex) {
+    return true;
+  }
+  viewer.dataSources.remove(layer, false);
+  viewer.dataSources.add(layer);
+  return true;
+}
+function bringPrimitiveCollectionToTop(viewer, collection) {
+  const primitives = viewer.scene.primitives;
+  const targetGuid = collection._guid;
+  let foundIndex = -1;
+  let foundPrimitive = null;
+  const count = primitives.length;
+  for (let i = 0; i < count; i++) {
+    const p = primitives.get(i);
+    if (p === collection || p._guid === targetGuid) {
+      foundIndex = i;
+      foundPrimitive = p;
+      break;
+    }
+  }
+  if (foundIndex < 0) {
+    console.warn("[LayerOrderManager] bringPrimitiveCollectionToTop: collection not found in primitives");
+    return false;
+  }
+  if (foundIndex === count - 1) {
+    return true;
+  }
+  primitives.raiseToTop(foundPrimitive);
+  return true;
+}
+function ensureLayerAbove(viewer, topLayerName, bottomLayerName) {
+  const topLayers = viewer.dataSources.getByName(topLayerName);
+  if (topLayers.length === 0) {
+    return;
+  }
+  if (!bottomLayerName) {
+    bringDataSourceToTop(viewer, topLayerName);
+    return;
+  }
+  const bottomLayers = viewer.dataSources.getByName(bottomLayerName);
+  if (bottomLayers.length === 0) {
+    bringDataSourceToTop(viewer, topLayerName);
+    return;
+  }
+  const topLayer = topLayers[0];
+  const bottomLayer = bottomLayers[0];
+  const topIndex = viewer.dataSources.indexOf(topLayer);
+  const bottomIndex = viewer.dataSources.indexOf(bottomLayer);
+  if (topIndex > bottomIndex) {
+    return;
+  }
+  bringDataSourceToTop(viewer, topLayerName);
+}
+function getDataSourceIndex(viewer, layerName) {
+  const layers = viewer.dataSources.getByName(layerName);
+  if (layers.length === 0) {
+    return -1;
+  }
+  return viewer.dataSources.indexOf(layers[0]);
+}
+function getDataSourceOrder(viewer) {
+  const result = [];
+  const count = viewer.dataSources.length;
+  for (let i = 0; i < count; i++) {
+    const ds = viewer.dataSources.get(i);
+    result.push({
+      name: ds.name,
+      index: i
+    });
+  }
+  return result;
+}
+
 // src/core/CZMLManager.ts
 var CZMLManager = class {
   constructor(CesiumNS, viewer) {
@@ -11524,16 +11632,7 @@ var CZMLManager = class {
       } else {
         layer = this.viewer.dataSources.getByName("subarray")[0];
       }
-      const inverterLayers = this.viewer.dataSources.getByName("inverter");
-      if (inverterLayers.length > 0) {
-        const inverterLayer = inverterLayers[0];
-        const index = this.viewer.dataSources.indexOf(inverterLayer);
-        const lastIndex = this.viewer.dataSources.length - 1;
-        if (index >= 0 && index < lastIndex) {
-          this.viewer.dataSources.remove(inverterLayer, false);
-          this.viewer.dataSources.add(inverterLayer);
-        }
-      }
+      ensureLayerAbove(this.viewer, "inverter", "subarray");
     } else if (type == "inverter") {
       if (this.viewer.dataSources.getByName("inverter").length < 1) {
         const data = new this.CesiumNS.CustomDataSource("inverter");
@@ -11542,14 +11641,7 @@ var CZMLManager = class {
       } else {
         layer = this.viewer.dataSources.getByName("inverter")[0];
       }
-      if (layer) {
-        const index = this.viewer.dataSources.indexOf(layer);
-        const lastIndex = this.viewer.dataSources.length - 1;
-        if (index >= 0 && index < lastIndex) {
-          this.viewer.dataSources.remove(layer, false);
-          this.viewer.dataSources.add(layer);
-        }
-      }
+      bringDataSourceToTop(this.viewer, "inverter");
     } else {
       if (this.viewer.dataSources.getByName("other").length < 1) {
         const data = new this.CesiumNS.CustomDataSource("other");
@@ -11558,14 +11650,7 @@ var CZMLManager = class {
       } else {
         layer = this.viewer.dataSources.getByName("other")[0];
       }
-      if (layer) {
-        const index = this.viewer.dataSources.indexOf(layer);
-        const lastIndex = this.viewer.dataSources.length - 1;
-        if (index >= 0 && index < lastIndex) {
-          this.viewer.dataSources.remove(layer, false);
-          this.viewer.dataSources.add(layer);
-        }
-      }
+      bringDataSourceToTop(this.viewer, "other");
     }
     const session = this.polygonEditor.startDrawing(type, layer, (entity) => {
       this.cancelActivePolygonDrawing();
@@ -11670,14 +11755,7 @@ var CZMLManager = class {
     } else {
       layer = this.viewer.dataSources.getByName("other")[0];
     }
-    if (layer) {
-      const index = this.viewer.dataSources.indexOf(layer);
-      const lastIndex = this.viewer.dataSources.length - 1;
-      if (index >= 0 && index < lastIndex) {
-        this.viewer.dataSources.remove(layer, false);
-        this.viewer.dataSources.add(layer);
-      }
-    }
+    bringDataSourceToTop(this.viewer, "other");
     return this.polygonEditor.startPointDrawing?.(layer, iconSvg, onComplete);
   }
   // New: start editing an existing polygon entity's vertices
@@ -11715,36 +11793,11 @@ var CZMLManager = class {
     const dataSource = this.getEntityDataSource(entity);
     if (!dataSource) return void 0;
     if (dataSource.name === "inverter") {
-      const index = this.viewer.dataSources.indexOf(dataSource);
-      const lastIndex = this.viewer.dataSources.length - 1;
-      if (index >= 0 && index < lastIndex) {
-        this.viewer.dataSources.remove(dataSource, false);
-        this.viewer.dataSources.add(dataSource);
-      }
-    }
-    if (dataSource.name === "subarray") {
-      const inverterLayers = this.viewer.dataSources.getByName("inverter");
-      if (inverterLayers.length > 0) {
-        const inverterLayer = inverterLayers[0];
-        const index = this.viewer.dataSources.indexOf(inverterLayer);
-        const lastIndex = this.viewer.dataSources.length - 1;
-        if (index >= 0 && index < lastIndex) {
-          this.viewer.dataSources.remove(inverterLayer, false);
-          this.viewer.dataSources.add(inverterLayer);
-        }
-      }
-    }
-    if (dataSource.name === "other") {
-      const otherLayers = this.viewer.dataSources.getByName("other");
-      if (otherLayers.length > 0) {
-        const otherLayer = otherLayers[0];
-        const index = this.viewer.dataSources.indexOf(otherLayer);
-        const lastIndex = this.viewer.dataSources.length - 1;
-        if (index >= 0 && index < lastIndex) {
-          this.viewer.dataSources.remove(otherLayer, false);
-          this.viewer.dataSources.add(otherLayer);
-        }
-      }
+      bringDataSourceToTop(this.viewer, "inverter");
+    } else if (dataSource.name === "subarray") {
+      ensureLayerAbove(this.viewer, "inverter", "subarray");
+    } else if (dataSource.name === "other") {
+      bringDataSourceToTop(this.viewer, "other");
     }
     return this.polygonEditor.startEditing(entity, dataSource, onComplete);
   }
@@ -13260,6 +13313,976 @@ var PathSafetyChecker = class {
   }
 };
 
+// src/core/polygon-manager/MassPolygonManager.ts
+var MassPolygonManager = class {
+  constructor(CesiumNS, viewer) {
+    __publicField(this, "CesiumNS");
+    __publicField(this, "viewer");
+    // 图层容器
+    __publicField(this, "layerCollection");
+    __publicField(this, "layerName");
+    // Primitives
+    __publicField(this, "primitive");
+    __publicField(this, "outlinePrimitive");
+    __publicField(this, "labelCollection");
+    // 数据存储
+    __publicField(this, "polygonDataMap", /* @__PURE__ */ new Map());
+    __publicField(this, "currentStyle");
+    __publicField(this, "currentOptions", {});
+    __publicField(this, "isClampToGround", false);
+    __publicField(this, "polygonHeight", 0);
+    // 多边形统一高度
+    // 交互配置（内部使用，回调可选）
+    __publicField(this, "interactionOptions");
+    // 事件处理器
+    __publicField(this, "hoverHandler");
+    __publicField(this, "clickHandler");
+    // 悬停状态
+    __publicField(this, "highlightedId");
+    __publicField(this, "originalHighlightFillColor");
+    __publicField(this, "originalHighlightOutlineColor");
+    // 选中状态
+    __publicField(this, "selectedId");
+    __publicField(this, "originalSelectFillColor");
+    __publicField(this, "originalSelectOutlineColor");
+    // 节流相关
+    __publicField(this, "lastPickTime", 0);
+    __publicField(this, "pickThrottleMs", 50);
+    // 悬停标签
+    __publicField(this, "hoverLabel");
+    // ========== 编辑支持方法 ==========
+    // 隐藏的多边形原始颜色存储
+    __publicField(this, "hiddenPolygonColors", /* @__PURE__ */ new Map());
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    this.currentStyle = {
+      fillColor: "rgba(0, 150, 255, 0.5)",
+      outlineColor: "rgba(255, 255, 255, 0.8)",
+      outlineWidth: 1
+    };
+    this.interactionOptions = {
+      enableHover: false,
+      enableClick: false,
+      highlightStyle: {
+        fillColor: "rgba(255, 255, 0, 0.7)",
+        outlineColor: "rgba(255, 255, 0, 1)"
+      },
+      selectStyle: {
+        fillColor: "rgba(0, 255, 128, 0.7)",
+        outlineColor: "rgba(0, 255, 128, 1)"
+      },
+      showHoverLabel: true,
+      hoverLabelStyle: {
+        font: "14px sans-serif",
+        fillColor: "#ffffff",
+        outlineColor: "#000000",
+        outlineWidth: 2,
+        backgroundColor: "rgba(0,0,0,0.7)",
+        backgroundPadding: [8, 4],
+        pixelOffset: [0, -20]
+      },
+      onHover: void 0,
+      onClick: void 0
+    };
+  }
+  /**
+   * 获取图层名称
+   */
+  getLayerName() {
+    return this.layerName;
+  }
+  /**
+   * 获取图层容器（PrimitiveCollection）
+   * 用于图层顺序管理
+   */
+  getLayerCollection() {
+    return this.layerCollection;
+  }
+  /**
+   * 批量创建多边形
+   */
+  create(polygons, options) {
+    const C = this.CesiumNS;
+    this.clear();
+    this.currentOptions = options ?? {};
+    this.layerName = options?.layerName;
+    if (options?.style) {
+      this.currentStyle = { ...this.currentStyle, ...options.style };
+    }
+    if (options?.interaction) {
+      const interaction = options.interaction;
+      this.interactionOptions = {
+        enableHover: interaction.enableHover ?? false,
+        enableClick: interaction.enableClick ?? false,
+        highlightStyle: {
+          fillColor: interaction.highlightStyle?.fillColor ?? this.interactionOptions.highlightStyle.fillColor,
+          outlineColor: interaction.highlightStyle?.outlineColor ?? this.interactionOptions.highlightStyle.outlineColor
+        },
+        selectStyle: {
+          fillColor: interaction.selectStyle?.fillColor ?? this.interactionOptions.selectStyle.fillColor,
+          outlineColor: interaction.selectStyle?.outlineColor ?? this.interactionOptions.selectStyle.outlineColor
+        },
+        showHoverLabel: interaction.showHoverLabel ?? true,
+        hoverLabelStyle: {
+          font: interaction.hoverLabelStyle?.font ?? this.interactionOptions.hoverLabelStyle.font,
+          fillColor: interaction.hoverLabelStyle?.fillColor ?? this.interactionOptions.hoverLabelStyle.fillColor,
+          outlineColor: interaction.hoverLabelStyle?.outlineColor ?? this.interactionOptions.hoverLabelStyle.outlineColor,
+          outlineWidth: interaction.hoverLabelStyle?.outlineWidth ?? this.interactionOptions.hoverLabelStyle.outlineWidth,
+          backgroundColor: interaction.hoverLabelStyle?.backgroundColor ?? this.interactionOptions.hoverLabelStyle.backgroundColor,
+          backgroundPadding: interaction.hoverLabelStyle?.backgroundPadding ?? this.interactionOptions.hoverLabelStyle.backgroundPadding,
+          pixelOffset: interaction.hoverLabelStyle?.pixelOffset ?? this.interactionOptions.hoverLabelStyle.pixelOffset
+        },
+        onHover: interaction.onHover,
+        onClick: interaction.onClick
+      };
+    }
+    this.isClampToGround = options?.clampToGround ?? false;
+    const asynchronous = options?.asynchronous ?? true;
+    this.polygonHeight = options?.height ?? 0;
+    if (this.isClampToGround && this.viewer.scene.globe) {
+      this.viewer.scene.globe.depthTestAgainstTerrain = true;
+    }
+    this.layerCollection = new C.PrimitiveCollection();
+    this.viewer.scene.primitives.add(this.layerCollection);
+    this.polygonDataMap.clear();
+    for (const polygon of polygons) {
+      this.polygonDataMap.set(polygon.id, polygon);
+    }
+    const fillInstances = [];
+    const outlineInstances = [];
+    const fillColor = C.Color.fromCssColorString(this.currentStyle.fillColor);
+    const outlineColor = C.Color.fromCssColorString(this.currentStyle.outlineColor);
+    for (const polygon of polygons) {
+      if (polygon.points.length < 3) {
+        console.warn(`[MassPolygonManager] \u591A\u8FB9\u5F62 ${polygon.id} \u9876\u70B9\u6570\u4E0D\u8DB3\uFF0C\u5DF2\u8DF3\u8FC7`);
+        continue;
+      }
+      const positions = this.convertPointsToCartesian(polygon.points);
+      const polygonGeometry = new C.PolygonGeometry({
+        polygonHierarchy: new C.PolygonHierarchy(positions),
+        perPositionHeight: false,
+        height: this.polygonHeight
+        // 使用配置的高度
+      });
+      fillInstances.push(new C.GeometryInstance({
+        geometry: polygonGeometry,
+        id: polygon.id,
+        attributes: {
+          color: C.ColorGeometryInstanceAttribute.fromColor(fillColor),
+          show: new C.ShowGeometryInstanceAttribute(true)
+        }
+      }));
+      const outlinePositionsWithHeight = polygon.points.map(
+        (p) => C.Cartesian3.fromDegrees(p.lon, p.lat, this.polygonHeight)
+      );
+      outlinePositionsWithHeight.push(outlinePositionsWithHeight[0]);
+      const outlineGeometry = new C.PolylineGeometry({
+        positions: outlinePositionsWithHeight,
+        width: this.currentStyle.outlineWidth
+      });
+      outlineInstances.push(new C.GeometryInstance({
+        geometry: outlineGeometry,
+        id: `${polygon.id}-outline`,
+        attributes: {
+          color: C.ColorGeometryInstanceAttribute.fromColor(outlineColor),
+          show: new C.ShowGeometryInstanceAttribute(true)
+        }
+      }));
+    }
+    if (fillInstances.length > 0) {
+      const appearance = new C.PerInstanceColorAppearance({ flat: true, translucent: true });
+      this.primitive = new C.Primitive({ geometryInstances: fillInstances, appearance, asynchronous });
+      this.layerCollection.add(this.primitive);
+    }
+    if (outlineInstances.length > 0) {
+      const appearance = new C.PolylineColorAppearance();
+      this.outlinePrimitive = new C.Primitive({ geometryInstances: outlineInstances, appearance, asynchronous });
+      this.layerCollection.add(this.outlinePrimitive);
+    }
+    this.labelCollection = new C.LabelCollection();
+    this.layerCollection.add(this.labelCollection);
+    if (this.interactionOptions.enableHover) {
+      this.setupHoverHandler();
+    }
+    if (this.interactionOptions.enableClick) {
+      this.setupClickHandler();
+    }
+    this.viewer.scene.requestRender();
+    return {
+      primitive: this.primitive,
+      count: fillInstances.length
+    };
+  }
+  /**
+   * 设置悬停事件处理器
+   */
+  setupHoverHandler() {
+    if (this.hoverHandler) {
+      this.hoverHandler.destroy();
+    }
+    const C = this.CesiumNS;
+    this.hoverHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
+    this.hoverHandler.setInputAction(
+      (movement) => {
+        const now = Date.now();
+        if (now - this.lastPickTime < this.pickThrottleMs) return;
+        this.lastPickTime = now;
+        const pickedObject = this.viewer.scene.pick(movement.endPosition);
+        if (pickedObject?.id && typeof pickedObject.id === "string") {
+          const polygonId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
+          if (this.polygonDataMap.has(polygonId)) {
+            if (this.highlightedId !== polygonId) {
+              this.clearHighlight();
+              this.highlightPolygon(polygonId);
+              const data = this.polygonDataMap.get(polygonId);
+              if (data) this.showLabel(data);
+              this.interactionOptions.onHover?.(polygonId, data ?? null);
+            }
+          } else {
+            this.handleMouseLeave();
+          }
+        } else {
+          this.handleMouseLeave();
+        }
+      },
+      C.ScreenSpaceEventType.MOUSE_MOVE
+    );
+  }
+  /**
+   * 设置点击事件处理器
+   */
+  setupClickHandler() {
+    if (this.clickHandler) {
+      this.clickHandler.destroy();
+    }
+    const C = this.CesiumNS;
+    this.clickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
+    this.clickHandler.setInputAction(
+      (movement) => {
+        const pickedObject = this.viewer.scene.pick(movement.position);
+        if (pickedObject?.id && typeof pickedObject.id === "string") {
+          const polygonId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
+          if (this.polygonDataMap.has(polygonId)) {
+            if (this.selectedId === polygonId) {
+              this.deselect();
+              this.interactionOptions.onClick?.(null, null);
+            } else {
+              this.select(polygonId);
+              const data = this.polygonDataMap.get(polygonId);
+              this.interactionOptions.onClick?.(polygonId, data ?? null);
+            }
+          } else {
+            if (this.selectedId) {
+              this.deselect();
+              this.interactionOptions.onClick?.(null, null);
+            }
+          }
+        } else {
+          if (this.selectedId) {
+            this.deselect();
+            this.interactionOptions.onClick?.(null, null);
+          }
+        }
+      },
+      C.ScreenSpaceEventType.LEFT_CLICK
+    );
+  }
+  /**
+   * 处理鼠标离开
+   */
+  handleMouseLeave() {
+    if (this.highlightedId) {
+      this.clearHighlight();
+      this.hideLabel();
+      this.interactionOptions.onHover?.(null, null);
+    }
+  }
+  /**
+   * 高亮指定多边形（悬停）
+   */
+  highlightPolygon(id) {
+    if (id === this.selectedId) return;
+    const C = this.CesiumNS;
+    if (!this.primitive) return;
+    try {
+      const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(id);
+      if (fillAttributes?.color) {
+        this.originalHighlightFillColor = new Uint8Array(fillAttributes.color);
+        const highlightColor = C.Color.fromCssColorString(this.interactionOptions.highlightStyle.fillColor);
+        fillAttributes.color = C.ColorGeometryInstanceAttribute.toValue(highlightColor);
+      }
+      if (this.outlinePrimitive) {
+        const outlineAttributes = this.outlinePrimitive.getGeometryInstanceAttributes?.(`${id}-outline`);
+        if (outlineAttributes?.color) {
+          this.originalHighlightOutlineColor = new Uint8Array(outlineAttributes.color);
+          const highlightColor = C.Color.fromCssColorString(this.interactionOptions.highlightStyle.outlineColor);
+          outlineAttributes.color = C.ColorGeometryInstanceAttribute.toValue(highlightColor);
+        }
+      }
+      this.highlightedId = id;
+      this.viewer.scene.requestRender();
+    } catch (e) {
+    }
+  }
+  /**
+   * 清除悬停高亮
+   */
+  clearHighlight() {
+    if (!this.highlightedId) return;
+    try {
+      if (this.primitive && this.originalHighlightFillColor) {
+        const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(this.highlightedId);
+        if (fillAttributes) {
+          fillAttributes.color = this.originalHighlightFillColor;
+        }
+      }
+      if (this.outlinePrimitive && this.originalHighlightOutlineColor) {
+        const outlineAttributes = this.outlinePrimitive.getGeometryInstanceAttributes?.(`${this.highlightedId}-outline`);
+        if (outlineAttributes) {
+          outlineAttributes.color = this.originalHighlightOutlineColor;
+        }
+      }
+      this.highlightedId = void 0;
+      this.originalHighlightFillColor = void 0;
+      this.originalHighlightOutlineColor = void 0;
+      this.viewer.scene.requestRender();
+    } catch (e) {
+    }
+  }
+  /**
+   * 选中指定多边形
+   * @param id 多边形 ID
+   * @returns 是否选中成功
+   */
+  select(id) {
+    if (!this.polygonDataMap.has(id)) return false;
+    if (this.selectedId && this.selectedId !== id) {
+      this.deselect();
+    }
+    if (this.highlightedId === id) {
+      this.clearHighlight();
+    }
+    const C = this.CesiumNS;
+    if (!this.primitive) return false;
+    try {
+      const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(id);
+      if (fillAttributes?.color) {
+        this.originalSelectFillColor = new Uint8Array(fillAttributes.color);
+        const selectColor = C.Color.fromCssColorString(this.interactionOptions.selectStyle.fillColor);
+        fillAttributes.color = C.ColorGeometryInstanceAttribute.toValue(selectColor);
+      }
+      if (this.outlinePrimitive) {
+        const outlineAttributes = this.outlinePrimitive.getGeometryInstanceAttributes?.(`${id}-outline`);
+        if (outlineAttributes?.color) {
+          this.originalSelectOutlineColor = new Uint8Array(outlineAttributes.color);
+          const selectColor = C.Color.fromCssColorString(this.interactionOptions.selectStyle.outlineColor);
+          outlineAttributes.color = C.ColorGeometryInstanceAttribute.toValue(selectColor);
+        }
+      }
+      this.selectedId = id;
+      this.viewer.scene.requestRender();
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * 取消选中
+   */
+  deselect() {
+    if (!this.selectedId) return;
+    try {
+      if (this.primitive && this.originalSelectFillColor) {
+        const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(this.selectedId);
+        if (fillAttributes) {
+          fillAttributes.color = this.originalSelectFillColor;
+        }
+      }
+      if (this.outlinePrimitive && this.originalSelectOutlineColor) {
+        const outlineAttributes = this.outlinePrimitive.getGeometryInstanceAttributes?.(`${this.selectedId}-outline`);
+        if (outlineAttributes) {
+          outlineAttributes.color = this.originalSelectOutlineColor;
+        }
+      }
+      this.selectedId = void 0;
+      this.originalSelectFillColor = void 0;
+      this.originalSelectOutlineColor = void 0;
+      this.viewer.scene.requestRender();
+    } catch (e) {
+    }
+  }
+  /**
+   * 获取当前选中的多边形数据
+   */
+  getSelected() {
+    if (!this.selectedId) return null;
+    return this.polygonDataMap.get(this.selectedId) ?? null;
+  }
+  /**
+   * 获取当前选中的多边形 ID
+   */
+  getSelectedId() {
+    return this.selectedId ?? null;
+  }
+  /**
+   * 计算多边形中心点
+   */
+  calculatePolygonCenter(points) {
+    let sumLon = 0, sumLat = 0, sumHeight = 0;
+    for (const p of points) {
+      sumLon += p.lon;
+      sumLat += p.lat;
+      sumHeight += p.height ?? 0;
+    }
+    return {
+      lon: sumLon / points.length,
+      lat: sumLat / points.length,
+      height: sumHeight / points.length
+    };
+  }
+  /**
+   * 显示悬停标签
+   */
+  showLabel(polygonData) {
+    if (!this.interactionOptions.showHoverLabel || !polygonData.name) return;
+    if (!this.labelCollection) return;
+    const C = this.CesiumNS;
+    const style = this.interactionOptions.hoverLabelStyle;
+    this.hideLabel();
+    const center = this.calculatePolygonCenter(polygonData.points);
+    const position = C.Cartesian3.fromDegrees(center.lon, center.lat, this.polygonHeight);
+    this.hoverLabel = this.labelCollection.add({
+      position,
+      text: polygonData.name,
+      font: style.font,
+      fillColor: C.Color.fromCssColorString(style.fillColor),
+      outlineColor: C.Color.fromCssColorString(style.outlineColor),
+      outlineWidth: style.outlineWidth,
+      style: C.LabelStyle.FILL_AND_OUTLINE,
+      showBackground: true,
+      backgroundColor: C.Color.fromCssColorString(style.backgroundColor),
+      backgroundPadding: new C.Cartesian2(style.backgroundPadding[0], style.backgroundPadding[1]),
+      pixelOffset: new C.Cartesian2(style.pixelOffset[0], style.pixelOffset[1]),
+      verticalOrigin: C.VerticalOrigin.BOTTOM,
+      horizontalOrigin: C.HorizontalOrigin.CENTER,
+      disableDepthTestDistance: Number.POSITIVE_INFINITY
+    });
+  }
+  /**
+   * 隐藏悬停标签
+   */
+  hideLabel() {
+    if (this.hoverLabel && this.labelCollection) {
+      this.labelCollection.remove(this.hoverLabel);
+      this.hoverLabel = void 0;
+      this.viewer.scene.requestRender();
+    }
+  }
+  /**
+   * 根据 ID 获取多边形数据
+   */
+  getById(id) {
+    return this.polygonDataMap.get(id);
+  }
+  /**
+   * 获取所有多边形数据
+   */
+  getAll() {
+    return Array.from(this.polygonDataMap.values());
+  }
+  /**
+   * 获取多边形数量
+   */
+  getCount() {
+    return this.polygonDataMap.size;
+  }
+  /**
+   * 获取所有多边形的边界框
+   */
+  getBounds() {
+    if (this.polygonDataMap.size === 0) return null;
+    const allPoints = [];
+    for (const polygon of this.polygonDataMap.values()) {
+      for (const point of polygon.points) {
+        allPoints.push({ lon: point.lon, lat: point.lat, alt: point.height });
+      }
+    }
+    return calculateGeoBounds(allPoints);
+  }
+  /**
+   * 飞行到所有多边形的范围
+   */
+  flyToBounds(options) {
+    const bounds = this.getBounds();
+    if (!bounds) {
+      console.warn("[MassPolygonManager] \u6CA1\u6709\u591A\u8FB9\u5F62\u6570\u636E\uFF0C\u65E0\u6CD5\u98DE\u884C");
+      return;
+    }
+    const C = this.CesiumNS;
+    const camera = this.viewer.camera;
+    const duration = options?.duration ?? 2;
+    const padding = options?.padding ?? 0.2;
+    const pitch = options?.pitch ?? C.Math.toRadians(-45);
+    const heading = options?.heading ?? 0;
+    const paddedWest = bounds.west - bounds.width * padding;
+    const paddedEast = bounds.east + bounds.width * padding;
+    const paddedSouth = bounds.south - bounds.height * padding;
+    const paddedNorth = bounds.north + bounds.height * padding;
+    const earthRadius = 6371e3;
+    const rectWidth = (paddedEast - paddedWest) * (Math.PI / 180) * earthRadius * Math.cos(bounds.centerLat * Math.PI / 180);
+    const rectHeight = (paddedNorth - paddedSouth) * (Math.PI / 180) * earthRadius;
+    const frustum = camera.frustum;
+    const fovy = frustum.fovy || frustum.fov || C.Math.toRadians(60);
+    const canvas = this.viewer.scene.canvas;
+    const aspectRatio = canvas.width / canvas.height;
+    const fovx = 2 * Math.atan(Math.tan(fovy / 2) * aspectRatio);
+    const absPitch = Math.abs(pitch);
+    const sinPitch = Math.sin(absPitch) || 0.707;
+    const altitudeForHeight = rectHeight / 2 / Math.tan(fovy / 2) / sinPitch;
+    const altitudeForWidth = rectWidth / 2 / Math.tan(fovx / 2) / sinPitch;
+    const altitude = Math.max(altitudeForHeight, altitudeForWidth, 500) * 1.1;
+    const destination = C.Cartesian3.fromDegrees(bounds.centerLon, bounds.centerLat, altitude);
+    const orientation = { heading, pitch, roll: 0 };
+    if (duration > 0) {
+      camera.flyTo({ destination, orientation, duration });
+    } else {
+      camera.setView({ destination, orientation });
+    }
+    console.log(`[MassPolygonManager] \u98DE\u884C\u5230\u8FB9\u754C: \u4E2D\u5FC3(${bounds.centerLon.toFixed(6)}, ${bounds.centerLat.toFixed(6)}), \u9AD8\u5EA6: ${altitude.toFixed(0)}m`);
+  }
+  /**
+   * 设置可见性
+   */
+  setVisibility(visible) {
+    if (this.layerCollection) {
+      this.layerCollection.show = visible;
+    }
+    this.viewer.scene.requestRender();
+  }
+  /**
+   * 更新样式（需要重新创建所有多边形）
+   */
+  updateStyle(style) {
+    this.currentStyle = { ...this.currentStyle, ...style };
+    const polygons = Array.from(this.polygonDataMap.values());
+    if (polygons.length > 0) {
+      this.create(polygons, { ...this.currentOptions, style: this.currentStyle });
+    }
+  }
+  /**
+   * 清除所有多边形
+   */
+  clear() {
+    if (this.hoverHandler) {
+      this.hoverHandler.destroy();
+      this.hoverHandler = void 0;
+    }
+    if (this.clickHandler) {
+      this.clickHandler.destroy();
+      this.clickHandler = void 0;
+    }
+    this.highlightedId = void 0;
+    this.selectedId = void 0;
+    this.originalHighlightFillColor = void 0;
+    this.originalHighlightOutlineColor = void 0;
+    this.originalSelectFillColor = void 0;
+    this.originalSelectOutlineColor = void 0;
+    this.hoverLabel = void 0;
+    if (this.layerCollection) {
+      this.viewer.scene.primitives.remove(this.layerCollection);
+      this.layerCollection = void 0;
+    }
+    this.primitive = void 0;
+    this.outlinePrimitive = void 0;
+    this.labelCollection = void 0;
+    this.polygonDataMap.clear();
+    this.viewer.scene.requestRender();
+  }
+  /**
+   * 销毁并释放资源
+   */
+  destroy() {
+    this.clear();
+  }
+  /**
+   * 将 PolygonPoint 数组转换为 Cartesian3 数组
+   */
+  convertPointsToCartesian(points) {
+    const C = this.CesiumNS;
+    return points.map((p) => C.Cartesian3.fromDegrees(p.lon, p.lat, p.height ?? 0));
+  }
+  /**
+   * 隐藏指定多边形（编辑时使用）
+   * 通过设置 show 属性为 false 实现视觉隐藏，保留数据
+   * @param id 多边形 ID
+   * @returns 是否成功隐藏
+   */
+  hidePolygon(id) {
+    if (!this.polygonDataMap.has(id)) {
+      console.warn(`[MassPolygonManager] hidePolygon: \u591A\u8FB9\u5F62 ${id} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    const C = this.CesiumNS;
+    if (!this.primitive) return false;
+    if (!this.primitive.ready) {
+      console.warn(`[MassPolygonManager] hidePolygon: Primitive \u5C1A\u672A\u51C6\u5907\u597D\uFF0C\u65E0\u6CD5\u9690\u85CF\u591A\u8FB9\u5F62 ${id}`);
+      return false;
+    }
+    try {
+      const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(id);
+      if (!fillAttributes) {
+        console.warn(`[MassPolygonManager] hidePolygon: \u65E0\u6CD5\u83B7\u53D6\u591A\u8FB9\u5F62 ${id} \u7684\u586B\u5145\u5C5E\u6027`);
+        return false;
+      }
+      const originalFill = fillAttributes.color ? new Uint8Array(fillAttributes.color) : new Uint8Array([255, 255, 255, 255]);
+      let originalOutline = new Uint8Array([255, 255, 255, 255]);
+      if (this.outlinePrimitive && this.outlinePrimitive.ready) {
+        const outlineAttributes = this.outlinePrimitive.getGeometryInstanceAttributes?.(`${id}-outline`);
+        if (outlineAttributes?.color) {
+          originalOutline = new Uint8Array(outlineAttributes.color);
+        }
+        if (outlineAttributes?.show !== void 0) {
+          outlineAttributes.show = C.ShowGeometryInstanceAttribute.toValue(false);
+        }
+      }
+      this.hiddenPolygonColors.set(id, {
+        fill: originalFill,
+        outline: originalOutline
+      });
+      if (fillAttributes.show !== void 0) {
+        fillAttributes.show = C.ShowGeometryInstanceAttribute.toValue(false);
+        this.viewer.scene.requestRender();
+        console.log(`[MassPolygonManager] \u5DF2\u9690\u85CF\u591A\u8FB9\u5F62: ${id}`);
+        return true;
+      }
+      console.warn(`[MassPolygonManager] hidePolygon: \u591A\u8FB9\u5F62 ${id} \u4E0D\u652F\u6301 show \u5C5E\u6027`);
+      return false;
+    } catch (e) {
+      console.error(`[MassPolygonManager] hidePolygon \u5931\u8D25:`, e);
+      return false;
+    }
+  }
+  /**
+   * 异步隐藏指定多边形（等待 Primitive 就绪后再隐藏）
+   * @param id 多边形 ID
+   * @param timeout 超时时间（毫秒），默认 5000ms
+   * @returns Promise<boolean> 是否成功隐藏
+   */
+  async hidePolygonAsync(id, timeout = 5e3) {
+    if (!this.polygonDataMap.has(id)) {
+      console.warn(`[MassPolygonManager] hidePolygonAsync: \u591A\u8FB9\u5F62 ${id} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    if (!this.primitive) return false;
+    if (this.primitive.ready) {
+      return this.hidePolygon(id);
+    }
+    console.log(`[MassPolygonManager] hidePolygonAsync: \u7B49\u5F85 Primitive \u51C6\u5907\u597D...`);
+    const startTime = Date.now();
+    return new Promise((resolve) => {
+      const checkReady = () => {
+        if (this.primitive?.ready) {
+          console.log(`[MassPolygonManager] hidePolygonAsync: Primitive \u5DF2\u51C6\u5907\u597D`);
+          resolve(this.hidePolygon(id));
+        } else if (Date.now() - startTime > timeout) {
+          console.error(`[MassPolygonManager] hidePolygonAsync: \u7B49\u5F85 Primitive \u8D85\u65F6`);
+          resolve(false);
+        } else {
+          requestAnimationFrame(checkReady);
+        }
+      };
+      checkReady();
+    });
+  }
+  /**
+   * 显示指定多边形（取消编辑或编辑失败时恢复）
+   * 恢复 show 状态为 true
+   * @param id 多边形 ID
+   * @returns 是否成功显示
+   */
+  showPolygon(id) {
+    const savedColors = this.hiddenPolygonColors.get(id);
+    if (!savedColors) {
+      console.warn(`[MassPolygonManager] showPolygon: \u591A\u8FB9\u5F62 ${id} \u672A\u88AB\u9690\u85CF\u6216\u72B6\u6001\u672A\u4FDD\u5B58`);
+      return false;
+    }
+    const C = this.CesiumNS;
+    if (!this.primitive) return false;
+    try {
+      const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(id);
+      if (!fillAttributes) {
+        console.warn(`[MassPolygonManager] showPolygon: \u65E0\u6CD5\u83B7\u53D6\u591A\u8FB9\u5F62 ${id} \u7684\u5C5E\u6027`);
+        return false;
+      }
+      if (fillAttributes.show !== void 0) {
+        fillAttributes.show = C.ShowGeometryInstanceAttribute.toValue(true);
+      }
+      if (this.outlinePrimitive && this.outlinePrimitive.ready) {
+        const outlineAttributes = this.outlinePrimitive.getGeometryInstanceAttributes?.(`${id}-outline`);
+        if (outlineAttributes?.show !== void 0) {
+          outlineAttributes.show = C.ShowGeometryInstanceAttribute.toValue(true);
+        }
+      }
+      this.hiddenPolygonColors.delete(id);
+      this.viewer.scene.requestRender();
+      console.log(`[MassPolygonManager] \u5DF2\u663E\u793A\u591A\u8FB9\u5F62: ${id}`);
+      return true;
+    } catch (e) {
+      console.error(`[MassPolygonManager] showPolygon \u5931\u8D25:`, e);
+      return false;
+    }
+  }
+  /**
+   * 检查多边形是否被隐藏
+   * @param id 多边形 ID
+   * @returns 是否被隐藏
+   */
+  isPolygonHidden(id) {
+    return this.hiddenPolygonColors.has(id);
+  }
+  /**
+   * 更新单个多边形的坐标
+   * 内部实现：更新 polygonDataMap，然后重建整个 Primitive
+   * （Primitive 不支持单个 instance 的几何修改，只能重建）
+   * @param id 多边形 ID
+   * @param newPoints 新的坐标点数组
+   * @returns 是否更新成功
+   */
+  updatePolygon(id, newPoints) {
+    const existingData = this.polygonDataMap.get(id);
+    if (!existingData) {
+      console.warn(`[MassPolygonManager] updatePolygon: \u591A\u8FB9\u5F62 ${id} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    if (newPoints.length < 3) {
+      console.warn(`[MassPolygonManager] updatePolygon: \u65B0\u5750\u6807\u70B9\u6570\u91CF\u4E0D\u8DB3 (${newPoints.length})`);
+      return false;
+    }
+    existingData.points = newPoints;
+    this.polygonDataMap.set(id, existingData);
+    this.hiddenPolygonColors.delete(id);
+    this.rebuild();
+    console.log(`[MassPolygonManager] \u5DF2\u66F4\u65B0\u591A\u8FB9\u5F62: ${id}, \u65B0\u5750\u6807\u70B9\u6570\u91CF: ${newPoints.length}`);
+    return true;
+  }
+  /**
+   * 更新多边形数据（坐标和/或名称）
+   * @param id 多边形 ID
+   * @param data 要更新的数据
+   * @returns 是否更新成功
+   */
+  updatePolygonData(id, data) {
+    const existingData = this.polygonDataMap.get(id);
+    if (!existingData) {
+      console.warn(`[MassPolygonManager] updatePolygonData: \u591A\u8FB9\u5F62 ${id} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    if (data.points !== void 0) {
+      if (data.points.length < 3) {
+        console.warn(`[MassPolygonManager] updatePolygonData: \u65B0\u5750\u6807\u70B9\u6570\u91CF\u4E0D\u8DB3`);
+        return false;
+      }
+      existingData.points = data.points;
+    }
+    if (data.name !== void 0) {
+      existingData.name = data.name;
+    }
+    this.polygonDataMap.set(id, existingData);
+    if (data.points !== void 0) {
+      this.hiddenPolygonColors.delete(id);
+      this.rebuild();
+    }
+    return true;
+  }
+  /**
+   * 重建所有 Primitive（保留当前数据和配置）
+   * 用于坐标更新后刷新渲染
+   */
+  rebuild() {
+    const polygons = Array.from(this.polygonDataMap.values());
+    if (polygons.length === 0) {
+      this.clear();
+      return;
+    }
+    const wasSelectedId = this.selectedId;
+    this.create(polygons, this.currentOptions);
+    if (wasSelectedId && this.polygonDataMap.has(wasSelectedId)) {
+      this.select(wasSelectedId);
+    }
+    console.log(`[MassPolygonManager] \u5DF2\u91CD\u5EFA ${polygons.length} \u4E2A\u591A\u8FB9\u5F62`);
+  }
+  /**
+   * 删除指定多边形
+   * @param id 多边形 ID
+   * @returns 是否删除成功
+   */
+  removePolygon(id) {
+    if (!this.polygonDataMap.has(id)) {
+      console.warn(`[MassPolygonManager] removePolygon: \u591A\u8FB9\u5F62 ${id} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    if (this.selectedId === id) {
+      this.deselect();
+    }
+    this.hiddenPolygonColors.delete(id);
+    this.polygonDataMap.delete(id);
+    this.rebuild();
+    console.log(`[MassPolygonManager] \u5DF2\u5220\u9664\u591A\u8FB9\u5F62: ${id}`);
+    return true;
+  }
+  /**
+   * 添加新多边形
+   * @param polygon 多边形数据
+   * @returns 是否添加成功
+   */
+  addPolygon(polygon) {
+    if (this.polygonDataMap.has(polygon.id)) {
+      console.warn(`[MassPolygonManager] addPolygon: \u591A\u8FB9\u5F62 ${polygon.id} \u5DF2\u5B58\u5728`);
+      return false;
+    }
+    if (polygon.points.length < 3) {
+      console.warn(`[MassPolygonManager] addPolygon: \u5750\u6807\u70B9\u6570\u91CF\u4E0D\u8DB3`);
+      return false;
+    }
+    this.polygonDataMap.set(polygon.id, polygon);
+    this.rebuild();
+    console.log(`[MassPolygonManager] \u5DF2\u6DFB\u52A0\u591A\u8FB9\u5F62: ${polygon.id}`);
+    return true;
+  }
+};
+
+// src/utils/LODManager.ts
+var LODManager = class {
+  constructor(CesiumNS, viewer, config) {
+    __publicField(this, "viewer");
+    __publicField(this, "config");
+    __publicField(this, "targets", /* @__PURE__ */ new Set());
+    __publicField(this, "removeListener");
+    __publicField(this, "lastCheckTime", 0);
+    __publicField(this, "isRunning", false);
+    __publicField(this, "currentVisibility", true);
+    __publicField(this, "onPreRender", () => {
+      if (this.isRunning) {
+        this.checkVisibility();
+      }
+    });
+    this.viewer = viewer;
+    this.config = {
+      minHeight: config?.minHeight ?? 0,
+      maxHeight: config?.maxHeight ?? Infinity,
+      checkInterval: config?.checkInterval ?? 200
+    };
+  }
+  /**
+   * 添加 LOD 控制目标
+   * @param target 具有 show 属性的对象
+   */
+  addTarget(target) {
+    this.targets.add(target);
+    target.show = this.currentVisibility;
+  }
+  /**
+   * 移除 LOD 控制目标
+   * @param target 要移除的目标
+   */
+  removeTarget(target) {
+    this.targets.delete(target);
+  }
+  /**
+   * 清除所有目标
+   */
+  clearTargets() {
+    this.targets.clear();
+  }
+  /**
+   * 获取当前相机高度
+   */
+  getCameraHeight() {
+    const cartographic = this.viewer.camera.positionCartographic;
+    return cartographic?.height ?? 0;
+  }
+  /**
+   * 检查并更新可见性
+   */
+  checkVisibility() {
+    const now = Date.now();
+    if (now - this.lastCheckTime < this.config.checkInterval) {
+      return;
+    }
+    this.lastCheckTime = now;
+    const height = this.getCameraHeight();
+    const shouldShow = height >= this.config.minHeight && height <= this.config.maxHeight;
+    if (shouldShow !== this.currentVisibility) {
+      this.currentVisibility = shouldShow;
+      this.updateTargetsVisibility(shouldShow);
+    }
+  }
+  /**
+   * 更新所有目标的可见性
+   */
+  updateTargetsVisibility(visible) {
+    for (const target of this.targets) {
+      target.show = visible;
+    }
+    this.viewer.scene.requestRender();
+  }
+  /**
+   * 启动 LOD 管理
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.lastCheckTime = 0;
+    this.checkVisibility();
+    this.removeListener = this.viewer.camera.changed.addEventListener(() => {
+      this.checkVisibility();
+    });
+    this.viewer.scene.preRender.addEventListener(this.onPreRender);
+  }
+  /**
+   * 停止 LOD 管理
+   */
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.removeListener) {
+      this.removeListener();
+      this.removeListener = void 0;
+    }
+    this.viewer.scene.preRender.removeEventListener(this.onPreRender);
+  }
+  /**
+   * 更新配置
+   */
+  updateConfig(config) {
+    if (config.minHeight !== void 0) this.config.minHeight = config.minHeight;
+    if (config.maxHeight !== void 0) this.config.maxHeight = config.maxHeight;
+    if (config.checkInterval !== void 0) this.config.checkInterval = config.checkInterval;
+    this.lastCheckTime = 0;
+    this.checkVisibility();
+  }
+  /**
+   * 强制设置可见性（忽略 LOD 规则）
+   */
+  forceVisibility(visible) {
+    this.currentVisibility = visible;
+    this.updateTargetsVisibility(visible);
+  }
+  /**
+   * 获取当前可见性状态
+   */
+  isVisible() {
+    return this.currentVisibility;
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.stop();
+    this.clearTargets();
+  }
+};
+
 // src/index.ts
 var placeholder = { ready: true };
 var droneModelUrl = wurenji_default;
@@ -13272,7 +14295,9 @@ exports.CameraManager = CameraManager;
 exports.Emitter = Emitter;
 exports.FlightSimulator = FlightSimulator;
 exports.FrustumPyramid = FrustumPyramid;
+exports.LODManager = LODManager;
 exports.LayerManager = LayerManager;
+exports.MassPolygonManager = MassPolygonManager;
 exports.PathSafetyChecker = PathSafetyChecker;
 exports.PointCloudPicker = PointCloudPicker;
 exports.PolygonEditor = PolygonEditor;
@@ -13281,6 +14306,8 @@ exports.SceneManager = SceneManager;
 exports.Selector = Selector;
 exports.StateManager = StateManager;
 exports.assertCesiumAssetsConfigured = assertCesiumAssetsConfigured;
+exports.bringDataSourceToTop = bringDataSourceToTop;
+exports.bringPrimitiveCollectionToTop = bringPrimitiveCollectionToTop;
 exports.calculateAbsoluteHeight = calculateAbsoluteHeight;
 exports.calculateBoundsDiagonal = calculateBoundsDiagonal;
 exports.calculateDistance = calculateDistance;
@@ -13296,9 +14323,12 @@ exports.convertSinoflyWayline = convertSinoflyWayline;
 exports.convertSinoflyWaylines = convertSinoflyWaylines;
 exports.droneModelUrl = droneModelUrl;
 exports.ensureCesiumIonToken = ensureCesiumIonToken;
+exports.ensureLayerAbove = ensureLayerAbove;
 exports.expandBounds = expandBounds;
 exports.getCesiumBaseUrl = getCesiumBaseUrl;
 exports.getCesiumIonToken = getCesiumIonToken;
+exports.getDataSourceIndex = getDataSourceIndex;
+exports.getDataSourceOrder = getDataSourceOrder;
 exports.globalCameraEventBus = globalCameraEventBus;
 exports.globalState = globalState;
 exports.isPointInBounds = isPointInBounds;