@ifc-lite/viewer 1.14.0 → 1.14.1

package/dist/assets/{index-BMwpw264.js → index-JPFMj8C9.js}

@@ -1,6 +1,6 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/browser-D6lgLpkA.js","assets/index-UaDsJsCR.js","assets/index-Qp8stcGO.css"])))=>i.map(i=>d[i]);
-import { _ as u, b as S, __tla as __tla_0 } from "./index-UaDsJsCR.js";
-import { N as j, m as B, __tla as __tla_1 } from "./index-UaDsJsCR.js";
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/browser-Ch0OnmZN.js","assets/index-DJbbSLF9.js","assets/index-Qp8stcGO.css"])))=>i.map(i=>d[i]);
+import { _ as u, b as S, __tla as __tla_0 } from "./index-DJbbSLF9.js";
+import { N as j, m as B, __tla as __tla_1 } from "./index-DJbbSLF9.js";
 let c, g, L, D, x, R, A;
 let __tla = Promise.all([
     (()=>{
@@ -87,7 +87,7 @@ let __tla = Promise.all([
     function k() {
         return m || (m = (async ()=>{
             try {
-                const e = await u(()=>import("./browser-D6lgLpkA.js").then((i)=>i.b), __vite__mapDeps([0,1,2])), t = e.default ?? e;
+                const e = await u(()=>import("./browser-Ch0OnmZN.js").then((i)=>i.b), __vite__mapDeps([0,1,2])), t = e.default ?? e;
                 let s;
                 try {
                     s = (await u(()=>import("./esbuild-COv63sf-.js"), [])).default;

package/dist/assets/{native-bridge-DqELq4X0.js → native-bridge-BzC7HkDs.js}

@@ -1,4 +1,4 @@
-import { _ as c, __tla as __tla_0 } from "./index-UaDsJsCR.js";
+import { _ as c, __tla as __tla_0 } from "./index-DJbbSLF9.js";
 let m;
 let __tla = Promise.all([
     (()=>{

package/dist/assets/{wasm-bridge-CVWvHlfH.js → wasm-bridge-B_7dPwOa.js}

@@ -1 +1 @@
-import{I as f,a as m}from"./index-UaDsJsCR.js";class u{bridge;initialized=!1;constructor(){this.bridge=new f}async init(){this.initialized||(await this.bridge.init(),this.initialized=!0)}isInitialized(){return this.initialized}async processGeometry(s){this.initialized||await this.init(),performance.now();const i=new m(this.bridge.getApi(),s),n=i.collectMeshes(),r=i.getBuildingRotation();performance.now();let e=0,o=0;for(const c of n)e+=c.positions.length/3,o+=c.indices.length/3;return{meshes:n,totalVertices:e,totalTriangles:o,coordinateInfo:{originShift:{x:0,y:0,z:0},originalBounds:{min:{x:0,y:0,z:0},max:{x:0,y:0,z:0}},shiftedBounds:{min:{x:0,y:0,z:0},max:{x:0,y:0,z:0}},hasLargeCoordinates:!1,buildingRotation:r}}}async processGeometryStreaming(s,i){this.initialized||await this.init();const n=performance.now(),r=new m(this.bridge.getApi(),s);let e=0,o=0,a=0;try{for await(const t of r.collectMeshesStreaming(50)){if(t&&typeof t=="object"&&"type"in t&&t.type==="colorUpdate")continue;const l=t;e+=l.length;for(const d of l)o+=d.positions.length/3,a+=d.indices.length/3;i.onBatch?.({meshes:l,progress:{processed:e,total:e,currentType:"processing"}})}}catch(t){throw i.onError?.(t instanceof Error?t:new Error(String(t))),t}const h=performance.now()-n,g={totalMeshes:e,totalVertices:o,totalTriangles:a,parseTimeMs:h*.3,geometryTimeMs:h*.7};return i.onComplete?.(g),g}getApi(){return this.bridge.getApi()}}export{u as WasmBridge};
+import{I as f,a as m}from"./index-DJbbSLF9.js";class u{bridge;initialized=!1;constructor(){this.bridge=new f}async init(){this.initialized||(await this.bridge.init(),this.initialized=!0)}isInitialized(){return this.initialized}async processGeometry(s){this.initialized||await this.init(),performance.now();const i=new m(this.bridge.getApi(),s),n=i.collectMeshes(),r=i.getBuildingRotation();performance.now();let e=0,o=0;for(const c of n)e+=c.positions.length/3,o+=c.indices.length/3;return{meshes:n,totalVertices:e,totalTriangles:o,coordinateInfo:{originShift:{x:0,y:0,z:0},originalBounds:{min:{x:0,y:0,z:0},max:{x:0,y:0,z:0}},shiftedBounds:{min:{x:0,y:0,z:0},max:{x:0,y:0,z:0}},hasLargeCoordinates:!1,buildingRotation:r}}}async processGeometryStreaming(s,i){this.initialized||await this.init();const n=performance.now(),r=new m(this.bridge.getApi(),s);let e=0,o=0,a=0;try{for await(const t of r.collectMeshesStreaming(50)){if(t&&typeof t=="object"&&"type"in t&&t.type==="colorUpdate")continue;const l=t;e+=l.length;for(const d of l)o+=d.positions.length/3,a+=d.indices.length/3;i.onBatch?.({meshes:l,progress:{processed:e,total:e,currentType:"processing"}})}}catch(t){throw i.onError?.(t instanceof Error?t:new Error(String(t))),t}const h=performance.now()-n,g={totalMeshes:e,totalVertices:o,totalTriangles:a,parseTimeMs:h*.3,geometryTimeMs:h*.7};return i.onComplete?.(g),g}getApi(){return this.bridge.getApi()}}export{u as WasmBridge};

package/dist/index.html

@@ -44,7 +44,7 @@
   <meta name="theme-color" content="#7aa2f7">
   <meta name="msapplication-TileColor" content="#1a1b26">
   <meta name="msapplication-TileImage" content="/favicon-192x192-cropped.png">
-  <script type="module" crossorigin src="/assets/index-UaDsJsCR.js"></script>
+  <script type="module" crossorigin src="/assets/index-DJbbSLF9.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-Qp8stcGO.css">
 </head>
 <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/viewer",
-  "version": "1.14.0",
+  "version": "1.14.1",
   "description": "IFC-Lite viewer application",
   "type": "module",
   "dependencies": {
@@ -41,24 +41,24 @@
     "tailwind-merge": "^3.4.0",
     "tailwindcss": "^4.1.18",
     "zustand": "^4.4.0",
-    "@ifc-lite/bcf": "^1.14.0",
-    "@ifc-lite/cache": "^1.14.0",
-    "@ifc-lite/data": "^1.14.0",
-    "@ifc-lite/drawing-2d": "^1.14.0",
-    "@ifc-lite/encoding": "^1.14.0",
-    "@ifc-lite/export": "^1.14.0",
-    "@ifc-lite/geometry": "^1.14.0",
-    "@ifc-lite/ids": "^1.14.0",
-    "@ifc-lite/lens": "^1.14.0",
-    "@ifc-lite/lists": "^1.14.0",
-    "@ifc-lite/mutations": "^1.14.0",
-    "@ifc-lite/parser": "^1.14.0",
-    "@ifc-lite/query": "^1.14.0",
-    "@ifc-lite/renderer": "^1.14.0",
-    "@ifc-lite/sandbox": "^1.14.0",
-    "@ifc-lite/server-client": "^1.14.0",
-    "@ifc-lite/spatial": "^1.14.0",
-    "@ifc-lite/wasm": "^1.14.0"
+    "@ifc-lite/bcf": "^1.14.1",
+    "@ifc-lite/cache": "^1.14.1",
+    "@ifc-lite/data": "^1.14.1",
+    "@ifc-lite/drawing-2d": "^1.14.1",
+    "@ifc-lite/encoding": "^1.14.1",
+    "@ifc-lite/export": "^1.14.1",
+    "@ifc-lite/geometry": "^1.14.1",
+    "@ifc-lite/ids": "^1.14.1",
+    "@ifc-lite/lens": "^1.14.1",
+    "@ifc-lite/lists": "^1.14.1",
+    "@ifc-lite/mutations": "^1.14.1",
+    "@ifc-lite/parser": "^1.14.1",
+    "@ifc-lite/query": "^1.14.1",
+    "@ifc-lite/renderer": "^1.14.1",
+    "@ifc-lite/sandbox": "^1.14.1",
+    "@ifc-lite/server-client": "^1.14.1",
+    "@ifc-lite/spatial": "^1.14.1",
+    "@ifc-lite/wasm": "^1.14.1"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",

package/src/components/viewer/HierarchyPanel.tsx

@@ -200,7 +200,9 @@ export function HierarchyPanel() {
     if (node.type === 'type-group') {
       const elements = getNodeElements(node);
       if (elements.length > 0) {
-        setSelectedEntityIds(elements);
+        // Clear multi-selection highlight — isolate shows the class members,
+        // but we don't want every element highlighted/selected
+        setSelectedEntityIds([]);
         setSelectedEntity(resolveEntityRef(elements[0]));
         isolateEntities(elements);
       }
@@ -288,6 +290,10 @@ export function HierarchyPanel() {
       const elementId = node.expressIds[0];  // Original expressId
       const modelId = node.modelIds[0];
 
+      // Clear multi-selection (e.g. from a prior type-group click) so only
+      // this single element is highlighted, matching Viewport pick behavior
+      setSelectedEntityIds([]);
+
       if (modelId !== 'legacy') {
         // Multi-model: need to convert to globalId for renderer
         const model = models.get(modelId);

package/src/components/viewer/MainToolbar.tsx

@@ -196,37 +196,70 @@ export function MainToolbar({ onShowShortcuts }: MainToolbarProps = {} as MainTo
   const toggleLensPanel = useViewerStore((state) => state.toggleLensPanel);
   const setLensPanelVisible = useViewerStore((state) => state.setLensPanelVisible);
 
-  // Check which type geometries exist across ALL loaded models (federation-aware)
+  // Check which type geometries exist across ALL loaded models (federation-aware).
+  // PERF: Use meshes.length as dep proxy instead of full geometryResult, and
+  // scan incrementally — once a type is found it stays found, so we only scan
+  // NEW meshes since the last check. Per-model cursors ensure federated models
+  // each track their own scan position independently.
+  const typeGeomScanRef = useRef({
+    spaces: false, openings: false, site: false,
+    legacyLastLen: 0,
+    modelLastLen: new Map<string | number, number>(),
+  });
+  const meshLen = geometryResult?.meshes.length ?? 0;
   const typeGeometryExists = useMemo(() => {
-    const result = { spaces: false, openings: false, site: false };
+    const scan = typeGeomScanRef.current;
+
+    // Reset if legacy meshes array shrunk (new file loaded)
+    if (meshLen < scan.legacyLastLen) {
+      scan.spaces = false;
+      scan.openings = false;
+      scan.site = false;
+      scan.legacyLastLen = 0;
+      scan.modelLastLen.clear();
+    }
+
+    // Already found all types — nothing to do
+    if (scan.spaces && scan.openings && scan.site) {
+      return { spaces: scan.spaces, openings: scan.openings, site: scan.site };
+    }
 
-    // Check all federated models
+    // Check federated models (scan only new meshes per model)
     if (models.size > 0) {
-      for (const [, model] of models) {
+      for (const [modelId, model] of models) {
         const meshes = model.geometryResult?.meshes;
         if (!meshes) continue;
-        for (const m of meshes) {
-          if (m.ifcType === 'IfcSpace') result.spaces = true;
-          else if (m.ifcType === 'IfcOpeningElement') result.openings = true;
-          else if (m.ifcType === 'IfcSite') result.site = true;
-          // Early exit if all found
-          if (result.spaces && result.openings && result.site) return result;
+        const modelStart = scan.modelLastLen.get(modelId) ?? 0;
+        // Reset cursor if model was reloaded (mesh array shrunk)
+        const start = meshes.length < modelStart ? 0 : modelStart;
+        for (let i = start; i < meshes.length; i++) {
+          const t = meshes[i].ifcType;
+          if (t === 'IfcSpace') scan.spaces = true;
+          else if (t === 'IfcOpeningElement') scan.openings = true;
+          else if (t === 'IfcSite') scan.site = true;
+          if (scan.spaces && scan.openings && scan.site) break;
         }
+        scan.modelLastLen.set(modelId, meshes.length);
+        if (scan.spaces && scan.openings && scan.site) break;
       }
     }
 
-    // Fallback: also check legacy single-model geometryResult
+    // Legacy single-model path (scan only new meshes)
     if (geometryResult?.meshes) {
-      for (const m of geometryResult.meshes) {
-        if (m.ifcType === 'IfcSpace') result.spaces = true;
-        else if (m.ifcType === 'IfcOpeningElement') result.openings = true;
-        else if (m.ifcType === 'IfcSite') result.site = true;
-        if (result.spaces && result.openings && result.site) return result;
+      const meshes = geometryResult.meshes;
+      for (let i = scan.legacyLastLen; i < meshes.length; i++) {
+        const t = meshes[i].ifcType;
+        if (t === 'IfcSpace') scan.spaces = true;
+        else if (t === 'IfcOpeningElement') scan.openings = true;
+        else if (t === 'IfcSite') scan.site = true;
+        if (scan.spaces && scan.openings && scan.site) break;
       }
     }
 
-    return result;
-  }, [models, geometryResult]);
+    scan.legacyLastLen = meshLen;
+    return { spaces: scan.spaces, openings: scan.openings, site: scan.site };
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- meshLen is a stable proxy for geometryResult
+  }, [models, meshLen]);
 
   const handleFileSelect = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
     const files = e.target.files;

package/src/components/viewer/Viewport.tsx

@@ -40,12 +40,15 @@ import { useRenderUpdates } from './useRenderUpdates.js';
 
 interface ViewportProps {
   geometry: MeshData[] | null;
+  /** Monotonic counter that increments when geometry changes — used to trigger
+   *  streaming effects even when the geometry array reference is stable. */
+  geometryVersion?: number;
   coordinateInfo?: CoordinateInfo;
   computedIsolatedIds?: Set<number> | null;
   modelIdToIndex?: Map<string, number>;
 }
 
-export function Viewport({ geometry, coordinateInfo, computedIsolatedIds, modelIdToIndex }: ViewportProps) {
+export function Viewport({ geometry, geometryVersion, coordinateInfo, computedIsolatedIds, modelIdToIndex }: ViewportProps) {
   const canvasRef = useRef<HTMLCanvasElement>(null);
   const rendererRef = useRef<Renderer | null>(null);
   const [isInitialized, setIsInitialized] = useState(false);
@@ -789,6 +792,7 @@ export function Viewport({ geometry, coordinateInfo, computedIsolatedIds, modelI
     rendererRef,
     isInitialized,
     geometry,
+    geometryVersion,
     coordinateInfo,
     isStreaming,
     geometryBoundsRef,

package/src/components/viewer/ViewportContainer.tsx

@@ -173,58 +173,79 @@ export function ViewportContainer() {
   // Check if any models are loaded (even if hidden) - used to show empty 3D vs starting UI
   const hasLoadedModels = storeModels.size > 0 || (geometryResult?.meshes && geometryResult.meshes.length > 0);
 
-  // Filter geometry based on type visibility only
-  // PERFORMANCE FIX: Don't filter by storey or hiddenEntities here
-  // Instead, let the renderer handle visibility filtering at the batch level
-  // This avoids expensive batch rebuilding when visibility changes
+  // PERF: Incremental geometry filtering using refs.
+  // Instead of creating a new 200K+ element array every batch (~200ms),
+  // we push ONLY new meshes into a cached array — O(batch_size) not O(total).
+  // A version counter triggers downstream re-renders via the Viewport prop.
+  const filteredCacheRef = useRef<MeshData[]>([]);
+  const filteredSourceLenRef = useRef(0);
+  const filteredTypeVisRef = useRef(typeVisibility);
+  const filteredVersionRef = useRef(0);
+
   const filteredGeometry = useMemo(() => {
     if (!mergedGeometryResult?.meshes) {
+      filteredCacheRef.current = [];
+      filteredSourceLenRef.current = 0;
+      filteredVersionRef.current = 0;
       return null;
     }
 
-    let meshes = mergedGeometryResult.meshes;
+    const allMeshes = mergedGeometryResult.meshes;
+    const cache = filteredCacheRef.current;
+
+    // Full rebuild if: type visibility changed, source shrunk (new file), or empty cache
+    const prevVis = filteredTypeVisRef.current;
+    const typeVisChanged =
+      prevVis.spaces !== typeVisibility.spaces ||
+      prevVis.openings !== typeVisibility.openings ||
+      prevVis.site !== typeVisibility.site;
+    if (typeVisChanged || allMeshes.length < filteredSourceLenRef.current) {
+      cache.length = 0;
+      filteredSourceLenRef.current = 0;
+      filteredTypeVisRef.current = typeVisibility;
+    }
+
+    const needsFilter = !typeVisibility.spaces || !typeVisibility.openings || !typeVisibility.site;
+    const prevCacheLen = cache.length;
 
-    // Filter by type visibility (spatial elements)
-    meshes = meshes.filter(mesh => {
+    // Only process NEW meshes since last run — O(batch_size) not O(total)
+    for (let i = filteredSourceLenRef.current; i < allMeshes.length; i++) {
+      const mesh = allMeshes[i];
       const ifcType = mesh.ifcType;
 
-      // Check type visibility
-      if (ifcType === 'IfcSpace' && !typeVisibility.spaces) {
-        return false;
+      if (needsFilter) {
+        if (ifcType === 'IfcSpace' && !typeVisibility.spaces) continue;
+        if (ifcType === 'IfcOpeningElement' && !typeVisibility.openings) continue;
+        if (ifcType === 'IfcSite' && !typeVisibility.site) continue;
       }
-      if (ifcType === 'IfcOpeningElement' && !typeVisibility.openings) {
-        return false;
-      }
-      if (ifcType === 'IfcSite' && !typeVisibility.site) {
-        return false;
-      }
-
-      return true;
-    });
 
-    // Apply transparency for spatial elements
-    meshes = meshes.map(mesh => {
-      const ifcType = mesh.ifcType;
-      const isSpace = ifcType === 'IfcSpace';
-      const isOpening = ifcType === 'IfcOpeningElement';
-
-      if (isSpace || isOpening) {
-        // Create a new color array with reduced opacity
-        const newColor: [number, number, number, number] = [
-          mesh.color[0],
-          mesh.color[1],
-          mesh.color[2],
-          Math.min(mesh.color[3] * 0.3, 0.3), // Semi-transparent (30% opacity max)
-        ];
-        return { ...mesh, color: newColor };
+      if (ifcType === 'IfcSpace' || ifcType === 'IfcOpeningElement') {
+        cache.push({
+          ...mesh,
+          color: [mesh.color[0], mesh.color[1], mesh.color[2], Math.min(mesh.color[3] * 0.3, 0.3)],
+        });
+      } else {
+        cache.push(mesh);
       }
+    }
 
-      return mesh;
-    });
+    filteredSourceLenRef.current = allMeshes.length;
 
-    return meshes;
+    // Only bump version when cache content actually changed — avoids
+    // unnecessary downstream re-renders when memo runs with same data.
+    if (cache.length !== prevCacheLen || typeVisChanged) {
+      filteredVersionRef.current++;
+    }
+
+    // Return the same array reference — downstream change detection uses
+    // geometryVersion (which increments each batch) instead of array identity.
+    return cache;
   }, [mergedGeometryResult, typeVisibility]);
 
+  // Version counter that changes every batch — triggers useGeometryStreaming
+  // without requiring a new geometry array reference.
+  const geometryVersion = filteredVersionRef.current;
+
   // Compute combined isolation set (storeys + manual isolation)
   // This is passed to the renderer for batch-level visibility filtering
   // Now supports multi-model: aggregates elements from all models for selected storeys
@@ -580,6 +601,7 @@ export function ViewportContainer() {
 
       <Viewport
         geometry={filteredGeometry}
+        geometryVersion={geometryVersion}
         coordinateInfo={mergedGeometryResult?.coordinateInfo}
         computedIsolatedIds={computedIsolatedIds}
         modelIdToIndex={modelIdToIndex}

package/src/components/viewer/hierarchy/useHierarchyTree.ts

@@ -164,11 +164,15 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
     return geometryResult?.meshes.length ?? 0;
   }, [models, geometryResult?.meshes.length]);
 
-  // Pre-computed set of global IDs with geometry — stable across color changes
+  // Pre-computed set of global IDs with geometry — stable across color changes.
+  // PERF: Skip when no geometry source exists (during initial streaming before
+  // any data is ready). Gate on models OR ifcDataStore so federated scenarios
+  // (models.size > 0 but ifcDataStore is null) still build the set correctly.
+  const hasGeometrySource = models.size > 0 || !!ifcDataStore;
   const geometricIds = useMemo(
-    () => buildGeometricIdSet(models, geometryResult),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- meshCount is a stable proxy
-    [models, meshCount]
+    () => hasGeometrySource ? buildGeometricIdSet(models, geometryResult) : new Set<number>(),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- meshCount is a stable proxy; hasGeometrySource gates streaming
+    [models, hasGeometrySource ? meshCount : 0]
   );
 
   // Build the tree data structure based on grouping mode

package/src/components/viewer/properties/BsddCard.tsx

@@ -16,7 +16,7 @@ import { Button } from '@/components/ui/button';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { Badge } from '@/components/ui/badge';
 import { useViewerStore } from '@/store';
-import { PropertyValueType, QuantityType } from '@ifc-lite/data';
+import { type PropertyValue, PropertyValueType, QuantityType } from '@ifc-lite/data';
 import {
   fetchClassInfo,
   bsddDataTypeLabel,
@@ -59,7 +59,7 @@ function toPropertyValueType(bsddType: string | null): PropertyValueType {
   return PropertyValueType.Label;
 }
 
-function defaultValue(_bsddType: string | null): unknown {
+function defaultValue(_bsddType: string | null): PropertyValue {
   // Always return empty string – user fills in values manually
   return '';
 }