@ifc-lite/viewer 1.1.6 → 1.5.0

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

@@ -0,0 +1,125 @@
+/* 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 { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { createSectionSlice, type SectionSlice } from './sectionSlice.js';
+import { SECTION_PLANE_DEFAULTS } from '../constants.js';
+
+describe('SectionSlice', () => {
+  let state: SectionSlice;
+  let setState: (partial: Partial<SectionSlice> | ((state: SectionSlice) => Partial<SectionSlice>)) => void;
+
+  beforeEach(() => {
+    // Create a mock set function that updates state
+    setState = (partial) => {
+      if (typeof partial === 'function') {
+        const updates = partial(state);
+        state = { ...state, ...updates };
+      } else {
+        state = { ...state, ...partial };
+      }
+    };
+
+    // Create slice with mock set function
+    state = createSectionSlice(setState, () => state, {} as any);
+  });
+
+  describe('initial state', () => {
+    it('should have default section plane values', () => {
+      assert.strictEqual(state.sectionPlane.axis, SECTION_PLANE_DEFAULTS.AXIS);
+      assert.strictEqual(state.sectionPlane.position, SECTION_PLANE_DEFAULTS.POSITION);
+      assert.strictEqual(state.sectionPlane.enabled, SECTION_PLANE_DEFAULTS.ENABLED);
+      assert.strictEqual(state.sectionPlane.flipped, SECTION_PLANE_DEFAULTS.FLIPPED);
+    });
+  });
+
+  describe('setSectionPlaneAxis', () => {
+    it('should update the axis', () => {
+      state.setSectionPlaneAxis('front');
+      assert.strictEqual(state.sectionPlane.axis, 'front');
+    });
+
+    it('should preserve other section plane properties', () => {
+      state.sectionPlane.position = 75;
+      state.setSectionPlaneAxis('side');
+      assert.strictEqual(state.sectionPlane.axis, 'side');
+      assert.strictEqual(state.sectionPlane.position, 75);
+    });
+  });
+
+  describe('setSectionPlanePosition', () => {
+    it('should update the position', () => {
+      state.setSectionPlanePosition(75);
+      assert.strictEqual(state.sectionPlane.position, 75);
+    });
+
+    it('should clamp position to minimum 0', () => {
+      state.setSectionPlanePosition(-10);
+      assert.strictEqual(state.sectionPlane.position, 0);
+    });
+
+    it('should clamp position to maximum 100', () => {
+      state.setSectionPlanePosition(150);
+      assert.strictEqual(state.sectionPlane.position, 100);
+    });
+
+    it('should handle NaN by defaulting to 0', () => {
+      state.setSectionPlanePosition(NaN);
+      assert.strictEqual(state.sectionPlane.position, 0);
+    });
+
+    it('should coerce string numbers', () => {
+      state.setSectionPlanePosition('50' as any);
+      assert.strictEqual(state.sectionPlane.position, 50);
+    });
+  });
+
+  describe('toggleSectionPlane', () => {
+    it('should toggle enabled from true to false', () => {
+      assert.strictEqual(state.sectionPlane.enabled, true);
+      state.toggleSectionPlane();
+      assert.strictEqual(state.sectionPlane.enabled, false);
+    });
+
+    it('should toggle enabled from false to true', () => {
+      state.sectionPlane.enabled = false;
+      state.toggleSectionPlane();
+      assert.strictEqual(state.sectionPlane.enabled, true);
+    });
+  });
+
+  describe('flipSectionPlane', () => {
+    it('should toggle flipped from false to true', () => {
+      assert.strictEqual(state.sectionPlane.flipped, false);
+      state.flipSectionPlane();
+      assert.strictEqual(state.sectionPlane.flipped, true);
+    });
+
+    it('should toggle flipped from true to false', () => {
+      state.sectionPlane.flipped = true;
+      state.flipSectionPlane();
+      assert.strictEqual(state.sectionPlane.flipped, false);
+    });
+  });
+
+  describe('resetSectionPlane', () => {
+    it('should reset to default values', () => {
+      // Modify state
+      state.sectionPlane = {
+        axis: 'side',
+        position: 25,
+        enabled: false,
+        flipped: true,
+      };
+
+      state.resetSectionPlane();
+
+      assert.strictEqual(state.sectionPlane.axis, SECTION_PLANE_DEFAULTS.AXIS);
+      assert.strictEqual(state.sectionPlane.position, SECTION_PLANE_DEFAULTS.POSITION);
+      assert.strictEqual(state.sectionPlane.enabled, SECTION_PLANE_DEFAULTS.ENABLED);
+      assert.strictEqual(state.sectionPlane.flipped, SECTION_PLANE_DEFAULTS.FLIPPED);
+    });
+  });
+});

package/src/store/slices/sectionSlice.ts

@@ -0,0 +1,58 @@
+/* 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/. */
+
+/**
+ * Section plane state slice
+ */
+
+import type { StateCreator } from 'zustand';
+import type { SectionPlane, SectionPlaneAxis } from '../types.js';
+import { SECTION_PLANE_DEFAULTS } from '../constants.js';
+
+export interface SectionSlice {
+  // State
+  sectionPlane: SectionPlane;
+
+  // Actions
+  setSectionPlaneAxis: (axis: SectionPlaneAxis) => void;
+  setSectionPlanePosition: (position: number) => void;
+  toggleSectionPlane: () => void;
+  flipSectionPlane: () => void;
+  resetSectionPlane: () => void;
+}
+
+const getDefaultSectionPlane = (): SectionPlane => ({
+  axis: SECTION_PLANE_DEFAULTS.AXIS,
+  position: SECTION_PLANE_DEFAULTS.POSITION,
+  enabled: SECTION_PLANE_DEFAULTS.ENABLED,
+  flipped: SECTION_PLANE_DEFAULTS.FLIPPED,
+});
+
+export const createSectionSlice: StateCreator<SectionSlice, [], [], SectionSlice> = (set) => ({
+  // Initial state
+  sectionPlane: getDefaultSectionPlane(),
+
+  // Actions
+  setSectionPlaneAxis: (axis) => set((state) => ({
+    sectionPlane: { ...state.sectionPlane, axis },
+  })),
+
+  setSectionPlanePosition: (position) => set((state) => {
+    // Clamp position to valid range [0, 100]
+    const clampedPosition = Math.min(100, Math.max(0, Number(position) || 0));
+    return {
+      sectionPlane: { ...state.sectionPlane, position: clampedPosition },
+    };
+  }),
+
+  toggleSectionPlane: () => set((state) => ({
+    sectionPlane: { ...state.sectionPlane, enabled: !state.sectionPlane.enabled },
+  })),
+
+  flipSectionPlane: () => set((state) => ({
+    sectionPlane: { ...state.sectionPlane, flipped: !state.sectionPlane.flipped },
+  })),
+
+  resetSectionPlane: () => set({ sectionPlane: getDefaultSectionPlane() }),
+});

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

@@ -0,0 +1,286 @@
+/* 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 { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { createSelectionSlice, type SelectionSlice } from './selectionSlice.js';
+import type { EntityRef } from '../types.js';
+
+describe('SelectionSlice', () => {
+  let state: SelectionSlice;
+  let setState: (partial: Partial<SelectionSlice> | ((state: SelectionSlice) => Partial<SelectionSlice>)) => void;
+
+  beforeEach(() => {
+    setState = (partial) => {
+      if (typeof partial === 'function') {
+        const updates = partial(state);
+        state = { ...state, ...updates };
+      } else {
+        state = { ...state, ...partial };
+      }
+    };
+
+    state = createSelectionSlice(setState, () => state, {} as any);
+  });
+
+  describe('initial state', () => {
+    it('should have null selectedEntity', () => {
+      assert.strictEqual(state.selectedEntity, null);
+    });
+
+    it('should have empty selectedEntitiesSet', () => {
+      assert.strictEqual(state.selectedEntitiesSet.size, 0);
+    });
+
+    it('should have null selectedEntityId (legacy)', () => {
+      assert.strictEqual(state.selectedEntityId, null);
+    });
+  });
+
+  describe('multi-model selection: setSelectedEntity', () => {
+    it('should set primary selection with model context', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.setSelectedEntity(ref);
+
+      assert.deepStrictEqual(state.selectedEntity, ref);
+    });
+
+    it('should NOT update selectedEntityId (caller must use setSelectedEntityId for global ID)', () => {
+      // NOTE: selectedEntityId holds the GLOBAL ID for renderer highlighting,
+      // while selectedEntity.expressId holds the ORIGINAL express ID for property lookup.
+      // The caller should use setSelectedEntityId(globalId) separately.
+      const ref: EntityRef = { modelId: 'model-1', expressId: 456 };
+      state.setSelectedEntity(ref);
+
+      // selectedEntityId should remain null - caller must set it separately with globalId
+      assert.strictEqual(state.selectedEntityId, null);
+    });
+
+    it('should allow clearing selection with null', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.setSelectedEntity(ref);
+      state.setSelectedEntity(null);
+
+      assert.strictEqual(state.selectedEntity, null);
+      assert.strictEqual(state.selectedEntityId, null);
+    });
+  });
+
+  describe('multi-model selection: addEntityToSelection', () => {
+    it('should add entity to selection set', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+
+      assert.strictEqual(state.selectedEntitiesSet.size, 1);
+      assert.ok(state.selectedEntitiesSet.has('model-1:123'));
+    });
+
+    it('should update primary selection', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+
+      assert.deepStrictEqual(state.selectedEntity, ref);
+    });
+
+    it('should allow multiple entities from different models', () => {
+      const ref1: EntityRef = { modelId: 'model-1', expressId: 123 };
+      const ref2: EntityRef = { modelId: 'model-2', expressId: 456 };
+
+      state.addEntityToSelection(ref1);
+      state.addEntityToSelection(ref2);
+
+      assert.strictEqual(state.selectedEntitiesSet.size, 2);
+      assert.ok(state.selectedEntitiesSet.has('model-1:123'));
+      assert.ok(state.selectedEntitiesSet.has('model-2:456'));
+    });
+
+    it('should allow multiple entities from same model', () => {
+      const ref1: EntityRef = { modelId: 'model-1', expressId: 100 };
+      const ref2: EntityRef = { modelId: 'model-1', expressId: 200 };
+
+      state.addEntityToSelection(ref1);
+      state.addEntityToSelection(ref2);
+
+      assert.strictEqual(state.selectedEntitiesSet.size, 2);
+    });
+  });
+
+  describe('multi-model selection: removeEntityFromSelection', () => {
+    it('should remove entity from selection set', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+      state.removeEntityFromSelection(ref);
+
+      assert.strictEqual(state.selectedEntitiesSet.size, 0);
+    });
+
+    it('should update primary selection when removing primary', () => {
+      const ref1: EntityRef = { modelId: 'model-1', expressId: 123 };
+      const ref2: EntityRef = { modelId: 'model-2', expressId: 456 };
+
+      state.addEntityToSelection(ref1);
+      state.addEntityToSelection(ref2);
+      state.removeEntityFromSelection(ref2);
+
+      // Primary should update to remaining entity
+      assert.strictEqual(state.selectedEntitiesSet.size, 1);
+      assert.ok(state.selectedEntitiesSet.has('model-1:123'));
+    });
+
+    it('should clear primary when removing last entity', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+      state.removeEntityFromSelection(ref);
+
+      assert.strictEqual(state.selectedEntity, null);
+      assert.strictEqual(state.selectedEntityId, null);
+    });
+  });
+
+  describe('multi-model selection: toggleEntitySelection', () => {
+    it('should add entity if not selected', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.toggleEntitySelection(ref);
+
+      assert.strictEqual(state.selectedEntitiesSet.size, 1);
+      assert.ok(state.selectedEntitiesSet.has('model-1:123'));
+    });
+
+    it('should remove entity if already selected', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+      state.toggleEntitySelection(ref);
+
+      assert.strictEqual(state.selectedEntitiesSet.size, 0);
+    });
+
+    it('should update primary selection correctly', () => {
+      const ref1: EntityRef = { modelId: 'model-1', expressId: 123 };
+      const ref2: EntityRef = { modelId: 'model-1', expressId: 456 };
+
+      state.toggleEntitySelection(ref1);
+      assert.deepStrictEqual(state.selectedEntity, ref1);
+
+      state.toggleEntitySelection(ref2);
+      assert.deepStrictEqual(state.selectedEntity, ref2);
+
+      state.toggleEntitySelection(ref2);
+      // After removing ref2, primary should go back to ref1
+      assert.ok(state.selectedEntity?.expressId === 123 || state.selectedEntity === null);
+    });
+  });
+
+  describe('multi-model selection: clearEntitySelection', () => {
+    it('should clear all multi-model selection state', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+      state.clearEntitySelection();
+
+      assert.strictEqual(state.selectedEntity, null);
+      assert.strictEqual(state.selectedEntitiesSet.size, 0);
+      assert.strictEqual(state.selectedEntityId, null);
+    });
+
+    it('should also clear legacy selection state', () => {
+      state.setSelectedEntityIds([1, 2, 3]);
+      state.clearEntitySelection();
+
+      assert.strictEqual(state.selectedEntityIds.size, 0);
+    });
+  });
+
+  describe('multi-model selection: isEntitySelected', () => {
+    it('should return true for selected entity', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      state.addEntityToSelection(ref);
+
+      assert.strictEqual(state.isEntitySelected(ref), true);
+    });
+
+    it('should return false for non-selected entity', () => {
+      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
+      assert.strictEqual(state.isEntitySelected(ref), false);
+    });
+
+    it('should distinguish between models', () => {
+      const ref1: EntityRef = { modelId: 'model-1', expressId: 123 };
+      const ref2: EntityRef = { modelId: 'model-2', expressId: 123 }; // Same expressId, different model
+
+      state.addEntityToSelection(ref1);
+
+      assert.strictEqual(state.isEntitySelected(ref1), true);
+      assert.strictEqual(state.isEntitySelected(ref2), false);
+    });
+  });
+
+  describe('multi-model selection: getSelectedEntitiesForModel', () => {
+    it('should return only entities for specified model', () => {
+      state.addEntityToSelection({ modelId: 'model-1', expressId: 100 });
+      state.addEntityToSelection({ modelId: 'model-1', expressId: 200 });
+      state.addEntityToSelection({ modelId: 'model-2', expressId: 300 });
+
+      const model1Entities = state.getSelectedEntitiesForModel('model-1');
+      const model2Entities = state.getSelectedEntitiesForModel('model-2');
+
+      assert.strictEqual(model1Entities.length, 2);
+      assert.ok(model1Entities.includes(100));
+      assert.ok(model1Entities.includes(200));
+
+      assert.strictEqual(model2Entities.length, 1);
+      assert.ok(model2Entities.includes(300));
+    });
+
+    it('should return empty array for model with no selections', () => {
+      state.addEntityToSelection({ modelId: 'model-1', expressId: 100 });
+
+      const result = state.getSelectedEntitiesForModel('model-2');
+      assert.deepStrictEqual(result, []);
+    });
+  });
+
+  describe('legacy selection: setSelectedEntityId', () => {
+    it('should set legacy selectedEntityId', () => {
+      state.setSelectedEntityId(123);
+      assert.strictEqual(state.selectedEntityId, 123);
+    });
+
+    it('should allow clearing with null', () => {
+      state.setSelectedEntityId(123);
+      state.setSelectedEntityId(null);
+      assert.strictEqual(state.selectedEntityId, null);
+    });
+  });
+
+  describe('legacy selection: storey selection', () => {
+    it('should toggle storey selection', () => {
+      state.toggleStoreySelection(1);
+      assert.ok(state.selectedStoreys.has(1));
+
+      state.toggleStoreySelection(1);
+      assert.ok(!state.selectedStoreys.has(1));
+    });
+
+    it('should set single storey selection', () => {
+      state.setStoreySelection(1);
+      state.setStoreySelection(2);
+
+      assert.strictEqual(state.selectedStoreys.size, 1);
+      assert.ok(state.selectedStoreys.has(2));
+    });
+
+    it('should toggle off when selecting already-selected storey', () => {
+      state.setStoreySelection(1);
+      state.setStoreySelection(1);
+
+      assert.strictEqual(state.selectedStoreys.size, 0);
+    });
+
+    it('should clear storey selection', () => {
+      state.setStoreysSelection([1, 2, 3]);
+      state.clearStoreySelection();
+
+      assert.strictEqual(state.selectedStoreys.size, 0);
+    });
+  });
+});