raintee-maputils 1.0.15 → 1.0.17

package/dist/index.js

@@ -1,298 +1,3 @@
-class CustomOptionsControl {
-    constructor(args) {
-        const { options, onConfirm } = args;
-
-        this._container = null;
-        this._map = null;
-
-        this._options = options || [];
-        this._onConfirm = onConfirm || (() => { });
-
-        if (!this._options || !Array.isArray(this._options)) {
-            console.error('请传入有效的 options 参数（数组）');
-        }
-    }
-
-    onAdd(map) {
-        this._map = map;
-
-        // 创建控件外层容器
-        this._container = document.createElement('div');
-        this._container.className = 'mapboxgl-ctrl mapboxgl-ctrl-group custom-options-control';
-
-        // 创建主按钮（初始只显示“三维模型”文字，点击展开）
-        const mainButton = document.createElement('button');
-        mainButton.style.cssText = `
-            width: 100%;
-            height: 100%;
-            padding: 0.25rem 0.5rem;
-            margin: 0;
-            border: 1px solid #ccc;
-            background: white;
-            border-radius: 4px;
-            cursor: pointer;
-            font-size: 14px;
-            text-align: left;
-        `;
-        mainButton.textContent = '三维模型';
-        mainButton.addEventListener('click', () => this._toggleExpanded());
-
-        this._container.appendChild(mainButton);
-
-        // 创建隐藏的选项面板（默认不显示）
-        this._panel = document.createElement('div');
-        this._panel.style.display = 'none';
-        this._panel.style.padding = '10px';
-        this._container.appendChild(this._panel);
-
-        // 创建选项列表和按钮组
-        this._renderOptionsPanel();
-
-        return this._container;
-    }
-
-    _toggleExpanded() {
-        const isExpanded = this._panel.style.display !== 'none';
-        this._setExpanded(!isExpanded);
-    }
-
-    _setExpanded(isExpanded) {
-        this._panel.style.display = isExpanded ? 'block' : 'none';
-    }
-
-    _renderOptionsPanel() {
-        // 清空面板内容
-        this._panel.innerHTML = '';
-
-        // 创建复选框选项列表
-        this._options.forEach((opt) => {
-            const optionDiv = document.createElement('div');
-            optionDiv.style.marginBottom = '6px';
-
-            const label = document.createElement('label');
-            label.style.display = 'flex';
-            label.style.alignItems = 'center';
-            label.style.cursor = 'pointer';
-
-            const checkbox = document.createElement('input');
-            checkbox.type = 'checkbox';
-            checkbox.value = opt.value;
-            checkbox.style.marginRight = '8px';
-
-            // 绑定选中状态
-            checkbox.checked = this._getSelectedOption(opt.value);
-            checkbox.addEventListener('change', () => this._toggleOption(opt.value));
-
-            const span = document.createElement('span');
-            span.textContent = opt.label;
-
-            label.appendChild(checkbox);
-            label.appendChild(span);
-            optionDiv.appendChild(label);
-            this._panel.appendChild(optionDiv);
-        });
-
-        // 创建按钮组：取消 / 确定
-        const buttonGroup = document.createElement('div');
-        buttonGroup.style.marginTop = '12px';
-        buttonGroup.style.display = 'flex';
-        buttonGroup.style.gap = '8px';
-        buttonGroup.style.justifyContent = 'flex-end';
-
-        const cancelButton = document.createElement('button');
-        cancelButton.textContent = '取消';
-        cancelButton.style.cssText = `
-            padding: 6px 12px;
-            background: #ccc;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-            width: auto;
-        `;
-        cancelButton.addEventListener('click', () => this._handleCancel());
-
-        const confirmButton = document.createElement('button');
-        confirmButton.textContent = '确定';
-        confirmButton.style.cssText = `
-            padding: 6px 12px;
-            background: #007cba;
-            color: white;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-            width: auto;
-        `;
-        confirmButton.addEventListener('click', () => this._handleConfirm());
-
-        buttonGroup.appendChild(cancelButton);
-        buttonGroup.appendChild(confirmButton);
-        this._panel.appendChild(buttonGroup);
-    }
-
-    _getSelectedOption(value) {
-        return this._selectedOptions?.includes(value) || false;
-    }
-
-    _toggleOption(value) {
-        if (!this._selectedOptions) this._selectedOptions = [];
-
-        const idx = this._selectedOptions.indexOf(value);
-        if (idx > -1) {
-            this._selectedOptions.splice(idx, 1);
-        } else {
-            this._selectedOptions.push(value);
-        }
-
-        // 可选：重新渲染复选框状态（如果需要动态更新 UI，但目前 onchange 已处理）
-    }
-
-    _handleConfirm() {
-        this._setExpanded(false);
-
-        this._onConfirm({
-            selectedOptions: this._selectedOptions || [],
-            unselectedOptions: this._options.filter((item) => !this._selectedOptions?.includes(item.value)),
-            allOptions: this._options,
-        });
-    }
-
-    _handleCancel() {
-        this._setExpanded(false);
-    }
-
-    onRemove() {
-        if (this._container && this._container.parentNode) {
-            this._container.parentNode.removeChild(this._container);
-        }
-    }
-}
-
-// 自定义控件类：ToggleControl
-class ToggleControl {
-    /**
-     * 构造函数
-     * @param {Object} options
-     * @param {string} options.name - 控件名称（用于识别，可选展示）
-     * @param {string} options.field - 控制的字段名，对应 map.SourceMap[field]
-     * @param {boolean} options.defaultValue - 默认值（当 field 未定义时使用）
-     * @param {string} options.svgIcon - SVG 图标字符串，例如 '<svg>...</svg>'
-     * @param {Function} [options.onToggle] - 可选的回调函数，状态切换后调用，参数为最新的布尔值
-     */
-    constructor({ name, field, defaultValue = false, svgIcon, onToggle }) {
-        this.name = name;
-        this.field = field;
-        this.defaultValue = defaultValue;
-        this.svgIcon = svgIcon;
-        this.onToggle = onToggle; // ✅ 新增：回调函数
-
-        // 控件容器
-        this._container = null;
-        this._button = null;
-        this.isActive = false; // 当前是否为激活状态（高亮/true）
-    }
-
-    // Mapbox 要求的 onAdd 方法
-    onAdd(map) {
-        this.map = map;
-
-        // 创建外层容器 div
-        this._container = document.createElement('div');
-        this._container.className = 'mapboxgl-ctrl mapboxgl-ctrl-group';
-
-        // 创建 button 元素
-        this._button = document.createElement('button');
-        this._button.type = 'button';
-        this._button.innerHTML = this.svgIcon;
-
-        // 设置按钮样式
-        this._button.style.cursor = 'pointer';
-        this._button.style.border = 'none';
-        this._button.style.background = 'none';
-        this._button.style.padding = '0';
-        this._button.style.display = 'flex';
-        this._button.style.alignItems = 'center';
-        this._button.style.justifyContent = 'center';
-
-        // 初始化状态
-        this.updateStatus();
-
-        // 绑定点击事件
-        this._button.addEventListener('click', () => {
-            this.toggle();
-        });
-
-        this._container.appendChild(this._button);
-
-        return this._container;
-    }
-
-    // Mapbox 要求的 onRemove 方法
-    onRemove() {
-        if (this._container && this._container.parentNode) {
-            this._container.parentNode.removeChild(this._container);
-        }
-        this.map = null;
-        this._container = null;
-        this._button = null;
-    }
-
-    // 更新控件状态（根据当前 field 值）
-    updateStatus() {
-        // 从 map.SourceMap 中获取当前 field 的值，如果不存在则使用 defaultValue
-        let currentValue = this.defaultValue;
-
-        if (
-            this.map &&
-            this.map.SourceMap &&
-            typeof this.map.SourceMap[this.field] === 'boolean'
-        ) {
-            currentValue = this.map.SourceMap[this.field];
-        }
-
-        this.isActive = currentValue; // true 表示激活，false 表示未激活
-
-        // 更新按钮样式
-        if (this.isActive) {
-            this._button.style.opacity = '1';
-            this._button.style.filter = 'none';
-        } else {
-            this._button.style.opacity = '0.4';
-            this._button.style.filter = 'grayscale(100%)';
-        }
-    }
-
-    // 切换状态
-    toggle() {
-        // 获取当前值
-        let currentValue = this.defaultValue;
-
-        if (
-            this.map &&
-            this.map.SourceMap &&
-            typeof this.map.SourceMap[this.field] === 'boolean'
-        ) {
-            currentValue = this.map.SourceMap[this.field];
-        }
-
-        // 切换值
-        const newValue = !currentValue;
-
-        // 更新到 map.SourceMap 中
-        if (this.map && this.map.SourceMap) {
-            this.map.SourceMap[this.field] = newValue;
-        }
-
-        // 更新内部状态
-        this.isActive = newValue;
-
-        // 更新 UI 样式
-        this.updateStatus();
-
-        // ✅ 调用回调函数（如果传入了 onToggle），并传入最新的值
-        this.onToggle?.(newValue); // 安全调用，仅当函数存在时才执行
-    }
-}
-
 const predefineColorSet = {
     '默认单色预设': [{
         Property: '默认',
@@ -5621,501 +5326,796 @@ var Segment = class _Segment {
       const seg = this.prev.consumedBy || this.prev;
       this._beforeState = seg.afterState();
     }
-    return this._beforeState;
+    return this._beforeState;
+  }
+  afterState() {
+    if (this._afterState !== void 0) return this._afterState;
+    const beforeState = this.beforeState();
+    this._afterState = {
+      rings: beforeState.rings.slice(0),
+      windings: beforeState.windings.slice(0),
+      multiPolys: []
+    };
+    const ringsAfter = this._afterState.rings;
+    const windingsAfter = this._afterState.windings;
+    const mpsAfter = this._afterState.multiPolys;
+    for (let i = 0, iMax = this.rings.length; i < iMax; i++) {
+      const ring = this.rings[i];
+      const winding = this.windings[i];
+      const index = ringsAfter.indexOf(ring);
+      if (index === -1) {
+        ringsAfter.push(ring);
+        windingsAfter.push(winding);
+      } else windingsAfter[index] += winding;
+    }
+    const polysAfter = [];
+    const polysExclude = [];
+    for (let i = 0, iMax = ringsAfter.length; i < iMax; i++) {
+      if (windingsAfter[i] === 0) continue;
+      const ring = ringsAfter[i];
+      const poly = ring.poly;
+      if (polysExclude.indexOf(poly) !== -1) continue;
+      if (ring.isExterior) polysAfter.push(poly);
+      else {
+        if (polysExclude.indexOf(poly) === -1) polysExclude.push(poly);
+        const index = polysAfter.indexOf(ring.poly);
+        if (index !== -1) polysAfter.splice(index, 1);
+      }
+    }
+    for (let i = 0, iMax = polysAfter.length; i < iMax; i++) {
+      const mp = polysAfter[i].multiPoly;
+      if (mpsAfter.indexOf(mp) === -1) mpsAfter.push(mp);
+    }
+    return this._afterState;
+  }
+  /* Is this segment part of the final result? */
+  isInResult() {
+    if (this.consumedBy) return false;
+    if (this._isInResult !== void 0) return this._isInResult;
+    const mpsBefore = this.beforeState().multiPolys;
+    const mpsAfter = this.afterState().multiPolys;
+    switch (operation_default.type) {
+      case "union": {
+        const noBefores = mpsBefore.length === 0;
+        const noAfters = mpsAfter.length === 0;
+        this._isInResult = noBefores !== noAfters;
+        break;
+      }
+      case "intersection": {
+        let least;
+        let most;
+        if (mpsBefore.length < mpsAfter.length) {
+          least = mpsBefore.length;
+          most = mpsAfter.length;
+        } else {
+          least = mpsAfter.length;
+          most = mpsBefore.length;
+        }
+        this._isInResult = most === operation_default.numMultiPolys && least < most;
+        break;
+      }
+      case "xor": {
+        const diff = Math.abs(mpsBefore.length - mpsAfter.length);
+        this._isInResult = diff % 2 === 1;
+        break;
+      }
+      case "difference": {
+        const isJustSubject = (mps) => mps.length === 1 && mps[0].isSubject;
+        this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter);
+        break;
+      }
+    }
+    return this._isInResult;
+  }
+};
+
+// src/geom-in.ts
+var RingIn = class {
+  poly;
+  isExterior;
+  segments;
+  bbox;
+  constructor(geomRing, poly, isExterior) {
+    if (!Array.isArray(geomRing) || geomRing.length === 0) {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    this.poly = poly;
+    this.isExterior = isExterior;
+    this.segments = [];
+    if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    const firstPoint = precision.snap({ x: new BigNumber(geomRing[0][0]), y: new BigNumber(geomRing[0][1]) });
+    this.bbox = {
+      ll: { x: firstPoint.x, y: firstPoint.y },
+      ur: { x: firstPoint.x, y: firstPoint.y }
+    };
+    let prevPoint = firstPoint;
+    for (let i = 1, iMax = geomRing.length; i < iMax; i++) {
+      if (typeof geomRing[i][0] !== "number" || typeof geomRing[i][1] !== "number") {
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      }
+      const point = precision.snap({ x: new BigNumber(geomRing[i][0]), y: new BigNumber(geomRing[i][1]) });
+      if (point.x.eq(prevPoint.x) && point.y.eq(prevPoint.y)) continue;
+      this.segments.push(Segment.fromRing(prevPoint, point, this));
+      if (point.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = point.x;
+      if (point.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = point.y;
+      if (point.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = point.x;
+      if (point.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = point.y;
+      prevPoint = point;
+    }
+    if (!firstPoint.x.eq(prevPoint.x) || !firstPoint.y.eq(prevPoint.y)) {
+      this.segments.push(Segment.fromRing(prevPoint, firstPoint, this));
+    }
+  }
+  getSweepEvents() {
+    const sweepEvents = [];
+    for (let i = 0, iMax = this.segments.length; i < iMax; i++) {
+      const segment = this.segments[i];
+      sweepEvents.push(segment.leftSE);
+      sweepEvents.push(segment.rightSE);
+    }
+    return sweepEvents;
+  }
+};
+var PolyIn = class {
+  multiPoly;
+  exteriorRing;
+  interiorRings;
+  bbox;
+  constructor(geomPoly, multiPoly) {
+    if (!Array.isArray(geomPoly)) {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    this.exteriorRing = new RingIn(geomPoly[0], this, true);
+    this.bbox = {
+      ll: { x: this.exteriorRing.bbox.ll.x, y: this.exteriorRing.bbox.ll.y },
+      ur: { x: this.exteriorRing.bbox.ur.x, y: this.exteriorRing.bbox.ur.y }
+    };
+    this.interiorRings = [];
+    for (let i = 1, iMax = geomPoly.length; i < iMax; i++) {
+      const ring = new RingIn(geomPoly[i], this, false);
+      if (ring.bbox.ll.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = ring.bbox.ll.x;
+      if (ring.bbox.ll.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = ring.bbox.ll.y;
+      if (ring.bbox.ur.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = ring.bbox.ur.x;
+      if (ring.bbox.ur.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = ring.bbox.ur.y;
+      this.interiorRings.push(ring);
+    }
+    this.multiPoly = multiPoly;
+  }
+  getSweepEvents() {
+    const sweepEvents = this.exteriorRing.getSweepEvents();
+    for (let i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
+      const ringSweepEvents = this.interiorRings[i].getSweepEvents();
+      for (let j = 0, jMax = ringSweepEvents.length; j < jMax; j++) {
+        sweepEvents.push(ringSweepEvents[j]);
+      }
+    }
+    return sweepEvents;
   }
-  afterState() {
-    if (this._afterState !== void 0) return this._afterState;
-    const beforeState = this.beforeState();
-    this._afterState = {
-      rings: beforeState.rings.slice(0),
-      windings: beforeState.windings.slice(0),
-      multiPolys: []
-    };
-    const ringsAfter = this._afterState.rings;
-    const windingsAfter = this._afterState.windings;
-    const mpsAfter = this._afterState.multiPolys;
-    for (let i = 0, iMax = this.rings.length; i < iMax; i++) {
-      const ring = this.rings[i];
-      const winding = this.windings[i];
-      const index = ringsAfter.indexOf(ring);
-      if (index === -1) {
-        ringsAfter.push(ring);
-        windingsAfter.push(winding);
-      } else windingsAfter[index] += winding;
+};
+var MultiPolyIn = class {
+  isSubject;
+  polys;
+  bbox;
+  constructor(geom, isSubject) {
+    if (!Array.isArray(geom)) {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
     }
-    const polysAfter = [];
-    const polysExclude = [];
-    for (let i = 0, iMax = ringsAfter.length; i < iMax; i++) {
-      if (windingsAfter[i] === 0) continue;
-      const ring = ringsAfter[i];
-      const poly = ring.poly;
-      if (polysExclude.indexOf(poly) !== -1) continue;
-      if (ring.isExterior) polysAfter.push(poly);
-      else {
-        if (polysExclude.indexOf(poly) === -1) polysExclude.push(poly);
-        const index = polysAfter.indexOf(ring.poly);
-        if (index !== -1) polysAfter.splice(index, 1);
-      }
+    try {
+      if (typeof geom[0][0][0] === "number") geom = [geom];
+    } catch (ex) {
     }
-    for (let i = 0, iMax = polysAfter.length; i < iMax; i++) {
-      const mp = polysAfter[i].multiPoly;
-      if (mpsAfter.indexOf(mp) === -1) mpsAfter.push(mp);
+    this.polys = [];
+    this.bbox = {
+      ll: { x: new BigNumber(Number.POSITIVE_INFINITY), y: new BigNumber(Number.POSITIVE_INFINITY) },
+      ur: { x: new BigNumber(Number.NEGATIVE_INFINITY), y: new BigNumber(Number.NEGATIVE_INFINITY) }
+    };
+    for (let i = 0, iMax = geom.length; i < iMax; i++) {
+      const poly = new PolyIn(geom[i], this);
+      if (poly.bbox.ll.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = poly.bbox.ll.x;
+      if (poly.bbox.ll.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = poly.bbox.ll.y;
+      if (poly.bbox.ur.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = poly.bbox.ur.x;
+      if (poly.bbox.ur.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = poly.bbox.ur.y;
+      this.polys.push(poly);
     }
-    return this._afterState;
+    this.isSubject = isSubject;
   }
-  /* Is this segment part of the final result? */
-  isInResult() {
-    if (this.consumedBy) return false;
-    if (this._isInResult !== void 0) return this._isInResult;
-    const mpsBefore = this.beforeState().multiPolys;
-    const mpsAfter = this.afterState().multiPolys;
-    switch (operation_default.type) {
-      case "union": {
-        const noBefores = mpsBefore.length === 0;
-        const noAfters = mpsAfter.length === 0;
-        this._isInResult = noBefores !== noAfters;
-        break;
-      }
-      case "intersection": {
-        let least;
-        let most;
-        if (mpsBefore.length < mpsAfter.length) {
-          least = mpsBefore.length;
-          most = mpsAfter.length;
-        } else {
-          least = mpsAfter.length;
-          most = mpsBefore.length;
-        }
-        this._isInResult = most === operation_default.numMultiPolys && least < most;
-        break;
-      }
-      case "xor": {
-        const diff = Math.abs(mpsBefore.length - mpsAfter.length);
-        this._isInResult = diff % 2 === 1;
-        break;
-      }
-      case "difference": {
-        const isJustSubject = (mps) => mps.length === 1 && mps[0].isSubject;
-        this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter);
-        break;
+  getSweepEvents() {
+    const sweepEvents = [];
+    for (let i = 0, iMax = this.polys.length; i < iMax; i++) {
+      const polySweepEvents = this.polys[i].getSweepEvents();
+      for (let j = 0, jMax = polySweepEvents.length; j < jMax; j++) {
+        sweepEvents.push(polySweepEvents[j]);
       }
     }
-    return this._isInResult;
+    return sweepEvents;
   }
 };
+var difference = (geom, ...moreGeoms) => operation_default.run("difference", geom, moreGeoms);
+precision.set;
+
+// index.ts
+function difference2(features) {
+  const geoms = [];
+  geomEach(features, (geom) => {
+    geoms.push(geom.coordinates);
+  });
+  if (geoms.length < 2) {
+    throw new Error("Must have at least two features");
+  }
+  const properties = features.features[0].properties || {};
+  const differenced = difference(geoms[0], ...geoms.slice(1));
+  if (differenced.length === 0) return null;
+  if (differenced.length === 1) return polygon(differenced[0], properties);
+  return multiPolygon(differenced, properties);
+}
+
+/**
+ * 传入一个 features 数组（至少包含两个要素），
+ * 计算第二个要素（features[1]）中，不在第一个要素（features[0]）内部的部分，
+ * 即：features[1] 减去 features[0]，返回这一部分（GeoJSON Feature）。
+ *
+ * @param {Array<turf.Feature>} features - GeoJSON Feature 数组，至少包含两个要素
+ * @returns {turf.Feature | null} - 返回 features[1] 减去 features[0] 的部分，如果出错或无效返回 null
+ */
+function getFeatureOutsidePart(features) {
+    if (!Array.isArray(features) || features.length < 2) {
+        console.error('Input must be an array of at least two GeoJSON Features.');
+        return null;
+    }
+
+    // 我们要计算的是：featureB - featureA，即 featureB 的外部部分（不在 featureA 中的部分）
+    const differenceResult = difference2(featureCollection(features));
+
+    if (!differenceResult) {
+        console.warn('Difference result is empty or invalid. The second feature may be fully inside the first one.');
+        return null; // 两者无差异，或者输入几何有问题
+    }
+
+    return differenceResult; // 返回的就是 features[1] 在 features[0] 外部的部分
+}
+const RT_FitBoundsMapbox = (map, featureCollection) => {
+    try {
+        if (!map || !featureCollection) {
+            console.error('RT_FitBoundsMapbox: map 或 featureCollection 参数不能为空');
+            return;
+        }
+
+
+        const boundsArray = bbox(featureCollection); // [minLng, minLat, maxLng, maxLat]
+
+        if (!boundsArray || boundsArray.length !== 4) {
+            console.error('RT_FitBoundsMapbox: 无法计算有效的包围盒');
+            return;
+        }
+
+        const [minLng, minLat, maxLng, maxLat] = boundsArray;
+
+        const bounds = [
+            [minLng, minLat], // 左下角
+            [maxLng, maxLat]  // 右上角
+        ];
+
+        map.fitBounds(bounds, {
+            padding: 20,          // 可选：边距（单位像素）
+            maxZoom: 15,          // 可选：最大缩放级别，避免太近
+            duration: 1000,        // 可选：动画时长（毫秒）
+            easing: (t) => {
+                return t;
+            }
+        });
+    } catch (error) {
+        console.error('RT_FitBoundsMapbox: 拟合地图边界时出错', error);
+    }
+
+};
+const RT_FitBoundsMapboxNative = (map, featureCollection) => {
+    try {
+        if (!map || !featureCollection) {
+            console.error('RT_FitBoundsMapbox: map 或 featureCollection 参数不能为空');
+            return;
+        }
+
+        // ✅ 手写函数：计算 FeatureCollection 的 Bounding Box [minLng, minLat, maxLng, maxLat]
+        const calculateBoundingBox = (featureCollection) => {
+            let minLng = Infinity;
+            let minLat = Infinity;
+            let maxLng = -Infinity;
+            let maxLat = -Infinity;
+
+            // 遍历每个 feature
+            for (const feature of featureCollection.features) {
+                const coords = feature.geometry.coordinates;
+
+                // 递归遍历坐标（支持 Point、LineString、Polygon、Multi 等）
+                const traverseCoordinates = (coords) => {
+                    if (!Array.isArray(coords)) return;
+
+                    // 判断坐标类型：
+                    if (typeof coords[0] === 'number') {
+                        // 🟢 这是一个点 [lng, lat]
+                        const [lng, lat] = coords;
+                        if (lng < minLng) minLng = lng;
+                        if (lng > maxLng) maxLng = lng;
+                        if (lat < minLat) minLat = lat;
+                        if (lat > maxLat) maxLat = lat;
+                    } else if (Array.isArray(coords[0])) {
+                        // 🔵 可能是 LineString、Polygon、MultiPoint 等（嵌套数组）
+                        for (const subCoords of coords) {
+                            traverseCoordinates(subCoords);
+                        }
+                    }
+                    // 注意：更复杂的 GeometryCollection 或 MultiPolygon 也按类似方式递归，但此处已覆盖大部分情况
+                };
+
+                traverseCoordinates(coords);
+            }
+
+            // 如果没有有效的点（比如 featureCollection 为空或没有坐标）
+            if (
+                minLng === Infinity ||
+                minLat === Infinity ||
+                maxLng === -Infinity ||
+                maxLat === -Infinity
+            ) {
+                console.error('RT_FitBoundsMapbox: 未找到有效的坐标点');
+                return null;
+            }
+
+            return [minLng, minLat, maxLng, maxLat];
+        };
+
+        // ✅ 调用手写函数，计算 bounding box
+        const boundsArray = calculateBoundingBox(featureCollection);
+
+        if (!boundsArray) {
+            console.error('RT_FitBoundsMapbox: 无法计算有效的包围盒');
+            return;
+        }
+
+        const [minLng, minLat, maxLng, maxLat] = boundsArray;
+
+        const bounds = [
+            [minLng, minLat], // 左下角
+            [maxLng, maxLat]  // 右上角
+        ];
+        console.log(`output->bounds`, bounds);
+        bounds.forEach(item => {
+            item.forEach((i, index) => {
+                item[index] = Number((i).toFixed(6));
+            });
+        });
+        // ✅ 调用 Mapbox 的 fitBounds
+        map.fitBounds(bounds, {
+            padding: 50,          // 可选：边距（单位像素）
+            maxZoom: 15,          // 可选：最大缩放级别，避免太近
+            duration: 1000,        // 可选：动画时长（毫秒）
+        });
+
+    } catch (error) {
+        console.error('RT_FitBoundsMapbox: 拟合地图边界时出错', error);
+    }
+};
 
-// src/geom-in.ts
-var RingIn = class {
-  poly;
-  isExterior;
-  segments;
-  bbox;
-  constructor(geomRing, poly, isExterior) {
-    if (!Array.isArray(geomRing) || geomRing.length === 0) {
-      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
-    }
-    this.poly = poly;
-    this.isExterior = isExterior;
-    this.segments = [];
-    if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") {
-      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
-    }
-    const firstPoint = precision.snap({ x: new BigNumber(geomRing[0][0]), y: new BigNumber(geomRing[0][1]) });
-    this.bbox = {
-      ll: { x: firstPoint.x, y: firstPoint.y },
-      ur: { x: firstPoint.x, y: firstPoint.y }
-    };
-    let prevPoint = firstPoint;
-    for (let i = 1, iMax = geomRing.length; i < iMax; i++) {
-      if (typeof geomRing[i][0] !== "number" || typeof geomRing[i][1] !== "number") {
-        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
-      }
-      const point = precision.snap({ x: new BigNumber(geomRing[i][0]), y: new BigNumber(geomRing[i][1]) });
-      if (point.x.eq(prevPoint.x) && point.y.eq(prevPoint.y)) continue;
-      this.segments.push(Segment.fromRing(prevPoint, point, this));
-      if (point.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = point.x;
-      if (point.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = point.y;
-      if (point.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = point.x;
-      if (point.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = point.y;
-      prevPoint = point;
-    }
-    if (!firstPoint.x.eq(prevPoint.x) || !firstPoint.y.eq(prevPoint.y)) {
-      this.segments.push(Segment.fromRing(prevPoint, firstPoint, this));
-    }
-  }
-  getSweepEvents() {
-    const sweepEvents = [];
-    for (let i = 0, iMax = this.segments.length; i < iMax; i++) {
-      const segment = this.segments[i];
-      sweepEvents.push(segment.leftSE);
-      sweepEvents.push(segment.rightSE);
-    }
-    return sweepEvents;
-  }
-};
-var PolyIn = class {
-  multiPoly;
-  exteriorRing;
-  interiorRings;
-  bbox;
-  constructor(geomPoly, multiPoly) {
-    if (!Array.isArray(geomPoly)) {
-      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
-    }
-    this.exteriorRing = new RingIn(geomPoly[0], this, true);
-    this.bbox = {
-      ll: { x: this.exteriorRing.bbox.ll.x, y: this.exteriorRing.bbox.ll.y },
-      ur: { x: this.exteriorRing.bbox.ur.x, y: this.exteriorRing.bbox.ur.y }
-    };
-    this.interiorRings = [];
-    for (let i = 1, iMax = geomPoly.length; i < iMax; i++) {
-      const ring = new RingIn(geomPoly[i], this, false);
-      if (ring.bbox.ll.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = ring.bbox.ll.x;
-      if (ring.bbox.ll.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = ring.bbox.ll.y;
-      if (ring.bbox.ur.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = ring.bbox.ur.x;
-      if (ring.bbox.ur.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = ring.bbox.ur.y;
-      this.interiorRings.push(ring);
-    }
-    this.multiPoly = multiPoly;
-  }
-  getSweepEvents() {
-    const sweepEvents = this.exteriorRing.getSweepEvents();
-    for (let i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
-      const ringSweepEvents = this.interiorRings[i].getSweepEvents();
-      for (let j = 0, jMax = ringSweepEvents.length; j < jMax; j++) {
-        sweepEvents.push(ringSweepEvents[j]);
-      }
-    }
-    return sweepEvents;
-  }
-};
-var MultiPolyIn = class {
-  isSubject;
-  polys;
-  bbox;
-  constructor(geom, isSubject) {
-    if (!Array.isArray(geom)) {
-      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
-    }
-    try {
-      if (typeof geom[0][0][0] === "number") geom = [geom];
-    } catch (ex) {
-    }
-    this.polys = [];
-    this.bbox = {
-      ll: { x: new BigNumber(Number.POSITIVE_INFINITY), y: new BigNumber(Number.POSITIVE_INFINITY) },
-      ur: { x: new BigNumber(Number.NEGATIVE_INFINITY), y: new BigNumber(Number.NEGATIVE_INFINITY) }
-    };
-    for (let i = 0, iMax = geom.length; i < iMax; i++) {
-      const poly = new PolyIn(geom[i], this);
-      if (poly.bbox.ll.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = poly.bbox.ll.x;
-      if (poly.bbox.ll.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = poly.bbox.ll.y;
-      if (poly.bbox.ur.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = poly.bbox.ur.x;
-      if (poly.bbox.ur.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = poly.bbox.ur.y;
-      this.polys.push(poly);
-    }
-    this.isSubject = isSubject;
-  }
-  getSweepEvents() {
-    const sweepEvents = [];
-    for (let i = 0, iMax = this.polys.length; i < iMax; i++) {
-      const polySweepEvents = this.polys[i].getSweepEvents();
-      for (let j = 0, jMax = polySweepEvents.length; j < jMax; j++) {
-        sweepEvents.push(polySweepEvents[j]);
-      }
-    }
-    return sweepEvents;
-  }
-};
-var difference = (geom, ...moreGeoms) => operation_default.run("difference", geom, moreGeoms);
-precision.set;
+var RainteeGISUtil = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RT_FitBoundsMapbox: RT_FitBoundsMapbox,
+    RT_FitBoundsMapboxNative: RT_FitBoundsMapboxNative,
+    getFeatureOutsidePart: getFeatureOutsidePart
+});
+
+const treeDataAdapter = (data) => {
+    let i = 0;
+    let treeData = [];
+    let checkedKeys = [];
+    data.forEach((item) => {
+        let kvs = item.id.split(';').map(kvstr => kvstr.split('='));
+        let groups = kvs.find(item => item[0] === 'Main')[1].split('/');
+        let layerName = kvs.find(item => item[0] === 'CN')[1];
+        let currentNode = treeData;
+        groups.forEach((group, index) => {
+            currentNode.find(item => item.label === group) || i++;
+            currentNode.find(item => item.label === group) || currentNode.push({
+                id: i,
+                label: group,
+                children: []
+            });
+            currentNode = currentNode.find(item => item.label === group).children;
+        });
+        i++;
+        currentNode.push({
+            id: i,
+            label: layerName,
+            fullLayerName: groups.length === 0 ? layerName : groups.join('-') + '-' + layerName,
+            layerId: item.id,
+            opacity: '1.0',
+        });
+        if (item.layout && item.layout.visibility == 'visible') {
+            checkedKeys.push(i);
+        }
+    });
+    return { treeData, checkedKeys }
+};
+const treeDataAdapterNext = (data) => {
+    let i = 0;
+    let treeData = [];
+    let checkedKeys = [];
+    data.forEach((item) => {
+        let kvs = item.id.split(';').map(kvstr => kvstr.split('='));
+        let groups = kvs.find(item => item[0] === 'Main')[1].split('/');
+        let layerName = kvs.find(item => item[0] === 'CN')[1];
+        let currentNode = treeData;
+        groups.length === 0 ? layerName : groups.join('-') + '-' + layerName;
+        groups.forEach((group, index) => {
+            currentNode.find(item => item.label === group) || i++;
+            currentNode.find(item => item.label === group) || currentNode.push({
+                id: `TreeId=${i};`,
+                label: group,
+                children: []
+            });
+            currentNode = currentNode.find(item => item.label === group).children;
+        });
+        i++;
+        currentNode.push({
+            id: item.id,
+            label: layerName,
+            fullLayerName: getLayerIdFidld(item.id, 'Main') + '-' + getLayerIdFidld(item.id, 'CN'),
+            layerId: item.id,
+            opacity: '1.0',
+        });
+        if (item.layout && item.layout.visibility == 'visible') {
+            checkedKeys.push(i);
+        }
+    });
+    return { treeData, checkedKeys }
+};
+const getLayerIdFidld = (str, field) => {
+    let kvs = str.split(';').map(kvstr => kvstr.split('='));
+    let layerId = kvs.find(item => item[0] === field)[1];
+    return layerId
+};
+/**
+ * 生成唯一ID字符串
+ * @param {string} projectId 项目ID
+ * @param {string} objectTypeId 对象种类ID
+ * @param {string} groupId 对象分组ID
+ * @param {string} objectId 对象ID
+ * @returns {string} 唯一ID字符串
+ */
+const GenerateUniqueId = (
+    projectId,
+    objectTypeId,
+    groupId,
+    objectId
+) => {
+    // 将参数组合成一个字符串
+    const combinedString = `${projectId}|${objectTypeId}|${groupId}|${objectId}`;
+
+    // 使用简单的哈希函数生成固定长度的字符串
+    let hash = 0;
+    for (let i = 0; i < combinedString.length; i++) {
+        const char = combinedString.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+
+    // 转换为16进制字符串并补零到8位
+    const hexHash = (hash >>> 0).toString(16).padStart(8, "0");
+
+    // 添加前缀和分隔符增强可读性
+    return `UID-${projectId.slice(0, 2)}-${objectTypeId.slice(
+        0,
+        2
+    )}-${groupId.slice(0, 2)}-${hexHash}`;
+};
 
-// index.ts
-function difference2(features) {
-  const geoms = [];
-  geomEach(features, (geom) => {
-    geoms.push(geom.coordinates);
-  });
-  if (geoms.length < 2) {
-    throw new Error("Must have at least two features");
-  }
-  const properties = features.features[0].properties || {};
-  const differenced = difference(geoms[0], ...geoms.slice(1));
-  if (differenced.length === 0) return null;
-  if (differenced.length === 1) return polygon(differenced[0], properties);
-  return multiPolygon(differenced, properties);
-}
+var RainteeSourceMapTool = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    GenerateUniqueId: GenerateUniqueId,
+    getLayerIdFidld: getLayerIdFidld,
+    treeDataAdapter: treeDataAdapter,
+    treeDataAdapterNext: treeDataAdapterNext
+});
 
-/**
- * 传入一个 features 数组（至少包含两个要素），
- * 计算第二个要素（features[1]）中，不在第一个要素（features[0]）内部的部分，
- * 即：features[1] 减去 features[0]，返回这一部分（GeoJSON Feature）。
- *
- * @param {Array<turf.Feature>} features - GeoJSON Feature 数组，至少包含两个要素
- * @returns {turf.Feature | null} - 返回 features[1] 减去 features[0] 的部分，如果出错或无效返回 null
- */
-function getFeatureOutsidePart(features) {
-    if (!Array.isArray(features) || features.length < 2) {
-        console.error('Input must be an array of at least two GeoJSON Features.');
-        return null;
+class CustomOptionsControl {
+    constructor(args) {
+        const { options, onConfirm } = args;
+
+        this._container = null;
+        this._map = null;
+
+        this._options = options || [];
+        this._onConfirm = onConfirm || (() => { });
+
+        if (!this._options || !Array.isArray(this._options)) {
+            console.error('请传入有效的 options 参数（数组）');
+        }
     }
 
-    // 我们要计算的是：featureB - featureA，即 featureB 的外部部分（不在 featureA 中的部分）
-    const differenceResult = difference2(featureCollection(features));
+    onAdd(map) {
+        this._map = map;
 
-    if (!differenceResult) {
-        console.warn('Difference result is empty or invalid. The second feature may be fully inside the first one.');
-        return null; // 两者无差异，或者输入几何有问题
+        // 创建控件外层容器
+        this._container = document.createElement('div');
+        this._container.className = 'mapboxgl-ctrl mapboxgl-ctrl-group custom-options-control';
+
+        // 创建主按钮（初始只显示“三维模型”文字，点击展开）
+        const mainButton = document.createElement('button');
+        mainButton.style.cssText = `
+            width: 100%;
+            height: 100%;
+            padding: 0.25rem 0.5rem;
+            margin: 0;
+            border: 1px solid #ccc;
+            background: white;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 14px;
+            text-align: left;
+        `;
+        mainButton.textContent = '三维模型';
+        mainButton.addEventListener('click', () => this._toggleExpanded());
+
+        this._container.appendChild(mainButton);
+
+        // 创建隐藏的选项面板（默认不显示）
+        this._panel = document.createElement('div');
+        this._panel.style.display = 'none';
+        this._panel.style.padding = '10px';
+        this._container.appendChild(this._panel);
+
+        // 创建选项列表和按钮组
+        this._renderOptionsPanel();
+
+        return this._container;
     }
 
-    return differenceResult; // 返回的就是 features[1] 在 features[0] 外部的部分
-}
-const RT_FitBoundsMapbox = (map, featureCollection) => {
-    try {
-        if (!map || !featureCollection) {
-            console.error('RT_FitBoundsMapbox: map 或 featureCollection 参数不能为空');
-            return;
-        }
+    _toggleExpanded() {
+        const isExpanded = this._panel.style.display !== 'none';
+        this._setExpanded(!isExpanded);
+    }
 
+    _setExpanded(isExpanded) {
+        this._panel.style.display = isExpanded ? 'block' : 'none';
+    }
 
-        const boundsArray = bbox(featureCollection); // [minLng, minLat, maxLng, maxLat]
+    _renderOptionsPanel() {
+        // 清空面板内容
+        this._panel.innerHTML = '';
 
-        if (!boundsArray || boundsArray.length !== 4) {
-            console.error('RT_FitBoundsMapbox: 无法计算有效的包围盒');
-            return;
+        // 创建复选框选项列表
+        this._options.forEach((opt) => {
+            const optionDiv = document.createElement('div');
+            optionDiv.style.marginBottom = '6px';
+
+            const label = document.createElement('label');
+            label.style.display = 'flex';
+            label.style.alignItems = 'center';
+            label.style.cursor = 'pointer';
+
+            const checkbox = document.createElement('input');
+            checkbox.type = 'checkbox';
+            checkbox.value = opt.value;
+            checkbox.style.marginRight = '8px';
+
+            // 绑定选中状态
+            checkbox.checked = this._getSelectedOption(opt.value);
+            checkbox.addEventListener('change', () => this._toggleOption(opt.value));
+
+            const span = document.createElement('span');
+            span.textContent = opt.label;
+
+            label.appendChild(checkbox);
+            label.appendChild(span);
+            optionDiv.appendChild(label);
+            this._panel.appendChild(optionDiv);
+        });
+
+        // 创建按钮组：取消 / 确定
+        const buttonGroup = document.createElement('div');
+        buttonGroup.style.marginTop = '12px';
+        buttonGroup.style.display = 'flex';
+        buttonGroup.style.gap = '8px';
+        buttonGroup.style.justifyContent = 'flex-end';
+
+        const cancelButton = document.createElement('button');
+        cancelButton.textContent = '取消';
+        cancelButton.style.cssText = `
+            padding: 6px 12px;
+            background: #ccc;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            width: auto;
+        `;
+        cancelButton.addEventListener('click', () => this._handleCancel());
+
+        const confirmButton = document.createElement('button');
+        confirmButton.textContent = '确定';
+        confirmButton.style.cssText = `
+            padding: 6px 12px;
+            background: #007cba;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            width: auto;
+        `;
+        confirmButton.addEventListener('click', () => this._handleConfirm());
+
+        buttonGroup.appendChild(cancelButton);
+        buttonGroup.appendChild(confirmButton);
+        this._panel.appendChild(buttonGroup);
+    }
+
+    _getSelectedOption(value) {
+        return this._selectedOptions?.includes(value) || false;
+    }
+
+    _toggleOption(value) {
+        if (!this._selectedOptions) this._selectedOptions = [];
+
+        const idx = this._selectedOptions.indexOf(value);
+        if (idx > -1) {
+            this._selectedOptions.splice(idx, 1);
+        } else {
+            this._selectedOptions.push(value);
         }
 
-        const [minLng, minLat, maxLng, maxLat] = boundsArray;
+        // 可选：重新渲染复选框状态（如果需要动态更新 UI，但目前 onchange 已处理）
+    }
 
-        const bounds = [
-            [minLng, minLat], // 左下角
-            [maxLng, maxLat]  // 右上角
-        ];
+    _handleConfirm() {
+        this._setExpanded(false);
 
-        map.fitBounds(bounds, {
-            padding: 20,          // 可选：边距（单位像素）
-            maxZoom: 15,          // 可选：最大缩放级别，避免太近
-            duration: 1000,        // 可选：动画时长（毫秒）
-            easing: (t) => {
-                return t;
-            }
+        this._onConfirm({
+            selectedOptions: this._selectedOptions || [],
+            unselectedOptions: this._options.filter((item) => !this._selectedOptions?.includes(item.value)),
+            allOptions: this._options,
         });
-    } catch (error) {
-        console.error('RT_FitBoundsMapbox: 拟合地图边界时出错', error);
     }
 
-};
-const RT_FitBoundsMapboxNative = (map, featureCollection) => {
-    try {
-        if (!map || !featureCollection) {
-            console.error('RT_FitBoundsMapbox: map 或 featureCollection 参数不能为空');
-            return;
+    _handleCancel() {
+        this._setExpanded(false);
+    }
+
+    onRemove() {
+        if (this._container && this._container.parentNode) {
+            this._container.parentNode.removeChild(this._container);
         }
+    }
+}
+
+// 自定义控件类：ToggleControl
+class CustomToggleControl {
+    /**
+     * 构造函数
+     * @param {Object} options
+     * @param {string} options.name - 控件名称（用于识别，可选展示）
+     * @param {string} options.field - 控制的字段名，对应 map.SourceMap[field]
+     * @param {boolean} options.defaultValue - 默认值（当 field 未定义时使用）
+     * @param {string} options.svgIcon - SVG 图标字符串，例如 '<svg>...</svg>'
+     * @param {Function} [options.onToggle] - 可选的回调函数，状态切换后调用，参数为最新的布尔值
+     */
+    constructor({ name, field, defaultValue = false, svgIcon, onToggle }) {
+        this.name = name;
+        this.field = field;
+        this.defaultValue = defaultValue;
+        this.svgIcon = svgIcon;
+        this.onToggle = onToggle; // ✅ 新增：回调函数
 
-        // ✅ 手写函数：计算 FeatureCollection 的 Bounding Box [minLng, minLat, maxLng, maxLat]
-        const calculateBoundingBox = (featureCollection) => {
-            let minLng = Infinity;
-            let minLat = Infinity;
-            let maxLng = -Infinity;
-            let maxLat = -Infinity;
+        // 控件容器
+        this._container = null;
+        this._button = null;
+        this.isActive = false; // 当前是否为激活状态（高亮/true）
+    }
+
+    // Mapbox 要求的 onAdd 方法
+    onAdd(map) {
+        this.map = map;
 
-            // 遍历每个 feature
-            for (const feature of featureCollection.features) {
-                const coords = feature.geometry.coordinates;
+        // 创建外层容器 div
+        this._container = document.createElement('div');
+        this._container.className = 'mapboxgl-ctrl mapboxgl-ctrl-group';
 
-                // 递归遍历坐标（支持 Point、LineString、Polygon、Multi 等）
-                const traverseCoordinates = (coords) => {
-                    if (!Array.isArray(coords)) return;
+        // 创建 button 元素
+        this._button = document.createElement('button');
+        this._button.type = 'button';
+        this._button.innerHTML = this.svgIcon;
 
-                    // 判断坐标类型：
-                    if (typeof coords[0] === 'number') {
-                        // 🟢 这是一个点 [lng, lat]
-                        const [lng, lat] = coords;
-                        if (lng < minLng) minLng = lng;
-                        if (lng > maxLng) maxLng = lng;
-                        if (lat < minLat) minLat = lat;
-                        if (lat > maxLat) maxLat = lat;
-                    } else if (Array.isArray(coords[0])) {
-                        // 🔵 可能是 LineString、Polygon、MultiPoint 等（嵌套数组）
-                        for (const subCoords of coords) {
-                            traverseCoordinates(subCoords);
-                        }
-                    }
-                    // 注意：更复杂的 GeometryCollection 或 MultiPolygon 也按类似方式递归，但此处已覆盖大部分情况
-                };
+        // 设置按钮样式
+        this._button.style.cursor = 'pointer';
+        this._button.style.border = 'none';
+        this._button.style.background = 'none';
+        this._button.style.padding = '0';
+        this._button.style.display = 'flex';
+        this._button.style.alignItems = 'center';
+        this._button.style.justifyContent = 'center';
 
-                traverseCoordinates(coords);
-            }
+        // 初始化状态
+        this.updateStatus();
 
-            // 如果没有有效的点（比如 featureCollection 为空或没有坐标）
-            if (
-                minLng === Infinity ||
-                minLat === Infinity ||
-                maxLng === -Infinity ||
-                maxLat === -Infinity
-            ) {
-                console.error('RT_FitBoundsMapbox: 未找到有效的坐标点');
-                return null;
-            }
+        // 绑定点击事件
+        this._button.addEventListener('click', () => {
+            this.toggle();
+        });
 
-            return [minLng, minLat, maxLng, maxLat];
-        };
+        this._container.appendChild(this._button);
 
-        // ✅ 调用手写函数，计算 bounding box
-        const boundsArray = calculateBoundingBox(featureCollection);
+        return this._container;
+    }
 
-        if (!boundsArray) {
-            console.error('RT_FitBoundsMapbox: 无法计算有效的包围盒');
-            return;
+    // Mapbox 要求的 onRemove 方法
+    onRemove() {
+        if (this._container && this._container.parentNode) {
+            this._container.parentNode.removeChild(this._container);
         }
+        this.map = null;
+        this._container = null;
+        this._button = null;
+    }
 
-        const [minLng, minLat, maxLng, maxLat] = boundsArray;
+    // 更新控件状态（根据当前 field 值）
+    updateStatus() {
+        // 从 map.SourceMap 中获取当前 field 的值，如果不存在则使用 defaultValue
+        let currentValue = this.defaultValue;
 
-        const bounds = [
-            [minLng, minLat], // 左下角
-            [maxLng, maxLat]  // 右上角
-        ];
-        console.log(`output->bounds`, bounds);
-        bounds.forEach(item => {
-            item.forEach((i, index) => {
-                item[index] = Number((i).toFixed(6));
-            });
-        });
-        // ✅ 调用 Mapbox 的 fitBounds
-        map.fitBounds(bounds, {
-            padding: 50,          // 可选：边距（单位像素）
-            maxZoom: 15,          // 可选：最大缩放级别，避免太近
-            duration: 1000,        // 可选：动画时长（毫秒）
-        });
+        if (
+            this.map &&
+            this.map.SourceMap &&
+            typeof this.map.SourceMap[this.field] === 'boolean'
+        ) {
+            currentValue = this.map.SourceMap[this.field];
+        }
 
-    } catch (error) {
-        console.error('RT_FitBoundsMapbox: 拟合地图边界时出错', error);
+        this.isActive = currentValue; // true 表示激活，false 表示未激活
+
+        // 更新按钮样式
+        if (this.isActive) {
+            this._button.style.opacity = '1';
+            this._button.style.filter = 'none';
+        } else {
+            this._button.style.opacity = '0.4';
+            this._button.style.filter = 'grayscale(100%)';
+        }
     }
-};
-
-var RainteeGISUtil = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    RT_FitBoundsMapbox: RT_FitBoundsMapbox,
-    RT_FitBoundsMapboxNative: RT_FitBoundsMapboxNative,
-    getFeatureOutsidePart: getFeatureOutsidePart
-});
-
-const treeDataAdapter = (data) => {
-    let i = 0;
-    let treeData = [];
-    let checkedKeys = [];
-    data.forEach((item) => {
-        let kvs = item.id.split(';').map(kvstr => kvstr.split('='));
-        let groups = kvs.find(item => item[0] === 'Main')[1].split('/');
-        let layerName = kvs.find(item => item[0] === 'CN')[1];
-        let currentNode = treeData;
-        groups.forEach((group, index) => {
-            currentNode.find(item => item.label === group) || i++;
-            currentNode.find(item => item.label === group) || currentNode.push({
-                id: i,
-                label: group,
-                children: []
-            });
-            currentNode = currentNode.find(item => item.label === group).children;
-        });
-        i++;
-        currentNode.push({
-            id: i,
-            label: layerName,
-            fullLayerName: groups.length === 0 ? layerName : groups.join('-') + '-' + layerName,
-            layerId: item.id,
-            opacity: '1.0',
-        });
-        if (item.layout && item.layout.visibility == 'visible') {
-            checkedKeys.push(i);
+
+    // 切换状态
+    toggle() {
+        // 获取当前值
+        let currentValue = this.defaultValue;
+
+        if (
+            this.map &&
+            this.map.SourceMap &&
+            typeof this.map.SourceMap[this.field] === 'boolean'
+        ) {
+            currentValue = this.map.SourceMap[this.field];
         }
-    });
-    return { treeData, checkedKeys }
-};
-const treeDataAdapterNext = (data) => {
-    let i = 0;
-    let treeData = [];
-    let checkedKeys = [];
-    data.forEach((item) => {
-        let kvs = item.id.split(';').map(kvstr => kvstr.split('='));
-        let groups = kvs.find(item => item[0] === 'Main')[1].split('/');
-        let layerName = kvs.find(item => item[0] === 'CN')[1];
-        let currentNode = treeData;
-        groups.length === 0 ? layerName : groups.join('-') + '-' + layerName;
-        groups.forEach((group, index) => {
-            currentNode.find(item => item.label === group) || i++;
-            currentNode.find(item => item.label === group) || currentNode.push({
-                id: `TreeId=${i};`,
-                label: group,
-                children: []
-            });
-            currentNode = currentNode.find(item => item.label === group).children;
-        });
-        i++;
-        currentNode.push({
-            id: item.id,
-            label: layerName,
-            fullLayerName: getLayerIdFidld(item.id, 'Main') + '-' + getLayerIdFidld(item.id, 'CN'),
-            layerId: item.id,
-            opacity: '1.0',
-        });
-        if (item.layout && item.layout.visibility == 'visible') {
-            checkedKeys.push(i);
+
+        // 切换值
+        const newValue = !currentValue;
+
+        // 更新到 map.SourceMap 中
+        if (this.map && this.map.SourceMap) {
+            this.map.SourceMap[this.field] = newValue;
         }
-    });
-    return { treeData, checkedKeys }
-};
-const getLayerIdFidld = (str, field) => {
-    let kvs = str.split(';').map(kvstr => kvstr.split('='));
-    let layerId = kvs.find(item => item[0] === field)[1];
-    return layerId
-};
-/**
- * 生成唯一ID字符串
- * @param {string} projectId 项目ID
- * @param {string} objectTypeId 对象种类ID
- * @param {string} groupId 对象分组ID
- * @param {string} objectId 对象ID
- * @returns {string} 唯一ID字符串
- */
-const GenerateUniqueId = (
-    projectId,
-    objectTypeId,
-    groupId,
-    objectId
-) => {
-    // 将参数组合成一个字符串
-    const combinedString = `${projectId}|${objectTypeId}|${groupId}|${objectId}`;
 
-    // 使用简单的哈希函数生成固定长度的字符串
-    let hash = 0;
-    for (let i = 0; i < combinedString.length; i++) {
-        const char = combinedString.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
+        // 更新内部状态
+        this.isActive = newValue;
 
-    // 转换为16进制字符串并补零到8位
-    const hexHash = (hash >>> 0).toString(16).padStart(8, "0");
+        // 更新 UI 样式
+        this.updateStatus();
 
-    // 添加前缀和分隔符增强可读性
-    return `UID-${projectId.slice(0, 2)}-${objectTypeId.slice(
-        0,
-        2
-    )}-${groupId.slice(0, 2)}-${hexHash}`;
-};
-
-var RainteeSourceMapTool = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    GenerateUniqueId: GenerateUniqueId,
-    getLayerIdFidld: getLayerIdFidld,
-    treeDataAdapter: treeDataAdapter,
-    treeDataAdapterNext: treeDataAdapterNext
-});
+        // ✅ 调用回调函数（如果传入了 onToggle），并传入最新的值
+        this.onToggle?.(newValue); // 安全调用，仅当函数存在时才执行
+    }
+}
 
 // RasterLayerController.js
 
-class RasterLayerController {
+class RasterLayerControl {
     constructor() {
         this._panel = null;
         this._isOpen = false;
@@ -6562,5 +6562,5 @@ const useDrawCache = () => {
     }
 };
 
-export { CustomOptionsControl, ToggleControl as CustomToggleControl, RainteeConstants, RainteeGISUtil, RainteeSourceMapTool, RasterLayerController, TerrainToggleControl, useDrawCache };
+export { CustomOptionsControl, CustomToggleControl, RainteeConstants, RainteeGISUtil, RainteeSourceMapTool, RasterLayerControl, TerrainToggleControl, useDrawCache };
 //# sourceMappingURL=index.js.map