@twinfinity/printing 5.0.3-ci.28538-beta

package/src/layout/legendUtils.ts

@@ -0,0 +1,144 @@
+import {
+    LEGEND_TEXT_WIDTH_FACTOR,
+    LEGEND_MIN_CONTENT_WIDTH_EM,
+    LEGEND_TEXT_Y_OFFSET_FACTOR,
+    PX_PER_MM
+} from './legendConstants';
+// v2 format: { digits?: number; prefix?: string; suffix?: string } or undefined
+type LegendFormat = { digits?: number; prefix?: string; suffix?: string } | string | undefined;
+import {
+    RGB_MAX,
+    RED_SHIFT,
+    GREEN_SHIFT,
+    HASH_COLOR_MODULO,
+    HASH_GREEN_SHIFT,
+    HASH_BLUE_SHIFT,
+    RGB_MIN
+} from './colorConstants';
+
+import { isRecord, getProp } from './typeGuards';
+
+export function parseLegendColor(value: unknown, fallbackKey: string): [number, number, number, number] {
+    if (Array.isArray(value) && (value.length === 3 || value.length === 4)) {
+        const [r, g, b, a = RGB_MAX] = value.map((v) => Number(v) || 0);
+        return [clampColor(r), clampColor(g), clampColor(b), clampColor(a)];
+    }
+    if (typeof value === 'string') {
+        const hex = value.trim();
+        const match = /^#?([a-fA-F0-9]{6})([a-fA-F0-9]{2})?$/.exec(hex);
+        if (match) {
+            const intVal = parseInt(match[1], 16);
+            const aHex = match[2];
+            return [
+                (intVal >> RED_SHIFT) & 0xff,
+                (intVal >> GREEN_SHIFT) & 0xff,
+                intVal & 0xff,
+                aHex ? parseInt(aHex, 16) : RGB_MAX
+            ];
+        }
+    }
+    const hash = Math.abs(hashCode(fallbackKey || ''));
+    return [
+        hash % HASH_COLOR_MODULO,
+        (hash >> HASH_GREEN_SHIFT) % HASH_COLOR_MODULO,
+        (hash >> HASH_BLUE_SHIFT) % HASH_COLOR_MODULO,
+        RGB_MAX
+    ];
+}
+
+export function formatLegendValue(value: unknown, fmt?: LegendFormat): string {
+    if (fmt === undefined || fmt === null || fmt === 'string') {
+        return value === undefined || value === null ? '' : String(value);
+    }
+
+    if (typeof fmt === 'string') {
+        const fixedMatch = /^fixed\((\d+)(?:,\s*([^)]*))?\)$/i.exec(fmt);
+        if (fixedMatch) {
+            const digits = parseInt(fixedMatch[1], 10);
+            const suffix = fixedMatch[2] || '';
+            const num = Number(value);
+            if (Number.isFinite(num)) {
+                return `${num.toFixed(digits)}${suffix ? ` ${suffix.trim()}` : ''}`.trim();
+            }
+        }
+        return String(value ?? '');
+    }
+
+    if (isRecord(fmt)) {
+        const digits = getProp(fmt, 'digits');
+        const prefix = getProp(fmt, 'prefix');
+        const suffix = getProp(fmt, 'suffix');
+        const num = Number(value);
+        if (Number.isFinite(num) && typeof digits === 'number') {
+            const prefixStr = typeof prefix === 'string' ? prefix : '';
+            const suffixStr = typeof suffix === 'string' ? suffix : '';
+            return `${prefixStr}${num.toFixed(digits)}${suffixStr}`;
+        }
+        return String(value ?? '');
+    }
+
+    return String(value ?? '');
+}
+
+export function computeLegendColumnWidths(
+    columnLabels: { label: string; minWidthMm?: number; maxWidthMm?: number }[],
+    rows: { values: string[] }[],
+    fontSizeMm: number,
+    cellPaddingMm: number,
+    swatchWidthMm: number,
+    fontFamily: string
+): { colWidthsMm: number[]; columnCount: number } {
+    const columnCount = Math.min(6, Math.max(2, columnLabels.length + 1));
+    const colWidthsMm: number[] = new Array(columnCount).fill(0);
+    colWidthsMm[0] = swatchWidthMm;
+    const measureTextWidthMm = createLegendTextMeasurer(fontFamily, fontSizeMm);
+
+    for (let c = 1; c < columnCount; c++) {
+        const colIdx = c - 1;
+        const col = columnLabels[colIdx];
+        const minWidth = col.minWidthMm ?? fontSizeMm * LEGEND_MIN_CONTENT_WIDTH_EM;
+        const maxWidth = col.maxWidthMm ?? Number.POSITIVE_INFINITY;
+        let maxWidthMeasured = measureTextWidthMm(col.label ?? '');
+        rows.forEach((row) => {
+            const text = row.values[colIdx] ?? '';
+            maxWidthMeasured = Math.max(maxWidthMeasured, measureTextWidthMm(text));
+        });
+        const contentWidth = Math.max(minWidth, Math.min(maxWidth, maxWidthMeasured + cellPaddingMm * 2));
+        colWidthsMm[c] = contentWidth;
+    }
+
+    return { colWidthsMm, columnCount };
+}
+
+export function computeLegendTextYOffset(fontSizeMm: number): number {
+    return fontSizeMm * LEGEND_TEXT_Y_OFFSET_FACTOR;
+}
+
+export const createLegendTextMeasurer = (fontFamily: string, fontSizeMm: number): ((text: string) => number) => {
+    if (typeof document !== 'undefined') {
+        const canvas = document.createElement('canvas');
+        canvas.width = 1024;
+        canvas.height = 64;
+        const canvasCtx = canvas.getContext('2d');
+        if (canvasCtx) {
+            canvasCtx.font = `${fontSizeMm * PX_PER_MM}px ${fontFamily}`;
+            const measureTextWidthMm = (text: string): number => {
+                const metrics = canvasCtx.measureText(text);
+                return metrics.width / PX_PER_MM;
+            };
+            return measureTextWidthMm;
+        }
+    }
+    return (text: string): number => text.length * fontSizeMm * LEGEND_TEXT_WIDTH_FACTOR;
+};
+
+const clampColor = (value: number): number => Math.max(RGB_MIN, Math.min(RGB_MAX, Math.round(value)));
+
+const hashCode = (str: string): number => {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash << 5) - hash + str.charCodeAt(i);
+        hash |= 0;
+    }
+    return hash;
+};

package/src/layout/metadata.ts

@@ -0,0 +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);