@ifc-lite/viewer 1.7.0 → 1.9.0

package/src/store/slices/pinboardSlice.ts

@@ -3,20 +3,26 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 /**
- * Pinboard state slice
+ * Pinboard (Basket) state slice
  *
- * Persistent selection basket for tracking components across sessions.
- * Users can pin entities, then isolate/show the pinned set.
+ * The basket is an incremental isolation set. Users build it with:
+ *   = (set)    — replace basket with current selection
+ *   + (add)    — add current selection to basket
+ *   − (remove) — remove current selection from basket
+ *
+ * When the basket is non-empty, only basket entities are visible (isolation).
+ * The basket also syncs to isolatedEntities for renderer consumption.
  */
 
 import type { StateCreator } from 'zustand';
 import type { EntityRef } from '../types.js';
 import { entityRefToString, stringToEntityRef } from '../types.js';
 
-/** Minimal interface for accessing isolation + models from the combined store */
-interface CombinedStoreAccess {
-  isolateEntities?: (ids: number[]) => void;
-  models?: Map<string, { idOffset: number }>;
+/** Cross-slice state that pinboard reads/writes via the combined store */
+interface PinboardCrossSliceState {
+  isolatedEntities: Set<number> | null;
+  hiddenEntities: Set<number>;
+  models: Map<string, { idOffset: number }>;
 }
 
 export interface PinboardSlice {
@@ -25,46 +31,94 @@ export interface PinboardSlice {
   pinboardEntities: Set<string>;
 
   // Actions
-  /** Add entities to pinboard */
+  /** Add entities to pinboard/basket */
   addToPinboard: (refs: EntityRef[]) => void;
-  /** Remove entities from pinboard */
+  /** Remove entities from pinboard/basket */
   removeFromPinboard: (refs: EntityRef[]) => void;
-  /** Replace pinboard contents */
+  /** Replace pinboard/basket contents (= operation) */
   setPinboard: (refs: EntityRef[]) => void;
-  /** Clear pinboard */
+  /** Clear pinboard/basket and isolation */
   clearPinboard: () => void;
-  /** Isolate pinboard entities (show only pinned) */
+  /** Isolate pinboard entities (sync basket → isolatedEntities) */
   showPinboard: () => void;
-  /** Check if entity is pinned */
+  /** Check if entity is in basket */
   isInPinboard: (ref: EntityRef) => boolean;
-  /** Get pinboard count */
+  /** Get basket count */
   getPinboardCount: () => number;
-  /** Get all pinboard entities as EntityRef array */
+  /** Get all basket entities as EntityRef array */
   getPinboardEntities: () => EntityRef[];
+
+  // Basket actions (semantic aliases that also sync isolation)
+  /** = Set basket to exactly these entities and isolate them */
+  setBasket: (refs: EntityRef[]) => void;
+  /** + Add entities to basket and update isolation */
+  addToBasket: (refs: EntityRef[]) => void;
+  /** − Remove entities from basket and update isolation */
+  removeFromBasket: (refs: EntityRef[]) => void;
+  /** Clear basket and clear isolation */
+  clearBasket: () => void;
+}
+
+/** Convert basket EntityRefs to global IDs using model offsets */
+function basketToGlobalIds(
+  basketEntities: Set<string>,
+  models: Map<string, { idOffset: number }>,
+): Set<number> {
+  const globalIds = new Set<number>();
+  for (const str of basketEntities) {
+    const ref = stringToEntityRef(str);
+    const model = models.get(ref.modelId);
+    const offset = model?.idOffset ?? 0;
+    globalIds.add(ref.expressId + offset);
+  }
+  return globalIds;
+}
+
+/** Compute a single EntityRef's global ID */
+function refToGlobalId(ref: EntityRef, models: Map<string, { idOffset: number }>): number {
+  const model = models.get(ref.modelId);
+  return ref.expressId + (model?.idOffset ?? 0);
 }
 
-export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSlice> = (set, get) => ({
+export const createPinboardSlice: StateCreator<
+  PinboardSlice & PinboardCrossSliceState,
+  [],
+  [],
+  PinboardSlice
+> = (set, get) => ({
   // Initial state
   pinboardEntities: new Set(),
 
-  // Actions
+  // Legacy actions (kept for backward compat, but now they also sync isolation)
   addToPinboard: (refs) => {
     set((state) => {
-      const next = new Set(state.pinboardEntities);
+      const next = new Set<string>(state.pinboardEntities);
       for (const ref of refs) {
         next.add(entityRefToString(ref));
       }
-      return { pinboardEntities: next };
+      const isolatedEntities = basketToGlobalIds(next, state.models);
+      const hiddenEntities = new Set<number>(state.hiddenEntities);
+      // Unhide any entities being added to basket
+      for (const ref of refs) {
+        const model = state.models.get(ref.modelId);
+        const offset = model?.idOffset ?? 0;
+        hiddenEntities.delete(ref.expressId + offset);
+      }
+      return { pinboardEntities: next, isolatedEntities, hiddenEntities };
     });
   },
 
   removeFromPinboard: (refs) => {
     set((state) => {
-      const next = new Set(state.pinboardEntities);
+      const next = new Set<string>(state.pinboardEntities);
       for (const ref of refs) {
         next.delete(entityRefToString(ref));
       }
-      return { pinboardEntities: next };
+      if (next.size === 0) {
+        return { pinboardEntities: next, isolatedEntities: null };
+      }
+      const isolatedEntities = basketToGlobalIds(next, state.models);
+      return { pinboardEntities: next, isolatedEntities };
     });
   },
 
@@ -73,31 +127,29 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
     for (const ref of refs) {
       next.add(entityRefToString(ref));
     }
-    set({ pinboardEntities: next });
+    if (next.size === 0) {
+      set({ pinboardEntities: next, isolatedEntities: null });
+      return;
+    }
+    const s = get();
+    const hiddenEntities = new Set<number>(s.hiddenEntities);
+    // Unhide basket entities
+    for (const ref of refs) {
+      const model = s.models.get(ref.modelId);
+      const offset = model?.idOffset ?? 0;
+      hiddenEntities.delete(ref.expressId + offset);
+    }
+    const isolatedEntities = basketToGlobalIds(next, s.models);
+    set({ pinboardEntities: next, isolatedEntities, hiddenEntities });
   },
 
-  clearPinboard: () => set({ pinboardEntities: new Set() }),
+  clearPinboard: () => set({ pinboardEntities: new Set(), isolatedEntities: null }),
 
   showPinboard: () => {
-    const entities = get().getPinboardEntities();
-    if (entities.length === 0) return;
-
-    // Access combined store methods via typed interface
-    const store = get() as unknown as CombinedStoreAccess;
-    if (!store.isolateEntities) return;
-
-    // Convert EntityRef to global IDs for isolation
-    const globalIds: number[] = [];
-    for (const ref of entities) {
-      if (store.models) {
-        const model = store.models.get(ref.modelId);
-        const offset = model?.idOffset ?? 0;
-        globalIds.push(ref.expressId + offset);
-      } else {
-        globalIds.push(ref.expressId);
-      }
-    }
-    store.isolateEntities(globalIds);
+    const state = get();
+    if (state.pinboardEntities.size === 0) return;
+    const isolatedEntities = basketToGlobalIds(state.pinboardEntities, state.models);
+    set({ isolatedEntities });
   },
 
   isInPinboard: (ref) => get().pinboardEntities.has(entityRefToString(ref)),
@@ -111,4 +163,81 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
     }
     return result;
   },
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Basket actions (= + −)
+  // These are the primary API for the new basket-based isolation UX.
+  // ──────────────────────────────────────────────────────────────────────────
+
+  /** = Set basket to exactly these entities and isolate them */
+  setBasket: (refs) => {
+    if (refs.length === 0) {
+      set({ pinboardEntities: new Set(), isolatedEntities: null });
+      return;
+    }
+    const next = new Set<string>();
+    for (const ref of refs) {
+      next.add(entityRefToString(ref));
+    }
+    const s = get();
+    const hiddenEntities = new Set<number>(s.hiddenEntities);
+    // Unhide basket entities
+    for (const ref of refs) {
+      const model = s.models.get(ref.modelId);
+      const offset = model?.idOffset ?? 0;
+      hiddenEntities.delete(ref.expressId + offset);
+    }
+    const isolatedEntities = basketToGlobalIds(next, s.models);
+    set({ pinboardEntities: next, isolatedEntities, hiddenEntities });
+  },
+
+  /** + Add entities to basket and update isolation (incremental — avoids re-parsing all strings) */
+  addToBasket: (refs) => {
+    if (refs.length === 0) return;
+    set((state) => {
+      const next = new Set<string>(state.pinboardEntities);
+      for (const ref of refs) {
+        next.add(entityRefToString(ref));
+      }
+      const hiddenEntities = new Set<number>(state.hiddenEntities);
+      // Incrementally add new globalIds to existing isolation set instead of re-parsing all
+      const prevIsolated = state.isolatedEntities;
+      const isolatedEntities = prevIsolated ? new Set<number>(prevIsolated) : basketToGlobalIds(state.pinboardEntities, state.models);
+      for (const ref of refs) {
+        const gid = refToGlobalId(ref, state.models);
+        isolatedEntities.add(gid);
+        hiddenEntities.delete(gid);
+      }
+      return { pinboardEntities: next, isolatedEntities, hiddenEntities };
+    });
+  },
+
+  /** − Remove entities from basket and update isolation (incremental — avoids re-parsing all strings) */
+  removeFromBasket: (refs) => {
+    if (refs.length === 0) return;
+    set((state) => {
+      const next = new Set<string>(state.pinboardEntities);
+      for (const ref of refs) {
+        next.delete(entityRefToString(ref));
+      }
+      if (next.size === 0) {
+        return { pinboardEntities: next, isolatedEntities: null };
+      }
+      // Incrementally remove globalIds from existing isolation set instead of re-parsing all
+      const prevIsolated = state.isolatedEntities;
+      if (prevIsolated) {
+        const isolatedEntities = new Set<number>(prevIsolated);
+        for (const ref of refs) {
+          isolatedEntities.delete(refToGlobalId(ref, state.models));
+        }
+        return { pinboardEntities: next, isolatedEntities };
+      }
+      // Fallback: full recompute if no existing isolation set
+      const isolatedEntities = basketToGlobalIds(next, state.models);
+      return { pinboardEntities: next, isolatedEntities };
+    });
+  },
+
+  /** Clear basket and clear isolation */
+  clearBasket: () => set({ pinboardEntities: new Set(), isolatedEntities: null }),
 });

package/src/store/slices/scriptSlice.ts

@@ -0,0 +1,218 @@
+/* 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/. */
+
+/**
+ * Script state slice — manages script editor state, saved scripts,
+ * and execution results.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { SavedScript } from '../../lib/scripts/persistence.js';
+import { loadSavedScripts, saveScripts, validateScriptName, canCreateScript, isScriptWithinSizeLimit } from '../../lib/scripts/persistence.js';
+
+export type ScriptExecutionState = 'idle' | 'running' | 'error' | 'success';
+
+export interface LogEntry {
+  level: 'log' | 'warn' | 'error' | 'info';
+  args: unknown[];
+  timestamp: number;
+}
+
+export interface ScriptResult {
+  value: unknown;
+  logs: LogEntry[];
+  durationMs: number;
+}
+
+export interface ScriptSlice {
+  // State
+  savedScripts: SavedScript[];
+  activeScriptId: string | null;
+  scriptEditorContent: string;
+  scriptEditorDirty: boolean;
+  scriptExecutionState: ScriptExecutionState;
+  scriptLastResult: ScriptResult | null;
+  scriptLastError: string | null;
+  scriptPanelVisible: boolean;
+  scriptDeleteConfirmId: string | null;
+
+  // Actions
+  createScript: (name: string, code?: string) => string;
+  saveActiveScript: () => void;
+  deleteScript: (id: string) => void;
+  renameScript: (id: string, name: string) => void;
+  setActiveScriptId: (id: string | null) => void;
+  setScriptEditorContent: (content: string) => void;
+  setScriptExecutionState: (state: ScriptExecutionState) => void;
+  setScriptResult: (result: ScriptResult | null) => void;
+  setScriptError: (error: string | null) => void;
+  setScriptPanelVisible: (visible: boolean) => void;
+  toggleScriptPanel: () => void;
+  setScriptDeleteConfirmId: (id: string | null) => void;
+}
+
+const DEFAULT_CODE = `// Write your BIM script here
+// The 'bim' object provides access to the SDK
+const models = bim.model.list()
+console.log('Loaded models:', models.length)
+
+// Query all entities
+const all = bim.query.all()
+console.log('Total entities:', all.length)
+
+// Count by type
+const counts = {}
+for (const e of all) {
+  counts[e.type] = (counts[e.type] || 0) + 1
+}
+for (const [type, count] of Object.entries(counts).sort((a, b) => b[1] - a[1])) {
+  console.log('  ' + type + ': ' + count)
+}
+`;
+
+export const createScriptSlice: StateCreator<ScriptSlice, [], [], ScriptSlice> = (set, get) => ({
+  // Initial state
+  savedScripts: loadSavedScripts(),
+  activeScriptId: null,
+  scriptEditorContent: DEFAULT_CODE,
+  scriptEditorDirty: false,
+  scriptExecutionState: 'idle',
+  scriptLastResult: null,
+  scriptLastError: null,
+  scriptPanelVisible: false,
+  scriptDeleteConfirmId: null,
+
+  // Actions
+  createScript: (name, code) => {
+    const { savedScripts } = get();
+    if (!canCreateScript(savedScripts.length)) {
+      console.warn('[Scripts] Maximum script limit reached');
+      return '';
+    }
+
+    const validName = validateScriptName(name) ?? 'Untitled Script';
+    const scriptCode = code ?? DEFAULT_CODE;
+    if (!isScriptWithinSizeLimit(scriptCode)) {
+      console.warn('[Scripts] Script code exceeds maximum size limit');
+      return '';
+    }
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const script: SavedScript = {
+      id,
+      name: validName,
+      code: scriptCode,
+      createdAt: now,
+      updatedAt: now,
+      version: 1,
+    };
+    const updated = [...savedScripts, script];
+    set({
+      savedScripts: updated,
+      activeScriptId: id,
+      scriptEditorContent: script.code,
+      scriptEditorDirty: false,
+    });
+    const result = saveScripts(updated);
+    if (!result.ok) {
+      console.warn('[Scripts] Save failed:', result.message);
+    }
+    return id;
+  },
+
+  saveActiveScript: () => {
+    const { activeScriptId, scriptEditorContent, savedScripts } = get();
+    if (!activeScriptId) return;
+    const updated = savedScripts.map((s) =>
+      s.id === activeScriptId
+        ? { ...s, code: scriptEditorContent, updatedAt: Date.now() }
+        : s,
+    );
+    set({ savedScripts: updated, scriptEditorDirty: false });
+    const result = saveScripts(updated);
+    if (!result.ok) {
+      console.warn('[Scripts] Save failed:', result.message);
+    }
+  },
+
+  deleteScript: (id) => {
+    const updated = get().savedScripts.filter((s) => s.id !== id);
+    const activeScriptId = get().activeScriptId === id ? null : get().activeScriptId;
+    const scriptEditorContent = activeScriptId === null ? DEFAULT_CODE : get().scriptEditorContent;
+    set({
+      savedScripts: updated,
+      activeScriptId,
+      scriptEditorContent,
+      scriptEditorDirty: false,
+      scriptDeleteConfirmId: null,
+    });
+    saveScripts(updated);
+  },
+
+  renameScript: (id, name) => {
+    const validName = validateScriptName(name);
+    if (!validName) return;
+    const updated = get().savedScripts.map((s) =>
+      s.id === id ? { ...s, name: validName, updatedAt: Date.now() } : s,
+    );
+    set({ savedScripts: updated });
+    saveScripts(updated);
+  },
+
+  setActiveScriptId: (activeScriptId) => {
+    // Save current before switching
+    const { activeScriptId: current, scriptEditorDirty } = get();
+    if (current && scriptEditorDirty) {
+      get().saveActiveScript();
+    }
+
+    if (activeScriptId) {
+      const script = get().savedScripts.find((s) => s.id === activeScriptId);
+      if (script) {
+        set({
+          activeScriptId,
+          scriptEditorContent: script.code,
+          scriptEditorDirty: false,
+          scriptLastResult: null,
+          scriptLastError: null,
+          scriptExecutionState: 'idle',
+        });
+        return;
+      }
+    }
+    set({
+      activeScriptId: null,
+      scriptEditorContent: DEFAULT_CODE,
+      scriptEditorDirty: false,
+      scriptLastResult: null,
+      scriptLastError: null,
+      scriptExecutionState: 'idle',
+    });
+  },
+
+  setScriptEditorContent: (scriptEditorContent) => {
+    set({ scriptEditorContent, scriptEditorDirty: true });
+  },
+
+  setScriptExecutionState: (scriptExecutionState) => set({ scriptExecutionState }),
+
+  setScriptResult: (scriptLastResult) =>
+    set({ scriptLastResult, scriptLastError: null, scriptExecutionState: 'success' }),
+
+  // Error and execution state are set independently — clearing an error
+  // does NOT change execution state unless explicitly transitioned
+  setScriptError: (scriptLastError) => {
+    if (scriptLastError) {
+      set({ scriptLastError, scriptExecutionState: 'error' });
+    } else {
+      set({ scriptLastError: null });
+    }
+  },
+
+  setScriptPanelVisible: (scriptPanelVisible) => set({ scriptPanelVisible }),
+
+  toggleScriptPanel: () => set((state) => ({ scriptPanelVisible: !state.scriptPanelVisible })),
+
+  setScriptDeleteConfirmId: (scriptDeleteConfirmId) => set({ scriptDeleteConfirmId }),
+});

package/src/store/slices/uiSlice.ts

@@ -44,12 +44,14 @@ export const createUISlice: StateCreator<UISlice, [], [], UISlice> = (set, get)
 
   setTheme: (theme) => {
     document.documentElement.classList.toggle('dark', theme === 'dark');
+    localStorage.setItem('ifc-lite-theme', theme);
     set({ theme });
   },
 
   toggleTheme: () => {
     const newTheme = get().theme === 'dark' ? 'light' : 'dark';
     document.documentElement.classList.toggle('dark', newTheme === 'dark');
+    localStorage.setItem('ifc-lite-theme', newTheme);
     set({ theme: newTheme });
   },
 

package/src/store.ts

@@ -45,3 +45,6 @@ export type {
 
 // Re-export utility functions for multi-model federation
 export { entityRefToString, stringToEntityRef, entityRefEquals, isIfcxDataStore } from './store/types.js';
+
+// Re-export single source of truth for globalId → EntityRef resolution
+export { resolveEntityRef } from './store/resolveEntityRef.js';

package/tsconfig.json

@@ -13,8 +13,11 @@
       "@ifc-lite/spatial": ["../../packages/spatial/src"],
       "@ifc-lite/data": ["../../packages/data/src"],
       "@ifc-lite/export": ["../../packages/export/src"],
-      "@ifc-lite/cache": ["../../packages/cache/src"]
+      "@ifc-lite/cache": ["../../packages/cache/src"],
+      "@ifc-lite/sdk": ["../../packages/sdk/src"],
+      "@ifc-lite/lens": ["../../packages/lens/src"]
     }
   },
-  "include": ["src/**/*", "../../packages/renderer/src/webgpu-types.d.ts"]
+  "include": ["src/**/*", "../../packages/renderer/src/webgpu-types.d.ts"],
+  "exclude": ["src/lib/scripts/templates"]
 }

package/vite.config.ts

@@ -182,6 +182,14 @@ export default defineConfig({
       '@ifc-lite/cache': path.resolve(__dirname, '../../packages/cache/src'),
       '@ifc-lite/ifcx': path.resolve(__dirname, '../../packages/ifcx/src'),
       '@ifc-lite/wasm': path.resolve(__dirname, '../../packages/wasm/pkg/ifc-lite.js'),
+      '@ifc-lite/sdk': path.resolve(__dirname, '../../packages/sdk/src'),
+      '@ifc-lite/lens': path.resolve(__dirname, '../../packages/lens/src'),
+      '@ifc-lite/mutations': path.resolve(__dirname, '../../packages/mutations/src'),
+      '@ifc-lite/bcf': path.resolve(__dirname, '../../packages/bcf/src'),
+      '@ifc-lite/drawing-2d': path.resolve(__dirname, '../../packages/drawing-2d/src'),
+      '@ifc-lite/encoding': path.resolve(__dirname, '../../packages/encoding/src'),
+      '@ifc-lite/ids': path.resolve(__dirname, '../../packages/ids/src'),
+      '@ifc-lite/lists': path.resolve(__dirname, '../../packages/lists/src'),
     },
   },
   server: {