@ifc-lite/viewer 1.17.2 → 1.17.4

package/src/utils/nativeSpatialDataStore.ts

@@ -0,0 +1,250 @@
+/* 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 {
+  IfcTypeEnumFromString,
+  isBuildingLikeSpatialType,
+  isStoreyLikeSpatialType,
+  type SpatialHierarchy,
+  type SpatialNode,
+} from '@ifc-lite/data';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { NativeMetadataEntitySummary, NativeMetadataSnapshot, NativeMetadataSpatialNode } from '@/store/types';
+
+function normalizeSummary(summary: Partial<NativeMetadataEntitySummary> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }): NativeMetadataEntitySummary | null {
+  const source = summary.summary ? { ...summary.summary, ...summary } : summary;
+  const expressId = typeof source.expressId === 'number' ? source.expressId : null;
+  const type = typeof source.type === 'string'
+    ? source.type
+    : typeof source.typeName === 'string'
+      ? source.typeName
+      : null;
+  if (expressId === null || !type) {
+    return null;
+  }
+  return {
+    expressId,
+    type,
+    name: typeof source.name === 'string' ? source.name : `${type} #${expressId}`,
+    globalId: typeof source.globalId === 'string' ? source.globalId : null,
+    kind: source.kind === 'spatial' ? 'spatial' : 'element',
+    hasChildren: Boolean(source.hasChildren),
+    elementCount: typeof source.elementCount === 'number' ? source.elementCount : undefined,
+    elevation: typeof source.elevation === 'number' ? source.elevation : undefined,
+  };
+}
+
+function normalizeSpatialNode(
+  node: NativeMetadataSpatialNode | (Partial<NativeMetadataSpatialNode> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }),
+): (NativeMetadataSpatialNode & { elements: NativeMetadataEntitySummary[] }) | null {
+  const summary = normalizeSummary(node as Partial<NativeMetadataEntitySummary> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> });
+  if (!summary) {
+    return null;
+  }
+  const children = Array.isArray(node.children)
+    ? node.children
+        .map((child) => normalizeSpatialNode(child as Partial<NativeMetadataSpatialNode> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }))
+        .filter((child): child is NativeMetadataSpatialNode & { elements: NativeMetadataEntitySummary[] } => child !== null)
+    : [];
+  const elements = Array.isArray((node as { elements?: unknown[] }).elements)
+    ? ((node as { elements?: unknown[] }).elements ?? [])
+        .map((entry) => normalizeSummary(entry as Partial<NativeMetadataEntitySummary> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }))
+        .filter((entry): entry is NativeMetadataEntitySummary => entry !== null)
+    : [];
+  return {
+    ...summary,
+    children,
+    elements,
+  };
+}
+
+function buildEntityLookup() {
+  const ids: number[] = [];
+  const typeEnums: number[] = [];
+  const flags: number[] = [];
+  const nameById = new Map<number, string>();
+  const typeNameById = new Map<number, string>();
+  const byType = new Map<string, number[]>();
+
+  const addSummary = (summary: NativeMetadataEntitySummary) => {
+    if (!summary.type) {
+      return;
+    }
+    if (nameById.has(summary.expressId)) {
+      return;
+    }
+    ids.push(summary.expressId);
+    typeEnums.push(IfcTypeEnumFromString(summary.type));
+    flags.push(0);
+    nameById.set(summary.expressId, summary.name);
+    typeNameById.set(summary.expressId, summary.type);
+    const typeKey = summary.type.toUpperCase();
+    const existing = byType.get(typeKey);
+    if (existing) {
+      existing.push(summary.expressId);
+    } else {
+      byType.set(typeKey, [summary.expressId]);
+    }
+  };
+
+  return {
+    addSummary,
+    buildEntities() {
+      return {
+        count: ids.length,
+        expressId: Uint32Array.from(ids),
+        typeEnum: Uint32Array.from(typeEnums),
+        flags: Uint8Array.from(flags),
+        getName(expressId: number) {
+          return nameById.get(expressId);
+        },
+        getTypeName(expressId: number) {
+          return typeNameById.get(expressId) ?? 'Unknown';
+        },
+        getByType(type: string | number) {
+          const key = typeof type === 'string' ? type.toUpperCase() : String(type);
+          return byType.get(key) ?? [];
+        },
+      };
+    },
+    buildByType() {
+      return byType;
+    },
+  };
+}
+
+function buildPathResolver(project: SpatialNode) {
+  return (elementId: number): SpatialNode[] => {
+    const path: SpatialNode[] = [];
+    const visit = (node: SpatialNode): boolean => {
+      path.push(node);
+      if (node.elements.includes(elementId)) {
+        return true;
+      }
+      for (const child of node.children) {
+        if (visit(child)) {
+          return true;
+        }
+      }
+      path.pop();
+      return false;
+    };
+    visit(project);
+    return path;
+  };
+}
+
+export function buildIfcDataStoreFromNativeMetadata(snapshot: NativeMetadataSnapshot): IfcDataStore | null {
+  const root = snapshot.spatialTree ? normalizeSpatialNode(snapshot.spatialTree) : null;
+  if (!root) {
+    return null;
+  }
+
+  const byStorey = new Map<number, number[]>();
+  const byBuilding = new Map<number, number[]>();
+  const bySite = new Map<number, number[]>();
+  const bySpace = new Map<number, number[]>();
+  const storeyElevations = new Map<number, number>();
+  const storeyHeights = new Map<number, number>();
+  const elementToStorey = new Map<number, number>();
+  const elementToSpace = new Map<number, number>();
+  const entityLookup = buildEntityLookup();
+
+  const buildNode = (
+    node: NativeMetadataSpatialNode & { elements: NativeMetadataEntitySummary[] },
+    currentStoreyId: number | null,
+    currentSpaceId: number | null,
+  ): SpatialNode => {
+    entityLookup.addSummary(node);
+    const typeEnum = IfcTypeEnumFromString(node.type);
+    const nextStoreyId = isStoreyLikeSpatialType(typeEnum) ? node.expressId : currentStoreyId;
+    const nextSpaceId = node.type === 'IfcSpace' ? node.expressId : currentSpaceId;
+    const elements = node.elements.map((summary) => {
+      entityLookup.addSummary(summary);
+      if (nextStoreyId !== null) {
+        elementToStorey.set(summary.expressId, nextStoreyId);
+      }
+      if (nextSpaceId !== null) {
+        elementToSpace.set(summary.expressId, nextSpaceId);
+      }
+      return summary.expressId;
+    });
+
+    const childNodes = node.children.map((child) => buildNode(child, nextStoreyId, nextSpaceId));
+    const spatialNode: SpatialNode = {
+      expressId: node.expressId,
+      type: typeEnum,
+      name: node.name,
+      elevation: node.elevation ?? undefined,
+      children: childNodes,
+      elements,
+    };
+
+    if (isStoreyLikeSpatialType(typeEnum)) {
+      byStorey.set(node.expressId, elements);
+      if (typeof node.elevation === 'number') {
+        storeyElevations.set(node.expressId, node.elevation);
+      }
+    } else if (isBuildingLikeSpatialType(typeEnum)) {
+      byBuilding.set(node.expressId, elements);
+    } else if (node.type === 'IfcSite') {
+      bySite.set(node.expressId, elements);
+    } else if (node.type === 'IfcSpace') {
+      bySpace.set(node.expressId, elements);
+    }
+
+    return spatialNode;
+  };
+
+  const project = buildNode(root, null, null);
+  const getPath = buildPathResolver(project);
+  const hierarchy: SpatialHierarchy = {
+    project,
+    byStorey,
+    byBuilding,
+    bySite,
+    bySpace,
+    storeyElevations,
+    storeyHeights,
+    elementToStorey,
+    getStoreyElements(storeyId: number) {
+      return byStorey.get(storeyId) ?? [];
+    },
+    getStoreyByElevation(z: number) {
+      let closestStoreyId: number | null = null;
+      let closestDistance = Number.POSITIVE_INFINITY;
+      for (const [storeyId, elevation] of storeyElevations) {
+        const distance = Math.abs(elevation - z);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestStoreyId = storeyId;
+        }
+      }
+      return closestStoreyId;
+    },
+    getContainingSpace(elementId: number) {
+      return elementToSpace.get(elementId) ?? null;
+    },
+    getPath,
+  };
+
+  const entities = entityLookup.buildEntities();
+  return {
+    fileSize: 0,
+    schemaVersion: snapshot.schemaVersion,
+    entityCount: snapshot.entityCount,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: {
+      byId: new Map(),
+      byType: entityLookup.buildByType(),
+    },
+    strings: {} as IfcDataStore['strings'],
+    entities: entities as unknown as IfcDataStore['entities'],
+    properties: undefined as unknown as IfcDataStore['properties'],
+    quantities: undefined as unknown as IfcDataStore['quantities'],
+    relationships: undefined as unknown as IfcDataStore['relationships'],
+    spatialHierarchy: hierarchy,
+  } as IfcDataStore;
+}

package/src/utils/serverDataModel.ts

@@ -394,6 +394,10 @@ function buildEntityTable(
       if (!indices) return [];
       return indices.map(idx => expressId[idx]);
     },
+    getTypeEnum: (id) => {
+      const i = indexOfId(id);
+      return i >= 0 ? typeEnumArr[i] as IfcTypeEnum : IfcTypeEnum.Unknown;
+    },
     getExpressIdByGlobalId: (gid) => {
       return globalIdToExpressId.get(gid) ?? -1;
     },

package/src/utils/spatialHierarchy.ts

@@ -32,12 +32,9 @@ export function rebuildSpatialHierarchy(
   entities: EntityTable,
   relationships: RelationshipGraph
 ): SpatialHierarchy | undefined {
-  // PRE-BUILD INDEX MAP: O(n) once, then O(1) lookups
-  // This eliminates the O(n²) nested loops from before
-  const entityTypeMap = new Map<number, IfcTypeEnum>();
-  for (let i = 0; i < entities.count; i++) {
-    entityTypeMap.set(entities.expressId[i], entities.typeEnum[i]);
-  }
+  // Use EntityTable.getTypeEnum() for O(1) lookups via its internal idToIndex map.
+  // This avoids building a temporary Map<number, IfcTypeEnum> with 4.4M entries
+  // (~350MB for large files) that duplicates data already in the entity table.
 
   const byStorey = new Map<number, number[]>();
   const byBuilding = new Map<number, number[]>();
@@ -58,7 +55,7 @@ export function rebuildSpatialHierarchy(
   // Build node tree recursively - NOW O(1) lookups!
   function buildNode(expressId: number): SpatialNode {
     // O(1) lookup instead of O(n) linear search
-    const typeEnum = entityTypeMap.get(expressId) ?? IfcTypeEnum.Unknown;
+    const typeEnum = entities.getTypeEnum(expressId);
     const name = entities.getName(expressId) || `Entity #${expressId}`;
 
     // Get contained elements via IfcRelContainedInSpatialStructure
@@ -68,10 +65,12 @@ export function rebuildSpatialHierarchy(
       'forward'
     );
 
-    // Filter out spatial structure elements - O(1) per element now!
+    // Filter out spatial structure elements — keep unknown types (custom/newer IFC classes).
+    // getTypeEnum() returns IfcTypeEnum.Unknown for both missing and unrecognized entities;
+    // isSpatialStructureType(Unknown) is false, so unknown types pass through correctly.
     const containedElements = rawContainedElements.filter((id) => {
-      const elemType = entityTypeMap.get(id);
-      return elemType !== undefined && !isSpatialStructureType(elemType);
+      const elemType = entities.getTypeEnum(id);
+      return !isSpatialStructureType(elemType);
     });
 
     // Get aggregated children via IfcRelAggregates
@@ -84,7 +83,7 @@ export function rebuildSpatialHierarchy(
     // Filter to spatial structure types and recurse - O(1) per child now!
     const childNodes: SpatialNode[] = [];
     for (const childId of aggregatedChildren) {
-      const childType = entityTypeMap.get(childId);
+      const childType = entities.getTypeEnum(childId);
       if (childType && isSpatialStructureType(childType) && childType !== IfcTypeEnum.IfcProject) {
         childNodes.push(buildNode(childId));
       }

package/vite.config.ts

@@ -2,9 +2,13 @@ import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
 import wasm from 'vite-plugin-wasm';
 import topLevelAwait from 'vite-plugin-top-level-await';
+import { viteStaticCopy } from 'vite-plugin-static-copy';
+import { createRequire } from 'node:module';
 import path from 'path';
 import fs from 'fs';
 
+const require = createRequire(import.meta.url);
+
 // --- Build-time changelog parser ---
 
 interface ReleaseHighlight {
@@ -213,12 +217,28 @@ export default defineConfig({
     react(),
     wasm(),
     topLevelAwait(),
+    // Copy Cesium static assets (Workers, ThirdParty, Assets) to public path
+    // so CesiumJS can load them at runtime via CESIUM_BASE_URL.
+    // Use require.resolve to handle pnpm's .pnpm store structure.
+    (() => {
+      const cesiumPkg = path.dirname(require.resolve('cesium/package.json'));
+      const cesiumBuild = path.join(cesiumPkg, 'Build', 'Cesium');
+      return viteStaticCopy({
+        targets: [
+          { src: path.join(cesiumBuild, 'Workers'), dest: 'cesium' },
+          { src: path.join(cesiumBuild, 'ThirdParty'), dest: 'cesium' },
+          { src: path.join(cesiumBuild, 'Assets'), dest: 'cesium' },
+          { src: path.join(cesiumBuild, 'Widgets'), dest: 'cesium' },
+        ],
+      });
+    })(),
   ],
   define: {
     __APP_VERSION__: JSON.stringify(appVersion),
     __BUILD_DATE__: JSON.stringify(new Date().toISOString()),
     __RELEASE_HISTORY__: JSON.stringify(parseChangelogs()),
     __PACKAGE_VERSIONS__: JSON.stringify(collectPackageVersions()),
+    CESIUM_BASE_URL: JSON.stringify('/cesium'),
   },
   resolve: {
     alias: {
@@ -245,6 +265,9 @@ export default defineConfig({
       '@ifc-lite/encoding': path.resolve(__dirname, '../../packages/encoding/src'),
       '@ifc-lite/ids': path.resolve(__dirname, '../../packages/ids/src'),
       '@ifc-lite/lists': path.resolve(__dirname, '../../packages/lists/src'),
+      '@tauri-apps/api/core': path.resolve(__dirname, './src/services/tauri-core-stub.ts'),
+      '@tauri-apps/plugin-dialog': path.resolve(__dirname, './src/services/tauri-dialog-stub.ts'),
+      '@tauri-apps/plugin-fs': path.resolve(__dirname, './src/services/tauri-fs-stub.ts'),
     },
   },
   server: {
@@ -275,6 +298,24 @@ export default defineConfig({
   build: {
     target: 'esnext',
     chunkSizeWarningLimit: 6000,
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          if (id.includes('/packages/sandbox/')) return 'sandbox';
+          if (id.includes('/packages/export/')) return 'exporters';
+          if (id.includes('/packages/server-client/')) return 'server-client';
+          if (id.includes('/packages/bcf/')) return 'bcf';
+          if (id.includes('/packages/ids/')) return 'ids';
+          if (id.includes('/packages/lens/')) return 'lens';
+          if (id.includes('/packages/drawing-2d/')) return 'drawing-2d';
+          if (id.includes('/node_modules/jszip/')) return 'zip';
+          if (id.includes('/node_modules/apache-arrow/')) return 'arrow';
+          if (id.includes('/node_modules/parquet-wasm/')) return 'parquet';
+          if (id.includes('/node_modules/cesium/')) return 'cesium';
+          return undefined;
+        },
+      },
+    },
   },
   optimizeDeps: {
     exclude: [