@ifc-lite/viewer 1.19.1 → 1.21.0

package/src/utils/spatialHierarchy.test.ts

@@ -35,4 +35,120 @@ describe('rebuildSpatialHierarchy', () => {
     assert.equal(hierarchy.elementToStorey.get(4), undefined);
     assert.deepEqual(hierarchy.getPath(4).map((node) => node.expressId), [1, 2, 3]);
   });
+
+  it('propagates storey assignment to aggregated descendants of wall parts (Revit multilayer walls)', () => {
+    // Scenario: Revit-exported wall with three IfcBuildingElementPart aggregate
+    // children. The wall is directly contained in the storey via
+    // IfcRelContainedInSpatialStructure; the parts are reachable only through
+    // IfcRelAggregates. Pre-fix, the parts had no `elementToStorey` entry and
+    // clicking a part returned "no storey". The fix walks aggregate descendants
+    // of every storey-contained element and inherits the storey assignment.
+    const strings = new StringTable();
+    const entities = new EntityTableBuilder(8, strings);
+    entities.add(1, 'IFCPROJECT', 'p0', 'Project', '', '');
+    entities.add(2, 'IFCSITE', 's0', 'Site', '', '');
+    entities.add(3, 'IFCBUILDING', 'b0', 'Building', '', '');
+    entities.add(4, 'IFCBUILDINGSTOREY', 'st0', 'Level 1', '', '');
+    entities.add(5, 'IFCWALL', 'w0', 'Multilayer Wall', '', '', true);
+    entities.add(6, 'IFCBUILDINGELEMENTPART', 'part-a', 'Layer A', '', '', true);
+    entities.add(7, 'IFCBUILDINGELEMENTPART', 'part-b', 'Layer B', '', '', true);
+    entities.add(8, 'IFCBUILDINGELEMENTPART', 'part-c', 'Layer C', '', '', true);
+
+    const relationships = new RelationshipGraphBuilder();
+    // Spatial decomposition.
+    relationships.addEdge(1, 2, RelationshipType.Aggregates, 100);
+    relationships.addEdge(2, 3, RelationshipType.Aggregates, 101);
+    relationships.addEdge(3, 4, RelationshipType.Aggregates, 102);
+    // Wall is directly contained in the storey.
+    relationships.addEdge(4, 5, RelationshipType.ContainsElements, 103);
+    // Parts are aggregated into the wall (NOT directly contained in the storey).
+    relationships.addEdge(5, 6, RelationshipType.Aggregates, 104);
+    relationships.addEdge(5, 7, RelationshipType.Aggregates, 105);
+    relationships.addEdge(5, 8, RelationshipType.Aggregates, 106);
+
+    const hierarchy = rebuildSpatialHierarchy(entities.build(), relationships.build());
+    assert.ok(hierarchy);
+
+    // The wall itself is in elementToStorey (direct containment).
+    assert.equal(hierarchy.elementToStorey.get(5), 4);
+
+    // Each aggregated part now inherits the wall's storey assignment.
+    assert.equal(hierarchy.elementToStorey.get(6), 4);
+    assert.equal(hierarchy.elementToStorey.get(7), 4);
+    assert.equal(hierarchy.elementToStorey.get(8), 4);
+
+    // getStoreyElements keeps its contract: only directly-contained elements.
+    // Parts are intentionally NOT in this list — tree views rely on this.
+    assert.deepEqual(hierarchy.getStoreyElements(4), [5]);
+  });
+
+  it('preserves direct storey containment when a part is also aggregated under another element', () => {
+    // Edge case: a part is directly contained in storey A via
+    // IfcRelContainedInSpatialStructure AND aggregated under a wall in storey B.
+    // The direct containment must win (set first; descendant walk uses
+    // `if (!elementToStorey.has(...))` to avoid clobbering).
+    const strings = new StringTable();
+    const entities = new EntityTableBuilder(6, strings);
+    entities.add(1, 'IFCPROJECT', 'p0', 'Project', '', '');
+    entities.add(2, 'IFCBUILDING', 'b0', 'Building', '', '');
+    entities.add(3, 'IFCBUILDINGSTOREY', 'st-a', 'Storey A', '', '');
+    entities.add(4, 'IFCBUILDINGSTOREY', 'st-b', 'Storey B', '', '');
+    entities.add(5, 'IFCWALL', 'w0', 'Wall (Storey B)', '', '', true);
+    entities.add(6, 'IFCBUILDINGELEMENTPART', 'part-x', 'Shared Part', '', '', true);
+
+    const relationships = new RelationshipGraphBuilder();
+    relationships.addEdge(1, 2, RelationshipType.Aggregates, 200);
+    relationships.addEdge(2, 3, RelationshipType.Aggregates, 201);
+    relationships.addEdge(2, 4, RelationshipType.Aggregates, 202);
+    // Part is directly contained in storey A.
+    relationships.addEdge(3, 6, RelationshipType.ContainsElements, 203);
+    // Wall is contained in storey B.
+    relationships.addEdge(4, 5, RelationshipType.ContainsElements, 204);
+    // Wall aggregates the same part (rare but legal).
+    relationships.addEdge(5, 6, RelationshipType.Aggregates, 205);
+
+    const hierarchy = rebuildSpatialHierarchy(entities.build(), relationships.build());
+    assert.ok(hierarchy);
+    // Direct containment in storey A wins. The descendant walk from storey B's
+    // wall must NOT overwrite this.
+    assert.equal(hierarchy.elementToStorey.get(6), 3);
+    assert.equal(hierarchy.elementToStorey.get(5), 4);
+  });
+
+  it('terminates in bounded time on malformed aggregate cycles', () => {
+    // Cycle guard: part references back to wall via IfcRelAggregates. Without
+    // the `seen` set, the descendant walk would infinite-loop.
+    const strings = new StringTable();
+    const entities = new EntityTableBuilder(6, strings);
+    entities.add(1, 'IFCPROJECT', 'p0', 'Project', '', '');
+    entities.add(2, 'IFCBUILDING', 'b0', 'Building', '', '');
+    entities.add(3, 'IFCBUILDINGSTOREY', 'st0', 'Storey', '', '');
+    entities.add(4, 'IFCWALL', 'w0', 'Wall', '', '', true);
+    entities.add(5, 'IFCBUILDINGELEMENTPART', 'part-a', 'Part A', '', '', true);
+    entities.add(6, 'IFCBUILDINGELEMENTPART', 'part-b', 'Part B', '', '', true);
+
+    const relationships = new RelationshipGraphBuilder();
+    relationships.addEdge(1, 2, RelationshipType.Aggregates, 300);
+    relationships.addEdge(2, 3, RelationshipType.Aggregates, 301);
+    relationships.addEdge(3, 4, RelationshipType.ContainsElements, 302);
+    relationships.addEdge(4, 5, RelationshipType.Aggregates, 303);
+    relationships.addEdge(5, 6, RelationshipType.Aggregates, 304);
+    // Malformed back-edges forming a cycle: part-b -> wall, part-a -> wall.
+    relationships.addEdge(6, 4, RelationshipType.Aggregates, 305);
+    relationships.addEdge(5, 4, RelationshipType.Aggregates, 306);
+
+    const start = Date.now();
+    const hierarchy = rebuildSpatialHierarchy(entities.build(), relationships.build());
+    const elapsedMs = Date.now() - start;
+
+    assert.ok(hierarchy);
+    // Must finish quickly; without cycle guard this would never terminate.
+    // Generous bound for slow CI runners.
+    assert.ok(elapsedMs < 1000, `expected fast termination, took ${elapsedMs}ms`);
+
+    // All entities still get correct storey assignment despite the cycle.
+    assert.equal(hierarchy.elementToStorey.get(4), 3);
+    assert.equal(hierarchy.elementToStorey.get(5), 3);
+    assert.equal(hierarchy.elementToStorey.get(6), 3);
+  });
 });

package/src/utils/spatialHierarchy.ts

@@ -103,6 +103,29 @@ export function rebuildSpatialHierarchy(
     if (isStoreyLikeSpatialType(typeEnum)) {
       for (const elementId of containedElements) {
         elementToStorey.set(elementId, expressId);
+        // Propagate storey assignment to aggregated descendants (e.g. IfcBuildingElementPart
+        // children of an IfcWall). Without this, parts have no reverse-lookup entry even
+        // though the renderer emits them as standalone meshes.
+        // Cycle guard: malformed IFC files can have aggregate cycles.
+        // Direct storey containment wins — only set the descendant mapping if not already set.
+        const stack: number[] = [elementId];
+        const seen = new Set<number>([elementId]);
+        while (stack.length > 0) {
+          const current = stack.pop() as number;
+          const aggregatedKids = relationships.getRelated(
+            current,
+            RelationshipType.Aggregates,
+            'forward'
+          );
+          for (const kid of aggregatedKids) {
+            if (seen.has(kid)) continue;
+            seen.add(kid);
+            if (!elementToStorey.has(kid)) {
+              elementToStorey.set(kid, expressId);
+            }
+            stack.push(kid);
+          }
+        }
       }
     }
 

package/tailwind.config.js

@@ -60,11 +60,16 @@ export default {
           '0%, 100%': { opacity: '1' },
           '50%': { opacity: '0.7' },
         },
+        'fade-in-up': {
+          from: { opacity: '0', transform: 'translateY(-4px)' },
+          to: { opacity: '1', transform: 'translateY(0)' },
+        },
       },
       animation: {
         'accordion-down': 'accordion-down 0.2s ease-out',
         'accordion-up': 'accordion-up 0.2s ease-out',
         'pulse-subtle': 'pulse-subtle 2s ease-in-out infinite',
+        'fade-in-up': 'fade-in-up 180ms ease-out both',
       },
     },
   },

package/tsconfig.json

@@ -7,6 +7,7 @@
     "paths": {
       "@/*": ["./src/*"],
       "@ifc-lite/parser": ["../../packages/parser/src"],
+      "@ifc-lite/parser/browser": ["../../packages/parser/src/browser"],
       "@ifc-lite/geometry": ["../../packages/geometry/src"],
       "@ifc-lite/renderer": ["../../packages/renderer/src"],
       "@ifc-lite/query": ["../../packages/query/src"],

package/vite.config.ts

@@ -243,6 +243,7 @@ export default defineConfig({
   resolve: {
     alias: {
       '@': path.resolve(__dirname, './src'),
+      '@ifc-lite/parser/browser': path.resolve(__dirname, '../../packages/parser/src/browser.ts'),
       '@ifc-lite/parser': path.resolve(__dirname, '../../packages/parser/src'),
       '@ifc-lite/geometry': path.resolve(__dirname, '../../packages/geometry/src'),
       '@ifc-lite/renderer': path.resolve(__dirname, '../../packages/renderer/src'),
@@ -255,6 +256,11 @@ export default defineConfig({
       '@ifc-lite/ifcx': path.resolve(__dirname, '../../packages/ifcx/src'),
       '@ifc-lite/pointcloud': path.resolve(__dirname, '../../packages/pointcloud/src'),
       '@ifc-lite/wasm': path.resolve(__dirname, '../../packages/wasm/pkg/ifc-lite.js'),
+      // Phase 2 of single-controller-rayon-design.md — threaded bundle
+      // imported by `geometry-controller.worker.ts`. Kept separate from
+      // `@ifc-lite/wasm` so legacy code that doesn't need threading
+      // stays on the slim single-thread bundle.
+      '@ifc-lite/wasm-threaded': path.resolve(__dirname, '../../packages/wasm-threaded/pkg/ifc-lite.js'),
       '@ifc-lite/sdk': path.resolve(__dirname, '../../packages/sdk/src'),
       '@ifc-lite/create': path.resolve(__dirname, '../../packages/create/src'),
       '@ifc-lite/sandbox/schema': path.resolve(__dirname, '../../packages/sandbox/src/bridge-schema.ts'),