@ifc-lite/viewer 1.8.0 → 1.9.0

package/src/components/viewer/Viewport.tsx

@@ -783,6 +783,7 @@ export function Viewport({ geometry, coordinateInfo, computedIsolatedIds, modelI
     geometryBoundsRef,
     pendingColorUpdates,
     clearPendingColorUpdates,
+    clearColorRef,
   });
 
   useRenderUpdates({

package/src/components/viewer/useGeometryStreaming.ts

@@ -20,6 +20,8 @@ export interface UseGeometryStreamingParams {
   geometryBoundsRef: MutableRefObject<{ min: { x: number; y: number; z: number }; max: { x: number; y: number; z: number } }>;
   pendingColorUpdates: Map<number, [number, number, number, number]> | null;
   clearPendingColorUpdates: () => void;
+  // Clear color ref — color update renders must preserve theme background
+  clearColorRef: MutableRefObject<[number, number, number, number]>;
 }
 
 export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
@@ -32,6 +34,7 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     geometryBoundsRef,
     pendingColorUpdates,
     clearPendingColorUpdates,
+    clearColorRef,
   } = params;
 
   // Track processed meshes for incremental updates
@@ -397,7 +400,16 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
         // Non-empty map = set color overrides
         scene.setColorOverrides(pendingColorUpdates, device, pipeline);
       }
-      renderer.render();
+      // Re-render with current theme background — render() without options
+      // defaults to black background.  Do NOT pass hiddenIds/isolatedIds here:
+      // visibility filtering causes partial batches which write depth only for
+      // visible elements, but overlay batches cover all geometry.  Without
+      // filtering, all original batches write depth for every entity, ensuring
+      // depthCompare 'equal' matches exactly for the overlay pass.
+      // The next render from useRenderUpdates will apply the correct visibility.
+      renderer.render({
+        clearColor: clearColorRef.current,
+      });
       clearPendingColorUpdates();
     }
   }, [pendingColorUpdates, isInitialized, clearPendingColorUpdates]);

package/src/hooks/useKeyboardShortcuts.ts

@@ -279,5 +279,6 @@ export const KEYBOARD_SHORTCUTS = [
   { key: '1-6', description: 'Preset views', category: 'Camera' },
   { key: 'T', description: 'Toggle theme', category: 'UI' },
   { key: 'Esc', description: 'Reset all (clear selection, basket, isolation)', category: 'Selection' },
+  { key: 'Ctrl+K', description: 'Command palette', category: 'UI' },
   { key: '?', description: 'Show info panel', category: 'Help' },
 ] as const;

package/src/hooks/useLens.ts

@@ -24,6 +24,7 @@
 
 import { useEffect, useRef, useMemo } from 'react';
 import { evaluateLens, evaluateAutoColorLens, rgbaToHex, isGhostColor } from '@ifc-lite/lens';
+import type { AutoColorEvaluationResult } from '@ifc-lite/lens';
 import { useViewerStore } from '@/store';
 import { createLensDataProvider } from '@/lib/lens';
 import { useLensDiscovery } from './useLensDiscovery';
@@ -95,7 +96,7 @@ export function useLens() {
 
     // Store auto-color legend entries for UI display
     if (isAutoColor && 'legend' in result) {
-      useViewerStore.getState().setLensAutoColorLegend(result.legend);
+      useViewerStore.getState().setLensAutoColorLegend((result as AutoColorEvaluationResult).legend);
     } else {
       useViewerStore.getState().setLensAutoColorLegend([]);
     }

package/src/hooks/useSandbox.ts

@@ -0,0 +1,113 @@
+/* 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/. */
+
+/**
+ * useSandbox — React hook for executing scripts in a QuickJS sandbox.
+ *
+ * Creates a fresh sandbox context per execution for full isolation.
+ * The WASM module is cached across the session (cheap to reuse),
+ * but each script runs in a clean context with no leaked state.
+ */
+
+import { useCallback, useEffect, useRef } from 'react';
+import { useBim } from '../sdk/BimProvider.js';
+import { useViewerStore } from '../store/index.js';
+import type { Sandbox, ScriptResult, SandboxConfig } from '@ifc-lite/sandbox';
+
+/** Type guard for ScriptError shape (has logs + durationMs) */
+function isScriptError(err: unknown): err is { message: string; logs: Array<{ level: string; args: unknown[]; timestamp: number }>; durationMs: number } {
+  return (
+    err !== null &&
+    typeof err === 'object' &&
+    'logs' in err &&
+    Array.isArray((err as Record<string, unknown>).logs) &&
+    'durationMs' in err &&
+    typeof (err as Record<string, unknown>).durationMs === 'number'
+  );
+}
+
+/**
+ * Hook that provides a sandbox execution interface.
+ *
+ * Each execute() call creates a fresh QuickJS context for full isolation —
+ * scripts cannot leak global state between runs. The WASM module itself
+ * is cached (loaded once per app lifetime, ~1ms context creation overhead).
+ */
+export function useSandbox(config?: SandboxConfig) {
+  const bim = useBim();
+  const activeSandboxRef = useRef<Sandbox | null>(null);
+
+  const setExecutionState = useViewerStore((s) => s.setScriptExecutionState);
+  const setResult = useViewerStore((s) => s.setScriptResult);
+  const setError = useViewerStore((s) => s.setScriptError);
+
+  /** Execute a script in an isolated sandbox context */
+  const execute = useCallback(async (code: string): Promise<ScriptResult | null> => {
+    setExecutionState('running');
+    setError(null);
+
+    let sandbox: Sandbox | null = null;
+    try {
+      // Create a fresh sandbox for every execution — full isolation
+      const { createSandbox } = await import('@ifc-lite/sandbox');
+      sandbox = await createSandbox(bim, {
+        permissions: { model: true, query: true, viewer: true, mutate: true, lens: true, export: true, ...config?.permissions },
+        limits: { timeoutMs: 30_000, ...config?.limits },
+      });
+      activeSandboxRef.current = sandbox;
+
+      const result = await sandbox.eval(code);
+      setResult({
+        value: result.value,
+        logs: result.logs,
+        durationMs: result.durationMs,
+      });
+      return result;
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+
+      // If the error is a ScriptError with captured logs, preserve them
+      if (isScriptError(err)) {
+        setResult({
+          value: undefined,
+          logs: err.logs as ScriptResult['logs'],
+          durationMs: err.durationMs,
+        });
+      }
+      return null;
+    } finally {
+      // Always dispose the sandbox after execution
+      if (sandbox) {
+        sandbox.dispose();
+      }
+      if (activeSandboxRef.current === sandbox) {
+        activeSandboxRef.current = null;
+      }
+    }
+  }, [bim, config?.permissions, config?.limits, setExecutionState, setResult, setError]);
+
+  /** Reset clears any active sandbox (no-op if none running) */
+  const reset = useCallback(() => {
+    if (activeSandboxRef.current) {
+      activeSandboxRef.current.dispose();
+      activeSandboxRef.current = null;
+    }
+    setExecutionState('idle');
+    setResult(null);
+    setError(null);
+  }, [setExecutionState, setResult, setError]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (activeSandboxRef.current) {
+        activeSandboxRef.current.dispose();
+        activeSandboxRef.current = null;
+      }
+    };
+  }, []);
+
+  return { execute, reset };
+}

package/src/lib/recent-files.ts

@@ -0,0 +1,122 @@
+/* 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/. */
+
+/**
+ * Track recently opened model files via localStorage + IndexedDB.
+ *
+ * localStorage: metadata (name, size, timestamp) — for palette display.
+ * IndexedDB:    actual file blobs — so recent files can be loaded instantly
+ *               without the user re-selecting them from the file picker.
+ *
+ * Shared between MainToolbar (writes) and CommandPalette (reads).
+ */
+
+const KEY = 'ifc-lite:recent-files';
+const DB_NAME = 'ifc-lite-file-cache';
+const DB_VERSION = 1;
+const STORE_NAME = 'files';
+const MAX_CACHED_FILES = 5;
+/** Max file size to cache (150 MB) — avoids filling IndexedDB quota */
+const MAX_CACHE_SIZE = 150 * 1024 * 1024;
+
+export interface RecentFileEntry {
+  name: string;
+  size: number;
+  timestamp: number;
+}
+
+// ── localStorage (metadata) ─────────────────────────────────────────────
+
+export function getRecentFiles(): RecentFileEntry[] {
+  try { return JSON.parse(localStorage.getItem(KEY) ?? '[]'); }
+  catch { return []; }
+}
+
+export function recordRecentFiles(files: { name: string; size: number }[]) {
+  try {
+    const names = new Set(files.map(f => f.name));
+    const existing = getRecentFiles().filter(f => !names.has(f.name));
+    const entries: RecentFileEntry[] = files.map(f => ({
+      name: f.name,
+      size: f.size,
+      timestamp: Date.now(),
+    }));
+    localStorage.setItem(KEY, JSON.stringify([...entries, ...existing].slice(0, 10)));
+  } catch { /* noop */ }
+}
+
+/** Format bytes into human-readable size */
+export function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// ── IndexedDB (file blob cache) ─────────────────────────────────────────
+
+function openDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'name' });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+/** Cache file blobs in IndexedDB for instant reload from palette. */
+export async function cacheFileBlobs(files: File[]): Promise<void> {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    const store = tx.objectStore(STORE_NAME);
+
+    for (const file of files) {
+      if (file.size > MAX_CACHE_SIZE) continue; // skip oversized files
+      const blob = await file.arrayBuffer();
+      store.put({ name: file.name, blob, size: file.size, type: file.type, timestamp: Date.now() });
+    }
+
+    // Evict old entries beyond MAX_CACHED_FILES
+    const allReq = store.getAll();
+    allReq.onsuccess = () => {
+      const all = allReq.result as { name: string; timestamp: number }[];
+      if (all.length > MAX_CACHED_FILES) {
+        all.sort((a, b) => b.timestamp - a.timestamp);
+        for (let i = MAX_CACHED_FILES; i < all.length; i++) {
+          store.delete(all[i].name);
+        }
+      }
+    };
+
+    await new Promise<void>((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+    db.close();
+  } catch { /* IndexedDB unavailable — degrade gracefully */ }
+}
+
+/** Retrieve a cached file blob and reconstruct a File object. */
+export async function getCachedFile(name: string): Promise<File | null> {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, 'readonly');
+    const store = tx.objectStore(STORE_NAME);
+    const req = store.get(name);
+    const result = await new Promise<{ name: string; blob: ArrayBuffer; size: number; type: string } | undefined>((resolve, reject) => {
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+    db.close();
+    if (!result) return null;
+    return new File([result.blob], result.name, { type: result.type || 'application/octet-stream' });
+  } catch {
+    return null;
+  }
+}

package/src/lib/scripts/persistence.ts

@@ -0,0 +1,132 @@
+/* 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/. */
+
+/**
+ * Persistence for user scripts via localStorage.
+ *
+ * Uses a versioned schema so future additions (tags, description, etc.)
+ * can be migrated without data loss.
+ */
+
+/** Current schema version */
+const SCHEMA_VERSION = 1;
+
+export interface SavedScript {
+  id: string;
+  name: string;
+  code: string;
+  createdAt: number;
+  updatedAt: number;
+  version: number;
+}
+
+/** Stored wrapper with schema version for migration */
+interface StoredScripts {
+  schemaVersion: number;
+  scripts: SavedScript[];
+}
+
+const STORAGE_KEY = 'ifc-lite-scripts';
+
+/** Maximum scripts allowed (prevents storage exhaustion) */
+const MAX_SCRIPTS = 500;
+
+/** Maximum code size per script in characters (~100KB) */
+const MAX_SCRIPT_SIZE = 100_000;
+
+export function loadSavedScripts(): SavedScript[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+
+    const parsed: unknown = JSON.parse(raw);
+
+    // Handle legacy format (bare array without schema version)
+    if (Array.isArray(parsed)) {
+      return migrateFromLegacy(parsed);
+    }
+
+    // Versioned format — validate structure
+    if (
+      typeof parsed === 'object' &&
+      parsed !== null &&
+      'schemaVersion' in parsed &&
+      'scripts' in parsed &&
+      Array.isArray((parsed as StoredScripts).scripts)
+    ) {
+      return (parsed as StoredScripts).scripts;
+    }
+
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+/** Migrate from the original unversioned format — discards corrupted entries */
+function migrateFromLegacy(scripts: unknown[]): SavedScript[] {
+  const migrated: SavedScript[] = [];
+  for (const s of scripts) {
+    if (s === null || typeof s !== 'object') continue;
+    const script = s as Record<string, unknown>;
+
+    // Validate essential fields — discard garbage values from String()/Number() coercion
+    const id = typeof script.id === 'string' && script.id.length > 0 ? script.id : crypto.randomUUID();
+    const name = typeof script.name === 'string' && script.name.length > 0 ? script.name : 'Untitled';
+    const code = typeof script.code === 'string' ? script.code : '';
+    const createdAt = typeof script.createdAt === 'number' && isFinite(script.createdAt) ? script.createdAt : Date.now();
+    const updatedAt = typeof script.updatedAt === 'number' && isFinite(script.updatedAt) ? script.updatedAt : Date.now();
+
+    migrated.push({ id, name, code, createdAt, updatedAt, version: SCHEMA_VERSION });
+  }
+  // Save in new format
+  saveScripts(migrated);
+  return migrated;
+}
+
+export type SaveResult =
+  | { ok: true }
+  | { ok: false; reason: 'quota_exceeded' | 'serialization_error' | 'unknown'; message: string };
+
+export function saveScripts(scripts: SavedScript[]): SaveResult {
+  const stored: StoredScripts = {
+    schemaVersion: SCHEMA_VERSION,
+    scripts,
+  };
+
+  try {
+    const json = JSON.stringify(stored);
+    localStorage.setItem(STORAGE_KEY, json);
+    return { ok: true };
+  } catch (err: unknown) {
+    if (err instanceof DOMException && err.name === 'QuotaExceededError') {
+      console.warn('[Scripts] localStorage quota exceeded. Consider deleting unused scripts.');
+      return { ok: false, reason: 'quota_exceeded', message: 'Storage quota exceeded. Delete unused scripts to free space.' };
+    }
+    if (err instanceof TypeError) {
+      console.warn('[Scripts] Failed to serialize scripts:', err.message);
+      return { ok: false, reason: 'serialization_error', message: err.message };
+    }
+    console.warn('[Scripts] Failed to save scripts to localStorage');
+    return { ok: false, reason: 'unknown', message: String(err) };
+  }
+}
+
+/** Validate a script name — returns sanitized name or null if invalid */
+export function validateScriptName(name: string): string | null {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.length > 100) return trimmed.slice(0, 100);
+  return trimmed;
+}
+
+/** Check if adding another script is within limits */
+export function canCreateScript(currentCount: number): boolean {
+  return currentCount < MAX_SCRIPTS;
+}
+
+/** Check if script code is within size limits */
+export function isScriptWithinSizeLimit(code: string): boolean {
+  return code.length <= MAX_SCRIPT_SIZE;
+}

package/src/lib/scripts/templates/bim-globals.d.ts

@@ -0,0 +1,111 @@
+/* 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/. */
+
+/**
+ * AUTO-GENERATED — do not edit by hand.
+ * Run: npx tsx scripts/generate-bim-globals.ts
+ *
+ * Type declarations for the sandbox `bim` global.
+ * Generated from NAMESPACE_SCHEMAS in bridge-schema.ts.
+ */
+
+// ── Entity types ────────────────────────────────────────────────────────
+
+interface BimEntity {
+  ref: { modelId: string; expressId: number };
+  name: string; Name: string;
+  type: string; Type: string;
+  globalId: string; GlobalId: string;
+  description: string; Description: string;
+  objectType: string; ObjectType: string;
+}
+
+interface BimPropertySet {
+  name: string;
+  properties: Array<{ name: string; value: string | number | boolean | null }>;
+}
+
+interface BimQuantitySet {
+  name: string;
+  quantities: Array<{ name: string; value: number | null }>;
+}
+
+interface BimModelInfo {
+  id: string;
+  name: string;
+  schemaVersion: string;
+  entityCount: number;
+  fileSize: number;
+}
+
+// ── Namespace declarations ──────────────────────────────────────────────
+
+declare const bim: {
+  /** Model operations */
+  model: {
+    /** List loaded models */
+    list(): BimModelInfo[];
+    /** Get active model */
+    active(): BimModelInfo | null;
+    /** Get active model ID */
+    activeId(): string | null;
+  };
+  /** Query entities */
+  query: {
+    /** Get all entities */
+    all(): BimEntity[];
+    /** Filter by IFC type e.g. 'IfcWall' */
+    byType(...types: string[]): BimEntity[];
+    /** Get entity by model ID and express ID */
+    entity(modelId: string, expressId: number): BimEntity | null;
+    /** Get all IfcPropertySet data for an entity */
+    properties(entity: BimEntity): BimPropertySet[];
+    /** Get all IfcElementQuantity data for an entity */
+    quantities(entity: BimEntity): BimQuantitySet[];
+  };
+  /** Viewer control */
+  viewer: {
+    /** Colorize entities e.g. '#ff0000' */
+    colorize(entities: BimEntity[], color: string): void;
+    /** Batch colorize with [{entities, color}] */
+    colorizeAll(batches: Array<{ entities: BimEntity[]; color: string }>): void;
+    /** Hide entities */
+    hide(entities: BimEntity[]): void;
+    /** Show entities */
+    show(entities: BimEntity[]): void;
+    /** Isolate entities */
+    isolate(entities: BimEntity[]): void;
+    /** Select entities */
+    select(entities: BimEntity[]): void;
+    /** Fly camera to entities */
+    flyTo(entities: BimEntity[]): void;
+    /** Reset all colors */
+    resetColors(): void;
+    /** Reset all visibility */
+    resetVisibility(): void;
+  };
+  /** Property editing */
+  mutate: {
+    /** Set a property value */
+    setProperty(entity: unknown, psetName: string, propName: string, value: unknown): void;
+    /** Delete a property */
+    deleteProperty(entity: unknown, psetName: string, propName: string): void;
+    /** Undo last mutation */
+    undo(modelId: string): void;
+    /** Redo undone mutation */
+    redo(modelId: string): void;
+  };
+  /** Lens visualization */
+  lens: {
+    /** Get built-in lens presets */
+    presets(): unknown[];
+  };
+  /** Data export */
+  export: {
+    /** Export entities to CSV string */
+    csv(entities: BimEntity[], options: { columns: string[]; filename?: string; separator?: string }): string;
+    /** Export entities to JSON array */
+    json(entities: BimEntity[], columns: string[]): Record<string, unknown>[];
+  };
+};