bruce-cesium 6.0.3 → 6.0.5

package/dist/bruce-cesium.umd.js

@@ -10736,7 +10736,10 @@
             if (!cTileset) {
                 return false;
             }
-            if (cTileset.isDestroyed() || !viewer.scene.primitives.contains(cTileset)) {
+            else if (cTileset.isDestroyed() || !viewer.scene.primitives.contains(cTileset)) {
+                return false;
+            }
+            else if (visual.primitive && visual.primitive.isDestroyed()) {
                 return false;
             }
             return true;
@@ -10831,11 +10834,15 @@
     }
     function updateEntity(viewer, entityId, register, refresh, cache = {}) {
         var _a;
+        if (!entityId) {
+            // What are we doing?
+            return;
+        }
         // Unavailable for unoptimized single-Entity updates.
         if (!cache) {
             cache = {};
         }
-        let regos = register.GetRegos({
+        const regos = register.GetRegos({
             entityId
         });
         regos.sort((a, b) => {
@@ -11116,7 +11123,7 @@
                         for (let i = 0; i < batch.length; i++) {
                             const entityId = batch[i];
                             // Check if still registered.
-                            if (!this.rego[entityId] || !this.rego[entityId].length) {
+                            if (entityId && (!this.rego[entityId] || !this.rego[entityId].length)) {
                                 continue;
                             }
                             updateEntity(this.viewer, entityId, this, this.updateQueueSettings[entityId] == null ? false : this.updateQueueSettings[entityId], cache);
@@ -12157,6 +12164,7 @@
                     }
                     return visuals;
                 }
+                return [];
             }
             /**
              * Removes regos matching given criteria.
@@ -12294,6 +12302,77 @@
                     }
                 }
             }
+            /**
+             * Removes regos matching given visuals.
+             * This is used when we cannot unpack properties from the visual any longer to determine its ID.
+             * Usually for Tileset features.
+             * @param params
+             */
+            RemoveRegosByVisuals(params) {
+                var _a, _b, _c;
+                const { doRemove = true, requestRender = true, source, doUpdate, menuItemId } = params;
+                const entityIds = Object.keys(this.rego);
+                const removedEntityIds = [];
+                for (const entityId of entityIds) {
+                    const regos = this.rego[entityId];
+                    if (regos && regos.length) {
+                        for (const rego of regos) {
+                            if (params.visuals.includes(rego.visual)) {
+                                exports.EntityLabel.Detatch({
+                                    rego
+                                });
+                                if (doRemove != false) {
+                                    removeEntity(this.viewer, rego.visual);
+                                }
+                                rego.visual = null;
+                                this.rego[entityId] = regos.filter(r => r.visual !== rego.visual);
+                                const update = {
+                                    type: EVisualUpdateType.Remove,
+                                    entityId: rego.entityId,
+                                    rego: rego
+                                };
+                                if (source) {
+                                    update.source = source;
+                                }
+                                if (source !== EUpdateSource.TREE_CASCADE) {
+                                    (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+                                }
+                                if (doUpdate && menuItemId) {
+                                    this.queueUpdate({
+                                        entityId: entityId,
+                                        refresh: false
+                                    });
+                                }
+                                if (!removedEntityIds.includes(rego.entityId)) {
+                                    removedEntityIds.push(rego.entityId);
+                                }
+                            }
+                            // Check siblings.
+                            else if ((_b = rego.visual) === null || _b === void 0 ? void 0 : _b["_siblingGraphics"]) {
+                                let siblings = rego.visual["_siblingGraphics"];
+                                if (doRemove != false) {
+                                    for (const sibling of siblings) {
+                                        if (params.visuals.includes(sibling)) {
+                                            removeEntity(this.viewer, sibling);
+                                        }
+                                    }
+                                }
+                                siblings = siblings.filter(s => !params.visuals.includes(s));
+                                rego.visual["_siblingGraphics"] = siblings;
+                            }
+                        }
+                    }
+                    if (!((_c = this.rego[entityId]) === null || _c === void 0 ? void 0 : _c.length)) {
+                        delete this.rego[entityId];
+                    }
+                }
+                if (requestRender) {
+                    this.viewer.scene.requestRender();
+                }
+                return {
+                    removedEntityIds
+                };
+            }
             /**
              * Returns an array of drilled visuals associated with this register.
              * The top array item is the first found.
@@ -18291,6 +18370,17 @@
                 this.historicPossesInitialLoaded = false;
                 this.historicAnimation = null;
                 this.historicPossesLoadingProm = null;
+                // Queue of loaded in features that we haven't processed yet.
+                this.featureQueue = [];
+                // State is true for 'add' or 'false' for 'remove'.
+                this.featureQueueStates = new Map();
+                this.featureQueueInterval = null;
+                // Cache of feature properties we wanted to find vs what we found.
+                // Eg: "entityId" -> "entityId" | "bruceId" | "id" | null.
+                // Eg: "geomId" -> null | "geomId";
+                // Saves having to do a case-insensitive lookup every time.
+                this.featurePropCache = new Map();
+                this.featurePropsChecked = 0;
                 const { viewer, register: visualsManager, getters, item, modelSpace } = params;
                 this.viewer = viewer;
                 this.getters = getters;
@@ -18325,7 +18415,7 @@
                     // Single shared getter to avoid multiple assemblies fighting to render.
                     // This lets one complete, then the next start.
                     await exports.SharedGetters.Queue.Run("Rendering assembly.", async () => {
-                        var _a, _b, _c;
+                        var _a, _b;
                         if (this.disposed) {
                             return;
                         }
@@ -18383,30 +18473,39 @@
                                 viaCdn: false
                             });
                         }
-                        // ModelTree is needed to map incoming graphics to Entities.
-                        // So we load it first, then start rendering.
-                        try {
-                            // In >v1 the model-tree sits in its own file.
-                            if (((_a = tileset.settings) === null || _a === void 0 ? void 0 : _a["tilesetVersion"]) > 1) {
-                                const modelTreeUrl = BModels.Tileset.GetFileUrl({
-                                    api: api,
-                                    file: "model_tree.json",
-                                    tilesetId: tileset.id,
-                                    cacheToken: tileset.generateVersion,
-                                    viaCdn: Boolean(this.item.cdnEnabled == null ? true : this.item.cdnEnabled)
-                                });
-                                this.modelTree = await api.get(modelTreeUrl);
-                                this.modelTreeUpdate.Trigger(this.modelTree);
-                            }
-                            // In v1 the model-tree is inside the tileset.json.
-                            else {
-                                const tilesetJson = await api.get(tileset.loadUrl);
-                                this.modelTree = ((_b = tilesetJson === null || tilesetJson === void 0 ? void 0 : tilesetJson.extensions) === null || _b === void 0 ? void 0 : _b.modelTree) || null;
+                        // TODO: we shouldn't just assume we'll need it, huge assemblies are 100+ MB.
+                        // TODO: this is a problem as we need to know what nodes are collapsed...
+                        // In >v1 the model-tree sits in its own file.
+                        if (((_a = tileset.settings) === null || _a === void 0 ? void 0 : _a["tilesetVersion"]) > 1) {
+                            const modelTreeUrl = BModels.Tileset.GetFileUrl({
+                                api: api,
+                                file: "model_tree.json",
+                                tilesetId: tileset.id,
+                                cacheToken: tileset.generateVersion,
+                                viaCdn: Boolean(this.item.cdnEnabled == null ? true : this.item.cdnEnabled)
+                            });
+                            api.get(modelTreeUrl).then((blob) => {
+                                if (this.disposed) {
+                                    return;
+                                }
+                                this.modelTree = blob || null;
                                 this.modelTreeUpdate.Trigger(this.modelTree);
-                            }
+                            }).catch((err) => {
+                                this.modelTreeError = err.message || "Unknown error";
+                            });
                         }
-                        catch (e) {
-                            console.error(e);
+                        // In v1 the model-tree is inside the tileset.json.
+                        else {
+                            api.get(tileset.loadUrl).then((blob) => {
+                                var _a;
+                                if (this.disposed) {
+                                    return;
+                                }
+                                this.modelTree = ((_a = blob === null || blob === void 0 ? void 0 : blob.extensions) === null || _a === void 0 ? void 0 : _a.modelTree) || null;
+                                this.modelTreeUpdate.Trigger(this.modelTree);
+                            }).catch((err) => {
+                                this.modelTreeError = err.message || "Unknown error";
+                            });
                         }
                         if (this.disposed) {
                             return;
@@ -18415,7 +18514,7 @@
                         const rootId = settings.rootEntityId;
                         this.rootId = rootId;
                         // If historic, we'll see if the root Entity has a historic position to use.
-                        if (((_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historic) && rootId) {
+                        if (((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historic) && rootId) {
                             try {
                                 const { entity: root } = await BModels.Entity.Get({
                                     entityId: rootId,
@@ -18503,7 +18602,7 @@
                     });
                     cTileset.tileLoad.addEventListener((tile) => {
                         try {
-                            this.mapCTile(tile, true);
+                            this.queueTile(tile, true);
                         }
                         catch (e) {
                             console.error(e);
@@ -18511,7 +18610,7 @@
                     });
                     cTileset.tileUnload.addEventListener((tile) => {
                         try {
-                            this.mapCTile(tile, false);
+                            this.queueTile(tile, false);
                         }
                         catch (e) {
                             console.error(e);
@@ -18534,34 +18633,133 @@
              * @param load indicates if we are loading or unloading the tile.
              * @returns
              */
-            mapCTile(tile, load) {
+            queueTile(tile, load) {
                 const content = tile === null || tile === void 0 ? void 0 : tile.content;
                 if (!content) {
                     return;
                 }
-                const regosToQueue = new Map();
                 for (let i = 0; i < content.featuresLength; i++) {
                     const feature = content.getFeature(i);
-                    let rego = this.mapTilesetFeature(feature, load);
-                    if (!(rego === null || rego === void 0 ? void 0 : rego.entityId)) {
+                    if (!this.featureQueue.includes(feature)) {
+                        this.featureQueue.push(feature);
+                    }
+                    this.featureQueueStates.set(feature, load);
+                }
+                this.pingFeatureQueue();
+            }
+            /**
+             * Pings the feature queue to process any queued features.
+             * Does nothing if we're already processing.
+             * @returns
+             */
+            pingFeatureQueue() {
+                if (!this.featureQueue.length || this.featureQueueInterval || this.disposed) {
+                    return;
+                }
+                this.featureQueueInterval = setInterval(() => {
+                    if (this.disposed) {
+                        clearInterval(this.featureQueueInterval);
+                        this.featureQueueInterval = null;
+                        return;
+                    }
+                    this.processFeatureQueueBatch();
+                    if (!this.featureQueue) {
+                        clearInterval(this.featureQueueInterval);
+                        this.featureQueueInterval = null;
+                    }
+                }, 10);
+            }
+            /**
+             * Process a batch of features from the feature queue.
+             */
+            processFeatureQueueBatch() {
+                if (!this.featureQueue.length) {
+                    return;
+                }
+                // If features require geomId (don't have bruceId props) then the model tree must be loaded.
+                // If it's not loaded, we simply return and keep waiting.
+                if (!this.modelTree) {
+                    /*
+                    if (!this.featureQueue[0].getProperty("bruceId")) {
+                        return;
+                    }
+                    */
+                    // TODO: For now always requiring it when it's available.
+                    // This is because we need to think of a strategy or collapsed items first.
+                    if (!this.modelTreeError) {
+                        return;
+                    }
+                }
+                const BATCH_SIZE = 5000;
+                const batch = this.featureQueue.splice(0, BATCH_SIZE);
+                const regosToStyle = new Map();
+                const featuresToRemove = [];
+                for (const feature of batch) {
+                    const load = this.featureQueueStates.get(feature);
+                    this.featureQueueStates.delete(feature);
+                    if (!load) {
+                        featuresToRemove.push(feature);
+                        continue;
+                    }
+                    const result = this.mapTilesetFeature(feature);
+                    if (result === null) {
                         // Override the default hide state set by the style.
                         feature.show = true;
                         continue;
                     }
-                    regosToQueue.set(rego.entityId, rego);
+                    else if (result) {
+                        regosToStyle.set(result.entityId, result);
+                    }
                 }
-                if (this.styler && regosToQueue.size) {
-                    this.styler.QueueEntities(Array.from(regosToQueue.values()));
+                if (featuresToRemove.length) {
+                    const { removedEntityIds } = this.visualsManager.RemoveRegosByVisuals({
+                        visuals: featuresToRemove,
+                        requestRender: false,
+                        menuItemId: this.item.id,
+                        doRemove: false
+                    });
+                    for (const entityId of removedEntityIds) {
+                        delete this.loadedCesiumEntities[entityId];
+                    }
+                }
+                if (this.styler && regosToStyle.size) {
+                    this.styler.QueueEntities(Array.from(regosToStyle.values()));
+                }
+            }
+            evaluateFeatureProps(feature) {
+                var _a;
+                // If we've checked 10 features then we should have a good handle on what props are available.
+                if (this.featurePropsChecked >= 10) {
+                    return;
+                }
+                this.featurePropsChecked++;
+                const featureAny = feature;
+                const props = featureAny.getPropertyNames ? featureAny.getPropertyNames() : (_a = featureAny.getPropertyIds) === null || _a === void 0 ? void 0 : _a.call(featureAny);
+                if (!props) {
+                    return;
+                }
+                for (const prop of props) {
+                    if (!prop) {
+                        continue;
+                    }
+                    const lowered = prop.toLowerCase();
+                    if (lowered === "bruceid" || lowered === "id" || lowered === "entityid") {
+                        this.featurePropCache.set("entityId", prop);
+                    }
+                    else if (lowered === "geomid") {
+                        this.featurePropCache.set("geomId", prop);
+                    }
+                    else if (lowered === "brucepath") {
+                        this.featurePropCache.set("brucePath", prop);
+                    }
                 }
-                this.viewer.scene.requestRender();
             }
             /**
              * @param feature
-             * @param add indicates if we are adding or removing the feature.
              * @returns
              */
-            mapTilesetFeature(feature, add) {
-                var _a, _b, _c, _d, _e, _f;
+            mapTilesetFeature(feature) {
+                var _a, _b, _c, _d, _e;
                 const accountId = (_b = ((_a = this.item.tileset) === null || _a === void 0 ? void 0 : _a.ClientAccountID)) !== null && _b !== void 0 ? _b : this.getters.GetAccountId();
                 const canEdit = accountId === this.getters.GetAccountId() && !((_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historic);
                 let rego = {
@@ -18577,17 +18775,15 @@
                     tilesetType: BModels.Tileset.EType.Cad,
                     rootId: this.rootId
                 };
-                const featureAny = feature;
-                const propertyNames = featureAny.getPropertyNames ? featureAny.getPropertyNames() : (_e = featureAny.getPropertyIds) === null || _e === void 0 ? void 0 : _e.call(featureAny);
-                if (!propertyNames) {
-                    return null;
-                }
-                const setByGeomId = () => {
-                    const geomIdProp = propertyNames.find(x => String(x).toLowerCase() == "geomid");
+                this.evaluateFeatureProps(feature);
+                // Becoming legacy.
+                // Need to handle collapsed items somehow in newer path first.
+                if (!rego.entityId) {
+                    const geomIdProp = this.featurePropCache.get("geomId");
                     if (geomIdProp) {
                         const geomId = +feature.getProperty(geomIdProp);
                         if (geomId != null && (!!geomId || geomId == 0)) {
-                            const meta = this.getMetaByGeomId(geomId, feature.tileset);
+                            const meta = this.getMetaByGeomId(geomId);
                             if (meta) {
                                 rego.entityId = meta.entityId;
                                 rego.entityTypeId = meta.typeId;
@@ -18596,15 +18792,17 @@
                             }
                         }
                     }
-                };
-                const setByEntityId = () => {
-                    const bruceIdProp = propertyNames.find(x => (String(x).toLowerCase() == "bruceid"));
-                    if (bruceIdProp) {
-                        rego.entityId = feature.getProperty(bruceIdProp);
+                }
+                // Latest path.
+                if (!rego.entityId) {
+                    const entityIdProp = this.featurePropCache.get("entityId");
+                    if (entityIdProp) {
+                        rego.entityId = feature.getProperty(entityIdProp);
                     }
-                };
-                const setByPath = () => {
-                    const brucePathProp = propertyNames.find(x => String(x).toLowerCase() == "brucepath");
+                }
+                // Super legacy.
+                if (!rego.entityId) {
+                    const brucePathProp = this.featurePropCache.get("brucePath");
                     if (brucePathProp) {
                         const pathStr = feature.getProperty(brucePathProp);
                         if (pathStr) {
@@ -18614,20 +18812,13 @@
                             rego.entityId = path[path.length - 1];
                         }
                     }
-                };
-                setByGeomId();
-                if (!rego.entityId) {
-                    setByEntityId();
-                }
-                if (!rego.entityId) {
-                    setByPath();
                 }
                 if (!rego.entityId) {
                     return null;
                 }
                 // Optional menu item restriction.
                 // Allows only showing certain entities from a tileset.
-                const onlyIds = (_f = this.item.BruceEntity) === null || _f === void 0 ? void 0 : _f.EntityIds;
+                const onlyIds = (_e = this.item.BruceEntity) === null || _e === void 0 ? void 0 : _e.EntityIds;
                 if ((onlyIds === null || onlyIds === void 0 ? void 0 : onlyIds.length) && !onlyIds.includes(rego.entityId)) {
                     if (this.item.BruceEntity.Ghosts) {
                         feature.color = Cesium.Color.WHITE.clone().withAlpha(0.5);
@@ -18635,74 +18826,60 @@
                     else {
                         feature.show = false;
                     }
-                    return null;
+                    return false;
                 }
-                if (add) {
-                    // Get the initial hide/show state.
-                    const state = this.visualsManager.GetState({
-                        entityId: rego.entityId,
-                        menuItemId: this.item.id,
-                    });
-                    if (this.somethingIsolated == null ||
-                        // 5s cache.
-                        (this.somethingIsolatedDateTime && this.somethingIsolatedDateTime.getTime() + 5000 < new Date().getTime())) {
-                        this.somethingIsolated = this.visualsManager.GetIsIsolatedAny();
-                        this.somethingIsolatedDateTime = new Date();
+                // Get the initial hide/show state.
+                const state = this.visualsManager.GetState({
+                    entityId: rego.entityId,
+                    menuItemId: this.item.id,
+                });
+                if (this.somethingIsolated == null ||
+                    // 5s cache.
+                    (this.somethingIsolatedDateTime && this.somethingIsolatedDateTime.getTime() + 5000 < new Date().getTime())) {
+                    this.somethingIsolated = this.visualsManager.GetIsIsolatedAny();
+                    this.somethingIsolatedDateTime = new Date();
+                }
+                // Override the default hide state set by the style.
+                let hide = false;
+                if (state) {
+                    if (state.hidden) {
+                        hide = true;
                     }
-                    // Override the default hide state set by the style.
-                    let hide = false;
-                    if (state) {
-                        if (state.hidden) {
-                            hide = true;
-                        }
-                        else if (state.opacity === 0) {
-                            hide = true;
-                        }
-                        else if (!state.isolated && this.somethingIsolated) {
-                            hide = true;
-                        }
+                    else if (state.opacity === 0) {
+                        hide = true;
                     }
-                    feature.show = !hide;
-                    // Already exists, so we add this graphic as a sibling.
-                    if (this.loadedCesiumEntities[rego.entityId]) {
-                        rego = this.loadedCesiumEntities[rego.entityId];
-                        if (!rego.visual) {
-                            // No parent graphic.
-                            rego.visual = feature;
+                    else if (!state.isolated && this.somethingIsolated) {
+                        hide = true;
+                    }
+                }
+                feature.show = !hide;
+                // Already exists, so we add this graphic as a sibling.
+                if (this.loadedCesiumEntities[rego.entityId]) {
+                    rego = this.loadedCesiumEntities[rego.entityId];
+                    if (!rego.visual) {
+                        // No parent graphic.
+                        rego.visual = feature;
+                    }
+                    else if (rego.visual == feature) ;
+                    else {
+                        const visual = rego.visual;
+                        // Sibling graphic.
+                        if (!visual._siblingGraphics) {
+                            visual._siblingGraphics = [];
                         }
-                        else if (rego.visual == feature) ;
-                        else {
-                            const visual = rego.visual;
-                            // Sibling graphic.
-                            if (!visual._siblingGraphics) {
-                                visual._siblingGraphics = [];
-                            }
-                            if (visual._siblingGraphics.indexOf(feature) < 0) {
-                                visual._siblingGraphics.push(feature);
-                            }
+                        if (visual._siblingGraphics.indexOf(feature) < 0) {
+                            visual._siblingGraphics.push(feature);
                         }
                     }
-                    this.loadedCesiumEntities[rego.entityId] = rego;
-                    this.visualsManager.AddRego({
-                        rego,
-                        requestRender: false
-                    });
-                    return rego;
-                }
-                else {
-                    this.visualsManager.RemoveRegos({
-                        entityId: rego.entityId,
-                        requestRender: false,
-                        menuItemId: this.item.id,
-                        doRemove: false,
-                        source: exports.VisualsRegister.EUpdateSource.TILESET_DISPOSE
-                    });
-                    // Might have to do something smarter since siblings could still be OK.
-                    this.loadedCesiumEntities[rego.entityId] = null;
-                    delete this.loadedCesiumEntities[rego.entityId];
                 }
+                this.loadedCesiumEntities[rego.entityId] = rego;
+                this.visualsManager.AddRego({
+                    rego,
+                    requestRender: false
+                });
+                return rego;
             }
-            getMetaByGeomId(geomId, tileset) {
+            getMetaByGeomId(geomId) {
                 if (this.treeNodeByGeomId == null) {
                     if (!this.modelTree) {
                         return null;
@@ -18742,8 +18919,8 @@
                             newFirstFoundCollapsedBranch = cache;
                         }
                     }
-                    // Always process children regardless of collapse state
-                    // This ensures all nodes are mapped, even those under collapsed branches
+                    // Always process children regardless of collapse state.
+                    // This ensures all nodes are mapped, even those under collapsed branches.
                     if (node.children) {
                         for (let i = node.children.length - 1; i >= 0; i--) {
                             stack.push({
@@ -18768,8 +18945,8 @@
             }
             /**
              * Gets the parent node of a given entity.
-             * @param entityId The entity ID to find the parent for
-             * @returns The parent node or null if no parent exists
+             * @param entityId The entity ID to find the parent for.
+             * @returns The parent node or null if no parent exists.
              */
             getParentNode(entityId) {
                 if (this.treeNodeByEntityId == null) {
@@ -18786,8 +18963,8 @@
             }
             /**
              * Gets all child nodes of a given entity.
-             * @param entityId The entity ID to find children for
-             * @returns Array of child nodes
+             * @param entityId The entity ID to find children for.
+             * @returns Array of child nodes.
              */
             getChildNodes(entityId) {
                 if (this.treeNodeByEntityId == null) {
@@ -18836,7 +19013,7 @@
             }
             /**
              * Gets the root node of the model tree.
-             * @returns The root node or null if no tree exists
+             * @returns The root node or null if no tree exists.
              */
             getRootNode() {
                 if (this.treeNodeByEntityId == null) {
@@ -18845,7 +19022,7 @@
                     }
                     this.buildModelTreeNodes(this.modelTree);
                 }
-                // Find the node with no parent (root node)
+                // Find the node with no parent (root node).
                 for (const nodeId in this.treeNodeByEntityId) {
                     const node = this.treeNodeByEntityId[nodeId];
                     if (!node.parentId) {
@@ -18856,8 +19033,8 @@
             }
             /**
              * Gets the path from root to a given entity.
-             * @param entityId The entity ID to find the path for
-             * @returns Array of node IDs representing the path from root to the entity
+             * @param entityId The entity ID to find the path for.
+             * @returns Array of node IDs representing the path from root to the entity.
              */
             getNodePath(entityId) {
                 if (this.treeNodeByEntityId == null) {
@@ -18880,8 +19057,8 @@
             }
             /**
              * Batch operation to get multiple node paths efficiently.
-             * @param entityIds Array of entity IDs to get paths for
-             * @returns Map of entityId to path array
+             * @param entityIds Array of entity IDs to get paths for.
+             * @returns Map of entityId to path array.
              */
             getNodePathsBatch(entityIds) {
                 if (this.treeNodeByEntityId == null) {
@@ -18908,8 +19085,8 @@
             }
             /**
              * Batch operation to get multiple parent nodes efficiently.
-             * @param entityIds Array of entity IDs to get parents for
-             * @returns Map of entityId to parent node
+             * @param entityIds Array of entity IDs to get parents for.
+             * @returns Map of entityId to parent node.
              */
             getParentNodesBatch(entityIds) {
                 if (this.treeNodeByEntityId == null) {
@@ -18932,8 +19109,8 @@
             }
             /**
              * Batch operation to get multiple child nodes efficiently.
-             * @param entityIds Array of entity IDs to get children for
-             * @returns Map of entityId to array of child nodes
+             * @param entityIds Array of entity IDs to get children for.
+             * @returns Map of entityId to array of child nodes.
              */
             getChildNodesBatch(entityIds) {
                 if (this.treeNodeByEntityId == null) {
@@ -18943,11 +19120,11 @@
                     this.buildModelTreeNodes(this.modelTree);
                 }
                 const children = new Map();
-                // Initialize all entityIds with empty arrays
+                // Initialize all entityIds with empty arrays.
                 for (const entityId of entityIds) {
                     children.set(entityId, []);
                 }
-                // Build a reverse lookup for efficiency
+                // Build a reverse lookup for efficiency.
                 for (const nodeId in this.treeNodeByEntityId) {
                     const node = this.treeNodeByEntityId[nodeId];
                     if (node.parentId && children.has(node.parentId)) {
@@ -18965,6 +19142,11 @@
             }
             doDispose() {
                 var _a, _b;
+                if (this.featureQueueInterval) {
+                    clearInterval(this.featureQueueInterval);
+                    this.featureQueueInterval = null;
+                    this.featureQueue = [];
+                }
                 if (this.cTileset) {
                     const viewer = this.viewer;
                     if (!(viewer === null || viewer === void 0 ? void 0 : viewer.isDestroyed()) && this.viewer.scene.primitives.contains(this.cTileset)) {
@@ -33214,7 +33396,7 @@
         }
     }
 
-    const VERSION = "6.0.3";
+    const VERSION = "6.0.5";
 
     exports.VERSION = VERSION;
     exports.isOutlineChanged = isOutlineChanged;