@ifc-lite/viewer 1.10.0 → 1.11.1

package/src/store/basketVisibleSet.ts

@@ -0,0 +1,487 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { IfcTypeEnum, type SpatialNode } from '@ifc-lite/data';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { EntityRef } from './types.js';
+import { entityRefToString, stringToEntityRef } from './types.js';
+import { useViewerStore } from './index.js';
+
+type ViewerStateSnapshot = ReturnType<typeof useViewerStore.getState>;
+
+type VisibleCandidate = {
+  globalId: number;
+  modelId: string;
+  expressId: number;
+  ifcType?: string;
+};
+
+type BasketVisibleStats = {
+  visibleCount: number;
+  addCount: number;
+  removeCount: number;
+  basketCount: number;
+};
+
+export type BasketInputSource = 'selection' | 'hierarchy' | 'visible' | 'empty';
+
+type CacheEntry = { key: string; refs: EntityRef[] };
+let _visibleCache: CacheEntry | null = null;
+
+function digestNumberSet(values: Iterable<number>): string {
+  let count = 0;
+  let xor = 0;
+  let sum = 0;
+  for (const v of values) {
+    const n = Number.isFinite(v) ? (v | 0) : 0;
+    count++;
+    xor ^= n;
+    sum = (sum + (n >>> 0)) >>> 0;
+  }
+  return `${count}:${xor >>> 0}:${sum >>> 0}`;
+}
+
+function digestModelEntityMap(map: Map<string, Set<number>>): string {
+  if (map.size === 0) return '0';
+  const parts: string[] = [];
+  for (const [modelId, ids] of map) {
+    parts.push(`${modelId}:${digestNumberSet(ids)}`);
+  }
+  parts.sort();
+  return parts.join('|');
+}
+
+function visibilityFingerprint(state: ViewerStateSnapshot): string {
+  const tv = state.typeVisibility;
+  return [
+    digestNumberSet(state.hiddenEntities),
+    state.isolatedEntities ? digestNumberSet(state.isolatedEntities) : 'none',
+    digestNumberSet(state.lensHiddenIds),
+    digestModelEntityMap(state.hiddenEntitiesByModel),
+    digestModelEntityMap(state.isolatedEntitiesByModel),
+    tv.spaces ? 1 : 0,
+    tv.openings ? 1 : 0,
+    tv.site ? 1 : 0,
+    state.models.size,
+    state.activeBasketViewId ?? 'none',
+  ].join(':');
+}
+
+export function invalidateVisibleBasketCache(): void {
+  _visibleCache = null;
+}
+
+const STOREY_TYPE = 'IfcBuildingStorey';
+const SPATIAL_CONTAINER_TYPES = new Set(['IfcProject', 'IfcSite', 'IfcBuilding']);
+
+function dedupeRefs(refs: EntityRef[]): EntityRef[] {
+  const out: EntityRef[] = [];
+  const seen = new Set<string>();
+  for (const ref of refs) {
+    const key = entityRefToString(ref);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(ref);
+  }
+  return out;
+}
+
+function matchesTypeVisibility(ifcType: string | undefined, typeVisibility: ViewerStateSnapshot['typeVisibility']): boolean {
+  if (ifcType === 'IfcSpace' && !typeVisibility.spaces) return false;
+  if (ifcType === 'IfcOpeningElement' && !typeVisibility.openings) return false;
+  if (ifcType === 'IfcSite' && !typeVisibility.site) return false;
+  return true;
+}
+
+function getDataStoreForModel(state: ViewerStateSnapshot, modelId: string): IfcDataStore | null {
+  if (modelId === 'legacy') {
+    return state.ifcDataStore;
+  }
+  return state.models.get(modelId)?.ifcDataStore ?? null;
+}
+
+function getEntityTypeName(state: ViewerStateSnapshot, ref: EntityRef): string {
+  const dataStore = getDataStoreForModel(state, ref.modelId);
+  if (!dataStore) return '';
+  return dataStore.entities.getTypeName(ref.expressId) || '';
+}
+
+function findSpatialNode(root: SpatialNode, expressId: number): SpatialNode | null {
+  const stack: SpatialNode[] = [root];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current.expressId === expressId) {
+      return current;
+    }
+    for (const child of current.children || []) {
+      stack.push(child);
+    }
+  }
+  return null;
+}
+
+function getContainerElementIds(dataStore: IfcDataStore, containerExpressId: number): number[] {
+  const hierarchy = dataStore.spatialHierarchy;
+  if (!hierarchy?.project) return [];
+
+  const startNode = findSpatialNode(hierarchy.project, containerExpressId);
+  if (!startNode) return [];
+
+  const elementIds: number[] = [];
+  const seen = new Set<number>();
+  const stack: SpatialNode[] = [startNode];
+
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current.type === IfcTypeEnum.IfcBuildingStorey) {
+      const storeyElements = hierarchy.byStorey.get(current.expressId) as number[] | undefined;
+      if (storeyElements) {
+        for (const id of storeyElements) {
+          if (seen.has(id)) continue;
+          seen.add(id);
+          elementIds.push(id);
+        }
+      }
+    }
+    for (const child of current.children || []) {
+      stack.push(child);
+    }
+  }
+
+  return elementIds;
+}
+
+function expandRefToElements(state: ViewerStateSnapshot, ref: EntityRef): EntityRef[] {
+  const dataStore = getDataStoreForModel(state, ref.modelId);
+  if (!dataStore) return [ref];
+
+  const entityType = dataStore.entities.getTypeName(ref.expressId) || '';
+  if (entityType === STOREY_TYPE) {
+    const localIds = dataStore.spatialHierarchy?.byStorey.get(ref.expressId) as number[] | undefined;
+    if (!localIds || localIds.length === 0) return [];
+    return localIds.map((expressId) => ({ modelId: ref.modelId, expressId }));
+  }
+
+  if (SPATIAL_CONTAINER_TYPES.has(entityType)) {
+    const localIds = getContainerElementIds(dataStore, ref.expressId);
+    if (localIds.length === 0) return [];
+    return localIds.map((expressId) => ({ modelId: ref.modelId, expressId }));
+  }
+
+  return [ref];
+}
+
+function toGlobalId(modelId: string, expressId: number, state: ViewerStateSnapshot): number {
+  if (modelId === 'legacy') return expressId;
+  const model = state.models.get(modelId);
+  return expressId + (model?.idOffset ?? 0);
+}
+
+function globalIdToRef(state: ViewerStateSnapshot, globalId: number): EntityRef | null {
+  const resolved = state.resolveGlobalIdFromModels(globalId);
+  if (resolved) {
+    return { modelId: resolved.modelId, expressId: resolved.expressId };
+  }
+
+  if (state.models.size > 0) return null;
+
+  if (state.ifcDataStore) {
+    return { modelId: 'legacy', expressId: globalId };
+  }
+
+  return null;
+}
+
+function basketToGlobalIds(state: ViewerStateSnapshot): Set<number> {
+  const ids = new Set<number>();
+  for (const str of state.pinboardEntities) {
+    const ref = stringToEntityRef(str);
+    ids.add(toGlobalId(ref.modelId, ref.expressId, state));
+  }
+  return ids;
+}
+
+function getSelectedStoreyElementRefs(state: ViewerStateSnapshot): EntityRef[] {
+  if (state.selectedStoreys.size === 0) return [];
+
+  const refs: EntityRef[] = [];
+
+  if (state.models.size > 0) {
+    for (const [modelId, model] of state.models) {
+      const hierarchy = model.ifcDataStore?.spatialHierarchy;
+      if (!hierarchy) continue;
+      const offset = model.idOffset ?? 0;
+      for (const storeyId of state.selectedStoreys) {
+        const storeyElementIds = hierarchy.byStorey.get(storeyId) || hierarchy.byStorey.get(storeyId - offset);
+        if (!storeyElementIds) continue;
+        for (const localId of storeyElementIds) {
+          refs.push({ modelId, expressId: localId });
+        }
+      }
+    }
+  } else if (state.ifcDataStore?.spatialHierarchy) {
+    for (const storeyId of state.selectedStoreys) {
+      const storeyElementIds = state.ifcDataStore.spatialHierarchy.byStorey.get(storeyId);
+      if (!storeyElementIds) continue;
+      for (const id of storeyElementIds) {
+        refs.push({ modelId: 'legacy', expressId: id });
+      }
+    }
+  }
+
+  return dedupeRefs(refs);
+}
+
+function getSelectionBaseRefs(state: ViewerStateSnapshot): EntityRef[] {
+  const refs: EntityRef[] = [];
+
+  if (state.selectedEntitiesSet.size > 0) {
+    for (const str of state.selectedEntitiesSet) {
+      refs.push(stringToEntityRef(str));
+    }
+    return refs;
+  }
+
+  if (state.selectedEntityIds.size > 0) {
+    for (const globalId of state.selectedEntityIds) {
+      const resolved = globalIdToRef(state, globalId);
+      if (resolved) refs.push(resolved);
+    }
+    return refs;
+  }
+
+  if (state.selectedEntities.length > 0) {
+    return [...state.selectedEntities];
+  }
+
+  if (state.selectedEntity) {
+    return [state.selectedEntity];
+  }
+
+  if (state.selectedEntityId !== null) {
+    const resolved = globalIdToRef(state, state.selectedEntityId);
+    if (resolved) refs.push(resolved);
+  }
+
+  return refs;
+}
+
+function getExpandedSelectionRefs(state: ViewerStateSnapshot): EntityRef[] {
+  const baseRefs = getSelectionBaseRefs(state);
+  if (baseRefs.length === 0) return [];
+  return dedupeRefs(baseRefs.flatMap((ref) => expandRefToElements(state, ref)));
+}
+
+function computeStoreyIsolation(state: ViewerStateSnapshot): Set<number> | null {
+  if (state.selectedStoreys.size === 0) return null;
+
+  const ids = new Set<number>();
+
+  if (state.models.size > 0) {
+    for (const [, model] of state.models) {
+      const hierarchy = model.ifcDataStore?.spatialHierarchy;
+      if (!hierarchy) continue;
+      const offset = model.idOffset ?? 0;
+      for (const storeyId of state.selectedStoreys) {
+        const storeyElementIds = hierarchy.byStorey.get(storeyId) || hierarchy.byStorey.get(storeyId - offset);
+        if (!storeyElementIds) continue;
+        for (const localId of storeyElementIds) {
+          ids.add(localId + offset);
+        }
+      }
+    }
+  } else if (state.ifcDataStore?.spatialHierarchy) {
+    for (const storeyId of state.selectedStoreys) {
+      const storeyElementIds = state.ifcDataStore.spatialHierarchy.byStorey.get(storeyId);
+      if (!storeyElementIds) continue;
+      for (const id of storeyElementIds) {
+        ids.add(id);
+      }
+    }
+  }
+
+  return ids.size > 0 ? ids : null;
+}
+
+function collectVisibleCandidates(state: ViewerStateSnapshot): VisibleCandidate[] {
+  const candidates: VisibleCandidate[] = [];
+
+  if (state.models.size > 0) {
+    for (const [modelId, model] of state.models) {
+      if (!model.visible) continue;
+      const offset = model.idOffset ?? 0;
+      for (const mesh of model.geometryResult.meshes) {
+        if (!matchesTypeVisibility(mesh.ifcType, state.typeVisibility)) continue;
+        const globalId = mesh.expressId;
+        candidates.push({
+          globalId,
+          modelId,
+          expressId: globalId - offset,
+          ifcType: mesh.ifcType,
+        });
+      }
+    }
+  } else if (state.geometryResult) {
+    for (const mesh of state.geometryResult.meshes) {
+      if (!matchesTypeVisibility(mesh.ifcType, state.typeVisibility)) continue;
+      candidates.push({
+        globalId: mesh.expressId,
+        modelId: 'legacy',
+        expressId: mesh.expressId,
+        ifcType: mesh.ifcType,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function getVisibleGlobalIds(state: ViewerStateSnapshot): Set<number> {
+  const candidates = collectVisibleCandidates(state);
+
+  const globalHidden = new Set<number>(state.hiddenEntities);
+  for (const id of state.lensHiddenIds) {
+    globalHidden.add(id);
+  }
+
+  const globalIsolation = state.isolatedEntities ?? computeStoreyIsolation(state);
+
+  const visible = new Set<number>();
+  for (const candidate of candidates) {
+    if (globalIsolation !== null && !globalIsolation.has(candidate.globalId)) continue;
+    if (globalHidden.has(candidate.globalId)) continue;
+
+    const modelHidden = state.hiddenEntitiesByModel.get(candidate.modelId);
+    if (modelHidden?.has(candidate.expressId)) continue;
+
+    const modelIsolated = state.isolatedEntitiesByModel.get(candidate.modelId);
+    if (modelIsolated && !modelIsolated.has(candidate.expressId)) continue;
+
+    visible.add(candidate.globalId);
+  }
+
+  return visible;
+}
+
+export function getVisibleBasketEntityRefsFromStore(): EntityRef[] {
+  const state = useViewerStore.getState();
+  const key = visibilityFingerprint(state);
+  if (_visibleCache?.key === key) return _visibleCache.refs;
+
+  const visibleIds = getVisibleGlobalIds(state);
+  if (visibleIds.size === 0) {
+    _visibleCache = { key, refs: [] };
+    return [];
+  }
+
+  const refs: EntityRef[] = [];
+  for (const globalId of visibleIds) {
+    const resolved = state.resolveGlobalIdFromModels(globalId);
+    if (resolved) {
+      refs.push({ modelId: resolved.modelId, expressId: resolved.expressId });
+    } else {
+      refs.push({ modelId: 'legacy', expressId: globalId });
+    }
+  }
+  const result = dedupeRefs(refs);
+  _visibleCache = { key, refs: result };
+  return result;
+}
+
+/**
+ * Resolve active entity selection into basket refs.
+ * Explicit selected entities are preferred; if empty, selected storeys are expanded.
+ */
+export function getBasketSelectionRefsFromStore(): EntityRef[] {
+  const state = useViewerStore.getState();
+
+  const expandedSelection = getExpandedSelectionRefs(state);
+  if (expandedSelection.length > 0) {
+    return expandedSelection;
+  }
+
+  return getSelectedStoreyElementRefs(state);
+}
+
+/**
+ * Resolve hierarchy-derived basket source.
+ * Priority: explicit hierarchy source snapshot -> selected storeys -> selected hierarchy container/entity.
+ */
+export function getHierarchyBasketEntityRefsFromStore(): EntityRef[] {
+  const state = useViewerStore.getState();
+
+  if (state.hierarchyBasketSelection.size > 0) {
+    const hierarchyRefs = Array.from(state.hierarchyBasketSelection).map((key) => stringToEntityRef(key));
+    const expandedHierarchy = dedupeRefs(hierarchyRefs.flatMap((ref) => expandRefToElements(state, ref)));
+    if (expandedHierarchy.length > 0) {
+      return expandedHierarchy;
+    }
+  }
+
+  const storeyRefs = getSelectedStoreyElementRefs(state);
+  if (storeyRefs.length > 0) {
+    return storeyRefs;
+  }
+
+  const selectionRefs = getExpandedSelectionRefs(state);
+  if (selectionRefs.length > 0) {
+    const hasContainer = selectionRefs.some((ref) => {
+      const typeName = getEntityTypeName(state, ref);
+      return typeName === STOREY_TYPE || SPATIAL_CONTAINER_TYPES.has(typeName);
+    });
+    if (hasContainer || getSelectionBaseRefs(state).length > 0) {
+      return selectionRefs;
+    }
+  }
+
+  return [];
+}
+
+export function getSmartBasketInputFromStore(): { refs: EntityRef[]; source: BasketInputSource } {
+  const selectionRefs = getBasketSelectionRefsFromStore();
+  if (selectionRefs.length > 0) {
+    return { refs: selectionRefs, source: 'selection' };
+  }
+
+  const hierarchyRefs = getHierarchyBasketEntityRefsFromStore();
+  if (hierarchyRefs.length > 0) {
+    return { refs: hierarchyRefs, source: 'hierarchy' };
+  }
+
+  const visibleRefs = getVisibleBasketEntityRefsFromStore();
+  if (visibleRefs.length > 0) {
+    return { refs: visibleRefs, source: 'visible' };
+  }
+
+  return { refs: [], source: 'empty' };
+}
+
+export function isBasketIsolationActiveFromStore(): boolean {
+  const state = useViewerStore.getState();
+  if (state.pinboardEntities.size === 0 || state.isolatedEntities === null) return false;
+
+  const basketIds = basketToGlobalIds(state);
+  if (basketIds.size !== state.isolatedEntities.size) return false;
+  for (const id of basketIds) {
+    if (!state.isolatedEntities.has(id)) return false;
+  }
+  return true;
+}
+
+export function getVisibleBasketStatsFromStore(): BasketVisibleStats {
+  const state = useViewerStore.getState();
+  const visibleRefs = getVisibleBasketEntityRefsFromStore();
+  const visibleKeys = new Set<string>(visibleRefs.map(entityRefToString));
+  let removeCount = 0;
+  for (const key of state.pinboardEntities) {
+    if (visibleKeys.has(key)) removeCount++;
+  }
+
+  return {
+    visibleCount: visibleKeys.size,
+    addCount: Math.max(0, visibleKeys.size - removeCount),
+    removeCount,
+    basketCount: state.pinboardEntities.size,
+  };
+}

package/src/store/homeView.ts

@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { useViewerStore } from './index.js';
+
+export function resetVisibilityForHomeFromStore(): void {
+  const state = useViewerStore.getState();
+  state.showAllInAllModels();
+  state.clearStoreySelection();
+  state.clearHierarchyBasketSelection();
+  state.clearEntitySelection();
+  state.clearBasket();
+  useViewerStore.setState({ activeBasketViewId: null });
+}
+
+export function goHomeFromStore(): void {
+  resetVisibilityForHomeFromStore();
+  const state = useViewerStore.getState();
+  state.cameraCallbacks.home?.();
+}

package/src/store/index.ts

@@ -31,6 +31,7 @@ import { createListSlice, type ListSlice } from './slices/listSlice.js';
 import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.js';
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
 import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
+import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
 import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_DEFAULTS } from './constants.js';
@@ -122,6 +123,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
   resetViewerState: () => {
+    invalidateVisibleBasketCache();
     const [set] = args;
     set({
       // Selection (legacy)
@@ -148,6 +150,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
 
       // Data
       pendingColorUpdates: null,
+      pendingMeshColorUpdates: null,
 
       // Hover/Context
       hoverState: { entityId: null, screenX: 0, screenY: 0 },
@@ -202,6 +205,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       drawing2DPhase: '',
       drawing2DError: null,
       drawing2DPanelVisible: false,
+      suppressNextSection2DPanelAutoOpen: false,
       drawing2DSvgContent: null,
       drawing2DDisplayOptions: {
         showHiddenLines: true,
@@ -266,6 +270,10 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
 
       // Pinboard - clear pinned entities on new file
       pinboardEntities: new Set<string>(),
+      basketViews: [],
+      activeBasketViewId: null,
+      basketPresentationVisible: false,
+      hierarchyBasketSelection: new Set<string>(),
 
       // Script - reset execution state but keep saved scripts and editor content
       scriptPanelVisible: false,

package/src/store/slices/dataSlice.test.ts

@@ -46,6 +46,10 @@ describe('DataSlice', () => {
     it('should have null pendingColorUpdates', () => {
       assert.strictEqual(state.pendingColorUpdates, null);
     });
+
+    it('should have null pendingMeshColorUpdates', () => {
+      assert.strictEqual(state.pendingMeshColorUpdates, null);
+    });
   });
 
   describe('setIfcDataStore', () => {
@@ -136,9 +140,11 @@ describe('DataSlice', () => {
       state.updateMeshColors(updates);
 
       assert.deepStrictEqual(state.geometryResult?.meshes[0].color, [0, 1, 0, 1]);
+      assert.strictEqual(state.pendingColorUpdates, null);
+      assert.deepStrictEqual(state.pendingMeshColorUpdates?.get(1), [0, 1, 0, 1]);
     });
 
-    it('should clone the updates Map to prevent external mutation', () => {
+    it('should clone updates and avoid mutating state from external map writes', () => {
       const mesh = createMockMesh(1);
       state.appendGeometryBatch([mesh] as any);
 
@@ -151,16 +157,20 @@ describe('DataSlice', () => {
       updates.set(1, [1, 1, 1, 1]);
 
       // State should not be affected
-      assert.notStrictEqual(state.pendingColorUpdates, updates);
+      assert.deepStrictEqual(state.geometryResult?.meshes[0].color, [0, 1, 0, 1]);
+      assert.strictEqual(state.pendingColorUpdates, null);
+      assert.deepStrictEqual(state.pendingMeshColorUpdates?.get(1), [0, 1, 0, 1]);
     });
 
-    it('should not update when no geometry result', () => {
+    it('should skip mesh mutation but still set pendingMeshColorUpdates when no geometry result', () => {
       const updates = new Map<number, [number, number, number, number]>();
       updates.set(1, [0, 1, 0, 1]);
 
       state.updateMeshColors(updates);
 
       assert.strictEqual(state.geometryResult, null);
+      assert.strictEqual(state.pendingColorUpdates, null);
+      assert.deepStrictEqual(state.pendingMeshColorUpdates?.get(1), [0, 1, 0, 1]);
     });
 
     it('should preserve unaffected meshes', () => {
@@ -185,7 +195,7 @@ describe('DataSlice', () => {
 
       const updates = new Map<number, [number, number, number, number]>();
       updates.set(1, [0, 1, 0, 1]);
-      state.updateMeshColors(updates);
+      state.setPendingColorUpdates(updates);
 
       state.clearPendingColorUpdates();
 
@@ -193,6 +203,45 @@ describe('DataSlice', () => {
     });
   });
 
+  describe('clearPendingMeshColorUpdates', () => {
+    it('should clear pending mesh color updates', () => {
+      const mesh = createMockMesh(1);
+      state.appendGeometryBatch([mesh] as any);
+
+      const updates = new Map<number, [number, number, number, number]>();
+      updates.set(1, [0, 1, 0, 1]);
+      state.updateMeshColors(updates);
+
+      state.clearPendingMeshColorUpdates();
+
+      assert.strictEqual(state.pendingMeshColorUpdates, null);
+    });
+  });
+
+  describe('setPendingColorUpdates', () => {
+    it('should clone pending color updates map', () => {
+      const updates = new Map<number, [number, number, number, number]>();
+      updates.set(1, [0, 1, 0, 1]);
+      state.setPendingColorUpdates(updates);
+
+      updates.set(1, [1, 1, 1, 1]);
+      assert.notStrictEqual(state.pendingColorUpdates, updates);
+      assert.deepStrictEqual(state.pendingColorUpdates?.get(1), [0, 1, 0, 1]);
+    });
+
+    it('should not mutate persisted geometry colors', () => {
+      const mesh = createMockMesh(1, [0.2, 0.2, 0.2, 1]);
+      state.appendGeometryBatch([mesh] as any);
+      const updates = new Map<number, [number, number, number, number]>();
+      updates.set(1, [1, 0, 1, 0.5]);
+
+      state.setPendingColorUpdates(updates);
+
+      assert.deepStrictEqual(state.geometryResult?.meshes[0].color, [0.2, 0.2, 0.2, 1]);
+      assert.deepStrictEqual(state.pendingColorUpdates?.get(1), [1, 0, 1, 0.5]);
+    });
+  });
+
   describe('updateCoordinateInfo', () => {
     it('should update coordinate info', () => {
       const mesh = createMockMesh(1);