@ifc-lite/viewer 1.17.3 → 1.17.6

package/src/components/viewer/useMouseControls.ts

@@ -129,6 +129,8 @@ export interface UseMouseControlsParams {
   RENDER_THROTTLE_MS_SMALL: number;
   RENDER_THROTTLE_MS_LARGE: number;
   RENDER_THROTTLE_MS_HUGE: number;
+  /** When true, wheel zoom uses unrestricted pure-dolly mode (Cesium) */
+  fastZoomRef: MutableRefObject<boolean>;
 }
 
 export function useMouseControls(params: UseMouseControlsParams): void {
@@ -476,7 +478,8 @@ export function useMouseControls(params: UseMouseControlsParams): void {
       const rect = canvas.getBoundingClientRect();
       const mouseX = e.clientX - rect.left;
       const mouseY = e.clientY - rect.top;
-      camera.zoom(e.deltaY, false, mouseX, mouseY, canvas.width, canvas.height);
+      const fastZoom = e.shiftKey || params.fastZoomRef.current;
+      camera.zoom(e.deltaY, false, mouseX, mouseY, canvas.width, canvas.height, fastZoom);
 
       isInteractingRef.current = true;
       renderer.requestRender();

package/src/components/viewer/useRenderUpdates.ts

@@ -77,7 +77,7 @@ export function useRenderUpdates(params: UseRenderUpdatesParams): void {
 
   // Theme-aware clear color update
   useEffect(() => {
-    clearColorRef.current = getThemeClearColor(theme as 'light' | 'dark');
+    clearColorRef.current = getThemeClearColor(theme as 'light' | 'dark' | 'colorful');
     rendererRef.current?.requestRender();
   }, [theme, isInitialized]);
 

package/src/hooks/ids/idsDataAccessor.ts

@@ -19,7 +19,11 @@ import type {
   ParentInfo,
   PartOfRelation,
 } from '@ifc-lite/ids';
-import type { IfcDataStore } from '@ifc-lite/parser';
+import {
+  type IfcDataStore,
+  extractAllEntityAttributes,
+  extractTypeEntityOwnProperties,
+} from '@ifc-lite/parser';
 
 /**
  * Create an IFCDataAccessor from an IfcDataStore
@@ -59,7 +63,26 @@ export function createDataAccessor(
     },
 
     getObjectType(expressId: number): string | undefined {
-      return dataStore.entities?.getObjectType?.(expressId);
+      // Try the pre-computed ObjectType first (works for IfcObject subtypes)
+      const objectType = dataStore.entities?.getObjectType?.(expressId);
+      if (objectType) return objectType;
+
+      // For IfcTypeObject subtypes (IfcWallType, etc.), ObjectType doesn't exist —
+      // we need to extract PredefinedType from entity attributes instead.
+      // Also handles IfcObject subtypes that have PredefinedType at different positions.
+      const allAttrs = extractAllEntityAttributes(dataStore, expressId);
+      const predefinedType = allAttrs.find(a => a.name === 'PredefinedType');
+      if (predefinedType?.value && predefinedType.value !== 'NOTDEFINED') {
+        return predefinedType.value;
+      }
+
+      // If PredefinedType is USERDEFINED or absent, check ObjectType from attributes
+      const objTypeAttr = allAttrs.find(a => a.name === 'ObjectType');
+      if (objTypeAttr?.value) {
+        return objTypeAttr.value;
+      }
+
+      return undefined;
     },
 
     getEntitiesByType(typeName: string): number[] {
@@ -119,29 +142,42 @@ export function createDataAccessor(
 
     getPropertySets(expressId: number): PropertySetInfo[] {
       const propertiesStore = dataStore.properties;
-      if (!propertiesStore) return [];
 
-      // Use getForEntity (returns PropertySet[])
-      const psets = propertiesStore.getForEntity?.(expressId);
-      if (!psets) return [];
-
-      return psets.map((pset) => ({
-        name: pset.name,
-        properties: (pset.properties || []).map((prop) => {
-          // Convert value: ensure it's a primitive type (not array)
-          let value: string | number | boolean | null = null;
-          if (Array.isArray(prop.value)) {
-            value = JSON.stringify(prop.value);
-          } else {
-            value = prop.value as string | number | boolean | null;
-          }
-          return {
-            name: prop.name,
-            value,
-            dataType: String(prop.type || 'IFCLABEL'),
-          };
-        }),
-      }));
+      // Try relationship-based properties first (works for IfcObject instances)
+      const psets = propertiesStore?.getForEntity?.(expressId);
+
+      // Convert property sets to the IDS format
+      const mapPsets = (rawPsets: Array<{ name: string; properties: Array<{ name: string; value: unknown; type: unknown }> }>): PropertySetInfo[] =>
+        rawPsets.map((pset) => ({
+          name: pset.name,
+          properties: (pset.properties || []).map((prop) => {
+            let value: string | number | boolean | null = null;
+            if (Array.isArray(prop.value)) {
+              value = JSON.stringify(prop.value);
+            } else {
+              value = prop.value as string | number | boolean | null;
+            }
+            return {
+              name: prop.name,
+              value,
+              dataType: String(prop.type || 'IFCLABEL'),
+            };
+          }),
+        }));
+
+      if (psets && psets.length > 0) {
+        return mapPsets(psets);
+      }
+
+      // For IfcTypeObject subtypes (IfcWallType, IfcSlabType, etc.),
+      // properties come from the HasPropertySets attribute (index 5),
+      // not from IfcRelDefinesByProperties relationships.
+      const typePsets = extractTypeEntityOwnProperties(dataStore, expressId);
+      if (typePsets.length > 0) {
+        return mapPsets(typePsets);
+      }
+
+      return [];
     },
 
     getClassifications(expressId: number): ClassificationInfo[] {

package/src/hooks/ingest/viewerModelIngest.ts

@@ -0,0 +1,280 @@
+/* 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 { IfcParser, parseIfcx, type IfcDataStore } from '@ifc-lite/parser';
+import { GeometryProcessor, GeometryQuality, type CoordinateInfo, type DynamicBatchConfig, type GeometryResult, type MeshData } from '@ifc-lite/geometry';
+import { loadGLBToMeshData } from '@ifc-lite/cache';
+import type { SchemaVersion } from '../../store/types.js';
+import { calculateMeshBounds, calculateStoreyHeights, createCoordinateInfo, normalizeColor } from '../../utils/localParsingUtils.js';
+
+type RgbaColor = [number, number, number, number];
+
+interface RawIfcxMesh {
+  expressId?: number;
+  express_id?: number;
+  id?: number;
+  positions: Float32Array | number[];
+  indices: Uint32Array | number[];
+  normals: Float32Array | number[];
+  color?: [number, number, number, number] | [number, number, number];
+  ifcType?: string;
+  ifc_type?: string;
+}
+
+export interface ViewerModelPayload {
+  dataStore: IfcDataStore;
+  geometryResult: GeometryResult;
+  schemaVersion: SchemaVersion;
+}
+
+export interface StepBatchEvent {
+  batchIndex: number;
+  estimatedTotal: number;
+  totalSoFar: number;
+  meshes: MeshData[];
+  coordinateInfo?: CoordinateInfo | null;
+}
+
+export interface StepRtcOffsetEvent {
+  rtcOffset: { x: number; y: number; z: number };
+}
+
+export interface StepBufferIngestOptions {
+  fileName: string;
+  buffer: ArrayBuffer;
+  fileSizeMB: number;
+  getDynamicBatchSize: (fileSizeMB: number) => number | DynamicBatchConfig;
+  onProgress?: (progress: { phase: string; percent: number }) => void;
+  onBatch?: (event: StepBatchEvent) => void;
+  onColorUpdate?: (updates: Map<number, RgbaColor>) => void;
+  onSpatialReady?: (dataStore: IfcDataStore) => void;
+  onRtcOffset?: (event: StepRtcOffsetEvent) => void;
+  shouldAbort?: () => boolean;
+  /** Shared RTC offset from first federated model (IFC Z-up coords).
+   *  When set, this model uses the same RTC as the first model instead of
+   *  computing its own, ensuring all models share the same coordinate space. */
+  sharedRtcOffset?: { x: number; y: number; z: number };
+}
+
+export interface StepBufferIngestResult extends ViewerModelPayload {
+  allMeshes: MeshData[];
+  cumulativeColorUpdates: Map<number, RgbaColor>;
+}
+
+export function convertIfcxMeshes(rawMeshes: RawIfcxMesh[]): MeshData[] {
+  return rawMeshes.map((mesh) => {
+    const positions = mesh.positions instanceof Float32Array ? mesh.positions : new Float32Array(mesh.positions || []);
+    const indices = mesh.indices instanceof Uint32Array ? mesh.indices : new Uint32Array(mesh.indices || []);
+    const normals = mesh.normals instanceof Float32Array ? mesh.normals : new Float32Array(mesh.normals || []);
+
+    return {
+      expressId: mesh.expressId ?? mesh.express_id ?? mesh.id ?? 0,
+      positions,
+      indices,
+      normals,
+      color: normalizeColor(mesh.color),
+      ifcType: mesh.ifcType ?? mesh.ifc_type ?? 'IfcProduct',
+    };
+  }).filter((mesh) => mesh.positions.length > 0 && mesh.indices.length > 0);
+}
+
+export function createMinimalGlbDataStore(buffer: ArrayBuffer, meshCount: number): IfcDataStore {
+  return {
+    fileSize: buffer.byteLength,
+    schemaVersion: 'IFC4' as const,
+    entityCount: meshCount,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: { byId: new Map(), byType: new Map() },
+    strings: { getString: () => undefined, getStringId: () => undefined, count: 0 } as unknown as IfcDataStore['strings'],
+    entities: { count: 0, getId: () => 0, getType: () => 0, getName: () => undefined, getGlobalId: () => undefined } as unknown as IfcDataStore['entities'],
+    properties: { count: 0, getPropertiesForEntity: () => [], getPropertySetForEntity: () => [] } as unknown as IfcDataStore['properties'],
+    quantities: { count: 0, getQuantitiesForEntity: () => [] } as unknown as IfcDataStore['quantities'],
+    relationships: { count: 0, getRelationships: () => [], getRelated: () => [] } as unknown as IfcDataStore['relationships'],
+    spatialHierarchy: null as unknown as IfcDataStore['spatialHierarchy'],
+  } as unknown as IfcDataStore;
+}
+
+export function normalizeDataStoreStoreys(dataStore: IfcDataStore): IfcDataStore {
+  if (dataStore.spatialHierarchy && dataStore.spatialHierarchy.storeyHeights.size === 0 && dataStore.spatialHierarchy.storeyElevations.size > 1) {
+    const calculatedHeights = calculateStoreyHeights(dataStore.spatialHierarchy.storeyElevations);
+    for (const [storeyId, height] of calculatedHeights) {
+      dataStore.spatialHierarchy.storeyHeights.set(storeyId, height);
+    }
+  }
+  return dataStore;
+}
+
+export function getMaxExpressId(dataStore: IfcDataStore, meshes: MeshData[]): number {
+  const maxExpressIdFromMeshes = meshes.reduce((max, mesh) => Math.max(max, mesh.expressId), 0);
+  let maxExpressIdFromEntities = 0;
+  if (dataStore.entityIndex?.byId) {
+    for (const key of dataStore.entityIndex.byId.keys()) {
+      if (key > maxExpressIdFromEntities) {
+        maxExpressIdFromEntities = key;
+      }
+    }
+  }
+  return Math.max(maxExpressIdFromMeshes, maxExpressIdFromEntities);
+}
+
+export async function parseIfcxViewerModel(
+  buffer: ArrayBuffer,
+  onProgress?: (progress: { phase: string; percent: number }) => void,
+): Promise<ViewerModelPayload> {
+  const ifcxResult = await parseIfcx(buffer, {
+    onProgress: (progress) => {
+      onProgress?.({
+        phase: `IFCX ${progress.phase}`,
+        percent: 10 + (progress.percent * 0.8),
+      });
+    },
+  });
+
+  const meshes = convertIfcxMeshes(ifcxResult.meshes);
+  if (meshes.length === 0 && ifcxResult.entityCount > 0) {
+    throw new Error('overlay-only-ifcx');
+  }
+
+  const { bounds, stats } = calculateMeshBounds(meshes);
+  return {
+    dataStore: {
+      fileSize: ifcxResult.fileSize,
+      schemaVersion: 'IFC5' as const,
+      entityCount: ifcxResult.entityCount,
+      parseTime: ifcxResult.parseTime,
+      source: new Uint8Array(buffer),
+      entityIndex: { byId: new Map(), byType: new Map() },
+      strings: ifcxResult.strings,
+      entities: ifcxResult.entities,
+      properties: ifcxResult.properties,
+      quantities: ifcxResult.quantities,
+      relationships: ifcxResult.relationships,
+      spatialHierarchy: ifcxResult.spatialHierarchy,
+    } as unknown as IfcDataStore,
+    geometryResult: {
+      meshes,
+      totalVertices: stats.totalVertices,
+      totalTriangles: stats.totalTriangles,
+      coordinateInfo: createCoordinateInfo(bounds),
+    },
+    schemaVersion: 'IFC5',
+  };
+}
+
+export async function parseGlbViewerModel(buffer: ArrayBuffer): Promise<ViewerModelPayload> {
+  const meshes = loadGLBToMeshData(new Uint8Array(buffer));
+  if (meshes.length === 0) {
+    throw new Error('glb-empty');
+  }
+
+  const { bounds, stats } = calculateMeshBounds(meshes);
+  return {
+    dataStore: createMinimalGlbDataStore(buffer, meshes.length),
+    geometryResult: {
+      meshes,
+      totalVertices: stats.totalVertices,
+      totalTriangles: stats.totalTriangles,
+      coordinateInfo: createCoordinateInfo(bounds),
+    },
+    schemaVersion: 'IFC4',
+  };
+}
+
+export async function parseStepBufferViewerModel(options: StepBufferIngestOptions): Promise<StepBufferIngestResult> {
+  const geometryProcessor = new GeometryProcessor({ quality: GeometryQuality.Balanced });
+  await geometryProcessor.init();
+
+  const parser = new IfcParser();
+  const wasmApi = geometryProcessor.getApi();
+  const allMeshes: MeshData[] = [];
+  const cumulativeColorUpdates = new Map<number, RgbaColor>();
+  let finalCoordinateInfo: CoordinateInfo | null = null;
+  let batchIndex = 0;
+  let estimatedTotal = 0;
+  let capturedRtcOffset: { x: number; y: number; z: number } | null = null;
+
+  const dataStorePromise = parser.parseColumnar(options.buffer, {
+    wasmApi,
+    onSpatialReady: (partialStore) => {
+      if (options.shouldAbort?.()) {
+        return;
+      }
+      options.onSpatialReady?.(normalizeDataStoreStoreys(partialStore));
+    },
+  });
+
+  for await (const event of geometryProcessor.processAdaptive(new Uint8Array(options.buffer), {
+    sizeThreshold: 2 * 1024 * 1024,
+    batchSize: options.getDynamicBatchSize(options.fileSizeMB),
+    sharedRtcOffset: options.sharedRtcOffset,
+  })) {
+    if (options.shouldAbort?.()) {
+      break;
+    }
+    switch (event.type) {
+      case 'start':
+        estimatedTotal = event.totalEstimate;
+        break;
+      case 'colorUpdate':
+        for (const [expressId, color] of event.updates) {
+          cumulativeColorUpdates.set(expressId, color);
+        }
+        options.onColorUpdate?.(event.updates);
+        break;
+      case 'rtcOffset':
+        if (event.hasRtc) {
+          capturedRtcOffset = event.rtcOffset;
+          options.onRtcOffset?.({ rtcOffset: event.rtcOffset });
+        }
+        break;
+      case 'batch':
+        batchIndex += 1;
+        for (let i = 0; i < event.meshes.length; i++) {
+          allMeshes.push(event.meshes[i]);
+        }
+        finalCoordinateInfo = event.coordinateInfo ?? null;
+        options.onBatch?.({
+          batchIndex,
+          estimatedTotal,
+          totalSoFar: event.totalSoFar,
+          meshes: event.meshes,
+          coordinateInfo: event.coordinateInfo ?? null,
+        });
+        options.onProgress?.({
+          phase: `Processing geometry (${event.totalSoFar} meshes)`,
+          percent: 10 + Math.min(80, (allMeshes.length / 1000) * 0.8),
+        });
+        break;
+      case 'complete':
+        finalCoordinateInfo = event.coordinateInfo ?? null;
+        break;
+    }
+  }
+
+  const dataStore = normalizeDataStoreStoreys(await dataStorePromise);
+  if (!finalCoordinateInfo) {
+    finalCoordinateInfo = createCoordinateInfo(calculateMeshBounds(allMeshes).bounds);
+  }
+  if (capturedRtcOffset) {
+    finalCoordinateInfo.wasmRtcOffset = capturedRtcOffset;
+  }
+
+  return {
+    dataStore,
+    geometryResult: {
+      meshes: allMeshes,
+      totalVertices: allMeshes.reduce((sum, mesh) => sum + mesh.positions.length / 3, 0),
+      totalTriangles: allMeshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0),
+      coordinateInfo: finalCoordinateInfo,
+    },
+    schemaVersion: dataStore.schemaVersion === 'IFC4X3'
+      ? 'IFC4X3'
+      : dataStore.schemaVersion === 'IFC4'
+        ? 'IFC4'
+        : 'IFC2X3',
+    allMeshes,
+    cumulativeColorUpdates,
+  };
+}

package/src/hooks/useIDS.ts

@@ -793,7 +793,7 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
     const url = URL.createObjectURL(blob);
     const a = globalThis.document.createElement('a');
     a.href = url;
-    a.download = `ids-report-${new Date().toISOString().split('T')[0]}.bcf`;
+    a.download = `ids-report-${new Date().toISOString().split('T')[0]}.bcfzip`;
     a.click();
     URL.revokeObjectURL(url);
 

package/src/hooks/useIfc.ts

@@ -14,7 +14,7 @@
 
 import { useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '@/store';
 import { IfcQuery } from '@ifc-lite/query';
 import type { IfcDataStore } from '@ifc-lite/parser';
 
@@ -26,6 +26,8 @@ export function useIfc() {
   const {
     loading,
     progress,
+    geometryProgress,
+    metadataProgress,
     error,
     ifcDataStore,
     geometryResult,
@@ -45,6 +47,8 @@ export function useIfc() {
   } = useViewerStore(useShallow((s) => ({
     loading: s.loading,
     progress: s.progress,
+    geometryProgress: s.geometryProgress,
+    metadataProgress: s.metadataProgress,
     error: s.error,
     ifcDataStore: s.ifcDataStore,
     geometryResult: s.geometryResult,
@@ -94,6 +98,8 @@ export function useIfc() {
     // Legacy single-model API (backward compatibility)
     loading,
     progress,
+    geometryProgress,
+    metadataProgress,
     error,
     ifcDataStore,
     geometryResult,

package/src/hooks/useIfcCache.ts

@@ -16,7 +16,7 @@ import {
   type IfcDataStore as CacheDataStore,
   type GeometryData,
 } from '@ifc-lite/cache';
-import { SpatialHierarchyBuilder, StepTokenizer, buildCompactEntityIndex, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
+import { SpatialHierarchyBuilder, StepTokenizer, CompactEntityIndexBuilder, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
 import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
 import type { MeshData } from '@ifc-lite/geometry';
 
@@ -55,6 +55,13 @@ export interface CacheGeometryResult {
   };
 }
 
+export interface CacheLoadResult {
+  success: boolean;
+  meshCount: number;
+  totalVertices: number;
+  totalTriangles: number;
+}
+
 // ============================================================================
 // Hook
 // ============================================================================
@@ -81,7 +88,7 @@ export function useIfcCache() {
     cacheResult: CacheResult,
     fileName: string,
     cacheKey?: string
-  ): Promise<boolean> => {
+  ): Promise<CacheLoadResult> => {
     try {
       const cacheLoadStart = performance.now();
       setProgress({ phase: 'Loading from cache', percent: 10 });
@@ -100,19 +107,16 @@ export function useIfcCache() {
       if (cacheResult.sourceBuffer) {
         dataStore.source = new Uint8Array(cacheResult.sourceBuffer);
 
-        // Quick scan to rebuild entity index with byte offsets (needed for on-demand extraction)
+        // Quick scan to rebuild entity index with byte offsets (needed for on-demand extraction).
+        // Uses CompactEntityIndexBuilder to fill typed arrays directly during the scan,
+        // avoiding a temporary array of 4.4M+ objects (~350MB for large files).
         const tokenizer = new StepTokenizer(dataStore.source);
-        const entityRefs: Array<{ expressId: number; type: string; byteOffset: number; byteLength: number; lineNumber: number }> = [];
+        const estimatedCount = dataStore.entities?.count ?? 100_000;
+        const indexBuilder = new CompactEntityIndexBuilder(estimatedCount);
         const byType = new Map<string, number[]>();
 
         for (const ref of tokenizer.scanEntitiesFast()) {
-          entityRefs.push({
-            expressId: ref.expressId,
-            type: ref.type,
-            byteOffset: ref.offset,
-            byteLength: ref.length,
-            lineNumber: ref.line,
-          });
+          indexBuilder.add(ref.expressId, ref.type, ref.offset, ref.length);
           let typeList = byType.get(ref.type);
           if (!typeList) {
             typeList = [];
@@ -120,8 +124,7 @@ export function useIfcCache() {
           }
           typeList.push(ref.expressId);
         }
-        // Use compact entity index (typed arrays) for lower memory usage
-        const compactByIdIndex = buildCompactEntityIndex(entityRefs);
+        const compactByIdIndex = indexBuilder.build();
         dataStore.entityIndex = { byId: compactByIdIndex, byType };
 
         // Rebuild on-demand maps from relationships
@@ -201,7 +204,12 @@ export function useIfcCache() {
       const meshCount = result.geometry?.meshes.length || 0;
       console.log(`[useIfcCache] ✓ ${fileName} (cached) → ${meshCount} meshes | ${totalCacheTime.toFixed(0)}ms`);
 
-      return true;
+      return {
+        success: true,
+        meshCount,
+        totalVertices: result.geometry?.totalVertices || 0,
+        totalTriangles: result.geometry?.totalTriangles || 0,
+      };
     } catch (err) {
       console.error('[useIfcCache] Failed to load from cache:', err);
       // Clear corrupted cache entry if we have the key
@@ -213,7 +221,12 @@ export function useIfcCache() {
           // Ignore cleanup errors
         }
       }
-      return false;
+      return {
+        success: false,
+        meshCount: 0,
+        totalVertices: 0,
+        totalTriangles: 0,
+      };
     }
   }, [setProgress, setIfcDataStore, setGeometryResult]);