@ifc-lite/viewer 1.1.7 → 1.5.0

package/src/store/slices/modelSlice.ts

@@ -0,0 +1,211 @@
+/* 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/. */
+
+/**
+ * Model state slice for multi-model federation
+ *
+ * Uses FederationRegistry for bulletproof ID handling:
+ * - Each model gets a unique ID offset at load time
+ * - All meshes use globalIds (originalExpressId + offset)
+ * - No ID collisions possible between models
+ */
+
+import type { StateCreator } from 'zustand';
+import type { FederatedModel } from '../types.js';
+import { federationRegistry, type GlobalIdLookup } from '@ifc-lite/renderer';
+
+export interface ModelSlice {
+  // State
+  /** Map of all loaded models by ID */
+  models: Map<string, FederatedModel>;
+  /** ID of the currently active model (for property panel focus) */
+  activeModelId: string | null;
+
+  // Actions
+  /** Add a new model to the federation */
+  addModel: (model: FederatedModel) => void;
+  /** Remove a model from the federation */
+  removeModel: (modelId: string) => void;
+  /** Clear all models */
+  clearAllModels: () => void;
+  /** Set the active model for property panel focus */
+  setActiveModel: (modelId: string | null) => void;
+  /** Toggle model visibility */
+  setModelVisibility: (modelId: string, visible: boolean) => void;
+  /** Toggle model collapsed state in hierarchy */
+  setModelCollapsed: (modelId: string, collapsed: boolean) => void;
+  /** Rename a model */
+  setModelName: (modelId: string, name: string) => void;
+  /** Get a model by ID */
+  getModel: (modelId: string) => FederatedModel | undefined;
+  /** Get the currently active model */
+  getActiveModel: () => FederatedModel | undefined;
+  /** Get all visible models */
+  getAllVisibleModels: () => FederatedModel[];
+  /** Check if any models are loaded */
+  hasModels: () => boolean;
+
+  // Federation Registry helpers (wraps the singleton for convenience)
+  /**
+   * Register a model with the federation registry and get its offset
+   * Call this BEFORE adding meshes, passing the max expressId in the model
+   */
+  registerModelOffset: (modelId: string, maxExpressId: number) => number;
+  /** Convert local expressId to globalId */
+  toGlobalId: (modelId: string, expressId: number) => number;
+  /** Convert globalId back to (modelId, expressId) */
+  fromGlobalId: (globalId: number) => GlobalIdLookup | null;
+  /** Find which model contains a globalId */
+  findModelForGlobalId: (globalId: number) => string | null;
+  /** Get the offset for a model */
+  getModelOffset: (modelId: string) => number | null;
+
+  /**
+   * BULLETPROOF: Resolve globalId using model store data instead of singleton registry
+   * This is more reliable because it uses Zustand state which is always in sync with React
+   */
+  resolveGlobalIdFromModels: (globalId: number) => GlobalIdLookup | null;
+}
+
+export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (set, get) => ({
+  // Initial state
+  models: new Map(),
+  activeModelId: null,
+
+  // Actions
+  addModel: (model) => set((state) => {
+    const newModels = new Map(state.models);
+    newModels.set(model.id, model);
+
+    // If first model, make it active
+    // If adding more models, collapse all existing by default
+    if (state.models.size === 0) {
+      return { models: newModels, activeModelId: model.id };
+    } else {
+      // Collapse existing models when adding new ones
+      for (const [id, m] of newModels) {
+        if (id !== model.id) {
+          newModels.set(id, { ...m, collapsed: true });
+        }
+      }
+      return { models: newModels };
+    }
+  }),
+
+  removeModel: (modelId) => set((state) => {
+    const newModels = new Map(state.models);
+    newModels.delete(modelId);
+
+    // Unregister from federation registry
+    federationRegistry.unregisterModel(modelId);
+
+    // Update activeModelId if removed model was active
+    let newActiveId = state.activeModelId;
+    if (state.activeModelId === modelId) {
+      const remaining = Array.from(newModels.keys());
+      newActiveId = remaining.length > 0 ? remaining[0] : null;
+    }
+
+    return { models: newModels, activeModelId: newActiveId };
+  }),
+
+  clearAllModels: () => {
+    // Clear the federation registry
+    federationRegistry.clear();
+    return set({
+      models: new Map(),
+      activeModelId: null,
+    });
+  },
+
+  setActiveModel: (modelId) => set({ activeModelId: modelId }),
+
+  setModelVisibility: (modelId, visible) => set((state) => {
+    const model = state.models.get(modelId);
+    if (!model) return {};
+
+    const newModels = new Map(state.models);
+    newModels.set(modelId, { ...model, visible });
+    return { models: newModels };
+  }),
+
+  setModelCollapsed: (modelId, collapsed) => set((state) => {
+    const model = state.models.get(modelId);
+    if (!model) return {};
+
+    const newModels = new Map(state.models);
+    newModels.set(modelId, { ...model, collapsed });
+    return { models: newModels };
+  }),
+
+  setModelName: (modelId, name) => set((state) => {
+    const model = state.models.get(modelId);
+    if (!model) return {};
+
+    const newModels = new Map(state.models);
+    newModels.set(modelId, { ...model, name });
+    return { models: newModels };
+  }),
+
+  // Getters (synchronous access via get())
+  getModel: (modelId) => get().models.get(modelId),
+
+  getActiveModel: () => {
+    const state = get();
+    return state.activeModelId ? state.models.get(state.activeModelId) : undefined;
+  },
+
+  getAllVisibleModels: () => {
+    return Array.from(get().models.values()).filter(m => m.visible);
+  },
+
+  hasModels: () => get().models.size > 0,
+
+  // Federation Registry helpers
+  registerModelOffset: (modelId: string, maxExpressId: number) => {
+    return federationRegistry.registerModel(modelId, maxExpressId);
+  },
+
+  toGlobalId: (modelId: string, expressId: number) => {
+    return federationRegistry.toGlobalId(modelId, expressId);
+  },
+
+  fromGlobalId: (globalId: number) => {
+    return federationRegistry.fromGlobalId(globalId);
+  },
+
+  findModelForGlobalId: (globalId: number) => {
+    return federationRegistry.getModelForGlobalId(globalId);
+  },
+
+  getModelOffset: (modelId: string) => {
+    return federationRegistry.getOffset(modelId);
+  },
+
+  /**
+   * BULLETPROOF: Resolve globalId using model store data instead of singleton registry
+   * This iterates through all models and checks if the globalId falls within their range.
+   * More reliable than the singleton because it uses Zustand state which is always in sync.
+   */
+  resolveGlobalIdFromModels: (globalId: number) => {
+    const models = get().models;
+
+    // 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
+    for (const model of sortedModels) {
+      const localId = globalId - model.idOffset;
+      if (localId >= 0 && localId <= model.maxExpressId) {
+        return {
+          modelId: model.id,
+          expressId: localId,
+        };
+      }
+    }
+
+    return null;
+  },
+});

package/src/store/slices/mutationSlice.ts

@@ -0,0 +1,502 @@
+/* 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/. */
+
+/**
+ * Mutation slice - manages property/quantity mutations for IFC export
+ */
+
+import { type StateCreator } from 'zustand';
+import type { ViewerState } from '../index.js';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import type { Mutation, ChangeSet, PropertyValue } from '@ifc-lite/mutations';
+import { PropertyValueType } from '@ifc-lite/data';
+
+export interface MutationSlice {
+  // State
+  /** Mutation views per model */
+  mutationViews: Map<string, MutablePropertyView>;
+  /** All change sets */
+  changeSets: Map<string, ChangeSet>;
+  /** Active change set ID */
+  activeChangeSetId: string | null;
+  /** Undo stack per model */
+  undoStacks: Map<string, Mutation[]>;
+  /** Redo stack per model */
+  redoStacks: Map<string, Mutation[]>;
+  /** Models with unsaved changes */
+  dirtyModels: Set<string>;
+  /** Version counter to trigger re-renders when mutations change */
+  mutationVersion: number;
+
+  // Actions - Mutation View Management
+  /** Get or create mutation view for a model */
+  getMutationView: (modelId: string) => MutablePropertyView | null;
+  /** Register a mutation view for a model */
+  registerMutationView: (modelId: string, view: MutablePropertyView) => void;
+  /** Clear mutation view for a model */
+  clearMutationView: (modelId: string) => void;
+
+  // Actions - Property Mutations
+  /** Set a property value */
+  setProperty: (
+    modelId: string,
+    entityId: number,
+    psetName: string,
+    propName: string,
+    value: PropertyValue,
+    valueType?: PropertyValueType
+  ) => Mutation | null;
+  /** Delete a property */
+  deleteProperty: (
+    modelId: string,
+    entityId: number,
+    psetName: string,
+    propName: string
+  ) => Mutation | null;
+  /** Create a new property set */
+  createPropertySet: (
+    modelId: string,
+    entityId: number,
+    psetName: string,
+    properties: Array<{ name: string; value: PropertyValue; type?: PropertyValueType }>
+  ) => Mutation | null;
+  /** Delete a property set */
+  deletePropertySet: (
+    modelId: string,
+    entityId: number,
+    psetName: string
+  ) => Mutation | null;
+
+  // Actions - Undo/Redo
+  /** Undo last mutation for a model */
+  undo: (modelId: string) => void;
+  /** Redo last undone mutation for a model */
+  redo: (modelId: string) => void;
+  /** Check if undo is available */
+  canUndo: (modelId: string) => boolean;
+  /** Check if redo is available */
+  canRedo: (modelId: string) => boolean;
+
+  // Actions - Change Sets
+  /** Create a new change set */
+  createChangeSet: (name: string) => string;
+  /** Get active change set */
+  getActiveChangeSet: () => ChangeSet | null;
+  /** Set active change set */
+  setActiveChangeSet: (id: string | null) => void;
+  /** Export change set as JSON */
+  exportChangeSet: (id: string) => string | null;
+  /** Import change set from JSON */
+  importChangeSet: (json: string) => void;
+
+  // Actions - Query
+  /** Check if a model has unsaved changes */
+  hasChanges: (modelId: string) => boolean;
+  /** Get all mutations for a model */
+  getMutationsForModel: (modelId: string) => Mutation[];
+  /** Get count of modified entities across all models */
+  getModifiedEntityCount: () => number;
+
+  // Actions - Reset
+  /** Clear all mutations for a model */
+  clearMutations: (modelId: string) => void;
+  /** Clear all mutations */
+  clearAllMutations: () => void;
+  /** Manually bump mutation version (for bulk operations that bypass store) */
+  bumpMutationVersion: () => void;
+}
+
+function generateChangeSetId(): string {
+  return `cs_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+export const createMutationSlice: StateCreator<
+  ViewerState,
+  [],
+  [],
+  MutationSlice
+> = (set, get) => ({
+  // Initial state
+  mutationViews: new Map(),
+  changeSets: new Map(),
+  activeChangeSetId: null,
+  undoStacks: new Map(),
+  redoStacks: new Map(),
+  dirtyModels: new Set(),
+  mutationVersion: 0,
+
+  // Mutation View Management
+  getMutationView: (modelId) => {
+    return get().mutationViews.get(modelId) || null;
+  },
+
+  registerMutationView: (modelId, view) => {
+    set((state) => {
+      const newViews = new Map(state.mutationViews);
+      newViews.set(modelId, view);
+      return { mutationViews: newViews };
+    });
+  },
+
+  clearMutationView: (modelId) => {
+    set((state) => {
+      const newViews = new Map(state.mutationViews);
+      newViews.delete(modelId);
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.delete(modelId);
+      return { mutationViews: newViews, dirtyModels: newDirty };
+    });
+  },
+
+  // Property Mutations
+  setProperty: (modelId, entityId, psetName, propName, value, valueType = PropertyValueType.String) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.setProperty(entityId, psetName, propName, value, valueType);
+
+    set((state) => {
+      // Add to undo stack
+      const newUndoStacks = new Map(state.undoStacks);
+      const stack = newUndoStacks.get(modelId) || [];
+      newUndoStacks.set(modelId, [...stack, mutation]);
+
+      // Clear redo stack on new mutation
+      const newRedoStacks = new Map(state.redoStacks);
+      newRedoStacks.set(modelId, []);
+
+      // Mark model as dirty
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.add(modelId);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        dirtyModels: newDirty,
+        mutationVersion: state.mutationVersion + 1,
+      };
+    });
+
+    return mutation;
+  },
+
+  deleteProperty: (modelId, entityId, psetName, propName) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.deleteProperty(entityId, psetName, propName);
+    if (!mutation) return null;
+
+    set((state) => {
+      const newUndoStacks = new Map(state.undoStacks);
+      const stack = newUndoStacks.get(modelId) || [];
+      newUndoStacks.set(modelId, [...stack, mutation]);
+
+      const newRedoStacks = new Map(state.redoStacks);
+      newRedoStacks.set(modelId, []);
+
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.add(modelId);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        dirtyModels: newDirty,
+        mutationVersion: state.mutationVersion + 1,
+      };
+    });
+
+    return mutation;
+  },
+
+  createPropertySet: (modelId, entityId, psetName, properties) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.createPropertySet(entityId, psetName, properties);
+
+    set((state) => {
+      const newUndoStacks = new Map(state.undoStacks);
+      const stack = newUndoStacks.get(modelId) || [];
+      newUndoStacks.set(modelId, [...stack, mutation]);
+
+      const newRedoStacks = new Map(state.redoStacks);
+      newRedoStacks.set(modelId, []);
+
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.add(modelId);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        dirtyModels: newDirty,
+        mutationVersion: state.mutationVersion + 1,
+      };
+    });
+
+    return mutation;
+  },
+
+  deletePropertySet: (modelId, entityId, psetName) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.deletePropertySet(entityId, psetName);
+
+    set((state) => {
+      const newUndoStacks = new Map(state.undoStacks);
+      const stack = newUndoStacks.get(modelId) || [];
+      newUndoStacks.set(modelId, [...stack, mutation]);
+
+      const newRedoStacks = new Map(state.redoStacks);
+      newRedoStacks.set(modelId, []);
+
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.add(modelId);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        dirtyModels: newDirty,
+        mutationVersion: state.mutationVersion + 1,
+      };
+    });
+
+    return mutation;
+  },
+
+  // Undo/Redo
+  undo: (modelId) => {
+    const state = get();
+    const undoStack = state.undoStacks.get(modelId) || [];
+    if (undoStack.length === 0) return;
+
+    const mutation = undoStack[undoStack.length - 1];
+    const view = state.mutationViews.get(modelId);
+    if (!view) return;
+
+    // Apply inverse mutation (skipHistory=true to avoid polluting mutation history)
+    if (mutation.type === 'UPDATE_PROPERTY' || mutation.type === 'CREATE_PROPERTY') {
+      if (mutation.oldValue === null && mutation.psetName && mutation.propName) {
+        view.deleteProperty(mutation.entityId, mutation.psetName, mutation.propName, true);
+      } else if (mutation.psetName && mutation.propName && mutation.oldValue !== undefined) {
+        view.setProperty(
+          mutation.entityId,
+          mutation.psetName,
+          mutation.propName,
+          mutation.oldValue,
+          mutation.valueType,
+          undefined,
+          true // skipHistory
+        );
+      }
+    } else if (mutation.type === 'DELETE_PROPERTY') {
+      if (mutation.psetName && mutation.propName && mutation.oldValue !== undefined) {
+        view.setProperty(
+          mutation.entityId,
+          mutation.psetName,
+          mutation.propName,
+          mutation.oldValue,
+          mutation.valueType,
+          undefined,
+          true // skipHistory
+        );
+      }
+    }
+
+    set((s) => {
+      const newUndoStacks = new Map(s.undoStacks);
+      newUndoStacks.set(modelId, undoStack.slice(0, -1));
+
+      const newRedoStacks = new Map(s.redoStacks);
+      const redoStack = newRedoStacks.get(modelId) || [];
+      newRedoStacks.set(modelId, [...redoStack, mutation]);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        mutationVersion: s.mutationVersion + 1,
+      };
+    });
+  },
+
+  redo: (modelId) => {
+    const state = get();
+    const redoStack = state.redoStacks.get(modelId) || [];
+    if (redoStack.length === 0) return;
+
+    const mutation = redoStack[redoStack.length - 1];
+    const view = state.mutationViews.get(modelId);
+    if (!view) return;
+
+    // Re-apply mutation (skipHistory=true to avoid polluting mutation history)
+    if (mutation.type === 'UPDATE_PROPERTY' || mutation.type === 'CREATE_PROPERTY') {
+      if (mutation.psetName && mutation.propName && mutation.newValue !== undefined) {
+        view.setProperty(
+          mutation.entityId,
+          mutation.psetName,
+          mutation.propName,
+          mutation.newValue,
+          mutation.valueType,
+          undefined,
+          true // skipHistory
+        );
+      }
+    } else if (mutation.type === 'DELETE_PROPERTY') {
+      if (mutation.psetName && mutation.propName) {
+        view.deleteProperty(mutation.entityId, mutation.psetName, mutation.propName, true);
+      }
+    }
+
+    set((s) => {
+      const newRedoStacks = new Map(s.redoStacks);
+      newRedoStacks.set(modelId, redoStack.slice(0, -1));
+
+      const newUndoStacks = new Map(s.undoStacks);
+      const undoStack = newUndoStacks.get(modelId) || [];
+      newUndoStacks.set(modelId, [...undoStack, mutation]);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        mutationVersion: s.mutationVersion + 1,
+      };
+    });
+  },
+
+  canUndo: (modelId) => {
+    const stack = get().undoStacks.get(modelId);
+    return stack ? stack.length > 0 : false;
+  },
+
+  canRedo: (modelId) => {
+    const stack = get().redoStacks.get(modelId);
+    return stack ? stack.length > 0 : false;
+  },
+
+  // Change Sets
+  createChangeSet: (name) => {
+    const id = generateChangeSetId();
+    const changeSet: ChangeSet = {
+      id,
+      name,
+      createdAt: Date.now(),
+      mutations: [],
+      applied: false,
+    };
+
+    set((state) => {
+      const newChangeSets = new Map(state.changeSets);
+      newChangeSets.set(id, changeSet);
+      return { changeSets: newChangeSets, activeChangeSetId: id };
+    });
+
+    return id;
+  },
+
+  getActiveChangeSet: () => {
+    const state = get();
+    if (!state.activeChangeSetId) return null;
+    return state.changeSets.get(state.activeChangeSetId) || null;
+  },
+
+  setActiveChangeSet: (id) => {
+    set({ activeChangeSetId: id });
+  },
+
+  exportChangeSet: (id) => {
+    const changeSet = get().changeSets.get(id);
+    if (!changeSet) return null;
+
+    return JSON.stringify({
+      version: 1,
+      changeSet,
+      exportedAt: Date.now(),
+    }, null, 2);
+  },
+
+  importChangeSet: (json) => {
+    try {
+      const data = JSON.parse(json);
+      if (!data.changeSet) return;
+
+      const changeSet: ChangeSet = {
+        ...data.changeSet,
+        id: generateChangeSetId(),
+        applied: false,
+      };
+
+      set((state) => {
+        const newChangeSets = new Map(state.changeSets);
+        newChangeSets.set(changeSet.id, changeSet);
+        return { changeSets: newChangeSets };
+      });
+    } catch {
+      console.error('Failed to import change set');
+    }
+  },
+
+  // Query
+  hasChanges: (modelId) => {
+    return get().dirtyModels.has(modelId);
+  },
+
+  getMutationsForModel: (modelId) => {
+    const view = get().mutationViews.get(modelId);
+    return view ? view.getMutations() : [];
+  },
+
+  getModifiedEntityCount: () => {
+    let count = 0;
+    for (const view of get().mutationViews.values()) {
+      count += view.getModifiedEntityCount();
+    }
+    return count;
+  },
+
+  // Reset
+  clearMutations: (modelId) => {
+    const view = get().mutationViews.get(modelId);
+    if (view) {
+      view.clear();
+    }
+
+    set((state) => {
+      const newUndoStacks = new Map(state.undoStacks);
+      newUndoStacks.delete(modelId);
+
+      const newRedoStacks = new Map(state.redoStacks);
+      newRedoStacks.delete(modelId);
+
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.delete(modelId);
+
+      return {
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        dirtyModels: newDirty,
+        mutationVersion: state.mutationVersion + 1,
+      };
+    });
+  },
+
+  clearAllMutations: () => {
+    for (const view of get().mutationViews.values()) {
+      view.clear();
+    }
+
+    set((state) => ({
+      undoStacks: new Map(),
+      redoStacks: new Map(),
+      dirtyModels: new Set(),
+      mutationVersion: state.mutationVersion + 1,
+    }));
+  },
+
+  bumpMutationVersion: () => {
+    set((state) => ({
+      mutationVersion: state.mutationVersion + 1,
+    }));
+  },
+});