@ifc-lite/viewer 1.1.6 → 1.5.0

package/src/store/slices/measurementSlice.ts

@@ -0,0 +1,293 @@
+/* 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/. */
+
+/**
+ * Measurement state slice
+ */
+
+import type { StateCreator } from 'zustand';
+import type { SnapTarget } from '@ifc-lite/renderer';
+import type {
+  MeasurePoint,
+  Measurement,
+  ActiveMeasurement,
+  EdgeLockState,
+  SnapVisualization,
+  MeasurementConstraintEdge,
+  OrthogonalAxis,
+} from '../types.js';
+import { EDGE_LOCK_DEFAULTS } from '../constants.js';
+
+// Monotonic counter to prevent ID collisions under rapid measurement creation
+let measurementCounter = 0;
+
+export interface MeasurementSlice {
+  // State
+  measurements: Measurement[];
+  pendingMeasurePoint: MeasurePoint | null;
+  activeMeasurement: ActiveMeasurement | null;
+  snapTarget: SnapTarget | null;
+  snapEnabled: boolean;
+  snapVisualization: SnapVisualization | null;
+  edgeLockState: EdgeLockState;
+  /** Edge constraint for perpendicular measurements (when shift is held) */
+  measurementConstraintEdge: MeasurementConstraintEdge | null;
+
+  // Legacy measurement actions
+  addMeasurePoint: (point: MeasurePoint) => void;
+  completeMeasurement: (endPoint: MeasurePoint) => void;
+
+  // Drag-based measurement actions
+  startMeasurement: (point: MeasurePoint) => void;
+  updateMeasurement: (point: MeasurePoint) => void;
+  finalizeMeasurement: () => void;
+  cancelMeasurement: () => void;
+  deleteMeasurement: (id: string) => void;
+  clearMeasurements: () => void;
+  updateMeasurementScreenCoords: (
+    projectToScreen: (worldPos: { x: number; y: number; z: number }) => { x: number; y: number } | null
+  ) => void;
+
+  // Snap actions
+  setSnapTarget: (target: SnapTarget | null) => void;
+  setSnapVisualization: (viz: SnapVisualization | null) => void;
+  toggleSnap: () => void;
+
+  // Edge lock actions
+  setEdgeLock: (edge: EdgeLockState['edge'], meshExpressId: number | null, edgeT?: number) => void;
+  updateEdgeLockPosition: (edgeT: number, isCorner: boolean, cornerValence: number) => void;
+  clearEdgeLock: () => void;
+  incrementEdgeLockStrength: () => void;
+
+  // Orthogonal constraint actions (shift+drag)
+  setMeasurementConstraintEdge: (edge: MeasurementConstraintEdge | null) => void;
+  updateConstraintActiveAxis: (axis: OrthogonalAxis | null) => void;
+  clearMeasurementConstraintEdge: () => void;
+}
+
+const getDefaultEdgeLockState = (): EdgeLockState => ({
+  edge: null,
+  meshExpressId: null,
+  edgeT: 0,
+  lockStrength: 0,
+  isCorner: false,
+  cornerValence: 0,
+});
+
+export const createMeasurementSlice: StateCreator<MeasurementSlice, [], [], MeasurementSlice> = (set, get) => ({
+  // Initial state
+  measurements: [],
+  pendingMeasurePoint: null,
+  activeMeasurement: null,
+  snapTarget: null,
+  snapEnabled: true,
+  snapVisualization: null,
+  edgeLockState: getDefaultEdgeLockState(),
+  measurementConstraintEdge: null,
+
+  // Legacy measurement actions
+  addMeasurePoint: (point) => set({ pendingMeasurePoint: point }),
+
+  completeMeasurement: (endPoint) => set((state) => {
+    if (!state.pendingMeasurePoint) return {};
+    const start = state.pendingMeasurePoint;
+    const distance = Math.sqrt(
+      Math.pow(endPoint.x - start.x, 2) +
+      Math.pow(endPoint.y - start.y, 2) +
+      Math.pow(endPoint.z - start.z, 2)
+    );
+    // Use counter combined with timestamp to guarantee unique IDs
+    measurementCounter++;
+    const measurement: Measurement = {
+      id: `m-${Date.now()}-${measurementCounter}`,
+      start,
+      end: endPoint,
+      distance,
+    };
+    return {
+      measurements: [...state.measurements, measurement],
+      pendingMeasurePoint: null,
+    };
+  }),
+
+  // Drag-based measurement actions
+  startMeasurement: (point) => set({
+    activeMeasurement: {
+      start: point,
+      current: point,
+      distance: 0,
+    },
+  }),
+
+  updateMeasurement: (point) => set((state) => {
+    if (!state.activeMeasurement) return {};
+    const start = state.activeMeasurement.start;
+    const distance = Math.sqrt(
+      Math.pow(point.x - start.x, 2) +
+      Math.pow(point.y - start.y, 2) +
+      Math.pow(point.z - start.z, 2)
+    );
+    return {
+      activeMeasurement: {
+        start,
+        current: point,
+        distance,
+      },
+    };
+  }),
+
+  finalizeMeasurement: () => set((state) => {
+    if (!state.activeMeasurement) return {};
+    // Use counter combined with timestamp to guarantee unique IDs
+    measurementCounter++;
+    const measurement: Measurement = {
+      id: `m-${Date.now()}-${measurementCounter}`,
+      start: state.activeMeasurement.start,
+      end: state.activeMeasurement.current,
+      distance: state.activeMeasurement.distance,
+    };
+    return {
+      measurements: [...state.measurements, measurement],
+      activeMeasurement: null,
+      snapTarget: null,
+      measurementConstraintEdge: null,
+    };
+  }),
+
+  cancelMeasurement: () => set({
+    activeMeasurement: null,
+    snapTarget: null,
+    measurementConstraintEdge: null,
+  }),
+
+  deleteMeasurement: (id) => set((state) => ({
+    measurements: state.measurements.filter((m) => m.id !== id),
+  })),
+
+  clearMeasurements: () => set({
+    measurements: [],
+    pendingMeasurePoint: null,
+    activeMeasurement: null,
+    snapTarget: null,
+  }),
+
+  updateMeasurementScreenCoords: (projectToScreen) => {
+    const state = get();
+    let hasChanges = false;
+
+    // Check completed measurements for changes
+    const updatedMeasurements = state.measurements.map((m) => {
+      const startScreen = projectToScreen(m.start);
+      const endScreen = projectToScreen(m.end);
+
+      const newStartX = startScreen?.x ?? m.start.screenX;
+      const newStartY = startScreen?.y ?? m.start.screenY;
+      const newEndX = endScreen?.x ?? m.end.screenX;
+      const newEndY = endScreen?.y ?? m.end.screenY;
+
+      if (
+        newStartX !== m.start.screenX ||
+        newStartY !== m.start.screenY ||
+        newEndX !== m.end.screenX ||
+        newEndY !== m.end.screenY
+      ) {
+        hasChanges = true;
+      }
+
+      return {
+        ...m,
+        start: { ...m.start, screenX: newStartX, screenY: newStartY },
+        end: { ...m.end, screenX: newEndX, screenY: newEndY },
+      };
+    });
+
+    // Check active measurement for changes
+    let updatedActiveMeasurement = state.activeMeasurement;
+    if (state.activeMeasurement) {
+      const startScreen = projectToScreen(state.activeMeasurement.start);
+      const currentScreen = projectToScreen(state.activeMeasurement.current);
+
+      const newStartX = startScreen?.x ?? state.activeMeasurement.start.screenX;
+      const newStartY = startScreen?.y ?? state.activeMeasurement.start.screenY;
+      const newCurrentX = currentScreen?.x ?? state.activeMeasurement.current.screenX;
+      const newCurrentY = currentScreen?.y ?? state.activeMeasurement.current.screenY;
+
+      if (
+        newStartX !== state.activeMeasurement.start.screenX ||
+        newStartY !== state.activeMeasurement.start.screenY ||
+        newCurrentX !== state.activeMeasurement.current.screenX ||
+        newCurrentY !== state.activeMeasurement.current.screenY
+      ) {
+        hasChanges = true;
+      }
+
+      updatedActiveMeasurement = {
+        ...state.activeMeasurement,
+        start: { ...state.activeMeasurement.start, screenX: newStartX, screenY: newStartY },
+        current: { ...state.activeMeasurement.current, screenX: newCurrentX, screenY: newCurrentY },
+      };
+    }
+
+    // Early exit if nothing changed
+    if (!hasChanges) {
+      return;
+    }
+
+    set({
+      measurements: updatedMeasurements,
+      activeMeasurement: updatedActiveMeasurement,
+    });
+  },
+
+  // Snap actions
+  setSnapTarget: (snapTarget) => set({ snapTarget }),
+  setSnapVisualization: (snapVisualization) => set({ snapVisualization }),
+  toggleSnap: () => set((state) => ({ snapEnabled: !state.snapEnabled })),
+
+  // Edge lock actions
+  setEdgeLock: (edge, meshExpressId, edgeT = EDGE_LOCK_DEFAULTS.INITIAL_T) => set({
+    edgeLockState: {
+      edge,
+      meshExpressId,
+      edgeT,
+      lockStrength: EDGE_LOCK_DEFAULTS.INITIAL_STRENGTH,
+      isCorner: false,
+      cornerValence: 0,
+    },
+  }),
+
+  updateEdgeLockPosition: (edgeT, isCorner, cornerValence) => set((state) => ({
+    edgeLockState: {
+      ...state.edgeLockState,
+      edgeT,
+      isCorner,
+      cornerValence,
+    },
+  })),
+
+  clearEdgeLock: () => set({ edgeLockState: getDefaultEdgeLockState() }),
+
+  incrementEdgeLockStrength: () => set((state) => ({
+    edgeLockState: {
+      ...state.edgeLockState,
+      lockStrength: Math.min(
+        state.edgeLockState.lockStrength + EDGE_LOCK_DEFAULTS.STRENGTH_INCREMENT,
+        EDGE_LOCK_DEFAULTS.MAX_STRENGTH
+      ),
+    },
+  })),
+
+  // Orthogonal constraint actions
+  setMeasurementConstraintEdge: (edge) => set({ measurementConstraintEdge: edge }),
+  updateConstraintActiveAxis: (axis) => set((state) => {
+    if (!state.measurementConstraintEdge) return {};
+    return {
+      measurementConstraintEdge: {
+        ...state.measurementConstraintEdge,
+        activeAxis: axis,
+      },
+    };
+  }),
+  clearMeasurementConstraintEdge: () => set({ measurementConstraintEdge: null }),
+});

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

@@ -0,0 +1,271 @@
+/* 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 { createModelSlice, type ModelSlice } from './modelSlice.js';
+import type { FederatedModel } from '../types.js';
+
+// Helper to create a mock model
+function createMockModel(id: string, name: string): FederatedModel {
+  return {
+    id,
+    name,
+    ifcDataStore: {} as any,
+    geometryResult: {} as any,
+    visible: true,
+    collapsed: false,
+    schemaVersion: 'IFC4',
+    loadedAt: Date.now(),
+    fileSize: 1024,
+  };
+}
+
+describe('ModelSlice', () => {
+  let state: ModelSlice;
+  let setState: (partial: Partial<ModelSlice> | ((state: ModelSlice) => Partial<ModelSlice>)) => 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 = createModelSlice(setState, () => state, {} as any);
+  });
+
+  describe('initial state', () => {
+    it('should have empty models map', () => {
+      assert.strictEqual(state.models.size, 0);
+    });
+
+    it('should have null activeModelId', () => {
+      assert.strictEqual(state.activeModelId, null);
+    });
+
+    it('should report hasModels as false', () => {
+      assert.strictEqual(state.hasModels(), false);
+    });
+  });
+
+  describe('addModel', () => {
+    it('should add a model to the map', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+      assert.strictEqual(state.models.size, 1);
+      assert.strictEqual(state.models.get('model-1')?.name, 'Test Model');
+    });
+
+    it('should set first model as active', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+      assert.strictEqual(state.activeModelId, 'model-1');
+    });
+
+    it('should collapse existing models when adding new ones', () => {
+      const model1 = createMockModel('model-1', 'First Model');
+      const model2 = createMockModel('model-2', 'Second Model');
+
+      state.addModel(model1);
+      assert.strictEqual(state.models.get('model-1')?.collapsed, false);
+
+      state.addModel(model2);
+      // First model should now be collapsed
+      assert.strictEqual(state.models.get('model-1')?.collapsed, true);
+      // New model should not be collapsed
+      assert.strictEqual(state.models.get('model-2')?.collapsed, false);
+    });
+
+    it('should not change activeModelId when adding subsequent models', () => {
+      const model1 = createMockModel('model-1', 'First Model');
+      const model2 = createMockModel('model-2', 'Second Model');
+
+      state.addModel(model1);
+      state.addModel(model2);
+
+      // Active model should still be the first one
+      assert.strictEqual(state.activeModelId, 'model-1');
+    });
+
+    it('should report hasModels as true after adding', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+      assert.strictEqual(state.hasModels(), true);
+    });
+  });
+
+  describe('removeModel', () => {
+    it('should remove a model from the map', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+      state.removeModel('model-1');
+      assert.strictEqual(state.models.size, 0);
+    });
+
+    it('should update activeModelId if removed model was active', () => {
+      const model1 = createMockModel('model-1', 'First Model');
+      const model2 = createMockModel('model-2', 'Second Model');
+
+      state.addModel(model1);
+      state.addModel(model2);
+      state.setActiveModel('model-1');
+
+      state.removeModel('model-1');
+      // Active model should switch to model-2
+      assert.strictEqual(state.activeModelId, 'model-2');
+    });
+
+    it('should set activeModelId to null when last model removed', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+      state.removeModel('model-1');
+      assert.strictEqual(state.activeModelId, null);
+    });
+
+    it('should not affect activeModelId if removed model was not active', () => {
+      const model1 = createMockModel('model-1', 'First Model');
+      const model2 = createMockModel('model-2', 'Second Model');
+
+      state.addModel(model1);
+      state.addModel(model2);
+
+      state.removeModel('model-2');
+      assert.strictEqual(state.activeModelId, 'model-1');
+    });
+  });
+
+  describe('clearAllModels', () => {
+    it('should remove all models', () => {
+      state.addModel(createMockModel('model-1', 'First'));
+      state.addModel(createMockModel('model-2', 'Second'));
+
+      state.clearAllModels();
+
+      assert.strictEqual(state.models.size, 0);
+      assert.strictEqual(state.activeModelId, null);
+    });
+  });
+
+  describe('setActiveModel', () => {
+    it('should update activeModelId', () => {
+      const model1 = createMockModel('model-1', 'First Model');
+      const model2 = createMockModel('model-2', 'Second Model');
+
+      state.addModel(model1);
+      state.addModel(model2);
+
+      state.setActiveModel('model-2');
+      assert.strictEqual(state.activeModelId, 'model-2');
+    });
+
+    it('should allow setting to null', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+      state.setActiveModel(null);
+      assert.strictEqual(state.activeModelId, null);
+    });
+  });
+
+  describe('setModelVisibility', () => {
+    it('should update model visibility', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+
+      state.setModelVisibility('model-1', false);
+      assert.strictEqual(state.models.get('model-1')?.visible, false);
+
+      state.setModelVisibility('model-1', true);
+      assert.strictEqual(state.models.get('model-1')?.visible, true);
+    });
+
+    it('should do nothing for non-existent model', () => {
+      state.setModelVisibility('non-existent', false);
+      // Should not throw, just return empty update
+      assert.strictEqual(state.models.size, 0);
+    });
+  });
+
+  describe('setModelCollapsed', () => {
+    it('should update model collapsed state', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+
+      state.setModelCollapsed('model-1', true);
+      assert.strictEqual(state.models.get('model-1')?.collapsed, true);
+
+      state.setModelCollapsed('model-1', false);
+      assert.strictEqual(state.models.get('model-1')?.collapsed, false);
+    });
+  });
+
+  describe('setModelName', () => {
+    it('should update model name', () => {
+      const model = createMockModel('model-1', 'Original Name');
+      state.addModel(model);
+
+      state.setModelName('model-1', 'New Name');
+      assert.strictEqual(state.models.get('model-1')?.name, 'New Name');
+    });
+  });
+
+  describe('getModel', () => {
+    it('should return model by ID', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+
+      const retrieved = state.getModel('model-1');
+      assert.strictEqual(retrieved?.name, 'Test Model');
+    });
+
+    it('should return undefined for non-existent ID', () => {
+      const retrieved = state.getModel('non-existent');
+      assert.strictEqual(retrieved, undefined);
+    });
+  });
+
+  describe('getActiveModel', () => {
+    it('should return the active model', () => {
+      const model = createMockModel('model-1', 'Test Model');
+      state.addModel(model);
+
+      const active = state.getActiveModel();
+      assert.strictEqual(active?.id, 'model-1');
+    });
+
+    it('should return undefined when no active model', () => {
+      const active = state.getActiveModel();
+      assert.strictEqual(active, undefined);
+    });
+  });
+
+  describe('getAllVisibleModels', () => {
+    it('should return only visible models', () => {
+      state.addModel(createMockModel('model-1', 'First'));
+      state.addModel(createMockModel('model-2', 'Second'));
+      state.addModel(createMockModel('model-3', 'Third'));
+
+      state.setModelVisibility('model-2', false);
+
+      const visible = state.getAllVisibleModels();
+      assert.strictEqual(visible.length, 2);
+      assert.ok(visible.some(m => m.id === 'model-1'));
+      assert.ok(visible.some(m => m.id === 'model-3'));
+      assert.ok(!visible.some(m => m.id === 'model-2'));
+    });
+
+    it('should return empty array when all models hidden', () => {
+      state.addModel(createMockModel('model-1', 'First'));
+      state.setModelVisibility('model-1', false);
+
+      const visible = state.getAllVisibleModels();
+      assert.strictEqual(visible.length, 0);
+    });
+  });
+});