@twinfinity/printing 6.0.1-ci.28952-beta → 6.0.2-beta

package/src/layout/metadata.ts

@@ -1,210 +1,210 @@
-import { getPathValue as getValueByPath } from './renderUtils';
-import type { LayoutTemplate, ResolvedIncludeFilter, WhereCondition } from './types';
-
-export interface ModelMetadataEntry {
-    productId?: string;
-    ifcClass?: string;
-    ifcClassId?: string;
-    properties?: unknown;
-    [key: string]: unknown;
-}
-
-export type ModelMetadata = Record<string, ModelMetadataEntry>;
-
-import { isRecord, getProp } from './typeGuards';
-import { normalizeClass } from './filters';
-
-/** Resolve the IFC class name from a BIM product object's `.class` property. */
-export const resolveIfcClassName = (product: unknown): string | null => {
-    const classObj = getProp(product, 'class');
-    if (!classObj) return null;
-    return normalizeClass(getProp(classObj, 'name') ?? getProp(classObj, 'type') ?? getProp(classObj, 'id'));
-};
-
-/** Resolve the predefined IFC class ID (e.g. "USERDEFINED") from `.class.id`. */
-export const resolveIfcClassId = (product: unknown): string | null => {
-    const classObj = getProp(product, 'class');
-    if (!classObj) return null;
-    const id = getProp(classObj, 'id');
-    return typeof id === 'string' ? id : null;
-};
-
-export const normalizePropertySets = (
-    product: unknown
-): Record<string, Record<string, { value: unknown; unit?: string; type?: string }>> => {
-    const properties = getProp(product, 'properties');
-    // BIM products may have properties at various paths:
-    // - product.properties.data (Twinfinity standard)
-    // - product.properties.propertySets (BIM API)
-    // - product.propertySets (direct)
-    // - product.properties (fallback)
-    // New T8 API: product.propertySets → Record<string, T8PropertySet>
-    // where T8PropertySet.properties → Record<string, T8Property { value, type, unit }>
-    // Legacy: product.properties.data / product.properties.sets → Record<string, Record<string, unknown>>
-    const raw =
-        getProp(product, 'propertySets') ??
-        getProp(properties, 'data') ??
-        getProp(properties, 'sets') ??
-        properties ??
-        {};
-    const propertySets: Record<string, Record<string, { value: unknown; unit?: string; type?: string }>> = {};
-    if (!isRecord(raw)) return propertySets;
-    Object.entries(raw).forEach(([setName, setValue]) => {
-        if (!isRecord(setValue)) return;
-        // T8PropertySet has a .properties sub-record with T8Property entries
-        const innerProps = getProp(setValue, 'properties');
-        const source = isRecord(innerProps) ? innerProps : setValue;
-        const props: Record<string, { value: unknown; unit?: string; type?: string }> = {};
-        Object.entries(source).forEach(([propName, propVal]) => {
-            if (isRecord(propVal) && 'value' in propVal) {
-                props[propName] = propVal as { value: unknown; unit?: string; type?: string };
-            } else {
-                props[propName] = { value: propVal };
-            }
-        });
-        propertySets[setName] = props;
-    });
-    return propertySets;
-};
-
-export const buildMetadataMap = (entries: unknown[]): ModelMetadata => {
-    const out: ModelMetadata = {};
-    if (!Array.isArray(entries)) return out;
-    entries.forEach((entry) => {
-        const product = getProp(entry, 'product') ?? entry;
-        const gid = getProp(product, 'gid') ?? getProp(product, 'id') ?? null;
-        if (!gid) return;
-        const propertySets = normalizePropertySets(product);
-        const ifcClass = resolveIfcClassName(product) ?? undefined;
-        const ifcClassId = resolveIfcClassId(product) ?? undefined;
-        out[String(gid)] = {
-            productId: String(gid),
-            ifcClass,
-            ifcClassId,
-            properties: propertySets,
-            propertySets
-        };
-    });
-    return out;
-};
-
-export const resolveMeta = (meta: unknown, metadataById?: ModelMetadata): unknown => {
-    const productId = getProp(meta, 'productId') ?? getProp(meta, 'gid') ?? getProp(meta, 'id');
-    const base = productId && metadataById ? metadataById[String(productId)] : undefined;
-    if (!base) {
-        return meta;
-    }
-    const baseProps = getProp(base, 'properties');
-    const metaProps = getProp(meta, 'properties');
-    const mergedProps =
-        baseProps || metaProps
-            ? { ...(isRecord(baseProps) ? baseProps : {}), ...(isRecord(metaProps) ? metaProps : {}) }
-            : undefined;
-    return mergedProps
-        ? { ...base, ...(isRecord(meta) ? meta : {}), productId, properties: mergedProps }
-        : { ...base, ...(isRecord(meta) ? meta : {}), productId };
-};
-
-/**
- * Resolve includeClasses config to an array of filters.
- *
- * Supports:
- * - String arrays: ["space", "walls"]
- * - Filter objects: [{ class: "space", where: { "BIP.spacetype": "ROOM" } }]
- * - Preset references: { preset: "defaultBuilding" }
- * - Mixed arrays: ["walls", { class: "space", where: {...} }]
- *
- * @returns Array of filters (strings or class+where objects), or null if no filters
- */
-export const resolveIncludeClasses = (
-    includeClasses: unknown,
-    currentIncludePresets: Record<string, string[]>
-): ResolvedIncludeFilter[] | null => {
-    if (!includeClasses) return null;
-
-    // Handle array of filters (strings or objects)
-    if (Array.isArray(includeClasses)) {
-        const result: ResolvedIncludeFilter[] = [];
-        for (const item of includeClasses) {
-            if (typeof item === 'string' && item.length > 0) {
-                result.push(item);
-            } else if (isRecord(item)) {
-                const cls = getProp(item, 'class');
-                const where = getProp(item, 'where');
-                // Must have either class or where (or both)
-                if (cls !== undefined || (where && isRecord(where))) {
-                    result.push({ class: cls as string | string[] | undefined, where: where as WhereCondition });
-                }
-            }
-        }
-        return result.length > 0 ? result : null;
-    }
-
-    // Handle preset reference or filter object
-    if (isRecord(includeClasses)) {
-        const preset = getProp(includeClasses, 'preset');
-        const cls = getProp(includeClasses, 'class');
-        const where = getProp(includeClasses, 'where');
-
-        // Preset reference: { preset: "name" }
-        if (typeof preset === 'string') {
-            const presetName = preset;
-            const base = currentIncludePresets[presetName] ?? [];
-            const addProp = getProp(includeClasses, 'add');
-            const removeProp = getProp(includeClasses, 'remove');
-            const add = Array.isArray(addProp) ? addProp : [];
-            const remove = Array.isArray(removeProp) ? removeProp : [];
-            const set = new Set<string>();
-            base.forEach((c: string) => set.add(c));
-            add.forEach((c: unknown) => typeof c === 'string' && set.add(c));
-            remove.forEach((c: unknown) => typeof c === 'string' && set.delete(c));
-            const strings = Array.from(set).filter((c) => typeof c === 'string' && c.length > 0);
-            return strings.length > 0 ? strings : null;
-        }
-
-        // Filter object: { class: "space", where: {...} }
-        if (cls !== undefined || (where && isRecord(where))) {
-            return [{ class: cls as string | string[] | undefined, where: where as WhereCondition }];
-        }
-    }
-
-    return null;
-};
-
-/**
- * Resolve allowed class names from template/viewport includeClasses config.
- *
- * Extracts only string filters (class names), ignoring filter objects with where conditions.
- * Used for backward compatibility and simple class-based filtering.
- *
- * @returns Set of normalized class names, or null if no filters
- */
-export const resolveAllowedClasses = (layoutTemplate: LayoutTemplate, viewportId = 'main'): Set<string> | null => {
-    if (!layoutTemplate) return null;
-    const presets = layoutTemplate.presets?.includeClasses ?? {};
-    const templateClasses = resolveIncludeClasses(getProp(layoutTemplate, 'includeClasses'), presets);
-    const elements = layoutTemplate.elements;
-    const viewportEl = Array.isArray(elements)
-        ? elements.find((el) => isRecord(el) && getProp(el, 'kind') === 'viewport' && getProp(el, 'id') === viewportId)
-        : undefined;
-    const viewportClasses = resolveIncludeClasses(getProp(viewportEl, 'includeClasses'), presets);
-    const resolved = viewportClasses ?? templateClasses;
-    if (!resolved || !resolved.length) {
-        return null;
-    }
-    // Extract only string filters (class names)
-    const classNames = new Set<string>();
-    for (const filter of resolved) {
-        if (typeof filter === 'string') {
-            classNames.add(filter);
-        } else if (isRecord(filter) && filter.class) {
-            const classes = Array.isArray(filter.class) ? filter.class : [filter.class];
-            for (const c of classes) {
-                if (typeof c === 'string') classNames.add(c);
-            }
-        }
-    }
-    return classNames.size > 0 ? classNames : null;
-};
-
-export const getPathValue = (obj: unknown, path: string): unknown => getValueByPath(obj, path);
+import { getPathValue as getValueByPath } from './renderUtils';
+import type { LayoutTemplate, ResolvedIncludeFilter, WhereCondition } from './types';
+
+export interface ModelMetadataEntry {
+    productId?: string;
+    ifcClass?: string;
+    ifcClassId?: string;
+    properties?: unknown;
+    [key: string]: unknown;
+}
+
+export type ModelMetadata = Record<string, ModelMetadataEntry>;
+
+import { isRecord, getProp } from './typeGuards';
+import { normalizeClass } from './filters';
+
+/** Resolve the IFC class name from a BIM product object's `.class` property. */
+export const resolveIfcClassName = (product: unknown): string | null => {
+    const classObj = getProp(product, 'class');
+    if (!classObj) return null;
+    return normalizeClass(getProp(classObj, 'name') ?? getProp(classObj, 'type') ?? getProp(classObj, 'id'));
+};
+
+/** Resolve the predefined IFC class ID (e.g. "USERDEFINED") from `.class.id`. */
+export const resolveIfcClassId = (product: unknown): string | null => {
+    const classObj = getProp(product, 'class');
+    if (!classObj) return null;
+    const id = getProp(classObj, 'id');
+    return typeof id === 'string' ? id : null;
+};
+
+export const normalizePropertySets = (
+    product: unknown
+): Record<string, Record<string, { value: unknown; unit?: string; type?: string }>> => {
+    const properties = getProp(product, 'properties');
+    // BIM products may have properties at various paths:
+    // - product.properties.data (Twinfinity standard)
+    // - product.properties.propertySets (BIM API)
+    // - product.propertySets (direct)
+    // - product.properties (fallback)
+    // New T8 API: product.propertySets → Record<string, T8PropertySet>
+    // where T8PropertySet.properties → Record<string, T8Property { value, type, unit }>
+    // Legacy: product.properties.data / product.properties.sets → Record<string, Record<string, unknown>>
+    const raw =
+        getProp(product, 'propertySets') ??
+        getProp(properties, 'data') ??
+        getProp(properties, 'sets') ??
+        properties ??
+        {};
+    const propertySets: Record<string, Record<string, { value: unknown; unit?: string; type?: string }>> = {};
+    if (!isRecord(raw)) return propertySets;
+    Object.entries(raw).forEach(([setName, setValue]) => {
+        if (!isRecord(setValue)) return;
+        // T8PropertySet has a .properties sub-record with T8Property entries
+        const innerProps = getProp(setValue, 'properties');
+        const source = isRecord(innerProps) ? innerProps : setValue;
+        const props: Record<string, { value: unknown; unit?: string; type?: string }> = {};
+        Object.entries(source).forEach(([propName, propVal]) => {
+            if (isRecord(propVal) && 'value' in propVal) {
+                props[propName] = propVal as { value: unknown; unit?: string; type?: string };
+            } else {
+                props[propName] = { value: propVal };
+            }
+        });
+        propertySets[setName] = props;
+    });
+    return propertySets;
+};
+
+export const buildMetadataMap = (entries: unknown[]): ModelMetadata => {
+    const out: ModelMetadata = {};
+    if (!Array.isArray(entries)) return out;
+    entries.forEach((entry) => {
+        const product = getProp(entry, 'product') ?? entry;
+        const gid = getProp(product, 'gid') ?? getProp(product, 'id') ?? null;
+        if (!gid) return;
+        const propertySets = normalizePropertySets(product);
+        const ifcClass = resolveIfcClassName(product) ?? undefined;
+        const ifcClassId = resolveIfcClassId(product) ?? undefined;
+        out[String(gid)] = {
+            productId: String(gid),
+            ifcClass,
+            ifcClassId,
+            properties: propertySets,
+            propertySets
+        };
+    });
+    return out;
+};
+
+export const resolveMeta = (meta: unknown, metadataById?: ModelMetadata): unknown => {
+    const productId = getProp(meta, 'productId') ?? getProp(meta, 'gid') ?? getProp(meta, 'id');
+    const base = productId && metadataById ? metadataById[String(productId)] : undefined;
+    if (!base) {
+        return meta;
+    }
+    const baseProps = getProp(base, 'properties');
+    const metaProps = getProp(meta, 'properties');
+    const mergedProps =
+        baseProps || metaProps
+            ? { ...(isRecord(baseProps) ? baseProps : {}), ...(isRecord(metaProps) ? metaProps : {}) }
+            : undefined;
+    return mergedProps
+        ? { ...base, ...(isRecord(meta) ? meta : {}), productId, properties: mergedProps }
+        : { ...base, ...(isRecord(meta) ? meta : {}), productId };
+};
+
+/**
+ * Resolve includeClasses config to an array of filters.
+ *
+ * Supports:
+ * - String arrays: ["space", "walls"]
+ * - Filter objects: [{ class: "space", where: { "BIP.spacetype": "ROOM" } }]
+ * - Preset references: { preset: "defaultBuilding" }
+ * - Mixed arrays: ["walls", { class: "space", where: {...} }]
+ *
+ * @returns Array of filters (strings or class+where objects), or null if no filters
+ */
+export const resolveIncludeClasses = (
+    includeClasses: unknown,
+    currentIncludePresets: Record<string, string[]>
+): ResolvedIncludeFilter[] | null => {
+    if (!includeClasses) return null;
+
+    // Handle array of filters (strings or objects)
+    if (Array.isArray(includeClasses)) {
+        const result: ResolvedIncludeFilter[] = [];
+        for (const item of includeClasses) {
+            if (typeof item === 'string' && item.length > 0) {
+                result.push(item);
+            } else if (isRecord(item)) {
+                const cls = getProp(item, 'class');
+                const where = getProp(item, 'where');
+                // Must have either class or where (or both)
+                if (cls !== undefined || (where && isRecord(where))) {
+                    result.push({ class: cls as string | string[] | undefined, where: where as WhereCondition });
+                }
+            }
+        }
+        return result.length > 0 ? result : null;
+    }
+
+    // Handle preset reference or filter object
+    if (isRecord(includeClasses)) {
+        const preset = getProp(includeClasses, 'preset');
+        const cls = getProp(includeClasses, 'class');
+        const where = getProp(includeClasses, 'where');
+
+        // Preset reference: { preset: "name" }
+        if (typeof preset === 'string') {
+            const presetName = preset;
+            const base = currentIncludePresets[presetName] ?? [];
+            const addProp = getProp(includeClasses, 'add');
+            const removeProp = getProp(includeClasses, 'remove');
+            const add = Array.isArray(addProp) ? addProp : [];
+            const remove = Array.isArray(removeProp) ? removeProp : [];
+            const set = new Set<string>();
+            base.forEach((c: string) => set.add(c));
+            add.forEach((c: unknown) => typeof c === 'string' && set.add(c));
+            remove.forEach((c: unknown) => typeof c === 'string' && set.delete(c));
+            const strings = Array.from(set).filter((c) => typeof c === 'string' && c.length > 0);
+            return strings.length > 0 ? strings : null;
+        }
+
+        // Filter object: { class: "space", where: {...} }
+        if (cls !== undefined || (where && isRecord(where))) {
+            return [{ class: cls as string | string[] | undefined, where: where as WhereCondition }];
+        }
+    }
+
+    return null;
+};
+
+/**
+ * Resolve allowed class names from template/viewport includeClasses config.
+ *
+ * Extracts only string filters (class names), ignoring filter objects with where conditions.
+ * Used for backward compatibility and simple class-based filtering.
+ *
+ * @returns Set of normalized class names, or null if no filters
+ */
+export const resolveAllowedClasses = (layoutTemplate: LayoutTemplate, viewportId = 'main'): Set<string> | null => {
+    if (!layoutTemplate) return null;
+    const presets = layoutTemplate.presets?.includeClasses ?? {};
+    const templateClasses = resolveIncludeClasses(getProp(layoutTemplate, 'includeClasses'), presets);
+    const elements = layoutTemplate.elements;
+    const viewportEl = Array.isArray(elements)
+        ? elements.find((el) => isRecord(el) && getProp(el, 'kind') === 'viewport' && getProp(el, 'id') === viewportId)
+        : undefined;
+    const viewportClasses = resolveIncludeClasses(getProp(viewportEl, 'includeClasses'), presets);
+    const resolved = viewportClasses ?? templateClasses;
+    if (!resolved || !resolved.length) {
+        return null;
+    }
+    // Extract only string filters (class names)
+    const classNames = new Set<string>();
+    for (const filter of resolved) {
+        if (typeof filter === 'string') {
+            classNames.add(filter);
+        } else if (isRecord(filter) && filter.class) {
+            const classes = Array.isArray(filter.class) ? filter.class : [filter.class];
+            for (const c of classes) {
+                if (typeof c === 'string') classNames.add(c);
+            }
+        }
+    }
+    return classNames.size > 0 ? classNames : null;
+};
+
+export const getPathValue = (obj: unknown, path: string): unknown => getValueByPath(obj, path);