@ifc-lite/viewer 1.11.5 → 1.14.0

package/src/services/bsdd.ts

@@ -0,0 +1,262 @@
+/* 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/. */
+
+/**
+ * bSDD (buildingSMART Data Dictionary) API client.
+ *
+ * Fetches IFC class definitions, property sets, and properties from the
+ * bSDD REST API so that users can discover schema-conform properties
+ * for a selected IFC entity type and add them in one click.
+ *
+ * API docs: https://app.swaggerhub.com/apis/buildingSMART/Dictionaries/v1
+ */
+
+// Proxy through our own origin to avoid CORS issues.
+// In dev Vite proxies /api/bsdd → https://api.bsdd.buildingsmart.org,
+// in production Vercel rewrites do the same.
+const BSDD_API = '/api/bsdd';
+const IFC_DICTIONARY_URI =
+  'https://identifier.buildingsmart.org/uri/buildingsmart/ifc/4.3';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface BsddClassProperty {
+  /** Property name, e.g. "IsExternal" */
+  name: string;
+  /** URI of the property definition */
+  uri: string;
+  /** Human-readable description */
+  description: string | null;
+  /** bSDD data type, e.g. "Boolean", "Real", "String" */
+  dataType: string | null;
+  /** Name of the property set this property belongs to */
+  propertySet: string | null;
+  /** Allowed values (enum constraints) */
+  allowedValues: Array<{ uri?: string; value: string; description?: string }> | null;
+  /** Units */
+  units: string[] | null;
+  /** Whether this is from the IFC standard dictionary */
+  isIfcStandard: boolean;
+}
+
+export interface BsddClassInfo {
+  /** Class URI */
+  uri: string;
+  /** IFC entity code, e.g. "IfcWall" */
+  code: string;
+  /** Human-readable name */
+  name: string;
+  /** Description / definition */
+  definition: string | null;
+  /** Parent class URI */
+  parentClassUri: string | null;
+  /** Properties defined for this class */
+  classProperties: BsddClassProperty[];
+  /** Related IFC entity names */
+  relatedIfcEntityNames: string[] | null;
+}
+
+export interface BsddSearchResult {
+  uri: string;
+  code: string;
+  name: string;
+  definition: string | null;
+  dictionaryUri: string;
+}
+
+// ---------------------------------------------------------------------------
+// In-memory cache (keyed by class URI)
+// ---------------------------------------------------------------------------
+
+const classCache = new Map<string, { data: BsddClassInfo; ts: number }>();
+const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+function getCached(key: string): BsddClassInfo | null {
+  const entry = classCache.get(key);
+  if (entry && Date.now() - entry.ts < CACHE_TTL_MS) return entry.data;
+  if (entry) classCache.delete(key);
+  return null;
+}
+
+function setCache(key: string, data: BsddClassInfo) {
+  classCache.set(key, { data, ts: Date.now() });
+}
+
+// ---------------------------------------------------------------------------
+// API helpers
+// ---------------------------------------------------------------------------
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const res = await fetch(url, {
+    headers: { Accept: 'application/json' },
+  });
+  if (!res.ok) {
+    throw new Error(`bSDD API ${res.status}: ${res.statusText}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the bSDD class URI for an IFC entity type.
+ * e.g. "IfcWall" -> "https://identifier.buildingsmart.org/uri/buildingsmart/ifc/4.3/class/IfcWall"
+ */
+export function ifcClassUri(ifcType: string): string {
+  // Use the type name as-is.  IFC parsers typically produce PascalCase
+  // names (e.g. "IfcWall") which match the bSDD URI scheme directly.
+  // Previous best-effort lowercasing corrupted multi-word names like
+  // IFCWALLSTANDARDCASE → "IfcWallstandardcase", so we no longer attempt
+  // case normalisation — the bSDD API will simply 404 for unknown names
+  // and we handle that gracefully.
+  return `${IFC_DICTIONARY_URI}/class/${ifcType}`;
+}
+
+/**
+ * Fetch full class info (including properties) for an IFC entity type.
+ *
+ * Uses the `/api/Class/v1` endpoint with `IncludeClassProperties=true`
+ * (PascalCase parameter names per the bSDD OpenAPI spec).
+ * Falls back to the paginated `/api/Class/Properties/v1` endpoint when
+ * the inline property list comes back empty.
+ */
+export async function fetchClassInfo(
+  ifcType: string,
+): Promise<BsddClassInfo | null> {
+  const uri = ifcClassUri(ifcType);
+  const cached = getCached(uri);
+  if (cached) return cached;
+
+  try {
+    // Parameter names must be PascalCase per the bSDD OpenAPI spec
+    const raw = await fetchJson<Record<string, unknown>>(
+      `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
+    );
+
+    let info = mapClassResponse(raw, true);
+
+    // Fallback: if inline classProperties came back empty, try the
+    // dedicated paginated properties endpoint
+    if (info.classProperties.length === 0) {
+      const propsRaw = await fetchJson<Record<string, unknown>>(
+        `${BSDD_API}/api/Class/Properties/v1?ClassUri=${encodeURIComponent(uri)}`,
+      ).catch(() => null);
+
+      if (propsRaw) {
+        const propsList = propsRaw.classProperties as Array<Record<string, unknown>> | undefined;
+        if (propsList && propsList.length > 0) {
+          info = {
+            ...info,
+            classProperties: propsList.map((p) => ({
+              name: String(p.name ?? p.propertyCode ?? ''),
+              uri: String(p.propertyUri ?? p.uri ?? ''),
+              description: p.description ? String(p.description) : null,
+              dataType: p.dataType ? String(p.dataType) : null,
+              propertySet: p.propertySet ? String(p.propertySet) : null,
+              allowedValues: Array.isArray(p.allowedValues)
+                ? p.allowedValues.map((v: Record<string, unknown>) => ({
+                    uri: v.uri ? String(v.uri) : undefined,
+                    value: String(v.value ?? ''),
+                    description: v.description ? String(v.description) : undefined,
+                  }))
+                : null,
+              units: Array.isArray(p.units) ? (p.units as string[]) : null,
+              isIfcStandard: true,
+            })),
+          };
+        }
+      }
+    }
+
+    setCache(uri, info);
+    return info;
+  } catch {
+    // Silently return null – bSDD may not have data for every type
+    return null;
+  }
+}
+
+/**
+ * Search bSDD for classes related to a given IFC entity type across all
+ * dictionaries (not just the IFC dictionary).
+ *
+ * Uses `/api/Class/Search/v1` with a RelatedIfcEntities filter.
+ * Returns lightweight results. Call `fetchClassInfo` on a specific result
+ * to get full properties.
+ */
+export async function searchRelatedClasses(
+  ifcType: string,
+): Promise<BsddSearchResult[]> {
+  try {
+    const raw = await fetchJson<{
+      classes?: Array<Record<string, unknown>>;
+    }>(
+      `${BSDD_API}/api/Class/Search/v1?SearchText=${encodeURIComponent(ifcType)}&RelatedIfcEntities=${encodeURIComponent(ifcType)}`,
+    );
+    return (raw.classes ?? []).map((c) => ({
+      uri: String(c.uri ?? ''),
+      code: String(c.code ?? c.name ?? ''),
+      name: String(c.name ?? ''),
+      definition: c.definition ? String(c.definition) : null,
+      dictionaryUri: String(c.dictionaryUri ?? ''),
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Response mapping
+// ---------------------------------------------------------------------------
+
+function mapClassResponse(
+  raw: Record<string, unknown>,
+  isIfcStandard: boolean,
+): BsddClassInfo {
+  const props = raw.classProperties as Array<Record<string, unknown>> | undefined;
+
+  return {
+    uri: String(raw.uri ?? ''),
+    code: String(raw.code ?? raw.name ?? ''),
+    name: String(raw.name ?? ''),
+    definition: raw.definition ? String(raw.definition) : null,
+    parentClassUri: raw.parentClassReference
+      ? String((raw.parentClassReference as Record<string, unknown>).uri ?? '')
+      : null,
+    relatedIfcEntityNames: raw.relatedIfcEntityNames as string[] | null,
+    classProperties: (props ?? []).map((p) => ({
+      name: String(p.name ?? p.propertyCode ?? ''),
+      uri: String(p.propertyUri ?? p.uri ?? ''),
+      description: p.description ? String(p.description) : null,
+      dataType: p.dataType ? String(p.dataType) : null,
+      propertySet: p.propertySet ? String(p.propertySet) : null,
+      allowedValues: Array.isArray(p.allowedValues)
+        ? p.allowedValues.map((v: Record<string, unknown>) => ({
+            uri: v.uri ? String(v.uri) : undefined,
+            value: String(v.value ?? ''),
+            description: v.description ? String(v.description) : undefined,
+          }))
+        : null,
+      units: Array.isArray(p.units) ? (p.units as string[]) : null,
+      isIfcStandard,
+    })),
+  };
+}
+
+/**
+ * Map bSDD dataType string to a human-friendly label.
+ */
+export function bsddDataTypeLabel(dt: string | null): string {
+  if (!dt) return 'String';
+  const lower = dt.toLowerCase();
+  if (lower === 'boolean') return 'Boolean';
+  if (lower === 'real' || lower === 'number') return 'Real';
+  if (lower === 'integer') return 'Integer';
+  if (lower === 'string' || lower === 'character') return 'String';
+  return dt;
+}

package/src/store/index.ts

@@ -275,8 +275,8 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       basketPresentationVisible: false,
       hierarchyBasketSelection: new Set<string>(),
 
-      // Script - reset execution state but keep saved scripts and editor content
-      scriptPanelVisible: false,
+      // Script - reset execution state but keep saved scripts, editor content, and panel visibility
+      // (scripts that create-and-load a model should not close the panel)
       scriptExecutionState: 'idle' as const,
       scriptLastResult: null,
       scriptLastError: null,

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

@@ -47,7 +47,7 @@ describe('MeasurementSlice', () => {
 
   describe('addMeasurePoint', () => {
     it('should set pending measure point', () => {
-      const point = { x: 1, y: 2, z: 3 };
+      const point = { x: 1, y: 2, z: 3, screenX: 0, screenY: 0 };
       state.addMeasurePoint(point);
       assert.deepStrictEqual(state.pendingMeasurePoint, point);
     });
@@ -55,8 +55,8 @@ describe('MeasurementSlice', () => {
 
   describe('completeMeasurement', () => {
     it('should create measurement when pending point exists', () => {
-      const startPoint = { x: 0, y: 0, z: 0 };
-      const endPoint = { x: 3, y: 4, z: 0 };
+      const startPoint = { x: 0, y: 0, z: 0, screenX: 0, screenY: 0 };
+      const endPoint = { x: 3, y: 4, z: 0, screenX: 0, screenY: 0 };
 
       state.addMeasurePoint(startPoint);
       state.completeMeasurement(endPoint);
@@ -69,14 +69,14 @@ describe('MeasurementSlice', () => {
     });
 
     it('should not create measurement when no pending point', () => {
-      const endPoint = { x: 1, y: 1, z: 1 };
+      const endPoint = { x: 1, y: 1, z: 1, screenX: 0, screenY: 0 };
       state.completeMeasurement(endPoint);
       assert.strictEqual(state.measurements.length, 0);
     });
 
     it('should generate unique IDs for rapid measurements', () => {
-      const point1 = { x: 0, y: 0, z: 0 };
-      const point2 = { x: 1, y: 0, z: 0 };
+      const point1 = { x: 0, y: 0, z: 0, screenX: 0, screenY: 0 };
+      const point2 = { x: 1, y: 0, z: 0, screenX: 0, screenY: 0 };
 
       state.addMeasurePoint(point1);
       state.completeMeasurement(point2);
@@ -91,7 +91,7 @@ describe('MeasurementSlice', () => {
 
   describe('startMeasurement', () => {
     it('should initialize active measurement', () => {
-      const point = { x: 1, y: 2, z: 3 };
+      const point = { x: 1, y: 2, z: 3, screenX: 0, screenY: 0 };
       state.startMeasurement(point);
 
       assert.deepStrictEqual(state.activeMeasurement?.start, point);
@@ -102,8 +102,8 @@ describe('MeasurementSlice', () => {
 
   describe('updateMeasurement', () => {
     it('should update current point and distance', () => {
-      const startPoint = { x: 0, y: 0, z: 0 };
-      const currentPoint = { x: 3, y: 4, z: 0 };
+      const startPoint = { x: 0, y: 0, z: 0, screenX: 0, screenY: 0 };
+      const currentPoint = { x: 3, y: 4, z: 0, screenX: 0, screenY: 0 };
 
       state.startMeasurement(startPoint);
       state.updateMeasurement(currentPoint);
@@ -114,7 +114,7 @@ describe('MeasurementSlice', () => {
     });
 
     it('should not update when no active measurement', () => {
-      const point = { x: 1, y: 1, z: 1 };
+      const point = { x: 1, y: 1, z: 1, screenX: 0, screenY: 0 };
       state.updateMeasurement(point);
       assert.strictEqual(state.activeMeasurement, null);
     });
@@ -122,8 +122,8 @@ describe('MeasurementSlice', () => {
 
   describe('finalizeMeasurement', () => {
     it('should add completed measurement to list', () => {
-      const startPoint = { x: 0, y: 0, z: 0 };
-      const endPoint = { x: 1, y: 0, z: 0 };
+      const startPoint = { x: 0, y: 0, z: 0, screenX: 0, screenY: 0 };
+      const endPoint = { x: 1, y: 0, z: 0, screenX: 0, screenY: 0 };
 
       state.startMeasurement(startPoint);
       state.updateMeasurement(endPoint);
@@ -143,7 +143,7 @@ describe('MeasurementSlice', () => {
 
   describe('cancelMeasurement', () => {
     it('should clear active measurement', () => {
-      state.startMeasurement({ x: 0, y: 0, z: 0 });
+      state.startMeasurement({ x: 0, y: 0, z: 0, screenX: 0, screenY: 0 });
       state.cancelMeasurement();
       assert.strictEqual(state.activeMeasurement, null);
     });
@@ -157,8 +157,8 @@ describe('MeasurementSlice', () => {
 
   describe('deleteMeasurement', () => {
     it('should remove measurement by id', () => {
-      state.startMeasurement({ x: 0, y: 0, z: 0 });
-      state.updateMeasurement({ x: 1, y: 0, z: 0 });
+      state.startMeasurement({ x: 0, y: 0, z: 0, screenX: 0, screenY: 0 });
+      state.updateMeasurement({ x: 1, y: 0, z: 0, screenX: 0, screenY: 0 });
       state.finalizeMeasurement();
 
       const id = state.measurements[0].id;
@@ -169,12 +169,12 @@ describe('MeasurementSlice', () => {
 
     it('should not affect other measurements', () => {
       // Create two measurements
-      state.startMeasurement({ x: 0, y: 0, z: 0 });
-      state.updateMeasurement({ x: 1, y: 0, z: 0 });
+      state.startMeasurement({ x: 0, y: 0, z: 0, screenX: 0, screenY: 0 });
+      state.updateMeasurement({ x: 1, y: 0, z: 0, screenX: 0, screenY: 0 });
       state.finalizeMeasurement();
 
-      state.startMeasurement({ x: 0, y: 0, z: 0 });
-      state.updateMeasurement({ x: 2, y: 0, z: 0 });
+      state.startMeasurement({ x: 0, y: 0, z: 0, screenX: 0, screenY: 0 });
+      state.updateMeasurement({ x: 2, y: 0, z: 0, screenX: 0, screenY: 0 });
       state.finalizeMeasurement();
 
       const firstId = state.measurements[0].id;
@@ -187,11 +187,11 @@ describe('MeasurementSlice', () => {
 
   describe('clearMeasurements', () => {
     it('should clear all measurements and state', () => {
-      state.startMeasurement({ x: 0, y: 0, z: 0 });
-      state.updateMeasurement({ x: 1, y: 0, z: 0 });
+      state.startMeasurement({ x: 0, y: 0, z: 0, screenX: 0, screenY: 0 });
+      state.updateMeasurement({ x: 1, y: 0, z: 0, screenX: 0, screenY: 0 });
       state.finalizeMeasurement();
 
-      state.addMeasurePoint({ x: 5, y: 5, z: 5 });
+      state.addMeasurePoint({ x: 5, y: 5, z: 5, screenX: 0, screenY: 0 });
 
       state.clearMeasurements();
 

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

@@ -19,6 +19,8 @@ function createMockModel(id: string, name: string): FederatedModel {
     schemaVersion: 'IFC4',
     loadedAt: Date.now(),
     fileSize: 1024,
+    idOffset: 0,
+    maxExpressId: 0,
   };
 }
 

package/src/store/slices/mutationSlice.ts

@@ -10,7 +10,7 @@ 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';
+import { PropertyValueType, QuantityType } from '@ifc-lite/data';
 
 export interface MutationSlice {
   // State
@@ -68,6 +68,35 @@ export interface MutationSlice {
     psetName: string
   ) => Mutation | null;
 
+  // Actions - Quantity Mutations
+  /** Set a quantity value */
+  setQuantity: (
+    modelId: string,
+    entityId: number,
+    qsetName: string,
+    quantName: string,
+    value: number,
+    quantityType?: QuantityType,
+    unit?: string
+  ) => Mutation | null;
+  /** Create a new quantity set */
+  createQuantitySet: (
+    modelId: string,
+    entityId: number,
+    qsetName: string,
+    quantities: Array<{ name: string; value: number; quantityType: QuantityType; unit?: string }>
+  ) => Mutation | null;
+
+  // Actions - Attribute Mutations
+  /** Set an entity attribute value */
+  setAttribute: (
+    modelId: string,
+    entityId: number,
+    attrName: string,
+    value: string,
+    oldValue?: string
+  ) => Mutation | null;
+
   // Actions - Undo/Redo
   /** Undo last mutation for a model */
   undo: (modelId: string) => void;
@@ -266,6 +295,92 @@ export const createMutationSlice: StateCreator<
     return mutation;
   },
 
+  // Quantity Mutations
+  setQuantity: (modelId, entityId, qsetName, quantName, value, quantityType = QuantityType.Count, unit) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.setQuantity(entityId, qsetName, quantName, value, quantityType, unit);
+
+    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;
+  },
+
+  createQuantitySet: (modelId, entityId, qsetName, quantities) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.createQuantitySet(entityId, qsetName, quantities);
+
+    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;
+  },
+
+  // Attribute Mutations
+  setAttribute: (modelId, entityId, attrName, value, oldValue) => {
+    const view = get().mutationViews.get(modelId);
+    if (!view) return null;
+
+    const mutation = view.setAttribute(entityId, attrName, value, oldValue);
+
+    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();
@@ -303,6 +418,29 @@ export const createMutationSlice: StateCreator<
           true // skipHistory
         );
       }
+    } else if (mutation.type === 'CREATE_QUANTITY') {
+      // Undo creation: remove the quantity mutation
+      view.removeQuantityMutation(mutation.entityId, mutation.psetName!, mutation.propName);
+    } else if (mutation.type === 'UPDATE_QUANTITY') {
+      if (mutation.psetName && mutation.propName && mutation.oldValue !== undefined && mutation.oldValue !== null) {
+        view.setQuantity(
+          mutation.entityId,
+          mutation.psetName,
+          mutation.propName,
+          Number(mutation.oldValue),
+          undefined,
+          undefined,
+          true // skipHistory
+        );
+      }
+    } else if (mutation.type === 'UPDATE_ATTRIBUTE') {
+      if (mutation.attributeName) {
+        if (mutation.oldValue !== undefined && mutation.oldValue !== null) {
+          view.setAttribute(mutation.entityId, mutation.attributeName, String(mutation.oldValue), undefined, true);
+        } else {
+          view.removeAttributeMutation(mutation.entityId, mutation.attributeName);
+        }
+      }
     }
 
     set((s) => {
@@ -347,6 +485,22 @@ export const createMutationSlice: StateCreator<
       if (mutation.psetName && mutation.propName) {
         view.deleteProperty(mutation.entityId, mutation.psetName, mutation.propName, true);
       }
+    } else if (mutation.type === 'CREATE_QUANTITY' || mutation.type === 'UPDATE_QUANTITY') {
+      if (mutation.psetName && mutation.propName && mutation.newValue !== undefined) {
+        view.setQuantity(
+          mutation.entityId,
+          mutation.psetName,
+          mutation.propName,
+          Number(mutation.newValue),
+          undefined,
+          undefined,
+          true // skipHistory
+        );
+      }
+    } else if (mutation.type === 'UPDATE_ATTRIBUTE') {
+      if (mutation.attributeName && mutation.newValue !== undefined) {
+        view.setAttribute(mutation.entityId, mutation.attributeName, String(mutation.newValue), undefined, true);
+      }
     }
 
     set((s) => {

package/vite.config.ts

@@ -201,6 +201,13 @@ export default defineConfig({
     fs: {
       allow: ['../..'],
     },
+    proxy: {
+      '/api/bsdd': {
+        target: 'https://api.bsdd.buildingsmart.org',
+        changeOrigin: true,
+        rewrite: (p) => p.replace(/^\/api\/bsdd/, ''),
+      },
+    },
   },
   build: {
     target: 'esnext',