@ifc-lite/viewer 1.7.0 → 1.9.0

package/src/sdk/adapters/query-adapter.ts

@@ -0,0 +1,241 @@
+/* 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/. */
+
+import type {
+  EntityRef,
+  EntityData,
+  PropertySetData,
+  QuantitySetData,
+  QueryDescriptor,
+  QueryBackendMethods,
+} from '@ifc-lite/sdk';
+import type { StoreApi } from './types.js';
+import { EntityNode } from '@ifc-lite/query';
+import { RelationshipType, IfcTypeEnum, IfcTypeEnumFromString } from '@ifc-lite/data';
+import { getModelForRef, getAllModelEntries } from './model-compat.js';
+
+/** Map IFC relationship entity names to internal RelationshipType enum.
+ * Keys use proper IFC schema names (e.g. IfcRelAggregates, not "Aggregates"). */
+const REL_TYPE_MAP: Record<string, RelationshipType> = {
+  IfcRelContainedInSpatialStructure: RelationshipType.ContainsElements,
+  IfcRelAggregates: RelationshipType.Aggregates,
+  IfcRelDefinesByType: RelationshipType.DefinesByType,
+  IfcRelVoidsElement: RelationshipType.VoidsElement,
+  IfcRelFillsElement: RelationshipType.FillsElement,
+};
+
+/**
+ * IFC4 subtype map — maps parent types to their StandardCase/ElementedCase subtypes.
+ * In IFC4, many element types have *StandardCase subtypes that the parser stores
+ * as the full type name. This map lets byType('IfcWall') also find IfcWallStandardCase.
+ *
+ * Keys and values are UPPERCASE because entityIndex.byType uses UPPERCASE keys
+ * (raw STEP type names, e.g. IFCWALLSTANDARDCASE).
+ */
+const IFC_SUBTYPES: Record<string, string[]> = {
+  IFCWALL: ['IFCWALLSTANDARDCASE', 'IFCWALLELEMENTEDCASE'],
+  IFCBEAM: ['IFCBEAMSTANDARDCASE'],
+  IFCCOLUMN: ['IFCCOLUMNSTANDARDCASE'],
+  IFCDOOR: ['IFCDOORSTANDARDCASE'],
+  IFCWINDOW: ['IFCWINDOWSTANDARDCASE'],
+  IFCSLAB: ['IFCSLABSTANDARDCASE', 'IFCSLABELEMENTEDCASE'],
+  IFCMEMBER: ['IFCMEMBERSTANDARDCASE'],
+  IFCPLATE: ['IFCPLATESTANDARDCASE'],
+  IFCOPENINGELEMENT: ['IFCOPENINGSTANDARDCASE'],
+};
+
+/**
+ * Expand a type list to include known IFC subtypes.
+ * Converts PascalCase input (e.g. 'IfcWall') to UPPERCASE for entityIndex lookup.
+ */
+function expandTypes(types: string[]): string[] {
+  const result: string[] = [];
+  for (const type of types) {
+    const upper = type.toUpperCase();
+    result.push(upper);
+    const subtypes = IFC_SUBTYPES[upper];
+    if (subtypes) {
+      for (const sub of subtypes) result.push(sub);
+    }
+  }
+  return result;
+}
+
+/**
+ * Check if a type name represents a product/spatial entity.
+ *
+ * Uses IfcTypeEnum as a whitelist — only known IFC types pass.
+ * Excludes relationships, properties, quantities, element quantities,
+ * and type objects (IfcWallType, IfcDoorType, etc.).
+ *
+ * Type names from entityIndex.byType are UPPERCASE (e.g. IFCWALLSTANDARDCASE).
+ */
+function isProductType(type: string): boolean {
+  const enumVal = IfcTypeEnumFromString(type);
+  // Unknown = not a recognized product/spatial type (geometry definitions, placements, etc.)
+  if (enumVal === IfcTypeEnum.Unknown) return false;
+  // Exclude relationships, properties, quantities
+  const upper = type.toUpperCase();
+  if (upper.startsWith('IFCREL')) return false;
+  if (upper.startsWith('IFCPROPERTY')) return false;
+  if (upper.startsWith('IFCQUANTITY')) return false;
+  if (upper === 'IFCELEMENTQUANTITY') return false;
+  // Exclude type objects (IfcWallType, IfcDoorType, etc.) — metadata, not instances
+  if (upper.endsWith('TYPE')) return false;
+  return true;
+}
+
+export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
+  function getEntityData(ref: EntityRef): EntityData | null {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return null;
+
+    const node = new EntityNode(model.ifcDataStore, ref.expressId);
+    return {
+      ref,
+      globalId: node.globalId,
+      name: node.name,
+      type: node.type,
+      description: node.description,
+      objectType: node.objectType,
+    };
+  }
+
+  function getProperties(ref: EntityRef): PropertySetData[] {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return [];
+
+    const node = new EntityNode(model.ifcDataStore, ref.expressId);
+    return node.properties().map((pset: { name: string; globalId?: string; properties: Array<{ name: string; type: number; value: string | number | boolean | null }> }) => ({
+      name: pset.name,
+      globalId: pset.globalId,
+      properties: pset.properties.map((p: { name: string; type: number; value: string | number | boolean | null }) => ({
+        name: p.name,
+        type: p.type,
+        value: p.value,
+      })),
+    }));
+  }
+
+  function getQuantities(ref: EntityRef): QuantitySetData[] {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return [];
+
+    const node = new EntityNode(model.ifcDataStore, ref.expressId);
+    return node.quantities().map(qset => ({
+      name: qset.name,
+      quantities: qset.quantities.map(q => ({
+        name: q.name,
+        type: q.type,
+        value: q.value,
+      })),
+    }));
+  }
+
+  function queryEntities(descriptor: QueryDescriptor): EntityData[] {
+    const state = store.getState();
+    const results: EntityData[] = [];
+
+    const modelEntries = descriptor.modelId
+      ? [[descriptor.modelId, getModelForRef(state, descriptor.modelId)] as const].filter(([, m]) => m)
+      : getAllModelEntries(state);
+
+    for (const [modelId, model] of modelEntries) {
+      if (!model?.ifcDataStore) continue;
+
+      let entityIds: number[];
+      if (descriptor.types && descriptor.types.length > 0) {
+        // Expand types to include IFC4 subtypes (e.g., IfcWall → IfcWallStandardCase)
+        entityIds = [];
+        for (const type of expandTypes(descriptor.types)) {
+          const typeIds = model.ifcDataStore.entityIndex.byType.get(type) ?? [];
+          for (const id of typeIds) entityIds.push(id);
+        }
+      } else {
+        // No type filter — return product entities only (skip relationships, property defs)
+        entityIds = [];
+        for (const [typeName, ids] of model.ifcDataStore.entityIndex.byType) {
+          if (isProductType(typeName)) {
+            for (const id of ids) entityIds.push(id);
+          }
+        }
+      }
+      for (const expressId of entityIds) {
+        if (expressId === 0) continue;
+        const node = new EntityNode(model.ifcDataStore, expressId);
+        results.push({
+          ref: { modelId, expressId },
+          globalId: node.globalId,
+          name: node.name,
+          type: node.type,
+          description: node.description,
+          objectType: node.objectType,
+        });
+      }
+    }
+
+    // Apply property filters
+    let filtered = results;
+    if (descriptor.filters && descriptor.filters.length > 0) {
+      // Cache properties per entity to avoid O(n²) re-extraction per filter
+      const propsCache = new Map<string, PropertySetData[]>();
+      const getCachedProps = (ref: EntityRef): PropertySetData[] => {
+        const key = `${ref.modelId}:${ref.expressId}`;
+        let cached = propsCache.get(key);
+        if (!cached) {
+          cached = getProperties(ref);
+          propsCache.set(key, cached);
+        }
+        return cached;
+      };
+
+      for (const filter of descriptor.filters) {
+        filtered = filtered.filter(entity => {
+          const props = getCachedProps(entity.ref);
+          const pset = props.find(p => p.name === filter.psetName);
+          if (!pset) return false;
+          const prop = pset.properties.find(p => p.name === filter.propName);
+          if (!prop) return false;
+          if (filter.operator === 'exists') return true;
+
+          const val = prop.value;
+          switch (filter.operator) {
+            case '=': return String(val) === String(filter.value);
+            case '!=': return String(val) !== String(filter.value);
+            case '>': return Number(val) > Number(filter.value);
+            case '<': return Number(val) < Number(filter.value);
+            case '>=': return Number(val) >= Number(filter.value);
+            case '<=': return Number(val) <= Number(filter.value);
+            case 'contains': return String(val).includes(String(filter.value));
+            default: return false;
+          }
+        });
+      }
+    }
+
+    if (descriptor.offset != null && descriptor.offset > 0) filtered = filtered.slice(descriptor.offset);
+    if (descriptor.limit != null && descriptor.limit > 0) filtered = filtered.slice(0, descriptor.limit);
+
+    return filtered;
+  }
+
+  return {
+    entities: queryEntities,
+    entityData: getEntityData,
+    properties: getProperties,
+    quantities: getQuantities,
+    related(ref: EntityRef, relType: string, direction: 'forward' | 'inverse') {
+      const state = store.getState();
+      const model = getModelForRef(state, ref.modelId);
+      if (!model?.ifcDataStore) return [];
+      const relEnum = REL_TYPE_MAP[relType];
+      if (relEnum === undefined) return [];
+      const targets = model.ifcDataStore.relationships.getRelated(ref.expressId, relEnum, direction);
+      return targets.map((expressId: number) => ({ modelId: ref.modelId, expressId }));
+    },
+  };
+}

package/src/sdk/adapters/selection-adapter.ts

@@ -0,0 +1,29 @@
+/* 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/. */
+
+import type { EntityRef, SelectionBackendMethods } from '@ifc-lite/sdk';
+import type { StoreApi } from './types.js';
+
+export function createSelectionAdapter(store: StoreApi): SelectionBackendMethods {
+  return {
+    get() {
+      const state = store.getState();
+      return state.selectedEntities ?? [];
+    },
+    set(refs: EntityRef[]) {
+      const state = store.getState();
+      if (refs.length === 0) {
+        state.clearEntitySelection?.();
+      } else if (refs.length === 1) {
+        state.setSelectedEntity?.(refs[0]);
+      } else {
+        state.clearEntitySelection?.();
+        for (const ref of refs) {
+          state.addEntityToSelection?.(ref);
+        }
+      }
+      return undefined;
+    },
+  };
+}

package/src/sdk/adapters/spatial-adapter.ts

@@ -0,0 +1,37 @@
+/* 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/. */
+
+import type { AABB, SpatialFrustum, SpatialBackendMethods } from '@ifc-lite/sdk';
+import type { StoreApi } from './types.js';
+import { getModelForRef } from './model-compat.js';
+
+export function createSpatialAdapter(store: StoreApi): SpatialBackendMethods {
+  return {
+    queryBounds(modelId: string, bounds: AABB) {
+      const state = store.getState();
+      const model = getModelForRef(state, modelId);
+      if (!model?.ifcDataStore?.spatialIndex) return [];
+      const expressIds = model.ifcDataStore.spatialIndex.queryAABB(bounds);
+      return expressIds.map(expressId => ({ modelId, expressId }));
+    },
+    raycast(modelId: string, origin: [number, number, number], direction: [number, number, number]) {
+      const state = store.getState();
+      const model = getModelForRef(state, modelId);
+      if (!model?.ifcDataStore?.spatialIndex) return [];
+      const expressIds = model.ifcDataStore.spatialIndex.raycast(origin, direction);
+      return expressIds.map(expressId => ({ modelId, expressId }));
+    },
+    queryFrustum(modelId: string, frustum: SpatialFrustum) {
+      const state = store.getState();
+      const model = getModelForRef(state, modelId);
+      if (!model?.ifcDataStore?.spatialIndex) return [];
+      const index = model.ifcDataStore.spatialIndex as {
+        queryFrustum?: (frustum: SpatialFrustum) => number[];
+      };
+      if (!index.queryFrustum) return [];
+      const expressIds = index.queryFrustum(frustum);
+      return expressIds.map((expressId: number) => ({ modelId, expressId }));
+    },
+  };
+}

package/src/sdk/adapters/types.ts

@@ -0,0 +1,11 @@
+/* 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/. */
+
+import type { ViewerState } from '../../store/index.js';
+
+/** Store API surface needed by adapters */
+export type StoreApi = {
+  getState: () => ViewerState;
+  subscribe: (listener: (state: ViewerState, prevState: ViewerState) => void) => () => void;
+};

package/src/sdk/adapters/viewer-adapter.ts

@@ -0,0 +1,103 @@
+/* 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/. */
+
+import type { EntityRef, SectionPlane, CameraState, ViewerBackendMethods, RGBAColor } from '@ifc-lite/sdk';
+import type { StoreApi } from './types.js';
+import { getModelForRef } from './model-compat.js';
+
+const AXIS_TO_STORE: Record<string, 'down' | 'front' | 'side'> = {
+  x: 'side',
+  y: 'down',
+  z: 'front',
+};
+const STORE_TO_AXIS: Record<string, 'x' | 'y' | 'z'> = {
+  side: 'x',
+  down: 'y',
+  front: 'z',
+};
+
+export function createViewerAdapter(store: StoreApi): ViewerBackendMethods {
+  return {
+    colorize(refs: EntityRef[], color: [number, number, number, number]) {
+      const state = store.getState();
+      // Merge with existing pending colors (supports multiple colorize calls per script)
+      const existing = state.pendingColorUpdates;
+      const colorMap = existing ? new Map(existing) : new Map<number, [number, number, number, number]>();
+      for (const ref of refs) {
+        const model = getModelForRef(state, ref.modelId);
+        if (model) {
+          const globalId = ref.expressId + model.idOffset;
+          colorMap.set(globalId, color);
+        }
+      }
+      state.setPendingColorUpdates(colorMap);
+      return undefined;
+    },
+    colorizeAll(batches: Array<{ refs: EntityRef[]; color: [number, number, number, number] }>) {
+      const state = store.getState();
+      // Batch colorize: build the complete color map in a single call.
+      // Avoids accumulation issues when React effects fire between calls.
+      const batchMap = new Map<number, [number, number, number, number]>();
+      for (const batch of batches) {
+        for (const ref of batch.refs) {
+          const model = getModelForRef(state, ref.modelId);
+          if (model) {
+            batchMap.set(ref.expressId + model.idOffset, batch.color);
+          }
+        }
+      }
+      state.setPendingColorUpdates(batchMap);
+      return undefined;
+    },
+    resetColors() {
+      const state = store.getState();
+      // Set empty map to trigger scene.clearColorOverrides() (null skips the effect)
+      state.setPendingColorUpdates(new Map());
+      return undefined;
+    },
+    flyTo() {
+      // flyTo requires renderer access — wired via useBimHost
+      return undefined;
+    },
+    setSection(section: SectionPlane | null) {
+      const state = store.getState();
+      if (section) {
+        state.setSectionPlaneAxis?.(AXIS_TO_STORE[section.axis] ?? 'down');
+        state.setSectionPlanePosition?.(section.position);
+        if (section.flipped !== undefined && state.sectionPlane?.flipped !== section.flipped) {
+          state.flipSectionPlane?.();
+        }
+        if (state.sectionPlane?.enabled !== section.enabled) {
+          state.toggleSectionPlane?.();
+        }
+      } else {
+        if (state.sectionPlane?.enabled) {
+          state.toggleSectionPlane?.();
+        }
+      }
+      return undefined;
+    },
+    getSection() {
+      const state = store.getState();
+      if (!state.sectionPlane?.enabled) return null;
+      return {
+        axis: STORE_TO_AXIS[state.sectionPlane.axis] ?? 'y',
+        position: state.sectionPlane.position,
+        enabled: state.sectionPlane.enabled,
+        flipped: state.sectionPlane.flipped,
+      };
+    },
+    setCamera(cameraState: Partial<CameraState>) {
+      const state = store.getState();
+      if (cameraState.mode) {
+        state.setProjectionMode?.(cameraState.mode);
+      }
+      return undefined;
+    },
+    getCamera() {
+      const state = store.getState();
+      return { mode: state.projectionMode ?? 'perspective' };
+    },
+  };
+}

package/src/sdk/adapters/visibility-adapter.ts

@@ -0,0 +1,61 @@
+/* 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/. */
+
+import type { EntityRef, VisibilityBackendMethods } from '@ifc-lite/sdk';
+import type { StoreApi } from './types.js';
+import { getModelForRef } from './model-compat.js';
+
+export function createVisibilityAdapter(store: StoreApi): VisibilityBackendMethods {
+  return {
+    hide(refs: EntityRef[]) {
+      const state = store.getState();
+      // Convert EntityRef to global IDs — the renderer subscribes to the flat
+      // hiddenEntities set (global IDs), not hiddenEntitiesByModel.
+      const globalIds: number[] = [];
+      for (const ref of refs) {
+        const model = getModelForRef(state, ref.modelId);
+        if (model) {
+          globalIds.push(ref.expressId + model.idOffset);
+        }
+      }
+      if (globalIds.length > 0) {
+        state.hideEntities(globalIds);
+      }
+      return undefined;
+    },
+    show(refs: EntityRef[]) {
+      const state = store.getState();
+      const globalIds: number[] = [];
+      for (const ref of refs) {
+        const model = getModelForRef(state, ref.modelId);
+        if (model) {
+          globalIds.push(ref.expressId + model.idOffset);
+        }
+      }
+      if (globalIds.length > 0) {
+        state.showEntities(globalIds);
+      }
+      return undefined;
+    },
+    isolate(refs: EntityRef[]) {
+      const state = store.getState();
+      const globalIds: number[] = [];
+      for (const ref of refs) {
+        const model = getModelForRef(state, ref.modelId);
+        if (model) {
+          globalIds.push(ref.expressId + model.idOffset);
+        }
+      }
+      if (globalIds.length > 0) {
+        state.isolateEntities?.(globalIds);
+      }
+      return undefined;
+    },
+    reset() {
+      const state = store.getState();
+      state.showAllInAllModels?.();
+      return undefined;
+    },
+  };
+}

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 () => {};
+    }
+  }
+}