bruce-cesium 6.7.8 → 6.8.0

package/dist/lib/rendering/visuals-register.js

@@ -368,6 +368,18 @@ var VisualsRegister;
             this.id = bruce_models_1.ObjectUtils.UId();
             this.disposed = false;
             this.rego = {};
+            // Menu Item ID -> Set of Entity IDs registered under that menu item, for O(1) lookup.
+            this.entityIdsByMenuItem = {};
+            // Caches GetIsIsolatedAny(). `null` means "unknown, recompute".
+            // Invalidated on any write that could affect isolation.
+            this.isolatedAnyCache = null;
+            // Lazy OverrideStates() bookkeeping. See cancelLazyOverride()/startLazyOverride().
+            this.lazyOverrideToken = 0;
+            this.lazyOverrideActive = false;
+            // Entity ids a direct (non-lazy) write touched while a lazy apply was in-flight-
+            // skipped by the applier so a live user action always wins.
+            this.lazyOverrideExclusions = new Set();
+            this.lazyOverrideInterval = null;
             this.onUpdate = null;
             // Entity ID -> Menu Item ID -> State.
             // When no Menu Item ID is set, then the second key is a blank string.
@@ -375,6 +387,8 @@ var VisualsRegister;
             this.states = {};
             // Queue of Entity updates to process in batches to avoid overloading the render loop.
             this.updateQueue = [];
+            // Mirrors updateQueue for O(1) "already queued" checks.
+            this.updateQueueIds = new Set();
             // Settings related to those Entities in the queue.
             // This lets us modify the update without re-adding the item to the queue if it's already in it.
             this.updateQueueSettings = {};
@@ -385,6 +399,42 @@ var VisualsRegister;
                 register: this
             });
         }
+        indexMenuItemEntity(menuItemId, entityId) {
+            if (!menuItemId) {
+                return;
+            }
+            let set = this.entityIdsByMenuItem[menuItemId];
+            if (!set) {
+                set = this.entityIdsByMenuItem[menuItemId] = new Set();
+            }
+            set.add(entityId);
+        }
+        // Removes entityId from the menu item index only if it no longer has any rego
+        // registered under that menu item. Safe to call speculatively.
+        unindexMenuItemEntityIfAbsent(menuItemId, entityId) {
+            var _a;
+            if (!menuItemId) {
+                return;
+            }
+            const set = this.entityIdsByMenuItem[menuItemId];
+            if (!set) {
+                return;
+            }
+            const stillPresent = (_a = this.rego[entityId]) === null || _a === void 0 ? void 0 : _a.some(r => r.menuItemId === menuItemId);
+            if (!stillPresent) {
+                set.delete(entityId);
+                if (!set.size) {
+                    delete this.entityIdsByMenuItem[menuItemId];
+                }
+            }
+        }
+        // Records that `entityId` was just written to directly, outside of any lazy
+        // OverrideStates() apply. No-op unless a lazy apply is currently in-flight.
+        markLazyExclusion(entityId) {
+            if (this.lazyOverrideActive) {
+                this.lazyOverrideExclusions.add(entityId);
+            }
+        }
         queueUpdate(update) {
             if (this.Disposed) {
                 return;
@@ -417,7 +467,8 @@ var VisualsRegister;
             }
             this.updateQueueSettings[update.entityId] = settings;
             // Queue ID if it's not already in the queue.
-            if (!this.updateQueue.includes(update.entityId)) {
+            if (!this.updateQueueIds.has(update.entityId)) {
+                this.updateQueueIds.add(update.entityId);
                 this.updateQueue.push(update.entityId);
                 this.pingUpdateQueue();
             }
@@ -438,6 +489,7 @@ var VisualsRegister;
                     const cache = {};
                     for (let i = 0; i < batch.length; i++) {
                         const entityId = batch[i];
+                        this.updateQueueIds.delete(entityId);
                         // Check if still registered.
                         if (entityId && (!this.rego[entityId] || !this.rego[entityId].length)) {
                             continue;
@@ -550,6 +602,8 @@ var VisualsRegister;
         SetStates(states, source) {
             // Array of changed Entity IDs so we know what to refresh/notify at the end.
             const entityIds = [];
+            // Mirrors entityIds for O(1) "already recorded" checks.
+            const entityIdsSeen = new Set();
             // If we need to update all Entities.
             // This is usually for isolation changes.
             let updateAll = false;
@@ -582,8 +636,9 @@ var VisualsRegister;
             };
             const doUpdate = (state) => {
                 const eChanged = this.SetState(state, false, source);
-                if (eChanged && !entityIds.includes(state.entityId)) {
+                if (eChanged && !entityIdsSeen.has(state.entityId)) {
                     updateRefreshMarkers(state);
+                    entityIdsSeen.add(state.entityId);
                     entityIds.push(state.entityId);
                     changed = true;
                 }
@@ -618,7 +673,7 @@ var VisualsRegister;
                     for (let i = 0; i < keys.length; i++) {
                         const key = keys[i];
                         const state = states[key];
-                        if (entityIds.includes(state.entityId)) {
+                        if (entityIdsSeen.has(state.entityId)) {
                             const update = {
                                 type: EVisualUpdateType.Update,
                                 entityId: state.entityId
@@ -648,12 +703,18 @@ var VisualsRegister;
          * Sets the provided settings for a given Entity's state.
          * @param params
          */
-        setStateValues(values) {
+        setStateValues(values, fromLazyApplier = false) {
             const { entityId, menuItemId } = values;
             const keys = Object.keys(values).filter(k => k !== "entityId" && k !== "menuItemId");
             if (!keys.length) {
                 return false;
             }
+            if (!fromLazyApplier) {
+                this.markLazyExclusion(entityId);
+            }
+            if (keys.includes("isolated")) {
+                this.isolatedAnyCache = null;
+            }
             let changed = false;
             const eStates = this.states[entityId] || {};
             this.states[entityId] = eStates;
@@ -824,18 +885,68 @@ var VisualsRegister;
             }
             return false;
         }
+        buildClearDiffItem(state) {
+            const clearState = {
+                entityId: state.entityId,
+                menuItemId: state.menuItemId
+            };
+            const refresh = {};
+            // For each property that exists, set it to null to clear it.
+            // This will cause setStateValues to delete the property.
+            if (state.highlighted != null) {
+                clearState.highlighted = null;
+                refresh.highlighted = true;
+            }
+            if (state.selected != null) {
+                clearState.selected = null;
+                refresh.selected = true;
+            }
+            if (state.opacity != null) {
+                clearState.opacity = null;
+                refresh.opacity = true;
+            }
+            if (state.labelled != null) {
+                clearState.labelled = null;
+            }
+            if (state.hidden != null) {
+                clearState.hidden = null;
+            }
+            if (state.isolated != null) {
+                clearState.isolated = null;
+            }
+            return { clearState, refresh };
+        }
+        /**
+         * Refresh flags needed for an "add"/"update" state - the new value is applied as-is,
+         * this just says which visual properties changed.
+         */
+        buildSetDiffRefresh(state) {
+            const refresh = {};
+            if (state.hasOwnProperty("highlighted")) {
+                refresh.highlighted = true;
+            }
+            if (state.hasOwnProperty("selected")) {
+                refresh.selected = true;
+            }
+            if (state.hasOwnProperty("opacity")) {
+                refresh.opacity = true;
+            }
+            return refresh;
+        }
         /**
          * Applies a set of new states to override the existing ones using differential updates.
-         * This is more efficient than clearing and re-applying all states.
-         * @param states
          */
-        OverrideStates(states) {
-            // Calculate what needs to change.
+        OverrideStates(states, options) {
+            this.cancelLazyOverride();
             const diff = this.calculateStateDifference(states);
             // If nothing changed, exit early.
             if (diff.toAdd.length === 0 && diff.toRemove.length === 0 && diff.toUpdate.length === 0) {
                 return;
             }
+            if (options === null || options === void 0 ? void 0 : options.lazy) {
+                this.startLazyOverride(diff);
+                return;
+            }
             // Track which visual properties need refreshing per entity.
             const refreshMap = new Map();
             const updateRefreshForEntity = (entityId, props) => {
@@ -846,76 +957,16 @@ var VisualsRegister;
                     opacity: existing.opacity || props.opacity || false
                 });
             };
-            // Process removals.
             for (const state of diff.toRemove) {
-                // Create a state with inverted/cleared values.
-                const clearState = {
-                    entityId: state.entityId,
-                    menuItemId: state.menuItemId
-                };
-                // For each property that exists, set it to null to clear it.
-                // This will cause setStateValues to delete the property.
-                if (state.highlighted != null) {
-                    clearState.highlighted = null;
-                    updateRefreshForEntity(state.entityId, {
-                        highlighted: true
-                    });
-                }
-                if (state.selected != null) {
-                    clearState.selected = null;
-                    updateRefreshForEntity(state.entityId, {
-                        selected: true
-                    });
-                }
-                if (state.opacity != null) {
-                    clearState.opacity = null;
-                    updateRefreshForEntity(state.entityId, {
-                        opacity: true
-                    });
-                }
-                if (state.labelled != null) {
-                    clearState.labelled = null;
-                    updateRefreshForEntity(state.entityId, {});
-                }
-                if (state.hidden != null) {
-                    clearState.hidden = null;
-                    updateRefreshForEntity(state.entityId, {});
-                }
-                if (state.isolated != null) {
-                    clearState.isolated = null;
-                    updateRefreshForEntity(state.entityId, {});
-                }
+                const { clearState, refresh } = this.buildClearDiffItem(state);
+                updateRefreshForEntity(state.entityId, refresh);
                 this.setStateValues(clearState);
             }
-            // Process additions and updates.
             const statesToSet = [...diff.toAdd, ...diff.toUpdate];
             for (const state of statesToSet) {
-                // Determine what needs visual refresh based on what's changing.
-                if (state.hasOwnProperty("highlighted")) {
-                    updateRefreshForEntity(state.entityId, {
-                        highlighted: true
-                    });
-                }
-                if (state.hasOwnProperty("selected")) {
-                    updateRefreshForEntity(state.entityId, {
-                        selected: true
-                    });
-                }
-                if (state.hasOwnProperty("opacity")) {
-                    updateRefreshForEntity(state.entityId, {
-                        opacity: true
-                    });
-                }
-                if (state.hasOwnProperty("labelled")) {
-                    updateRefreshForEntity(state.entityId, {});
-                }
-                if (state.hasOwnProperty("hidden") || state.hasOwnProperty("isolated")) {
-                    updateRefreshForEntity(state.entityId, {});
-                }
+                updateRefreshForEntity(state.entityId, this.buildSetDiffRefresh(state));
                 this.setStateValues(state);
             }
-            // Queue updates for all affected entities.
-            // TODO: if a massive list we should async batch this.
             for (const entityId of diff.affectedEntityIds) {
                 const refresh = refreshMap.get(entityId);
                 this.queueUpdate({
@@ -925,6 +976,77 @@ var VisualsRegister;
             }
             this.viewer.scene.requestRender();
         }
+        /**
+         * Cancels any in-flight lazy OverrideStates() apply.
+         */
+        cancelLazyOverride() {
+            if (!this.lazyOverrideActive) {
+                return;
+            }
+            this.lazyOverrideToken++;
+            this.lazyOverrideActive = false;
+            this.lazyOverrideExclusions.clear();
+            if (this.lazyOverrideInterval) {
+                clearInterval(this.lazyOverrideInterval);
+                this.lazyOverrideInterval = null;
+            }
+        }
+        /**
+         * Starts (or restarts) a chunked, cancellable apply of a previously-computed diff.
+         * See OverrideStates() for the cancellation/priority semantics.
+         */
+        startLazyOverride(diff) {
+            const BATCH_SIZE = 2000;
+            const queue = [];
+            for (const state of diff.toRemove) {
+                queue.push({ state, isRemoval: true });
+            }
+            for (const state of diff.toAdd) {
+                queue.push({ state, isRemoval: false });
+            }
+            for (const state of diff.toUpdate) {
+                queue.push({ state, isRemoval: false });
+            }
+            this.lazyOverrideToken++;
+            const token = this.lazyOverrideToken;
+            this.lazyOverrideActive = true;
+            this.lazyOverrideExclusions.clear();
+            let index = 0;
+            this.lazyOverrideInterval = setInterval(() => {
+                // A newer lazy call (or a sync OverrideStates()) superseded this run.
+                if (token !== this.lazyOverrideToken || this.Disposed) {
+                    clearInterval(this.lazyOverrideInterval);
+                    this.lazyOverrideInterval = null;
+                    return;
+                }
+                const end = Math.min(index + BATCH_SIZE, queue.length);
+                for (; index < end; index++) {
+                    const { state, isRemoval } = queue[index];
+                    // A direct write already claimed this entity, the bookmark's still-pending
+                    // value for it is dropped for the rest of this run.
+                    if (this.lazyOverrideExclusions.has(state.entityId)) {
+                        continue;
+                    }
+                    if (isRemoval) {
+                        const { clearState, refresh } = this.buildClearDiffItem(state);
+                        this.setStateValues(clearState, true);
+                        this.queueUpdate({ entityId: state.entityId, refresh });
+                    }
+                    else {
+                        const refresh = this.buildSetDiffRefresh(state);
+                        this.setStateValues(state, true);
+                        this.queueUpdate({ entityId: state.entityId, refresh });
+                    }
+                }
+                this.viewer.scene.requestRender();
+                if (index >= queue.length) {
+                    clearInterval(this.lazyOverrideInterval);
+                    this.lazyOverrideInterval = null;
+                    this.lazyOverrideActive = false;
+                    this.lazyOverrideExclusions.clear();
+                }
+            }, 10);
+        }
         /**
          * Returns all states with the first detected Menu Item ID settings included.
          * This is a utility function for returning settings for apps that don't support the newer state settings.
@@ -940,9 +1062,8 @@ var VisualsRegister;
                 if (!eStates) {
                     continue;
                 }
-                if (!entityIds.includes(entityId)) {
-                    entityIds.push(entityId);
-                }
+                // Keys of this.states are already unique, no dedupe check needed.
+                entityIds.push(entityId);
                 const mKeys = Object.keys(eStates);
                 for (let i = 0; i < mKeys.length; i++) {
                     const menuItemId = mKeys[i];
@@ -1008,6 +1129,9 @@ var VisualsRegister;
             this.cameraCullerDispose = null;
             clearInterval(this.updateQueueInterval);
             this.updateQueueInterval = null;
+            clearInterval(this.lazyOverrideInterval);
+            this.lazyOverrideInterval = null;
+            this.lazyOverrideActive = false;
             this.disposed = true;
         }
         ForceUpdate(params) {
@@ -1079,12 +1203,15 @@ var VisualsRegister;
         ClearLabelled(params) {
             const cache = {};
             const toUpdateIds = [];
+            const toUpdateIdsSeen = new Set();
             this.ForEachState((state) => {
                 if (state.labelled == null || state.labelled === undefined) {
                     return;
                 }
+                this.markLazyExclusion(state.entityId);
                 delete state.labelled;
-                if (!toUpdateIds.includes(state.entityId)) {
+                if (!toUpdateIdsSeen.has(state.entityId)) {
+                    toUpdateIdsSeen.add(state.entityId);
                     toUpdateIds.push(state.entityId);
                 }
             });
@@ -1212,11 +1339,12 @@ var VisualsRegister;
         }
         ClearSelected(params) {
             var _a;
-            const cleared = [];
+            const cleared = new Set();
             this.ForEachState((state) => {
                 if (state.selected == null || state.selected === undefined) {
                     return;
                 }
+                this.markLazyExclusion(state.entityId);
                 delete state.selected;
                 const regos = this.GetRegos({
                     entityId: state.entityId,
@@ -1224,13 +1352,13 @@ var VisualsRegister;
                 });
                 for (let i = 0; i < regos.length; i++) {
                     const rego = regos[i];
-                    if ((rego === null || rego === void 0 ? void 0 : rego.visual) && !cleared.includes(rego)) {
+                    if ((rego === null || rego === void 0 ? void 0 : rego.visual) && !cleared.has(rego)) {
                         cesium_entity_styler_1.CesiumEntityStyler.Deselect({
                             entity: rego.visual,
                             viewer: this.viewer,
                             requestRender: false
                         });
-                        cleared.push(rego);
+                        cleared.add(rego);
                     }
                 }
             });
@@ -1343,10 +1471,13 @@ var VisualsRegister;
             var _a;
             // Null all states.
             let entityIds = [];
+            const entityIdsSeen = new Set();
             this.ForEachState((state) => {
                 if (state.highlighted) {
+                    this.markLazyExclusion(state.entityId);
                     delete state.highlighted;
-                    if (!entityIds.includes(state.entityId)) {
+                    if (!entityIdsSeen.has(state.entityId)) {
+                        entityIdsSeen.add(state.entityId);
                         entityIds.push(state.entityId);
                     }
                 }
@@ -1435,7 +1566,10 @@ var VisualsRegister;
             return state.isolated === true;
         }
         GetIsIsolatedAny() {
-            return Object.values(this.states).some(state => state && Object.values(state).some(item => item.isolated));
+            if (this.isolatedAnyCache == null) {
+                this.isolatedAnyCache = Object.values(this.states).some(state => state && Object.values(state).some(item => item.isolated));
+            }
+            return this.isolatedAnyCache;
         }
         /**
          * @deprecated Use GetStates() or GetState().
@@ -1456,10 +1590,15 @@ var VisualsRegister;
             this.ForEachState((state) => {
                 if (state.isolated) {
                     changed = true;
+                    this.markLazyExclusion(state.entityId);
                 }
                 delete state.isolated;
             });
-            if (changed && params.doUpdate !== false) {
+            if (changed) {
+                // Mutated `isolated` directly rather than through setStateValues().
+                this.isolatedAnyCache = false;
+            }
+            if (changed && (params === null || params === void 0 ? void 0 : params.doUpdate) !== false) {
                 this.updateAllEntities({
                     requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
                     refresh: true
@@ -1510,10 +1649,11 @@ var VisualsRegister;
             this.ForEachState((state) => {
                 if (state.hidden) {
                     changed = true;
+                    this.markLazyExclusion(state.entityId);
                 }
                 delete state.hidden;
             });
-            if (changed && params.doUpdate !== false) {
+            if (changed && (params === null || params === void 0 ? void 0 : params.doUpdate) !== false) {
                 this.updateAllEntities({
                     requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
                     refresh: true
@@ -1549,6 +1689,7 @@ var VisualsRegister;
             const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
             entityRegos.push(rego);
             this.rego[entityId] = entityRegos;
+            this.indexMenuItemEntity(rego.menuItemId, entityId);
             // Mark the visual as part of this register so selection works.
             markEntity(this, rego, rego.visual, false);
             // Run any updates on the visual based on the calculated state.
@@ -1572,6 +1713,74 @@ var VisualsRegister;
                 this.viewer.scene.requestRender();
             }
         }
+        /**
+         * Re-parents every rego registered under one menu item id to a different menu item id.
+         */
+        ReassignMenuItem(params) {
+            var _a, _b;
+            const { fromMenuItemId, toMenuItemId, toMenuItemType, toPriority, requestRender, source } = params;
+            if (!fromMenuItemId || !toMenuItemId || fromMenuItemId === toMenuItemId) {
+                return;
+            }
+            const entityIds = this.entityIdsByMenuItem[fromMenuItemId];
+            if (!entityIds) {
+                return;
+            }
+            // Snapshot: unindexMenuItemEntityIfAbsent() below mutates this same set.
+            for (const entityId of Array.from(entityIds)) {
+                const regos = this.rego[entityId];
+                if (!regos) {
+                    continue;
+                }
+                for (const rego of regos) {
+                    if (rego.menuItemId !== fromMenuItemId) {
+                        continue;
+                    }
+                    if (source !== EUpdateSource.TREE_CASCADE) {
+                        (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger({
+                            type: EVisualUpdateType.Remove,
+                            entityId,
+                            rego: { ...rego, menuItemId: fromMenuItemId },
+                            source
+                        });
+                    }
+                    rego.menuItemId = toMenuItemId;
+                    rego.menuItemType = toMenuItemType;
+                    if (toPriority != null) {
+                        rego.priority = toPriority;
+                    }
+                    if (source !== EUpdateSource.TREE_CASCADE) {
+                        (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({
+                            type: EVisualUpdateType.Add,
+                            entityId,
+                            rego,
+                            source
+                        });
+                    }
+                }
+                const eStates = this.states[entityId];
+                const movingState = eStates === null || eStates === void 0 ? void 0 : eStates[fromMenuItemId];
+                if (movingState) {
+                    delete eStates[fromMenuItemId];
+                    const existingTargetState = eStates[toMenuItemId];
+                    eStates[toMenuItemId] = {
+                        ...existingTargetState,
+                        ...movingState,
+                        entityId,
+                        menuItemId: toMenuItemId
+                    };
+                }
+                this.unindexMenuItemEntityIfAbsent(fromMenuItemId, entityId);
+                this.indexMenuItemEntity(toMenuItemId, entityId);
+                this.queueUpdate({
+                    entityId,
+                    refresh: true
+                });
+            }
+            if (requestRender != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
         /**
          * Locates a visual corresponding to a given entity id.
          * If no menu item id is provided, then it will pick the "best" one.
@@ -1682,7 +1891,10 @@ var VisualsRegister;
             // TODO: refactor.
             // Currently this was made by merging two functions.
             if (menuItemId && !entityId) {
-                for (const entityId in this.rego) {
+                // Entities registered under this menu item, keyed via entityIdsByMenuItem.
+                // Snapshot to an array since removals below mutate the backing set.
+                const entityIds = this.entityIdsByMenuItem[menuItemId] ? Array.from(this.entityIdsByMenuItem[menuItemId]) : [];
+                for (const entityId of entityIds) {
                     const entityRegos = this.rego[entityId];
                     if (entityRegos) {
                         const rego = entityRegos.find(r => r.menuItemId === menuItemId);
@@ -1704,6 +1916,7 @@ var VisualsRegister;
                         const doesInclude = this.rego[entityId].find(r => r.menuItemId === menuItemId);
                         if (doesInclude) {
                             this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                            this.unindexMenuItemEntityIfAbsent(menuItemId, entityId);
                         }
                         const update = {
                             type: EVisualUpdateType.Remove,
@@ -1756,6 +1969,7 @@ var VisualsRegister;
                         (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(update);
                     }
                     this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                    this.unindexMenuItemEntityIfAbsent(menuItemId, entityId);
                     if (doUpdate && menuItemId) {
                         this.queueUpdate({
                             entityId: entityId,
@@ -1778,7 +1992,11 @@ var VisualsRegister;
                         });
                         removeEntity(this.viewer, rego.visual);
                         rego.visual = null;
-                        this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                        this.rego[entityId] = entityRegos.filter(r => r !== rego);
+                        if (!this.rego[entityId].length) {
+                            delete this.rego[entityId];
+                        }
+                        this.unindexMenuItemEntityIfAbsent(rego.menuItemId, entityId);
                         const update = {
                             type: EVisualUpdateType.Remove,
                             entityId: rego.entityId,
@@ -1790,7 +2008,7 @@ var VisualsRegister;
                         if (source !== EUpdateSource.TREE_CASCADE) {
                             (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(update);
                         }
-                        if (doUpdate && menuItemId) {
+                        if (doUpdate) {
                             this.queueUpdate({
                                 entityId: entityId,
                                 refresh: false
@@ -1807,68 +2025,68 @@ var VisualsRegister;
          * @param params
          */
         RemoveRegosByVisuals(params) {
-            var _a, _b, _c;
+            var _a, _b;
             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)) {
-                            entity_label_1.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;
-                        }
+            const removedEntityIds = new Set();
+            for (const visual of params.visuals) {
+                const visExt = visual;
+                const rego = (visExt === null || visExt === void 0 ? void 0 : visExt._register) === this ? visExt._rego : null;
+                if (!rego || !rego.visual) {
+                    continue;
+                }
+                const entityId = rego.entityId;
+                const entityRegos = this.rego[entityId];
+                if (!entityRegos) {
+                    continue;
+                }
+                if (rego.visual === visual) {
+                    // The primary graphic for this rego - remove the rego entirely.
+                    entity_label_1.EntityLabel.Detatch({
+                        rego
+                    });
+                    if (doRemove != false) {
+                        removeEntity(this.viewer, rego.visual);
                     }
+                    rego.visual = null;
+                    this.rego[entityId] = entityRegos.filter(r => r !== rego);
+                    if (!this.rego[entityId].length) {
+                        delete this.rego[entityId];
+                    }
+                    this.unindexMenuItemEntityIfAbsent(rego.menuItemId, entityId);
+                    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
+                        });
+                    }
+                    removedEntityIds.add(entityId);
                 }
-                if (!((_c = this.rego[entityId]) === null || _c === void 0 ? void 0 : _c.length)) {
-                    delete this.rego[entityId];
+                else {
+                    const siblings = (_b = rego.visual) === null || _b === void 0 ? void 0 : _b["_siblingGraphics"];
+                    if (siblings === null || siblings === void 0 ? void 0 : siblings.length) {
+                        if (doRemove != false && siblings.includes(visual)) {
+                            removeEntity(this.viewer, visual);
+                        }
+                        rego.visual["_siblingGraphics"] = siblings.filter(s => s !== visual);
+                    }
                 }
             }
             if (requestRender) {
                 this.viewer.scene.requestRender();
             }
             return {
-                removedEntityIds
+                removedEntityIds: Array.from(removedEntityIds)
             };
         }
         /**
@@ -2024,16 +2242,17 @@ var VisualsRegister;
             return (totalOpacity && totalTicks) ? (totalOpacity / totalTicks) : totalOpacity != null && typeof totalOpacity == "number" ? totalOpacity : 1;
         }
         ClearOpacity(params) {
-            const clearedIds = [];
+            const clearedIds = new Set();
             this.ForEachState((state) => {
-                if (!clearedIds.includes(state.entityId) && state.opacity != null) {
+                if (!clearedIds.has(state.entityId) && state.opacity != null) {
+                    this.markLazyExclusion(state.entityId);
                     this.queueUpdate({
                         entityId: state.entityId,
                         refresh: {
                             opacity: true
                         }
                     });
-                    clearedIds.push(state.entityId);
+                    clearedIds.add(state.entityId);
                 }
                 delete state.opacity;
             });