bruce-cesium 6.2.1 → 6.2.2

package/dist/bruce-cesium.umd.js

@@ -11511,41 +11511,172 @@
                 return newStates;
             }
             /**
-             * Applies a set of new states to override the existing ones.
-             * This can be a costly operation as it will update all visuals.
+             * Calculates the difference between current states and new states.
+             * Returns what needs to be added, removed, and updated.
+             */
+            calculateStateDifference(newStates) {
+                const toAdd = [];
+                const toRemove = [];
+                const toUpdate = [];
+                const affectedEntityIds = new Set();
+                // State map for quick lookups.
+                const newStatesMap = new Map();
+                for (const state of newStates) {
+                    if (!state.entityId || isBlankState(state)) {
+                        continue;
+                    }
+                    const key = `${state.entityId}::${state.menuItemId || NO_MENU_ITEM_KEY}`;
+                    newStatesMap.set(key, state);
+                }
+                // Track existing states.
+                const existingKeys = new Set();
+                // Check existing states to see if they need removal or updating.
+                this.ForEachState((existingState) => {
+                    const key = `${existingState.entityId}::${existingState.menuItemId || NO_MENU_ITEM_KEY}`;
+                    existingKeys.add(key);
+                    const newState = newStatesMap.get(key);
+                    // State exists in current but not in new.
+                    if (!newState) {
+                        toRemove.push({ ...existingState });
+                        affectedEntityIds.add(existingState.entityId);
+                    }
+                    // State exists in both.
+                    // See if changed.
+                    else {
+                        if (this.isStateDifferent(existingState, newState)) {
+                            toUpdate.push({ ...newState });
+                            affectedEntityIds.add(existingState.entityId);
+                        }
+                    }
+                });
+                // Check for new states that don't exist currently.
+                for (const [key, newState] of newStatesMap) {
+                    if (!existingKeys.has(key)) {
+                        toAdd.push({ ...newState });
+                        affectedEntityIds.add(newState.entityId);
+                    }
+                }
+                return { toAdd, toRemove, toUpdate, affectedEntityIds };
+            }
+            /**
+             * Compares two states to determine if they're different.
+             * Only compares meaningful properties (not entityId/menuItemId).
+             */
+            isStateDifferent(state1, state2) {
+                const keys1 = Object.keys(state1).filter(k => k !== "entityId" && k !== "menuItemId");
+                const keys2 = Object.keys(state2).filter(k => k !== "entityId" && k !== "menuItemId");
+                // Different number of properties.
+                if (keys1.length !== keys2.length) {
+                    return true;
+                }
+                // Check if any property values differ.
+                for (const key of keys1) {
+                    if (state1[key] !== state2[key]) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            /**
+             * 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) {
-                // Clear current states.
-                this.ClearOpacity();
-                this.ClearLabelled();
-                this.ClearSelected();
-                this.ClearHighlighted();
-                this.ClearIsolated();
-                this.ClearHidden();
-                this.states = {};
-                let newStates = {};
-                for (let i = 0; i < states.length; i++) {
-                    const state = states[i];
-                    if (!state.menuItemId && state.hasOwnProperty("menuItemId")) {
-                        delete state.menuItemId;
+                // Calculate what needs to change.
+                const diff = this.calculateStateDifference(states);
+                // If nothing changed, exit early.
+                if (diff.toAdd.length === 0 && diff.toRemove.length === 0 && diff.toUpdate.length === 0) {
+                    return;
+                }
+                // Track which visual properties need refreshing per entity.
+                const refreshMap = new Map();
+                const updateRefreshForEntity = (entityId, props) => {
+                    const existing = refreshMap.get(entityId) || {};
+                    refreshMap.set(entityId, {
+                        highlighted: existing.highlighted || props.highlighted || false,
+                        selected: existing.selected || props.selected || false,
+                        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.entityId) {
-                        continue;
+                    if (state.selected != null) {
+                        clearState.selected = null;
+                        updateRefreshForEntity(state.entityId, {
+                            selected: true
+                        });
                     }
-                    if (isBlankState(state)) {
-                        continue;
+                    if (state.opacity != null) {
+                        clearState.opacity = null;
+                        updateRefreshForEntity(state.entityId, {
+                            opacity: true
+                        });
                     }
-                    if (!newStates[state.entityId]) {
-                        newStates[state.entityId] = {};
+                    if (state.labelled != null) {
+                        clearState.labelled = null;
+                        updateRefreshForEntity(state.entityId, {});
                     }
-                    newStates[state.entityId][state.menuItemId ? state.menuItemId : NO_MENU_ITEM_KEY] = {
-                        ...state
-                    };
+                    if (state.hidden != null) {
+                        clearState.hidden = null;
+                        updateRefreshForEntity(state.entityId, {});
+                    }
+                    if (state.isolated != null) {
+                        clearState.isolated = null;
+                        updateRefreshForEntity(state.entityId, {});
+                    }
+                    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, {});
+                    }
+                    this.setStateValues(state);
                 }
-                this.states = newStates;
-                // Reflect the rest of the changes.
-                this.updateAllEntities();
+                // 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({
+                        entityId: entityId,
+                        refresh: refresh || true
+                    });
+                }
+                this.viewer.scene.requestRender();
             }
             /**
              * Returns all states with the first detected Menu Item ID settings included.
@@ -11993,7 +12124,7 @@
             }
             SetIsolated(params) {
                 var _a;
-                const { entityIds, isolated: isolate, requestRender, menuItemId, source } = params;
+                const { entityIds, isolated: isolate, requestRender, menuItemId, source, doUpdate } = params;
                 for (let i = 0; i < entityIds.length; i++) {
                     const entityId = entityIds[i];
                     this.setStateValues({
@@ -12014,12 +12145,14 @@
                         (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
                     }
                 }
-                this.updateAllEntities({
-                    requestRender: false,
-                    refresh: isolate
-                });
-                if (requestRender != false) {
-                    this.viewer.scene.requestRender();
+                if (doUpdate !== false) {
+                    this.updateAllEntities({
+                        requestRender: false,
+                        refresh: isolate
+                    });
+                    if (requestRender != false) {
+                        this.viewer.scene.requestRender();
+                    }
                 }
             }
             GetIsIsolated(params) {
@@ -12055,7 +12188,7 @@
                     }
                     delete state.isolated;
                 });
-                if (changed) {
+                if (changed && params.doUpdate !== false) {
                     this.updateAllEntities({
                         requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
                         refresh: true
@@ -12109,7 +12242,7 @@
                     }
                     delete state.hidden;
                 });
-                if (changed) {
+                if (changed && params.doUpdate !== false) {
                     this.updateAllEntities({
                         requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
                         refresh: true
@@ -12503,16 +12636,27 @@
                     }
                 }
             }
-            updateAllEntities(params) {
-                for (const entityId in this.rego) {
-                    const regos = this.rego[entityId];
-                    if (regos && regos.length) {
-                        this.queueUpdate({
-                            entityId: entityId,
-                            refresh: (params === null || params === void 0 ? void 0 : params.refresh) == null ? true : params.refresh
-                        });
+            async updateAllEntities(params) {
+                const ids = Object.keys(this.rego);
+                const interval = setInterval(() => {
+                    const batch = ids.splice(0, 3000);
+                    if (!batch.length || (params.isCancelled && params.isCancelled())) {
+                        clearInterval(interval);
+                        return;
                     }
-                }
+                    for (const entityId of batch) {
+                        const regos = this.rego[entityId];
+                        if (regos && regos.length) {
+                            this.queueUpdate({
+                                entityId: entityId,
+                                refresh: (params === null || params === void 0 ? void 0 : params.refresh) == null ? true : params.refresh
+                            });
+                        }
+                    }
+                    if ((params === null || params === void 0 ? void 0 : params.requestRender) !== false) {
+                        this.viewer.scene.requestRender();
+                    }
+                }, 10);
             }
             /**
              * Sets opacity for given set of entities.
@@ -34217,7 +34361,7 @@
         }
     }
 
-    const VERSION = "6.2.1";
+    const VERSION = "6.2.2";
 
     exports.VERSION = VERSION;
     exports.isOutlineChanged = isOutlineChanged;