@ifc-lite/viewer 1.17.6 → 1.19.0

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

@@ -4,9 +4,11 @@
 
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert';
-import { createDataSlice, type DataSlice } from './dataSlice.js';
+import { createDataSlice, type DataSlice, type DataCrossSliceState } from './dataSlice.js';
 import { DATA_DEFAULTS } from '../constants.js';
 
+type DataTestState = DataSlice & DataCrossSliceState;
+
 // Mock mesh data for testing
 const createMockMesh = (expressId: number, color: [number, number, number, number] = [1, 0, 0, 1]) => ({
   expressId,
@@ -17,9 +19,16 @@ const createMockMesh = (expressId: number, color: [number, number, number, numbe
   ifcType: 'IfcWall',
 });
 
+type TestSetState = (
+  partial:
+    | Partial<DataTestState>
+    | ((state: DataTestState) => Partial<DataTestState>),
+) => void;
+type TestGetState = () => DataTestState;
+
 describe('DataSlice', () => {
-  let state: DataSlice;
-  let setState: (partial: Partial<DataSlice> | ((state: DataSlice) => Partial<DataSlice>)) => void;
+  let state: DataTestState;
+  let setState: TestSetState;
 
   beforeEach(() => {
     setState = (partial) => {
@@ -31,7 +40,17 @@ describe('DataSlice', () => {
       }
     };
 
-    state = createDataSlice(setState, () => state, {} as any);
+    const getState: TestGetState = () => state;
+
+    // Seed the cross-slice fields owned by ModelSlice. dataSlice's
+    // updaters look up the active model in this map, so the test mock
+    // has to provide it for the typed StateCreator to be satisfiable.
+    const slice = createDataSlice(
+      setState as Parameters<typeof createDataSlice>[0],
+      getState as Parameters<typeof createDataSlice>[1],
+      undefined as unknown as Parameters<typeof createDataSlice>[2],
+    );
+    state = { ...slice, activeModelId: null, models: new Map() };
   });
 
   describe('initial state', () => {

package/src/store/slices/dataSlice.ts

@@ -20,7 +20,7 @@ import { DATA_DEFAULTS } from '../constants.js';
  * consistent.  The types below describe the minimal ModelSlice surface
  * that dataSlice accesses through the merged Zustand state.
  */
-interface DataCrossSliceState {
+export interface DataCrossSliceState {
   activeModelId: string | null;
   models: Map<string, FederatedModel>;
 }

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

@@ -4,16 +4,34 @@
 
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert';
-import { createModelSlice, type ModelSlice } from './modelSlice.js';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { GeometryResult } from '@ifc-lite/geometry';
+import { createModelSlice, type ModelSlice, type ModelCrossSliceState } from './modelSlice.js';
 import type { FederatedModel } from '../types.js';
 
-// Helper to create a mock model
+type ModelTestState = ModelSlice & ModelCrossSliceState;
+
+// Typed setter / getter shim that mirrors zustand's StateCreator
+// signature without the broader middleware machinery the test doesn't
+// need. Using StateCreator's exact types here would pull in the whole
+// store; the local aliases below are tight enough for this test.
+type TestSetState = (
+  partial:
+    | Partial<ModelTestState>
+    | ((state: ModelTestState) => Partial<ModelTestState>),
+) => void;
+type TestGetState = () => ModelTestState;
+
+// Helper to create a mock model. `IfcDataStore` and `GeometryResult` are
+// large interfaces that the slice never inspects on these paths — the
+// double-cast through `unknown` is the minimum that satisfies the
+// compiler without an `any`.
 function createMockModel(id: string, name: string): FederatedModel {
   return {
     id,
     name,
-    ifcDataStore: {} as any,
-    geometryResult: {} as any,
+    ifcDataStore: {} as unknown as IfcDataStore,
+    geometryResult: {} as unknown as GeometryResult,
     visible: true,
     collapsed: false,
     schemaVersion: 'IFC4',
@@ -25,11 +43,10 @@ function createMockModel(id: string, name: string): FederatedModel {
 }
 
 describe('ModelSlice', () => {
-  let state: ModelSlice;
-  let setState: (partial: Partial<ModelSlice> | ((state: ModelSlice) => Partial<ModelSlice>)) => void;
+  let state: ModelTestState;
+  let setState: TestSetState;
 
   beforeEach(() => {
-    // Create a mock set function that updates state
     setState = (partial) => {
       if (typeof partial === 'function') {
         const updates = partial(state);
@@ -39,8 +56,17 @@ describe('ModelSlice', () => {
       }
     };
 
-    // Create slice with mock set function
-    state = createModelSlice(setState, () => state, {} as any);
+    const getState: TestGetState = () => state;
+
+    // The slice's StateCreator signature includes a third middleware
+    // argument (store API) that the slice's body never reads. We pass
+    // `undefined` cast to the empty middleware shape rather than `any`.
+    const slice = createModelSlice(
+      setState as Parameters<typeof createModelSlice>[0],
+      getState as Parameters<typeof createModelSlice>[1],
+      undefined as unknown as Parameters<typeof createModelSlice>[2],
+    );
+    state = { ...slice, ifcDataStore: null, geometryResult: null };
   });
 
   describe('initial state', () => {
@@ -270,4 +296,36 @@ describe('ModelSlice', () => {
       assert.strictEqual(visible.length, 0);
     });
   });
+
+  describe('resolveGlobalIdFromModels — overlay-allocated ids', () => {
+    it('falls through to mutation views when the id is past maxExpressId', () => {
+      const model = createMockModel('model-1', 'First');
+      model.idOffset = 0;
+      model.maxExpressId = 10_000;
+      state.addModel(model);
+
+      // Seed a fake mutation view with a fresh overlay entity. The
+      // resolver only reads `getNewEntity` from each view, so we type
+      // the map narrowly and let it satisfy the slice's wider type via
+      // a single-property cast on the wrapping state object.
+      type StubView = { getNewEntity: (id: number) => { expressId: number } | null };
+      const stubViews: Map<string, StubView> = new Map([
+        ['model-1', { getNewEntity: (id: number) => (id === 11_001 ? { expressId: id } : null) }],
+      ]);
+      state = { ...state, mutationViews: stubViews } as typeof state & { mutationViews: Map<string, StubView> };
+
+      // Inside the parsed range — first pass resolves it.
+      const within = state.resolveGlobalIdFromModels(42);
+      assert.deepStrictEqual(within, { modelId: 'model-1', expressId: 42 });
+
+      // Above the parsed range but in the overlay — second pass resolves it.
+      const overlay = state.resolveGlobalIdFromModels(11_001);
+      assert.deepStrictEqual(overlay, { modelId: 'model-1', expressId: 11_001 });
+
+      // Above the parsed range and NOT in the overlay — returns null
+      // so callers can fall back to the legacy single-model path.
+      const phantom = state.resolveGlobalIdFromModels(99_999);
+      assert.strictEqual(phantom, null);
+    });
+  });
 });

package/src/store/slices/modelSlice.ts

@@ -13,8 +13,20 @@
 
 import type { StateCreator } from 'zustand';
 import type { FederatedModel } from '../types.js';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { GeometryResult } from '@ifc-lite/geometry';
 import { federationRegistry, type GlobalIdLookup } from '@ifc-lite/renderer';
 
+/**
+ * Cross-slice fields the model actions write to. `ifcDataStore` and
+ * `geometryResult` are owned by `dataSlice` but `modelSlice`'s set()
+ * calls need to keep them in sync with the active model.
+ */
+export interface ModelCrossSliceState {
+  ifcDataStore: IfcDataStore | null;
+  geometryResult: GeometryResult | null;
+}
+
 export interface ModelSlice {
   // State
   /** Map of all loaded models by ID */
@@ -72,7 +84,7 @@ export interface ModelSlice {
   resolveGlobalIdFromModels: (globalId: number) => GlobalIdLookup | null;
 }
 
-export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (set, get) => ({
+export const createModelSlice: StateCreator<ModelSlice & ModelCrossSliceState, [], [], ModelSlice> = (set, get) => ({
   // Initial state
   models: new Map(),
   activeModelId: null,
@@ -245,19 +257,39 @@ export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (s
    */
   resolveGlobalIdFromModels: (globalId: number) => {
     const models = get().models;
+    const mutationViews = (get() as unknown as { mutationViews?: Map<string, { getNewEntity: (id: number) => unknown }> }).mutationViews;
 
     // Sort models by offset for correct range checking
     const sortedModels = Array.from(models.values()).sort((a, b) => a.idOffset - b.idOffset);
 
-    // Find the model that contains this globalId
-    // A model contains a globalId if: offset <= globalId <= offset + maxExpressId
+    // Find the model that contains this globalId.
+    //
+    // First pass — parse-time range. A model owns ids in
+    // `[offset, offset + maxExpressId]` from the original parse. This
+    // is the fast path covering 99% of selections.
+    //
+    // Second pass — overlay-allocated ids. Duplicates / scripted adds
+    // through StoreEditor land ABOVE the model's parse-time
+    // maxExpressId, so they fall outside the first-pass range. The
+    // federation resolver knows nothing about overlay state, so we
+    // consult each model's mutation view for the freshly-added
+    // entity. Falls back gracefully when no view is registered.
     for (const model of sortedModels) {
       const localId = globalId - model.idOffset;
       if (localId >= 0 && localId <= model.maxExpressId) {
-        return {
-          modelId: model.id,
-          expressId: localId,
-        };
+        return { modelId: model.id, expressId: localId };
+      }
+    }
+
+    if (mutationViews) {
+      for (const model of sortedModels) {
+        const localId = globalId - model.idOffset;
+        if (localId <= model.maxExpressId) continue; // already covered above
+        const view = mutationViews.get(model.id);
+        if (!view) continue;
+        if (view.getNewEntity(localId) !== null) {
+          return { modelId: model.id, expressId: localId };
+        }
       }
     }