@ifc-lite/viewer 1.8.0 → 1.10.0

package/src/sdk/local-backend.ts

@@ -0,0 +1,144 @@
+/* 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/. */
+
+/**
+ * LocalBackend — implements BimBackend via per-namespace adapters.
+ *
+ * This is the viewer's internal backend: zero serialization overhead.
+ * Each namespace is a typed property with named methods.
+ */
+
+import type {
+  BimBackend,
+  BimEventType,
+  ModelBackendMethods,
+  QueryBackendMethods,
+  SelectionBackendMethods,
+  VisibilityBackendMethods,
+  ViewerBackendMethods,
+  MutateBackendMethods,
+  SpatialBackendMethods,
+  ExportBackendMethods,
+  LensBackendMethods,
+} from '@ifc-lite/sdk';
+import type { StoreApi } from './adapters/types.js';
+import { LEGACY_MODEL_ID } from './adapters/model-compat.js';
+import { createModelAdapter } from './adapters/model-adapter.js';
+import { createQueryAdapter } from './adapters/query-adapter.js';
+import { createSelectionAdapter } from './adapters/selection-adapter.js';
+import { createVisibilityAdapter } from './adapters/visibility-adapter.js';
+import { createViewerAdapter } from './adapters/viewer-adapter.js';
+import { createMutateAdapter } from './adapters/mutate-adapter.js';
+import { createSpatialAdapter } from './adapters/spatial-adapter.js';
+import { createLensAdapter } from './adapters/lens-adapter.js';
+import { createExportAdapter } from './adapters/export-adapter.js';
+
+export class LocalBackend implements BimBackend {
+  readonly model: ModelBackendMethods;
+  readonly query: QueryBackendMethods;
+  readonly selection: SelectionBackendMethods;
+  readonly visibility: VisibilityBackendMethods;
+  readonly viewer: ViewerBackendMethods;
+  readonly mutate: MutateBackendMethods;
+  readonly spatial: SpatialBackendMethods;
+  readonly export: ExportBackendMethods;
+  readonly lens: LensBackendMethods;
+
+  private store: StoreApi;
+
+  constructor(store: StoreApi) {
+    this.store = store;
+    this.model = createModelAdapter(store);
+    this.query = createQueryAdapter(store);
+    this.selection = createSelectionAdapter(store);
+    this.visibility = createVisibilityAdapter(store);
+    this.viewer = createViewerAdapter(store);
+    this.mutate = createMutateAdapter(store);
+    this.spatial = createSpatialAdapter(store);
+    this.lens = createLensAdapter(store);
+    this.export = createExportAdapter(store);
+  }
+
+  subscribe(event: BimEventType, handler: (data: unknown) => void): () => void {
+    switch (event) {
+      case 'selection:changed':
+        return this.store.subscribe((state, prev) => {
+          if (state.selectedEntities !== prev.selectedEntities) {
+            handler({ refs: state.selectedEntities ?? [] });
+          }
+        });
+
+      case 'model:loaded':
+        return this.store.subscribe((state, prev) => {
+          if (state.models.size > prev.models.size) {
+            for (const [id, model] of state.models) {
+              if (!prev.models.has(id)) {
+                handler({
+                  model: {
+                    id: model.id,
+                    name: model.name,
+                    schemaVersion: model.schemaVersion,
+                    entityCount: model.ifcDataStore?.entities?.count ?? 0,
+                    fileSize: model.fileSize,
+                    loadedAt: model.loadedAt,
+                  },
+                });
+              }
+            }
+          }
+          if (state.ifcDataStore && !prev.ifcDataStore && state.models.size === 0) {
+            handler({
+              model: {
+                id: LEGACY_MODEL_ID,
+                name: 'Model',
+                schemaVersion: state.ifcDataStore.schemaVersion ?? 'IFC4',
+                entityCount: state.ifcDataStore.entities?.count ?? 0,
+                fileSize: state.ifcDataStore.source?.byteLength ?? 0,
+                loadedAt: 0,
+              },
+            });
+          }
+        });
+
+      case 'model:removed':
+        return this.store.subscribe((state, prev) => {
+          if (state.models.size < prev.models.size) {
+            for (const id of prev.models.keys()) {
+              if (!state.models.has(id)) {
+                handler({ modelId: id });
+              }
+            }
+          }
+        });
+
+      case 'visibility:changed':
+        return this.store.subscribe((state, prev) => {
+          if (
+            state.hiddenEntities !== prev.hiddenEntities ||
+            state.isolatedEntities !== prev.isolatedEntities ||
+            state.hiddenEntitiesByModel !== prev.hiddenEntitiesByModel
+          ) {
+            handler({});
+          }
+        });
+
+      case 'mutation:changed':
+        return this.store.subscribe((state, prev) => {
+          if (state.mutationVersion !== prev.mutationVersion) {
+            handler({});
+          }
+        });
+
+      case 'lens:changed':
+        return this.store.subscribe((state, prev) => {
+          if (state.activeLensId !== prev.activeLensId) {
+            handler({ lensId: state.activeLensId });
+          }
+        });
+
+      default:
+        return () => {};
+    }
+  }
+}

package/src/sdk/useBimHost.ts

@@ -0,0 +1,69 @@
+/* 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/. */
+
+/**
+ * useBimHost — React hook that initializes the SDK and BimHost.
+ *
+ * This hook:
+ * 1. Creates a LocalBackend backed by the Zustand store
+ * 2. Creates a BimContext (the `bim` object)
+ * 3. Starts a BimHost listening on BroadcastChannel 'ifc-lite'
+ * 4. External tools (ifc-scripts, ifc-flow) can connect to control the viewer
+ *
+ * Usage:
+ *   function App() {
+ *     const bim = useBimHost();
+ *     // bim is available for internal use
+ *     // External tools can connect via BroadcastChannel 'ifc-lite'
+ *   }
+ */
+
+import { useRef, useEffect, useMemo } from 'react';
+import { createBimContext, BimHost, type BimContext } from '@ifc-lite/sdk';
+import { useViewerStore } from '../store/index.js';
+import { LocalBackend } from './local-backend.js';
+
+const BROADCAST_CHANNEL = 'ifc-lite';
+
+/**
+ * Initialize the SDK with a local backend and start the BimHost.
+ * Returns the BimContext for internal use.
+ */
+export function useBimHost(): BimContext {
+  const hostRef = useRef<BimHost | null>(null);
+  const backendRef = useRef<LocalBackend | null>(null);
+
+  // Create local backend and BimContext once — single shared backend
+  const bim = useMemo(() => {
+    const storeApi = {
+      getState: useViewerStore.getState,
+      subscribe: useViewerStore.subscribe,
+    };
+    const backend = new LocalBackend(storeApi);
+    backendRef.current = backend;
+    return createBimContext({ backend });
+  }, []);
+
+  // Start BimHost for external connections — reuse the same backend
+  useEffect(() => {
+    const backend = backendRef.current;
+    if (!backend) return;
+    const host = new BimHost(backend);
+
+    try {
+      host.listenBroadcast(BROADCAST_CHANNEL);
+    } catch {
+      // BroadcastChannel not available (e.g., in some test environments)
+    }
+
+    hostRef.current = host;
+
+    return () => {
+      host.close();
+      hostRef.current = null;
+    };
+  }, []);
+
+  return bim;
+}

package/src/store/constants.ts

@@ -51,13 +51,41 @@ export const EDGE_LOCK_DEFAULTS = {
 // UI Defaults
 // ============================================================================
 
+/** Resolve the initial theme: localStorage override > system preference > dark fallback */
+function getInitialTheme(): 'light' | 'dark' {
+  if (typeof window === 'undefined') return 'dark';
+  const saved = localStorage.getItem('ifc-lite-theme');
+  if (saved === 'light' || saved === 'dark') return saved;
+  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+}
+
 export const UI_DEFAULTS = {
   /** Default active tool */
   ACTIVE_TOOL: 'select',
-  /** Default theme */
-  THEME: 'dark' as const,
+  /** Default theme – respects user's OS colour-scheme preference */
+  THEME: getInitialTheme(),
   /** Default hover tooltips state */
   HOVER_TOOLTIPS_ENABLED: false,
+  /** Global visual enhancement kill switch */
+  VISUAL_ENHANCEMENTS_ENABLED: true,
+  /** Edge contrast enhancement default */
+  EDGE_CONTRAST_ENABLED: true,
+  /** Edge contrast intensity */
+  EDGE_CONTRAST_INTENSITY: 1.2,
+  /** Contact shading quality preset */
+  CONTACT_SHADING_QUALITY: 'low' as const,
+  /** Contact shading intensity */
+  CONTACT_SHADING_INTENSITY: 0.35,
+  /** Contact shading radius in pixels */
+  CONTACT_SHADING_RADIUS: 1.5,
+  /** Separation-line overlay default */
+  SEPARATION_LINES_ENABLED: true,
+  /** Separation-line quality preset */
+  SEPARATION_LINES_QUALITY: 'low' as const,
+  /** Separation-line intensity */
+  SEPARATION_LINES_INTENSITY: 0.38,
+  /** Separation-line radius in pixels */
+  SEPARATION_LINES_RADIUS: 1.0,
 } as const;
 
 // ============================================================================

package/src/store/index.ts

@@ -30,6 +30,7 @@ import { createIdsSlice, type IDSSlice } from './slices/idsSlice.js';
 import { createListSlice, type ListSlice } from './slices/listSlice.js';
 import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.js';
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
+import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
 
 // Import constants for reset function
 import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_DEFAULTS } from './constants.js';
@@ -67,6 +68,9 @@ export type { PinboardSlice } from './slices/pinboardSlice.js';
 // Re-export Lens types
 export type { LensSlice, Lens, LensRule, LensCriteria } from './slices/lensSlice.js';
 
+// Re-export Script types
+export type { ScriptSlice } from './slices/scriptSlice.js';
+
 // Combined store type
 export type ViewerState = LoadingSlice &
   SelectionSlice &
@@ -85,7 +89,8 @@ export type ViewerState = LoadingSlice &
   IDSSlice &
   ListSlice &
   PinboardSlice &
-  LensSlice & {
+  LensSlice &
+  ScriptSlice & {
     resetViewerState: () => void;
   };
 
@@ -112,6 +117,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   ...createListSlice(...args),
   ...createPinboardSlice(...args),
   ...createLensSlice(...args),
+  ...createScriptSlice(...args),
 
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
@@ -178,6 +184,16 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
 
       // UI
       activeTool: UI_DEFAULTS.ACTIVE_TOOL,
+      visualEnhancementsEnabled: UI_DEFAULTS.VISUAL_ENHANCEMENTS_ENABLED,
+      edgeContrastEnabled: UI_DEFAULTS.EDGE_CONTRAST_ENABLED,
+      edgeContrastIntensity: UI_DEFAULTS.EDGE_CONTRAST_INTENSITY,
+      contactShadingQuality: UI_DEFAULTS.CONTACT_SHADING_QUALITY,
+      contactShadingIntensity: UI_DEFAULTS.CONTACT_SHADING_INTENSITY,
+      contactShadingRadius: UI_DEFAULTS.CONTACT_SHADING_RADIUS,
+      separationLinesEnabled: UI_DEFAULTS.SEPARATION_LINES_ENABLED,
+      separationLinesQuality: UI_DEFAULTS.SEPARATION_LINES_QUALITY,
+      separationLinesIntensity: UI_DEFAULTS.SEPARATION_LINES_INTENSITY,
+      separationLinesRadius: UI_DEFAULTS.SEPARATION_LINES_RADIUS,
 
       // Drawing 2D
       drawing2D: null,
@@ -251,6 +267,13 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       // Pinboard - clear pinned entities on new file
       pinboardEntities: new Set<string>(),
 
+      // Script - reset execution state but keep saved scripts and editor content
+      scriptPanelVisible: false,
+      scriptExecutionState: 'idle' as const,
+      scriptLastResult: null,
+      scriptLastError: null,
+      scriptDeleteConfirmId: null,
+
       // Lens - deactivate but keep saved lenses
       activeLensId: null,
       lensPanelVisible: false,

package/src/store/slices/pinboardSlice.ts

@@ -18,11 +18,11 @@ 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 {
-  isolatedEntities?: Set<number> | null;
-  hiddenEntities?: Set<number>;
-  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 {
@@ -62,29 +62,30 @@ export interface PinboardSlice {
 /** Convert basket EntityRefs to global IDs using model offsets */
 function basketToGlobalIds(
   basketEntities: Set<string>,
-  models?: Map<string, { idOffset: number }>,
+  models: Map<string, { idOffset: number }>,
 ): Set<number> {
   const globalIds = new Set<number>();
   for (const str of basketEntities) {
     const ref = stringToEntityRef(str);
-    if (models) {
-      const model = models.get(ref.modelId);
-      const offset = model?.idOffset ?? 0;
-      globalIds.add(ref.expressId + offset);
-    } else {
-      globalIds.add(ref.expressId);
-    }
+    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);
+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(),
 
@@ -95,12 +96,11 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
       for (const ref of refs) {
         next.add(entityRefToString(ref));
       }
-      const store = state as unknown as CombinedStoreAccess;
-      const isolatedEntities = basketToGlobalIds(next, store.models);
-      const hiddenEntities = new Set<number>(store.hiddenEntities ?? []);
+      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 = store.models?.get(ref.modelId);
+        const model = state.models.get(ref.modelId);
         const offset = model?.idOffset ?? 0;
         hiddenEntities.delete(ref.expressId + offset);
       }
@@ -117,8 +117,7 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
       if (next.size === 0) {
         return { pinboardEntities: next, isolatedEntities: null };
       }
-      const store = state as unknown as CombinedStoreAccess;
-      const isolatedEntities = basketToGlobalIds(next, store.models);
+      const isolatedEntities = basketToGlobalIds(next, state.models);
       return { pinboardEntities: next, isolatedEntities };
     });
   },
@@ -132,15 +131,15 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
       set({ pinboardEntities: next, isolatedEntities: null });
       return;
     }
-    const store = get() as unknown as CombinedStoreAccess;
-    const hiddenEntities = new Set<number>(store.hiddenEntities ?? []);
+    const s = get();
+    const hiddenEntities = new Set<number>(s.hiddenEntities);
     // Unhide basket entities
     for (const ref of refs) {
-      const model = store.models?.get(ref.modelId);
+      const model = s.models.get(ref.modelId);
       const offset = model?.idOffset ?? 0;
       hiddenEntities.delete(ref.expressId + offset);
     }
-    const isolatedEntities = basketToGlobalIds(next, store.models);
+    const isolatedEntities = basketToGlobalIds(next, s.models);
     set({ pinboardEntities: next, isolatedEntities, hiddenEntities });
   },
 
@@ -149,8 +148,7 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
   showPinboard: () => {
     const state = get();
     if (state.pinboardEntities.size === 0) return;
-    const store = state as unknown as CombinedStoreAccess;
-    const isolatedEntities = basketToGlobalIds(state.pinboardEntities, store.models);
+    const isolatedEntities = basketToGlobalIds(state.pinboardEntities, state.models);
     set({ isolatedEntities });
   },
 
@@ -181,15 +179,15 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
     for (const ref of refs) {
       next.add(entityRefToString(ref));
     }
-    const store = get() as unknown as CombinedStoreAccess;
-    const hiddenEntities = new Set<number>(store.hiddenEntities ?? []);
+    const s = get();
+    const hiddenEntities = new Set<number>(s.hiddenEntities);
     // Unhide basket entities
     for (const ref of refs) {
-      const model = store.models?.get(ref.modelId);
+      const model = s.models.get(ref.modelId);
       const offset = model?.idOffset ?? 0;
       hiddenEntities.delete(ref.expressId + offset);
     }
-    const isolatedEntities = basketToGlobalIds(next, store.models);
+    const isolatedEntities = basketToGlobalIds(next, s.models);
     set({ pinboardEntities: next, isolatedEntities, hiddenEntities });
   },
 
@@ -201,13 +199,12 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
       for (const ref of refs) {
         next.add(entityRefToString(ref));
       }
-      const store = state as unknown as CombinedStoreAccess;
-      const hiddenEntities = new Set<number>(store.hiddenEntities ?? []);
+      const hiddenEntities = new Set<number>(state.hiddenEntities);
       // Incrementally add new globalIds to existing isolation set instead of re-parsing all
-      const prevIsolated = store.isolatedEntities;
-      const isolatedEntities = prevIsolated ? new Set<number>(prevIsolated) : basketToGlobalIds(state.pinboardEntities, store.models);
+      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, store.models);
+        const gid = refToGlobalId(ref, state.models);
         isolatedEntities.add(gid);
         hiddenEntities.delete(gid);
       }
@@ -226,18 +223,17 @@ export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSl
       if (next.size === 0) {
         return { pinboardEntities: next, isolatedEntities: null };
       }
-      const store = state as unknown as CombinedStoreAccess;
       // Incrementally remove globalIds from existing isolation set instead of re-parsing all
-      const prevIsolated = store.isolatedEntities;
+      const prevIsolated = state.isolatedEntities;
       if (prevIsolated) {
         const isolatedEntities = new Set<number>(prevIsolated);
         for (const ref of refs) {
-          isolatedEntities.delete(refToGlobalId(ref, store.models));
+          isolatedEntities.delete(refToGlobalId(ref, state.models));
         }
         return { pinboardEntities: next, isolatedEntities };
       }
       // Fallback: full recompute if no existing isolation set
-      const isolatedEntities = basketToGlobalIds(next, store.models);
+      const isolatedEntities = basketToGlobalIds(next, state.models);
       return { pinboardEntities: next, isolatedEntities };
     });
   },