@ifc-lite/viewer 1.14.2 → 1.14.4

package/src/sdk/adapters/export-adapter.ts

@@ -6,7 +6,8 @@ import type { StoreApi } from './types.js';
 import type { EntityRef, EntityData, PropertySetData, QuantitySetData, ExportBackendMethods } from '@ifc-lite/sdk';
 import { EntityNode } from '@ifc-lite/query';
 import { StepExporter, type StepExportOptions } from '@ifc-lite/export';
-import { getModelForRef } from './model-compat.js';
+import { getModelForRef, LEGACY_MODEL_ID } from './model-compat.js';
+import { applyAttributeMutationsToEntityData, getMutationViewForModel } from './mutation-view.js';
 
 /** Options for CSV export */
 interface CsvOptions {
@@ -78,6 +79,28 @@ function normalizeRefs(raw: unknown[]): EntityRef[] {
   });
 }
 
+export function resolveVisibilityFilterSets(
+  state: StoreApi['getState'] extends () => infer T ? T : never,
+  modelId: string,
+  selectedExpressIds: Set<number>,
+  entityCount: number,
+): { visibleOnly: boolean; hiddenEntityIds: Set<number>; isolatedEntityIds: Set<number> | null } {
+  const shouldLimitToSelection = selectedExpressIds.size < entityCount;
+  const isLegacyModel = state.models.size === 0 && (modelId === LEGACY_MODEL_ID || modelId === 'legacy');
+  const modelHidden = state.hiddenEntitiesByModel.get(modelId) ?? (isLegacyModel ? state.hiddenEntities : undefined);
+  const modelIsolated = state.isolatedEntitiesByModel.get(modelId) ?? (isLegacyModel ? state.isolatedEntities : null);
+
+  return {
+    visibleOnly: shouldLimitToSelection,
+    hiddenEntityIds: shouldLimitToSelection
+      ? new Set<number>()
+      : new Set<number>(modelHidden ?? []),
+    isolatedEntityIds: shouldLimitToSelection
+      ? selectedExpressIds
+      : modelIsolated,
+  };
+}
+
 /**
  * Escape a CSV cell value — wrap in quotes if it contains the separator,
  * double-quotes, or newlines.
@@ -104,14 +127,14 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
     if (!model?.ifcDataStore) return null;
 
     const node = new EntityNode(model.ifcDataStore, ref.expressId);
-    return {
+    return applyAttributeMutationsToEntityData(store, ref.modelId, ref.expressId, {
       ref,
       globalId: node.globalId,
       name: node.name,
       type: node.type,
       description: node.description,
       objectType: node.objectType,
-    };
+    });
   }
 
   /** Resolve property sets for an entity */
@@ -317,19 +340,20 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
 
       const options = candidateOptions;
       const selectedExpressIds = new Set(refs.map(ref => ref.expressId));
-      const modelHidden = state.hiddenEntitiesByModel.get(modelId);
-      const modelIsolated = state.isolatedEntitiesByModel.get(modelId) ?? null;
-
-      const shouldLimitToSelection = selectedExpressIds.size < model.ifcDataStore.entityCount;
-      const visibleOnly = options.visibleOnly === true || shouldLimitToSelection;
-      const hiddenEntityIds = shouldLimitToSelection
-        ? new Set<number>()
-        : new Set<number>(modelHidden ?? []);
-      const isolatedEntityIds = shouldLimitToSelection
-        ? selectedExpressIds
-        : modelIsolated;
-
-      const exporter = new StepExporter(model.ifcDataStore);
+      const visibilityFilters = resolveVisibilityFilterSets(
+        state,
+        modelId,
+        selectedExpressIds,
+        model.ifcDataStore.entityCount,
+      );
+      const visibleOnly = options.visibleOnly === true || visibilityFilters.visibleOnly;
+      const hiddenEntityIds = visibleOnly ? visibilityFilters.hiddenEntityIds : new Set<number>();
+      const isolatedEntityIds = visibleOnly ? visibilityFilters.isolatedEntityIds : null;
+
+      const exporter = new StepExporter(
+        model.ifcDataStore,
+        options.includeMutations === false ? undefined : getMutationViewForModel(store, modelId) ?? undefined,
+      );
       const exportOptions: StepExportOptions = {
         schema: options.schema ?? model.ifcDataStore.schemaVersion,
         includeGeometry: true,

package/src/sdk/adapters/files-adapter.ts

@@ -0,0 +1,39 @@
+/* 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 type { FileAttachmentInfo, FilesBackendMethods } from '@ifc-lite/sdk';
+import { collectActiveFileAttachments } from '@/lib/attachments';
+import type { StoreApi } from './types.js';
+
+function getAttachments(store: StoreApi) {
+  const state = store.getState();
+  return collectActiveFileAttachments(state.chatMessages, state.chatAttachments);
+}
+
+export function createFilesAdapter(store: StoreApi): FilesBackendMethods {
+  return {
+    list(): FileAttachmentInfo[] {
+      return getAttachments(store).map((attachment) => ({
+        name: attachment.name,
+        type: attachment.type,
+        size: attachment.size,
+        rowCount: attachment.csvData?.length,
+        columns: attachment.csvColumns,
+        hasTextContent: typeof attachment.textContent === 'string',
+      }));
+    },
+    text(name: string): string | null {
+      const attachment = getAttachments(store).find((item) => item.name === name);
+      return attachment?.textContent ?? null;
+    },
+    csv(name: string): Record<string, string>[] | null {
+      const attachment = getAttachments(store).find((item) => item.name === name);
+      return attachment?.csvData ?? null;
+    },
+    csvColumns(name: string): string[] {
+      const attachment = getAttachments(store).find((item) => item.name === name);
+      return attachment?.csvColumns ?? [];
+    },
+  };
+}

package/src/sdk/adapters/model-compat.ts

@@ -42,7 +42,7 @@ export function getModelForRef(state: ViewerState, modelId: string): ModelLike |
   if (model) return model;
 
   // Legacy single-model fallback
-  if (modelId === LEGACY_MODEL_ID && state.models.size === 0 && state.ifcDataStore) {
+  if ((modelId === LEGACY_MODEL_ID || modelId === 'legacy') && state.models.size === 0 && state.ifcDataStore) {
     return buildLegacyModel(state.ifcDataStore);
   }
 

package/src/sdk/adapters/mutate-adapter.ts

@@ -4,31 +4,45 @@
 
 import type { EntityRef, MutateBackendMethods } from '@ifc-lite/sdk';
 import type { StoreApi } from './types.js';
+import { getOrCreateMutationView, normalizeMutationModelId } from './mutation-view.js';
 
 export function createMutateAdapter(store: StoreApi): MutateBackendMethods {
   return {
     setProperty(ref: EntityRef, psetName: string, propName: string, value: string | number | boolean) {
       const state = store.getState();
-      state.setProperty?.(ref.modelId, ref.expressId, psetName, propName, value);
+      const normalizedModelId = normalizeMutationModelId(state, ref.modelId);
+      if (!getOrCreateMutationView(store, ref.modelId)) return undefined;
+      state.setProperty?.(normalizedModelId, ref.expressId, psetName, propName, value);
+      return undefined;
+    },
+    setAttribute(ref: EntityRef, attrName: string, value: string) {
+      const state = store.getState();
+      const normalizedModelId = normalizeMutationModelId(state, ref.modelId);
+      if (!getOrCreateMutationView(store, ref.modelId)) return undefined;
+      state.setAttribute?.(normalizedModelId, ref.expressId, attrName, value);
       return undefined;
     },
     deleteProperty(ref: EntityRef, psetName: string, propName: string) {
       const state = store.getState();
-      state.deleteProperty?.(ref.modelId, ref.expressId, psetName, propName);
+      const normalizedModelId = normalizeMutationModelId(state, ref.modelId);
+      if (!getOrCreateMutationView(store, ref.modelId)) return undefined;
+      state.deleteProperty?.(normalizedModelId, ref.expressId, psetName, propName);
       return undefined;
     },
     undo(modelId: string) {
       const state = store.getState();
-      if (state.canUndo?.(modelId)) {
-        state.undo?.(modelId);
+      const normalizedModelId = normalizeMutationModelId(state, modelId);
+      if (state.canUndo?.(normalizedModelId)) {
+        state.undo?.(normalizedModelId);
         return true;
       }
       return false;
     },
     redo(modelId: string) {
       const state = store.getState();
-      if (state.canRedo?.(modelId)) {
-        state.redo?.(modelId);
+      const normalizedModelId = normalizeMutationModelId(state, modelId);
+      if (state.canRedo?.(normalizedModelId)) {
+        state.redo?.(normalizedModelId);
         return true;
       }
       return false;

package/src/sdk/adapters/mutation-view.ts

@@ -0,0 +1,112 @@
+/* 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 { MutablePropertyView } from '@ifc-lite/mutations';
+import { extractPropertiesOnDemand, extractQuantitiesOnDemand } from '@ifc-lite/parser';
+import type { EntityAttributeData, EntityData } from '@ifc-lite/sdk';
+import type { ViewerState } from '../../store/index.js';
+import { getModelForRef, LEGACY_MODEL_ID } from './model-compat.js';
+import type { StoreApi } from './types.js';
+
+export const LEGACY_MUTATION_MODEL_ID = '__legacy__';
+
+function isLegacyMutationRef(state: ViewerState, modelId: string): boolean {
+  return state.models.size === 0 && (modelId === 'legacy' || modelId === LEGACY_MODEL_ID || modelId === LEGACY_MUTATION_MODEL_ID);
+}
+
+export function normalizeMutationModelId(state: ViewerState, modelId: string): string {
+  if (isLegacyMutationRef(state, modelId)) {
+    return LEGACY_MUTATION_MODEL_ID;
+  }
+  return modelId;
+}
+
+export function getMutationViewForModel(store: StoreApi, modelId: string): MutablePropertyView | null {
+  const state = store.getState();
+  return state.getMutationView?.(normalizeMutationModelId(state, modelId)) ?? null;
+}
+
+export function getOrCreateMutationView(store: StoreApi, modelId: string): MutablePropertyView | null {
+  const state = store.getState();
+  const normalizedModelId = normalizeMutationModelId(state, modelId);
+  const existing = state.getMutationView?.(normalizedModelId);
+  if (existing) return existing;
+
+  const modelRefId = isLegacyMutationRef(state, modelId) ? LEGACY_MODEL_ID : modelId;
+  const model = getModelForRef(state, modelRefId);
+  const dataStore = model?.ifcDataStore;
+  if (!dataStore) return null;
+
+  const mutationView = new MutablePropertyView(dataStore.properties || null, normalizedModelId);
+
+  if (dataStore.onDemandPropertyMap && dataStore.source?.length) {
+    mutationView.setOnDemandExtractor((entityId: number) => (
+      extractPropertiesOnDemand(dataStore, entityId)
+    ));
+  }
+
+  if (dataStore.onDemandQuantityMap && dataStore.source?.length) {
+    mutationView.setQuantityExtractor((entityId: number) => (
+      extractQuantitiesOnDemand(dataStore, entityId)
+    ));
+  }
+
+  state.registerMutationView?.(normalizedModelId, mutationView);
+  return mutationView;
+}
+
+export function applyAttributeMutationsToEntityData(
+  store: StoreApi,
+  modelId: string,
+  expressId: number,
+  data: EntityData,
+): EntityData {
+  const mutationView = getMutationViewForModel(store, modelId);
+  if (!mutationView) return data;
+
+  const mutations = mutationView.getAttributeMutationsForEntity(expressId);
+  if (mutations.length === 0) return data;
+
+  const next = { ...data };
+  for (const mutation of mutations) {
+    switch (mutation.name) {
+      case 'GlobalId':
+        next.globalId = mutation.value;
+        break;
+      case 'Name':
+        next.name = mutation.value;
+        break;
+      case 'Description':
+        next.description = mutation.value;
+        break;
+      case 'ObjectType':
+        next.objectType = mutation.value;
+        break;
+    }
+  }
+  return next;
+}
+
+export function mergeAttributeMutations(
+  baseAttributes: EntityAttributeData[],
+  store: StoreApi,
+  modelId: string,
+  expressId: number,
+): EntityAttributeData[] {
+  const mutationView = getMutationViewForModel(store, modelId);
+  if (!mutationView) return baseAttributes;
+
+  const mutations = mutationView.getAttributeMutationsForEntity(expressId);
+  if (mutations.length === 0) return baseAttributes;
+
+  const merged = new Map<string, string>();
+  for (const attr of baseAttributes) {
+    merged.set(attr.name, attr.value);
+  }
+  for (const mutation of mutations) {
+    merged.set(mutation.name, mutation.value);
+  }
+
+  return [...merged.entries()].map(([name, value]) => ({ name, value }));
+}

package/src/sdk/adapters/query-adapter.ts

@@ -5,8 +5,14 @@
 import type {
   EntityRef,
   EntityData,
+  EntityAttributeData,
   PropertySetData,
   QuantitySetData,
+  ClassificationData,
+  MaterialData,
+  TypePropertiesData,
+  DocumentData,
+  EntityRelationshipsData,
   QueryDescriptor,
   QueryBackendMethods,
 } from '@ifc-lite/sdk';
@@ -14,6 +20,15 @@ import type { StoreApi } from './types.js';
 import { EntityNode } from '@ifc-lite/query';
 import { RelationshipType, IfcTypeEnum, IfcTypeEnumFromString } from '@ifc-lite/data';
 import { getModelForRef, getAllModelEntries } from './model-compat.js';
+import {
+  extractAllEntityAttributes,
+  extractClassificationsOnDemand,
+  extractMaterialsOnDemand,
+  extractTypePropertiesOnDemand,
+  extractDocumentsOnDemand,
+  extractRelationshipsOnDemand,
+} from '@ifc-lite/parser';
+import { applyAttributeMutationsToEntityData, mergeAttributeMutations } from './mutation-view.js';
 
 /** Map IFC relationship entity names to internal RelationshipType enum.
  * Keys use proper IFC schema names (e.g. IfcRelAggregates, not "Aggregates"). */
@@ -86,6 +101,18 @@ function isProductType(type: string): boolean {
   return true;
 }
 
+function normalizePropertyValue(value: unknown): string | number | boolean | null {
+  if (value == null) return null;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
 export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
   function getEntityData(ref: EntityRef): EntityData | null {
     const state = store.getState();
@@ -93,14 +120,14 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
     if (!model?.ifcDataStore) return null;
 
     const node = new EntityNode(model.ifcDataStore, ref.expressId);
-    return {
+    return applyAttributeMutationsToEntityData(store, ref.modelId, ref.expressId, {
       ref,
       globalId: node.globalId,
       name: node.name,
       type: node.type,
       description: node.description,
       objectType: node.objectType,
-    };
+    });
   }
 
   function getProperties(ref: EntityRef): PropertySetData[] {
@@ -120,6 +147,18 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
     }));
   }
 
+  function getAttributes(ref: EntityRef): EntityAttributeData[] {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return [];
+    return mergeAttributeMutations(
+      extractAllEntityAttributes(model.ifcDataStore, ref.expressId),
+      store,
+      ref.modelId,
+      ref.expressId,
+    );
+  }
+
   function getQuantities(ref: EntityRef): QuantitySetData[] {
     const state = store.getState();
     const model = getModelForRef(state, ref.modelId);
@@ -136,6 +175,57 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
     }));
   }
 
+  function getClassifications(ref: EntityRef): ClassificationData[] {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return [];
+    return extractClassificationsOnDemand(model.ifcDataStore, ref.expressId);
+  }
+
+  function getMaterials(ref: EntityRef): MaterialData | null {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return null;
+    return extractMaterialsOnDemand(model.ifcDataStore, ref.expressId);
+  }
+
+  function getTypeProperties(ref: EntityRef): TypePropertiesData | null {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return null;
+    const info = extractTypePropertiesOnDemand(model.ifcDataStore, ref.expressId);
+    if (!info) return null;
+    return {
+      typeName: info.typeName,
+      typeId: info.typeId,
+      properties: info.properties.map((pset) => ({
+        name: pset.name,
+        globalId: pset.globalId,
+        properties: pset.properties.map((prop) => ({
+          name: prop.name,
+          type: prop.type,
+          value: normalizePropertyValue(prop.value),
+        })),
+      })),
+    };
+  }
+
+  function getDocuments(ref: EntityRef): DocumentData[] {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) return [];
+    return extractDocumentsOnDemand(model.ifcDataStore, ref.expressId);
+  }
+
+  function getRelationships(ref: EntityRef): EntityRelationshipsData {
+    const state = store.getState();
+    const model = getModelForRef(state, ref.modelId);
+    if (!model?.ifcDataStore) {
+      return { voids: [], fills: [], groups: [], connections: [] };
+    }
+    return extractRelationshipsOnDemand(model.ifcDataStore, ref.expressId);
+  }
+
   function queryEntities(descriptor: QueryDescriptor): EntityData[] {
     const state = store.getState();
     const results: EntityData[] = [];
@@ -167,14 +257,14 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
       for (const expressId of entityIds) {
         if (expressId === 0) continue;
         const node = new EntityNode(model.ifcDataStore, expressId);
-        results.push({
+        results.push(applyAttributeMutationsToEntityData(store, modelId, expressId, {
           ref: { modelId, expressId },
           globalId: node.globalId,
           name: node.name,
           type: node.type,
           description: node.description,
           objectType: node.objectType,
-        });
+        }));
       }
     }
 
@@ -226,8 +316,14 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
   return {
     entities: queryEntities,
     entityData: getEntityData,
+    attributes: getAttributes,
     properties: getProperties,
     quantities: getQuantities,
+    classifications: getClassifications,
+    materials: getMaterials,
+    typeProperties: getTypeProperties,
+    documents: getDocuments,
+    relationships: getRelationships,
     related(ref: EntityRef, relType: string, direction: 'forward' | 'inverse') {
       const state = store.getState();
       const model = getModelForRef(state, ref.modelId);

package/src/sdk/local-backend.ts

@@ -21,6 +21,7 @@ import type {
   SpatialBackendMethods,
   ExportBackendMethods,
   LensBackendMethods,
+  FilesBackendMethods,
 } from '@ifc-lite/sdk';
 import type { StoreApi } from './adapters/types.js';
 import { LEGACY_MODEL_ID } from './adapters/model-compat.js';
@@ -33,6 +34,7 @@ import { createMutateAdapter } from './adapters/mutate-adapter.js';
 import { createSpatialAdapter } from './adapters/spatial-adapter.js';
 import { createLensAdapter } from './adapters/lens-adapter.js';
 import { createExportAdapter } from './adapters/export-adapter.js';
+import { createFilesAdapter } from './adapters/files-adapter.js';
 
 export class LocalBackend implements BimBackend {
   readonly model: ModelBackendMethods;
@@ -44,6 +46,7 @@ export class LocalBackend implements BimBackend {
   readonly spatial: SpatialBackendMethods;
   readonly export: ExportBackendMethods;
   readonly lens: LensBackendMethods;
+  readonly files: FilesBackendMethods;
 
   private store: StoreApi;
 
@@ -58,6 +61,7 @@ export class LocalBackend implements BimBackend {
     this.spatial = createSpatialAdapter(store);
     this.lens = createLensAdapter(store);
     this.export = createExportAdapter(store);
+    this.files = createFilesAdapter(store);
   }
 
   subscribe(event: BimEventType, handler: (data: unknown) => void): () => void {

package/src/store/index.ts

@@ -31,6 +31,7 @@ import { createListSlice, type ListSlice } from './slices/listSlice.js';
 import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.js';
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
 import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
+import { createChatSlice, type ChatSlice } from './slices/chatSlice.js';
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
@@ -72,6 +73,9 @@ export type { LensSlice, Lens, LensRule, LensCriteria } from './slices/lensSlice
 // Re-export Script types
 export type { ScriptSlice } from './slices/scriptSlice.js';
 
+// Re-export Chat types
+export type { ChatSlice } from './slices/chatSlice.js';
+
 // Combined store type
 export type ViewerState = LoadingSlice &
   SelectionSlice &
@@ -91,7 +95,8 @@ export type ViewerState = LoadingSlice &
   ListSlice &
   PinboardSlice &
   LensSlice &
-  ScriptSlice & {
+  ScriptSlice &
+  ChatSlice & {
     resetViewerState: () => void;
   };
 
@@ -119,6 +124,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   ...createPinboardSlice(...args),
   ...createLensSlice(...args),
   ...createScriptSlice(...args),
+  ...createChatSlice(...args),
 
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
@@ -280,6 +286,8 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       scriptExecutionState: 'idle' as const,
       scriptLastResult: null,
       scriptLastError: null,
+      scriptLastDiagnostics: [],
+      scriptAssistantTurnSnapshot: null,
       scriptDeleteConfirmId: null,
 
       // Lens - deactivate but keep saved lenses
@@ -289,6 +297,12 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       lensHiddenIds: new Set<number>(),
       lensRuleCounts: new Map<string, number>(),
       lensRuleEntityIds: new Map<string, number[]>(),
+
+      // Chat - keep messages and panel visible, reset streaming state
+      chatStatus: 'idle' as const,
+      chatStreamingContent: '',
+      chatError: null,
+      chatAbortController: null,
     });
   },
 }));