fl-web-component 2.1.19 → 2.1.21

package/packages/utils/StreamLoader.js

@@ -1,6 +1,124 @@
 import { gunzipSync } from 'fflate';
 import StreamLoaderParserWorker from './StreamLoaderParser.worker.js';
 
+const STREAM_LOADER_DB_NAME = 'StreamLoaderDB';
+const STREAM_LOADER_BOX_STORE = 'boxCache';
+
+// IndexedDB 连接在模块级复用，保证没有 StreamLoader 实例时也能读写缓存
+let streamLoaderDbReady = null;
+
+/**
+ * 生成包围盒缓存主键，必须与写入时保持完全一致
+ * @param {string|number} projectId - 项目ID
+ * @param {string|number} documentId - 模型文档ID
+ * @returns {string} 形如 `${projectId}:${documentId}` 的主键
+ */
+function buildBoxCacheKey(projectId, documentId) {
+  return `${projectId || 0}:${documentId}`;
+}
+
+/**
+ * 打开并缓存 StreamLoader 使用的 IndexedDB
+ * @returns {Promise<IDBDatabase|null>} 环境不支持或打开失败时返回 null
+ */
+function openStreamLoaderDB() {
+  if (streamLoaderDbReady) return streamLoaderDbReady;
+  streamLoaderDbReady = new Promise(resolve => {
+    if (typeof indexedDB === 'undefined') {
+      resolve(null);
+      return;
+    }
+    // 打开数据库
+    const request = indexedDB.open(STREAM_LOADER_DB_NAME, 1);
+    request.onerror = () => {
+      console.warn('IndexedDB open failed');
+      resolve(null);
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onupgradeneeded = event => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(STREAM_LOADER_BOX_STORE)) {
+        db.createObjectStore(STREAM_LOADER_BOX_STORE);
+      }
+    };
+  });
+  return streamLoaderDbReady;
+}
+
+/**
+ * 删除指定项目下的全部包围盒缓存
+ * @param {string|number} [projectId] - 项目ID，缺省时按 0 处理（与写入默认值一致）
+ * @returns {Promise<boolean>}
+ * cleared 为该项目下是否已确认无缓存残留（原本就没有缓存时同样为 true）；
+ * deletedCount 为本次实际删除条数，环境不支持 IndexedDB 或事务失败时 cleared 为 false
+ */
+export async function clearProjectBoxCache(projectId) {
+  const keyPrefix = `${projectId || 0}:`;
+  const matchPrefix = keys => (keys || []).filter(key => String(key).startsWith(keyPrefix));
+  let deletedCount = 0;
+  let remainingCount = -1;
+  try {
+    const db = await openStreamLoaderDB();
+    if (!db) return { cleared: false, deletedCount };
+    await new Promise((resolve, reject) => {
+      const transaction = db.transaction([STREAM_LOADER_BOX_STORE], 'readwrite');
+      const store = transaction.objectStore(STREAM_LOADER_BOX_STORE);
+      const keysRequest = store.getAllKeys();
+      keysRequest.onsuccess = () => {
+        // 主键带 projectId 前缀与冒号，因此不会误删相邻 ID（如 1 与 12）
+        const keys = matchPrefix(keysRequest.result);
+        deletedCount = keys.length;
+        keys.forEach(key => store.delete(key));
+        // 同一事务内请求按发起顺序执行，回查可确认该项目下是否真的清空
+        const verifyRequest = store.getAllKeys();
+        verifyRequest.onsuccess = () => {
+          remainingCount = matchPrefix(verifyRequest.result).length;
+        };
+        verifyRequest.onerror = () => reject(verifyRequest.error);
+      };
+      keysRequest.onerror = () => reject(keysRequest.error);
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error);
+    });
+    return remainingCount === 0;
+  } catch (e) {
+    console.warn('Error clearing IndexedDB box cache:', e);
+    return false;
+  }
+}
+
+/**
+ * 删除指定项目下单条包围盒缓存
+ * @param {string|number} documentId - 模型文档ID
+ * @param {string|number} [projectId] - 项目ID，缺省时按 0 处理（与写入默认值一致）
+ * @returns {Promise<boolean>} 命中的缓存是否存在并被删除
+ */
+export async function clearDocumentBoxCache(documentId, projectId) {
+  if (documentId === undefined || documentId === null || documentId === '') return false;
+  const key = buildBoxCacheKey(projectId, documentId);
+  try {
+    const db = await openStreamLoaderDB();
+    if (!db) return false;
+    let existed = false;
+    await new Promise((resolve, reject) => {
+      const transaction = db.transaction([STREAM_LOADER_BOX_STORE], 'readwrite');
+      const store = transaction.objectStore(STREAM_LOADER_BOX_STORE);
+      const countRequest = store.count(key);
+      countRequest.onsuccess = () => {
+        existed = countRequest.result > 0;
+        if (existed) store.delete(key);
+      };
+      countRequest.onerror = () => reject(countRequest.error);
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error);
+    });
+    return existed;
+  } catch (e) {
+    console.warn('Error clearing IndexedDB box cache:', e);
+    return false;
+  }
+}
+
 /**
  * StreamLoader 类
  * 封装流式加载、解析与渲染调度的核心逻辑
@@ -1468,68 +1586,68 @@ export class StreamLoader {
     }
   }
 
-  async getBox({ id, projectId = this.projectId || 0, isDebug }) {
-    // 1. 尝试从 IndexedDB 读取
-    const cached = await this._getFromDB(id, projectId);
-    if (cached && !isDebug) {
-      return cached;
-    }
-
-    const getLegacyBox = async () => {
-      if (!this.modelApi || typeof this.modelApi.getBox !== 'function') {
-        throw new Error('modelApi.getBox is not available');
-      }
-      const res = await this.modelApi.getBox({ id, projectId });
-      if (!res) return null;
-      this._applyPrefixId(res, 'id', id);
-      this._saveToDB(id, res, projectId);
-      return res;
-    };
-
-    // 2. 未配置批次数接口时，兼容旧版一次性请求。
-    if (!this.modelApi || typeof this.modelApi.getMeshBatchCount !== 'function') {
-      return getLegacyBox();
-    }
-
-    // 3. 先获取批次数量，再顺序拉取每一批包围盒数据。
-    let batchResult;
-    try {
-      batchResult = await this.modelApi.getMeshBatchCount({ id, projectId });
-    } catch (error) {
-      const status = error && error.response ? error.response.status : error && error.status;
-      if (status === 404) {
-        return getLegacyBox();
-      }
-      throw error;
-    }
-    const batchCount = Number(
-      batchResult && typeof batchResult === 'object' ? batchResult.index : batchResult
-    );
-    if (!Number.isInteger(batchCount) || batchCount < 0) {
-      throw new Error('Invalid getBox batch count');
-    }
-    if (batchCount === 0) {
-      return [];
-    }
-
-    const boxList = [];
-    for (let index = 0; index < batchCount; index++) {
-      const batch = await this.modelApi.getBox({ id, projectId, index });
-      if (!batch) {
-        throw new Error(`Failed to get box batch: ${index}`);
-      }
-      if (Array.isArray(batch)) {
-        boxList.push(...batch);
-      } else {
-        boxList.push(batch);
-      }
-    }
-
-    // 4. 全部批次成功后统一处理并写入完整缓存。
-    this._applyPrefixId(boxList, 'id', id);
-    this._saveToDB(id, boxList, projectId);
-    return boxList;
-  }
+  async getBox({ id, projectId = this.projectId || 0, isDebug }) {
+    // 1. 尝试从 IndexedDB 读取
+    const cached = await this._getFromDB(id, projectId);
+    if (cached && !isDebug) {
+      return cached;
+    }
+
+    const getLegacyBox = async () => {
+      if (!this.modelApi || typeof this.modelApi.getBox !== 'function') {
+        throw new Error('modelApi.getBox is not available');
+      }
+      const res = await this.modelApi.getBox({ id, projectId });
+      if (!res) return null;
+      this._applyPrefixId(res, 'id', id);
+      this._saveToDB(id, res, projectId);
+      return res;
+    };
+
+    // 2. 未配置批次数接口时，兼容旧版一次性请求。
+    if (!this.modelApi || typeof this.modelApi.getMeshBatchCount !== 'function') {
+      return getLegacyBox();
+    }
+
+    // 3. 先获取批次数量，再顺序拉取每一批包围盒数据。
+    let batchResult;
+    try {
+      batchResult = await this.modelApi.getMeshBatchCount({ id, projectId });
+    } catch (error) {
+      const status = error && error.response ? error.response.status : error && error.status;
+      if (status === 404) {
+        return getLegacyBox();
+      }
+      throw error;
+    }
+    const batchCount = Number(
+      batchResult && typeof batchResult === 'object' ? batchResult.index : batchResult
+    );
+    if (!Number.isInteger(batchCount) || batchCount < 0) {
+      throw new Error('Invalid getBox batch count');
+    }
+    if (batchCount === 0) {
+      return [];
+    }
+
+    const boxList = [];
+    for (let index = 0; index < batchCount; index++) {
+      const batch = await this.modelApi.getBox({ id, projectId, index });
+      if (!batch) {
+        throw new Error(`Failed to get box batch: ${index}`);
+      }
+      if (Array.isArray(batch)) {
+        boxList.push(...batch);
+      } else {
+        boxList.push(batch);
+      }
+    }
+
+    // 4. 全部批次成功后统一处理并写入完整缓存。
+    this._applyPrefixId(boxList, 'id', id);
+    this._saveToDB(id, boxList, projectId);
+    return boxList;
+  }
 
   async handleCameraControlForStream(args) {
     // 性能优化注释：禁用 range 被注释字段的解构声明与初始化
@@ -1771,27 +1889,7 @@ export class StreamLoader {
   // ----------------------------------------------------------------
 
   _initDB() {
-    if (this._dbReady) return this._dbReady;
-    this._dbReady = new Promise((resolve, reject) => {
-      if (typeof indexedDB === 'undefined') {
-        resolve(null);
-        return;
-      }
-      // 打开数据库
-      const request = indexedDB.open('StreamLoaderDB', 1);
-      request.onerror = () => {
-        console.warn('IndexedDB open failed');
-        resolve(null);
-      };
-      request.onsuccess = () => resolve(request.result);
-      request.onupgradeneeded = event => {
-        const db = event.target.result;
-        if (!db.objectStoreNames.contains('boxCache')) {
-          db.createObjectStore('boxCache');
-        }
-      };
-    });
-    return this._dbReady;
+    return openStreamLoaderDB();
   }
 
   async _getFromDB(id, projectId = this.projectId || 0) {
@@ -1801,7 +1899,7 @@ export class StreamLoader {
       return new Promise(resolve => {
         const transaction = db.transaction(['boxCache'], 'readonly');
         const store = transaction.objectStore('boxCache');
-        const request = store.get(`${projectId}:${id}`);
+        const request = store.get(buildBoxCacheKey(projectId, id));
         request.onsuccess = () => resolve(request.result);
         request.onerror = () => resolve(null);
       });
@@ -1817,9 +1915,28 @@ export class StreamLoader {
       if (!db) return;
       const transaction = db.transaction(['boxCache'], 'readwrite');
       const store = transaction.objectStore('boxCache');
-      store.put(data, `${projectId}:${id}`);
+      store.put(data, buildBoxCacheKey(projectId, id));
     } catch (e) {
       console.warn('Error saving to IndexedDB:', e);
     }
   }
+
+  /**
+   * 清除指定项目下的全部包围盒缓存
+   * @param {string|number} [projectId=this.projectId] - 项目ID
+   * @returns {Promise<{cleared: boolean, deletedCount: number}>} 该项目下是否已清空及实际删除条数
+   */
+  clearBoxCacheByProject(projectId = this.projectId || 0) {
+    return clearProjectBoxCache(projectId);
+  }
+
+  /**
+   * 清除指定项目下单条包围盒缓存
+   * @param {string|number} documentId - 模型文档ID
+   * @param {string|number} [projectId=this.projectId] - 项目ID
+   * @returns {Promise<boolean>} 命中的缓存是否存在并被删除
+   */
+  clearBoxCacheByDocumentId(documentId, projectId = this.projectId || 0) {
+    return clearDocumentBoxCache(documentId, projectId);
+  }
 }

package/src/utils/threejs/measure-area.js

@@ -427,10 +427,13 @@ MeasureArea.prototype = {
           transparent: true,
           opacity: 0.5,
           side: THREE.DoubleSide,
+          depthTest: false,
+          depthWrite: false,
           name: this.measureName
         });
         const mesh = new THREE.Mesh(geom, material);
         mesh.frustumCulled = false;
+        mesh.renderOrder = 998;
         _this.markMeasureObject(mesh);
         _this.polygonMesh = mesh;
         _this.scene.add(mesh);