@ifc-lite/viewer 1.14.3 → 1.14.4

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

@@ -4,7 +4,7 @@
 
 import { IfcTypeEnum, EntityFlags, RelationshipType, type SpatialNode } from '@ifc-lite/data';
 import type { IfcDataStore } from '@ifc-lite/parser';
-import type { FederatedModel } from '@/store';
+import { useViewerStore, type FederatedModel } from '@/store';
 import type { TreeNode, NodeType, StoreyData, UnifiedStorey } from './types';
 
 /** Helper to create elevation key (with 0.5m tolerance for matching) */
@@ -19,10 +19,74 @@ export function getNodeType(ifcType: IfcTypeEnum): NodeType {
     case IfcTypeEnum.IfcSite: return 'IfcSite';
     case IfcTypeEnum.IfcBuilding: return 'IfcBuilding';
     case IfcTypeEnum.IfcBuildingStorey: return 'IfcBuildingStorey';
+    case IfcTypeEnum.IfcSpace: return 'IfcSpace';
     default: return 'element';
   }
 }
 
+function resolveTreeGlobalId(
+  modelId: string,
+  expressId: number,
+  models: Map<string, FederatedModel>
+): number {
+  if (modelId === 'legacy' || !models.has(modelId)) {
+    return expressId;
+  }
+
+  return useViewerStore.getState().toGlobalId(modelId, expressId);
+}
+
+function collectDescendantSpaceElements(
+  spatialNode: SpatialNode,
+  hierarchy: IfcDataStore['spatialHierarchy'],
+  cache: Map<number, Set<number>>
+): Set<number> {
+  const cached = cache.get(spatialNode.expressId);
+  if (cached) return cached;
+
+  const elementIds = new Set<number>();
+
+  for (const child of spatialNode.children || []) {
+    if (getNodeType(child.type) === 'IfcSpace') {
+      for (const elementId of hierarchy?.bySpace.get(child.expressId) ?? []) {
+        elementIds.add(elementId);
+      }
+    }
+
+    for (const elementId of collectDescendantSpaceElements(child, hierarchy, cache)) {
+      elementIds.add(elementId);
+    }
+  }
+
+  cache.set(spatialNode.expressId, elementIds);
+  return elementIds;
+}
+
+function getSpatialNodeElements(
+  spatialNode: SpatialNode,
+  dataStore: IfcDataStore,
+  nodeType: NodeType,
+  descendantSpaceCache: Map<number, Set<number>>
+): number[] {
+  if (nodeType === 'IfcSpace') {
+    return (dataStore.spatialHierarchy?.bySpace.get(spatialNode.expressId) as number[]) || [];
+  }
+
+  if (nodeType !== 'IfcBuildingStorey') {
+    return [];
+  }
+
+  const storeyElements =
+    (dataStore.spatialHierarchy?.byStorey.get(spatialNode.expressId) as number[]) || [];
+  const descendantSpaceElements = collectDescendantSpaceElements(
+    spatialNode,
+    dataStore.spatialHierarchy,
+    descendantSpaceCache
+  );
+
+  return storeyElements.filter((elementId) => !descendantSpaceElements.has(elementId));
+}
+
 /** Build unified storey data for multi-model mode */
 export function buildUnifiedStoreys(models: Map<string, FederatedModel>): UnifiedStorey[] {
   if (models.size <= 1) return [];
@@ -82,11 +146,8 @@ export function getUnifiedStoreyElements(
   const allElements = new Array<number>(totalLength);
   let idx = 0;
   for (const storey of unifiedStorey.storeys) {
-    const model = models.get(storey.modelId);
-    const offset = model?.idOffset ?? 0;
-    // Direct assignment instead of spread for better performance
     for (const id of storey.elements) {
-      allElements[idx++] = id + offset;
+      allElements[idx++] = resolveTreeGlobalId(storey.modelId, id, models);
     }
   }
   return allElements;
@@ -96,13 +157,15 @@ export function getUnifiedStoreyElements(
 function buildSpatialNodes(
   spatialNode: SpatialNode,
   modelId: string,
+  models: Map<string, FederatedModel>,
   dataStore: IfcDataStore,
   depth: number,
   parentNodeId: string,
   stopAtBuilding: boolean,
   idOffset: number,
   expandedNodes: Set<string>,
-  nodes: TreeNode[]
+  nodes: TreeNode[],
+  descendantSpaceCache: Map<number, Set<number>>
 ): void {
   const nodeId = `${parentNodeId}-${spatialNode.expressId}`;
   const nodeType = getNodeType(spatialNode.type);
@@ -113,11 +176,7 @@ function buildSpatialNodes(
     return;
   }
 
-  // For storeys, get elements from byStorey map
-  let elements: number[] = [];
-  if (nodeType === 'IfcBuildingStorey') {
-    elements = (dataStore.spatialHierarchy?.byStorey.get(spatialNode.expressId) as number[]) || [];
-  }
+  const elements = getSpatialNodeElements(spatialNode, dataStore, nodeType, descendantSpaceCache);
 
   // Check if has children
   // In stopAtBuilding mode, buildings have no children (storeys shown separately)
@@ -126,11 +185,13 @@ function buildSpatialNodes(
   );
   const hasChildren = stopAtBuilding
     ? (nodeType !== 'IfcBuilding' && hasNonStoreyChildren)
-    : (spatialNode.children?.length > 0) || (nodeType === 'IfcBuildingStorey' && elements.length > 0);
+    : (spatialNode.children?.length > 0) ||
+      ((nodeType === 'IfcBuildingStorey' || nodeType === 'IfcSpace') && elements.length > 0);
 
   nodes.push({
     id: nodeId,
     expressIds: [spatialNode.expressId],
+    globalIds: [resolveTreeGlobalId(modelId, spatialNode.expressId, models)],
     modelIds: [modelId],
     name: (spatialNode.name && spatialNode.name.toLowerCase() !== 'unknown')
       ? spatialNode.name
@@ -140,7 +201,7 @@ function buildSpatialNodes(
     hasChildren,
     isExpanded: isNodeExpanded,
     isVisible: true, // Visibility computed lazily during render
-    elementCount: nodeType === 'IfcBuildingStorey' ? elements.length : undefined,
+    elementCount: nodeType === 'IfcBuildingStorey' || nodeType === 'IfcSpace' ? elements.length : undefined,
     storeyElevation: spatialNode.elevation,
     // Store idOffset for lazy visibility computation
     _idOffset: idOffset,
@@ -153,22 +214,36 @@ function buildSpatialNodes(
       : spatialNode.children || [];
 
     for (const child of sortedChildren) {
-      buildSpatialNodes(child, modelId, dataStore, depth + 1, nodeId, stopAtBuilding, idOffset, expandedNodes, nodes);
+      buildSpatialNodes(
+        child,
+        modelId,
+        models,
+        dataStore,
+        depth + 1,
+        nodeId,
+        stopAtBuilding,
+        idOffset,
+        expandedNodes,
+        nodes,
+        descendantSpaceCache
+      );
     }
 
     // For storeys (single-model only), add elements
-    if (!stopAtBuilding && nodeType === 'IfcBuildingStorey' && elements.length > 0) {
+    if (!stopAtBuilding && (nodeType === 'IfcBuildingStorey' || nodeType === 'IfcSpace') && elements.length > 0) {
       for (const elementId of elements) {
-        const globalId = elementId + idOffset;
+        const globalId = resolveTreeGlobalId(modelId, elementId, models);
         const entityType = dataStore.entities?.getTypeName(elementId) || 'Unknown';
         const entityName = dataStore.entities?.getName(elementId) || `${entityType} #${elementId}`;
 
         nodes.push({
           id: `element-${modelId}-${elementId}`,
-          expressIds: [globalId],  // Store global ID for visibility operations
+          expressIds: [elementId],
+          globalIds: [globalId],
           modelIds: [modelId],
           name: entityName,
           type: 'element',
+          ifcType: entityType,
           depth: depth + 1,
           hasChildren: false,
           isExpanded: false,
@@ -200,6 +275,7 @@ export function buildTreeData(
       nodes.push({
         id: storeyNodeId,
         expressIds: allStoreyIds,
+        globalIds: unified.storeys.map((s) => s.storeyId + (models.get(s.modelId)?.idOffset ?? 0)),
         modelIds: unified.storeys.map(s => s.modelId),
         name: unified.name,
         type: 'unified-storey',
@@ -225,6 +301,7 @@ export function buildTreeData(
           nodes.push({
             id: contribNodeId,
             expressIds: [storey.storeyId],
+            globalIds: [resolveTreeGlobalId(storey.modelId, storey.storeyId, models)],
             modelIds: [storey.modelId],
             name: modelName,
             type: 'model-header',
@@ -240,16 +317,18 @@ export function buildTreeData(
           if (contribExpanded) {
             const dataStore = model?.ifcDataStore;
             for (const elementId of storey.elements) {
-              const globalId = elementId + offset;
+              const globalId = resolveTreeGlobalId(storey.modelId, elementId, models);
               const entityType = dataStore?.entities?.getTypeName(elementId) || 'Unknown';
               const entityName = dataStore?.entities?.getName(elementId) || `${entityType} #${elementId}`;
 
               nodes.push({
                 id: `element-${storey.modelId}-${elementId}`,
-                expressIds: [globalId],  // Store global ID for visibility operations
+                expressIds: [elementId],
+                globalIds: [globalId],
                 modelIds: [storey.modelId],
                 name: entityName,
                 type: 'element',
+                ifcType: entityType,
                 depth: 2,
                 hasChildren: false,
                 isExpanded: false,
@@ -265,6 +344,7 @@ export function buildTreeData(
     nodes.push({
       id: 'models-header',
       expressIds: [],
+      globalIds: [],
       modelIds: [],
       name: 'Models',
       type: 'model-header',
@@ -283,6 +363,7 @@ export function buildTreeData(
       nodes.push({
         id: modelNodeId,
         expressIds: [],
+        globalIds: [],
         modelIds: [modelId],
         name: model.name,
         type: 'model-header',
@@ -295,16 +376,19 @@ export function buildTreeData(
 
       // If expanded, show Project -> Site -> Building (stop at building, no storeys)
       if (isModelExpanded && model.ifcDataStore?.spatialHierarchy?.project) {
+        const descendantSpaceCache = new Map<number, Set<number>>();
         buildSpatialNodes(
           model.ifcDataStore.spatialHierarchy.project,
           modelId,
+          models,
           model.ifcDataStore,
           1,
           modelNodeId,
           true,  // stopAtBuilding = true
           model.idOffset ?? 0,
           expandedNodes,
-          nodes
+          nodes,
+          descendantSpaceCache
         );
       }
     }
@@ -312,30 +396,36 @@ export function buildTreeData(
     // Single model: show full spatial hierarchy (including storeys)
     const [modelId, model] = Array.from(models.entries())[0];
     if (model.ifcDataStore?.spatialHierarchy?.project) {
+      const descendantSpaceCache = new Map<number, Set<number>>();
       buildSpatialNodes(
         model.ifcDataStore.spatialHierarchy.project,
         modelId,
+        models,
         model.ifcDataStore,
         0,
         'root',
         false,  // stopAtBuilding = false (show full hierarchy)
         model.idOffset ?? 0,
         expandedNodes,
-        nodes
+        nodes,
+        descendantSpaceCache
       );
     }
   } else if (ifcDataStore?.spatialHierarchy?.project) {
     // Legacy single-model mode (no offset)
+    const descendantSpaceCache = new Map<number, Set<number>>();
     buildSpatialNodes(
       ifcDataStore.spatialHierarchy.project,
       'legacy',
+      models,
       ifcDataStore,
       0,
       'root',
       false,
       0,
       expandedNodes,
-      nodes
+      nodes,
+      descendantSpaceCache
     );
   }
 
@@ -355,10 +445,10 @@ export function buildTypeTree(
   // Collect entities grouped by IFC class across all models
   const typeGroups = new Map<string, Array<{ expressId: number; globalId: number; name: string; modelId: string }>>();
 
-  const processDataStore = (dataStore: IfcDataStore, modelId: string, idOffset: number) => {
+  const processDataStore = (dataStore: IfcDataStore, modelId: string) => {
     for (let i = 0; i < dataStore.entities.count; i++) {
       const expressId = dataStore.entities.expressId[i];
-      const globalId = expressId + idOffset;
+      const globalId = resolveTreeGlobalId(modelId, expressId, models);
 
       // Only include entities that have geometry
       if (geometricIds && geometricIds.size > 0 && !geometricIds.has(globalId)) continue;
@@ -377,11 +467,11 @@ export function buildTypeTree(
   if (models.size > 0) {
     for (const [modelId, model] of models) {
       if (model.ifcDataStore) {
-        processDataStore(model.ifcDataStore, modelId, model.idOffset ?? 0);
+        processDataStore(model.ifcDataStore, modelId);
       }
     }
   } else if (ifcDataStore) {
-    processDataStore(ifcDataStore, 'legacy', 0);
+    processDataStore(ifcDataStore, 'legacy');
   }
 
   // Sort types alphabetically
@@ -399,10 +489,12 @@ export function buildTypeTree(
 
     nodes.push({
       id: groupNodeId,
-      expressIds: groupGlobalIds,
+      expressIds: entities.map((e) => e.expressId),
+      globalIds: groupGlobalIds,
       modelIds: [],
       name: typeName,
       type: 'type-group',
+      ifcType: typeName,
       depth: 0,
       hasChildren: entities.length > 0,
       isExpanded,
@@ -417,10 +509,12 @@ export function buildTypeTree(
         const suffix = isMultiModel ? ` [${models.get(entity.modelId)?.name || entity.modelId}]` : '';
         nodes.push({
           id: `element-${entity.modelId}-${entity.expressId}`,
-          expressIds: [entity.globalId],
+          expressIds: [entity.expressId],
+          globalIds: [entity.globalId],
           modelIds: [entity.modelId],
           name: entity.name + suffix,
           type: 'element',
+          ifcType: typeName,
           depth: 1,
           hasChildren: false,
           isExpanded: false,
@@ -451,13 +545,13 @@ export function buildIfcTypeTree(
     typeClassName: string;  // e.g. "IfcWallType"
     modelId: string;
     globalId: number;
-    instances: Array<{ expressId: number; globalId: number; name: string; modelId: string }>;
+    instances: Array<{ expressId: number; globalId: number; name: string; modelId: string; ifcType: string }>;
   }
 
   // Group by type class name (e.g. "IfcWallType") → individual types
   const typeClassGroups = new Map<string, TypeEntry[]>();
 
-  const processDataStore = (dataStore: IfcDataStore, modelId: string, idOffset: number) => {
+  const processDataStore = (dataStore: IfcDataStore, modelId: string) => {
     if (!dataStore.relationships) return;
 
     // Find all type entities (entities with IS_TYPE flag)
@@ -477,10 +571,11 @@ export function buildIfcTypeTree(
       const instances: TypeEntry['instances'] = [];
 
       for (const instId of instanceIds) {
-        const instGlobalId = instId + idOffset;
+        const instGlobalId = resolveTreeGlobalId(modelId, instId, models);
         if (geometricIds && geometricIds.size > 0 && !geometricIds.has(instGlobalId)) continue;
         const instName = dataStore.entities.getName(instId) || `#${instId}`;
-        instances.push({ expressId: instId, globalId: instGlobalId, name: instName, modelId });
+        const instIfcType = dataStore.entities.getTypeName(instId) || 'Unknown';
+        instances.push({ expressId: instId, globalId: instGlobalId, name: instName, modelId, ifcType: instIfcType });
       }
 
       const entry: TypeEntry = {
@@ -488,7 +583,7 @@ export function buildIfcTypeTree(
         typeName,
         typeClassName,
         modelId,
-        globalId: expressId + idOffset,
+        globalId: resolveTreeGlobalId(modelId, expressId, models),
         instances,
       };
 
@@ -502,11 +597,11 @@ export function buildIfcTypeTree(
   if (models.size > 0) {
     for (const [modelId, model] of models) {
       if (model.ifcDataStore) {
-        processDataStore(model.ifcDataStore, modelId, model.idOffset ?? 0);
+        processDataStore(model.ifcDataStore, modelId);
       }
     }
   } else if (ifcDataStore) {
-    processDataStore(ifcDataStore, 'legacy', 0);
+    processDataStore(ifcDataStore, 'legacy');
   }
 
   const nodes: TreeNode[] = [];
@@ -526,10 +621,12 @@ export function buildIfcTypeTree(
 
     nodes.push({
       id: classNodeId,
-      expressIds: allInstanceGlobalIds,
+      expressIds: types.flatMap(t => t.instances.map(i => i.expressId)),
+      globalIds: allInstanceGlobalIds,
       modelIds: [],
       name: className,
       type: 'type-group',
+      ifcType: className,
       depth: 0,
       hasChildren: types.length > 0,
       isExpanded: isClassExpanded,
@@ -549,11 +646,13 @@ export function buildIfcTypeTree(
 
         nodes.push({
           id: typeNodeId,
-          expressIds: instanceGlobalIds,
+          expressIds: typeEntry.instances.map(i => i.expressId),
+          globalIds: instanceGlobalIds,
           entityExpressId: typeEntry.typeExpressId,
           modelIds: [typeEntry.modelId],
           name: `${typeEntry.typeName}${suffix}`,
           type: 'ifc-type',
+          ifcType: typeEntry.typeClassName,
           depth: 1,
           hasChildren: typeEntry.instances.length > 0,
           isExpanded: isTypeExpanded,
@@ -567,10 +666,12 @@ export function buildIfcTypeTree(
             const instSuffix = isMultiModel ? ` [${models.get(inst.modelId)?.name || inst.modelId}]` : '';
             nodes.push({
               id: `element-${inst.modelId}-${inst.expressId}`,
-              expressIds: [inst.globalId],
+              expressIds: [inst.expressId],
+              globalIds: [inst.globalId],
               modelIds: [inst.modelId],
               name: inst.name + instSuffix,
               type: 'element',
+              ifcType: inst.ifcType,
               depth: 2,
               hasChildren: false,
               isExpanded: false,

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

@@ -10,20 +10,25 @@ export type NodeType =
   | 'IfcSite'             // Site node
   | 'IfcBuilding'         // Building node
   | 'IfcBuildingStorey'   // Storey node
+  | 'IfcSpace'            // Space node
   | 'type-group'          // IFC class grouping header (e.g., "IfcWall (47)")
   | 'ifc-type'            // IFC type entity node (e.g., "IfcWallType/W01")
   | 'element';            // Individual element
 
 export interface TreeNode {
   id: string;  // Unique ID for the node (can be composite)
-  /** Express IDs this node represents (for elements/storeys) */
+  /** Local express IDs this node represents */
   expressIds: number[];
+  /** Federated global IDs for selection/visibility operations */
+  globalIds: number[];
   /** Structured entity expressId for selectable non-element nodes (for example IFC type entities) */
   entityExpressId?: number;
   /** Model IDs this node belongs to */
   modelIds: string[];
   name: string;
   type: NodeType;
+  /** Actual IFC class for element rows and type groups */
+  ifcType?: string;
   depth: number;
   hasChildren: boolean;
   isExpanded: boolean;

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

@@ -5,7 +5,7 @@
 import { useMemo, useState, useCallback, useEffect } from 'react';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import type { GeometryResult } from '@ifc-lite/geometry';
-import type { FederatedModel } from '@/store';
+import { useViewerStore, type FederatedModel } from '@/store';
 import type { TreeNode, UnifiedStorey } from './types';
 import {
   buildUnifiedStoreys,
@@ -176,6 +176,12 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
     [models, hasGeometrySource ? meshCount : 0]
   );
 
+  const toGlobalIdsForModel = useCallback((modelId: string, expressIds: number[]): number[] => {
+    if (modelId === 'legacy') return expressIds;
+    const state = useViewerStore.getState();
+    return expressIds.map((expressId) => state.toGlobalId(modelId, expressId));
+  }, []);
+
   // Build the tree data structure based on grouping mode
   // Note: hiddenEntities intentionally NOT in deps - visibility computed lazily for performance
   const treeData = useMemo(
@@ -219,7 +225,7 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
   const getNodeElements = useCallback((node: TreeNode): number[] => {
     if (node.type === 'type-group' || node.type === 'ifc-type') {
       // GlobalIds are pre-stored on the node during tree construction — O(1)
-      return node.expressIds;
+      return node.globalIds;
     }
     if (node.type === 'unified-storey') {
       // Get all elements from all models for this unified storey
@@ -234,34 +240,43 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
       const model = models.get(modelId);
       if (model?.ifcDataStore?.spatialHierarchy) {
         const localIds = (model.ifcDataStore.spatialHierarchy.byStorey.get(storeyId) as number[]) || [];
-        // Convert local expressIds to global IDs using model's idOffset
-        const offset = model.idOffset ?? 0;
-        return localIds.map(id => id + offset);
+        return toGlobalIdsForModel(modelId, localIds);
       }
     } else if (node.type === 'IfcBuildingStorey') {
       // Get storey elements
       const storeyId = node.expressIds[0];
       const modelId = node.modelIds[0];
 
-      // Try legacy dataStore first (no offset needed, IDs are already global)
-      if (ifcDataStore?.spatialHierarchy) {
+      if (modelId === 'legacy' && ifcDataStore?.spatialHierarchy) {
         const elements = ifcDataStore.spatialHierarchy.byStorey.get(storeyId);
         if (elements) return elements as number[];
       }
 
-      // Or from the model in federation - need to apply idOffset
       const model = models.get(modelId);
       if (model?.ifcDataStore?.spatialHierarchy) {
         const localIds = (model.ifcDataStore.spatialHierarchy.byStorey.get(storeyId) as number[]) || [];
-        const offset = model.idOffset ?? 0;
-        return localIds.map(id => id + offset);
+        return toGlobalIdsForModel(modelId, localIds);
+      }
+    } else if (node.type === 'IfcSpace') {
+      const spaceId = node.expressIds[0];
+      const modelId = node.modelIds[0];
+
+      if (modelId === 'legacy' && ifcDataStore?.spatialHierarchy) {
+        const elements = ifcDataStore.spatialHierarchy.bySpace.get(spaceId) ?? [];
+        return [spaceId, ...(elements as number[])];
+      }
+
+      const model = models.get(modelId);
+      if (model?.ifcDataStore?.spatialHierarchy) {
+        const localIds = (model.ifcDataStore.spatialHierarchy.bySpace.get(spaceId) as number[]) || [];
+        return [...node.globalIds, ...toGlobalIdsForModel(modelId, localIds)];
       }
     } else if (node.type === 'element') {
-      return node.expressIds;
+      return node.globalIds;
     }
     // Spatial containers (Project, Site, Building) and top-level models don't have direct element visibility toggle
     return [];
-  }, [models, ifcDataStore, unifiedStoreys, getUnifiedStoreyElements]);
+  }, [models, ifcDataStore, unifiedStoreys, getUnifiedStoreyElements, toGlobalIdsForModel]);
 
   // Persist grouping mode preference
   const handleSetGroupingMode = useCallback((mode: GroupingMode) => {