@twinfinity/printing 5.0.3-ci.28538-beta

package/src/layout/model.ts

@@ -0,0 +1,372 @@
+import type { SectionPath, SectionLabel } from '@twinfinity/geometry';
+import type { SvgModelView, ViewportElement, LabelStyle, ResolvedIncludeFilter } from './types';
+import type { ModelMetadata } from './metadata';
+import { resolveIncludeClasses, resolveMeta } from './metadata';
+import { normalizeClass, matchesWhere } from './filters';
+import { escapeAttr, escapeText } from './renderUtils';
+import { BUILTIN_LABEL_DEFAULTS } from './renderDrawing';
+
+import { getProp, isRecord } from './typeGuards';
+
+export const buildModelViewFromRaw = (
+    rawPaths: SectionPath[] | undefined,
+    rawLabels: SectionLabel[] | undefined,
+    transform: SvgModelView['transform'] | undefined,
+    geometryTransform?: string,
+    labelStyle?: LabelStyle
+): SvgModelView | null => {
+    if (!rawPaths || !transform || !geometryTransform) {
+        return null;
+    }
+    const labelFill = labelStyle?.fill ?? BUILTIN_LABEL_DEFAULTS.fill;
+    const labelFontFamily = labelStyle?.fontFamily ?? BUILTIN_LABEL_DEFAULTS.fontFamily;
+    const labelFontWeight = labelStyle?.fontWeight ?? BUILTIN_LABEL_DEFAULTS.fontWeight;
+    const escapedFontFamily = escapeAttr(labelFontFamily);
+
+    const parts: string[] = [];
+    parts.push(`<g transform="${escapeAttr(geometryTransform)}">`);
+    rawPaths.forEach((path) => {
+        parts.push(
+            `<path d="${escapeAttr(path.d)}"` +
+                (path.fill ? ` fill="${escapeAttr(path.fill)}"` : ' fill="none"') +
+                (path.fillOpacity !== undefined ? ` fill-opacity="${path.fillOpacity}"` : '') +
+                (path.stroke ? ` stroke="${escapeAttr(path.stroke)}"` : '') +
+                (path.strokeWidth ? ` stroke-width="${path.strokeWidth}"` : '') +
+                (path.strokeOpacity !== undefined ? ` stroke-opacity="${path.strokeOpacity}"` : '') +
+                (path.fillRule ? ` fill-rule="${escapeAttr(path.fillRule)}"` : '') +
+                ` stroke-linejoin="round" stroke-linecap="round"` +
+                ` />`
+        );
+    });
+    parts.push(`</g>`);
+    if (rawLabels && rawLabels.length) {
+        parts.push(`<g pointer-events="none">`);
+        rawLabels.forEach((label) => {
+            const viewX = label.x - transform.viewMinX;
+            const viewY = transform.viewMaxZ - label.z;
+            if (!Number.isFinite(viewX) || !Number.isFinite(viewY)) {
+                return;
+            }
+            parts.push(
+                `<text x="${viewX}" y="${viewY}" font-size="${label.fontSize}" text-anchor="middle" dominant-baseline="middle" fill="${escapeAttr(labelFill)}" font-family="${escapedFontFamily}" font-weight="${labelFontWeight}">${escapeText(label.text)}</text>`
+            );
+        });
+        parts.push(`</g>`);
+    }
+    const svg = `<g>${parts.join('')}</g>`;
+    return {
+        groupSvg: svg,
+        widthModel: transform.viewWidth,
+        heightModel: transform.viewHeight,
+        transform,
+        geometryTransform,
+        rawPaths,
+        rawLabels,
+        labelStyle
+    };
+};
+
+/**
+ * Check whether a path's resolved class matches any of the filter classes.
+ * Used to determine which SVG paths are subject to GID-based include/exclude.
+ */
+const matchesFilterClass = (
+    cls: string | null,
+    clsId: unknown,
+    clsFromMap: string | null,
+    filterClasses: Set<string>
+): boolean => {
+    if (!filterClasses.size) return false;
+    if (cls && filterClasses.has(cls)) return true;
+    if (clsFromMap && filterClasses.has(clsFromMap)) return true;
+    if (clsId && typeof clsId === 'string') {
+        const normalized = normalizeClass(clsId);
+        if (normalized && filterClasses.has(normalized)) return true;
+    }
+    return false;
+};
+
+/**
+ * Check if an item matches any of the include filters.
+ *
+ * @param includeFilters - Array of filters (strings or class+where objects)
+ * @param cls - Normalized IFC class name
+ * @param clsId - Predefined IFC class ID
+ * @param meta - Item metadata (for property matching)
+ * @returns true if the item matches any filter, false otherwise
+ */
+const matchesIncludeFilter = (
+    includeFilters: ResolvedIncludeFilter[],
+    cls: string | null,
+    clsId: unknown,
+    meta: unknown
+): boolean => {
+    for (const filter of includeFilters) {
+        // String filter: class name only
+        if (typeof filter === 'string') {
+            const normalizedFilter = normalizeClass(filter);
+            if (cls && normalizedFilter === cls) return true;
+            if (clsId && typeof clsId === 'string') {
+                const normalizedId = normalizeClass(clsId);
+                if (normalizedId === normalizedFilter) return true;
+            }
+            continue;
+        }
+
+        // Object filter: class + where
+        if (isRecord(filter)) {
+            const filterClass = filter.class;
+            const filterWhere = filter.where;
+
+            // Check class match (if specified)
+            let classMatches = true;
+            if (filterClass !== undefined) {
+                const classes = Array.isArray(filterClass) ? filterClass : [filterClass];
+                classMatches = false;
+                for (const c of classes) {
+                    const normalizedC = normalizeClass(c);
+                    if (normalizedC && cls === normalizedC) {
+                        classMatches = true;
+                        break;
+                    }
+                    if (clsId && typeof clsId === 'string') {
+                        const normalizedId = normalizeClass(clsId);
+                        if (normalizedId === normalizedC) {
+                            classMatches = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Check where condition (if specified)
+            let whereMatches = true;
+            if (filterWhere && Object.keys(filterWhere).length > 0) {
+                whereMatches = matchesWhere(meta, filterWhere);
+            }
+
+            if (classMatches && whereMatches) return true;
+        }
+    }
+
+    return false;
+};
+
+export const filterModelForViewport = (
+    model: SvgModelView,
+    vp: ViewportElement,
+    metadataById?: ModelMetadata,
+    includePresets?: Record<string, string[]>,
+    allowedGids?: Set<string> | null,
+    highlight?: {
+        gids: Set<string> | null;
+        styles?: {
+            stroke?: string;
+            strokeWidthMm?: number;
+            strokeOpacity?: number;
+            fill?: string;
+            fillOpacity?: number;
+        };
+    },
+    filterClasses?: Set<string> | null
+): SvgModelView => {
+    const resolvedIncludeClasses = resolveIncludeClasses(vp.includeClasses as unknown, includePresets ?? {});
+    const includeFilters = resolvedIncludeClasses ?? null;
+    // Classes subject to GID-based filtering (highlight/clip include/exclude).
+    // Derived from template highlight.class and clip.class by the caller.
+    const effectiveFilterClasses = filterClasses ?? new Set<string>();
+    let styleMutated = false;
+    if (!model.rawPaths || !model.geometryTransform || !model.transform) {
+        return model;
+    }
+    const filteredPaths: SectionPath[] = [];
+    model.rawPaths.forEach((p: SectionPath) => {
+        const rawMeta = getProp(p, 'meta');
+        const meta = resolveMeta(rawMeta, metadataById);
+        const metaFromMap = (() => {
+            const pid =
+                getProp(meta, 'productId') ??
+                getProp(meta, 'gid') ??
+                getProp(meta, 'id') ??
+                getProp(rawMeta, 'gid') ??
+                getProp(rawMeta, 'id');
+            return pid && metadataById ? metadataById[String(pid)] : null;
+        })();
+        const productIdForMeta =
+            getProp(meta, 'productId') ??
+            getProp(meta, 'gid') ??
+            getProp(meta, 'id') ??
+            getProp(rawMeta, 'gid') ??
+            getProp(rawMeta, 'id') ??
+            metaFromMap?.productId ??
+            metaFromMap?.gid ??
+            null;
+        const pid = productIdForMeta ? String(productIdForMeta) : null;
+        const cls = normalizeClass(getProp(meta, 'ifcClass') ?? getProp(rawMeta, 'ifcClass') ?? metaFromMap?.ifcClass);
+        const clsId = getProp(meta, 'ifcClassId') ?? getProp(rawMeta, 'ifcClassId') ?? metaFromMap?.ifcClassId ?? null;
+        const clsFromMap = normalizeClass(metaFromMap?.ifcClass);
+        const isFilterable = matchesFilterClass(cls, clsId, clsFromMap, effectiveFilterClasses);
+        const shouldHighlight = !!highlight?.gids && highlight.gids.size > 0 && !!pid && highlight.gids.has(pid);
+        if (includeFilters && includeFilters.length > 0) {
+            if (isFilterable) {
+                // Highlight/clip class: only check includeClasses if no GID filtering will be applied
+                const hasGidFiltering =
+                    (highlight?.gids && highlight.gids.size > 0) || (allowedGids && allowedGids.size > 0);
+                if (!hasGidFiltering) {
+                    // No GID filtering active, so apply includeClasses filter
+                    const matches = matchesIncludeFilter(includeFilters, cls, clsId, meta);
+                    if (!matches) {
+                        return;
+                    }
+                }
+            } else {
+                // Not a highlight/clip class: always apply includeClasses filter
+                const matches = matchesIncludeFilter(includeFilters, cls, clsId, meta);
+                if (!matches) {
+                    return;
+                }
+            }
+        }
+        if (isFilterable) {
+            if (highlight?.gids && highlight.gids.size > 0) {
+                if (!pid || !highlight.gids.has(pid)) {
+                    return;
+                }
+            }
+            // Clip filtering logic: null means no filtering, empty Set means filtering active but no matches
+            const allowed =
+                !allowedGids || (allowedGids.size > 0 && !!(pid && allowedGids.has(pid))) || shouldHighlight;
+            if (!allowed) return;
+        }
+        // CRITICAL: Exclude space fills from model - buildFillSvg will handle them with matchClipFilter support
+        // Only keep space segments (outlines) in the model
+        // EXCEPT: Keep highlighted space fills so they can be styled with highlight colors
+        const isFill = getProp(meta, 'isFill') ?? getProp(rawMeta, 'isFill');
+        if (isFilterable && isFill && !shouldHighlight) {
+            return;
+        }
+        // Apply highlight styling when requested
+        if (shouldHighlight) {
+            const styledPath: SectionPath = { ...p };
+            if (highlight?.styles?.stroke !== undefined) {
+                styledPath.stroke = highlight.styles.stroke;
+            }
+            if (highlight?.styles?.strokeWidthMm !== undefined) {
+                styledPath.strokeWidth = highlight.styles.strokeWidthMm;
+            }
+            if (highlight?.styles?.strokeOpacity !== undefined) {
+                styledPath.strokeOpacity = highlight.styles.strokeOpacity;
+            }
+            if (highlight?.styles?.fill !== undefined) {
+                styledPath.fill = highlight.styles.fill;
+            }
+            if (highlight?.styles?.fillOpacity !== undefined) {
+                styledPath.fillOpacity = highlight.styles.fillOpacity;
+            }
+            styleMutated = true;
+            filteredPaths.push(styledPath);
+        } else {
+            filteredPaths.push(p);
+        }
+    });
+
+    const filteredLabels: SectionLabel[] = [];
+    (model.rawLabels ?? []).forEach((l: SectionLabel) => {
+        const rawMeta = getProp(l, 'meta');
+        const meta = resolveMeta(rawMeta, metadataById);
+        const cls = normalizeClass(getProp(meta, 'ifcClass'));
+        const clsId = getProp(meta, 'ifcClassId') ?? getProp(rawMeta, 'ifcClassId') ?? null;
+        const productIdForMeta =
+            getProp(meta, 'productId') ??
+            getProp(meta, 'gid') ??
+            getProp(meta, 'id') ??
+            getProp(rawMeta, 'gid') ??
+            getProp(rawMeta, 'id') ??
+            null;
+        if (includeFilters && includeFilters.length > 0) {
+            if (!matchesIncludeFilter(includeFilters, cls, clsId, meta)) {
+                return;
+            }
+        }
+        if (matchesFilterClass(cls, clsId, null, effectiveFilterClasses)) {
+            const pid = productIdForMeta ? String(productIdForMeta) : null;
+            if (highlight?.gids && highlight.gids.size > 0) {
+                if (!pid || !highlight.gids.has(pid)) {
+                    return;
+                }
+            }
+            if (allowedGids && allowedGids.size > 0) {
+                if (!pid || !allowedGids.has(pid)) {
+                    return;
+                }
+            }
+        }
+        filteredLabels.push(l);
+    });
+
+    // Count paths by IFC class before and after filtering
+    const classCountsBefore = new Map<string, number>();
+    const classCountsAfter = new Map<string, number>();
+    const excluded: Array<{ cls: string | null; clsId: unknown }> = [];
+
+    model.rawPaths.forEach((p: SectionPath) => {
+        const rawMeta = getProp(p, 'meta');
+        const meta = resolveMeta(rawMeta, metadataById);
+        const metaFromMap = (() => {
+            const pid =
+                getProp(meta, 'productId') ??
+                getProp(meta, 'gid') ??
+                getProp(meta, 'id') ??
+                getProp(rawMeta, 'gid') ??
+                getProp(rawMeta, 'id');
+            return pid && metadataById ? metadataById[String(pid)] : null;
+        })();
+        const cls = normalizeClass(getProp(meta, 'ifcClass') ?? getProp(rawMeta, 'ifcClass') ?? metaFromMap?.ifcClass);
+        const clsId = getProp(meta, 'ifcClassId') ?? getProp(rawMeta, 'ifcClassId') ?? metaFromMap?.ifcClassId ?? null;
+        const key = cls ?? String(clsId) ?? 'unknown';
+        classCountsBefore.set(key, (classCountsBefore.get(key) ?? 0) + 1);
+    });
+
+    filteredPaths.forEach((p: SectionPath) => {
+        const rawMeta = getProp(p, 'meta');
+        const meta = resolveMeta(rawMeta, metadataById);
+        const metaFromMap = (() => {
+            const pid =
+                getProp(meta, 'productId') ??
+                getProp(meta, 'gid') ??
+                getProp(meta, 'id') ??
+                getProp(rawMeta, 'gid') ??
+                getProp(rawMeta, 'id');
+            return pid && metadataById ? metadataById[String(pid)] : null;
+        })();
+        const cls = normalizeClass(getProp(meta, 'ifcClass') ?? getProp(rawMeta, 'ifcClass') ?? metaFromMap?.ifcClass);
+        const clsId = getProp(meta, 'ifcClassId') ?? getProp(rawMeta, 'ifcClassId') ?? metaFromMap?.ifcClassId ?? null;
+        const key = cls ?? String(clsId) ?? 'unknown';
+        classCountsAfter.set(key, (classCountsAfter.get(key) ?? 0) + 1);
+    });
+
+    // Find excluded classes
+    classCountsBefore.forEach((countBefore, cls) => {
+        const countAfter = classCountsAfter.get(cls) ?? 0;
+        if (countAfter < countBefore) {
+            excluded.push({ cls, clsId: `${countBefore - countAfter} paths removed` });
+        }
+    });
+
+    if (
+        !styleMutated &&
+        filteredPaths.length === model.rawPaths.length &&
+        filteredLabels.length === (model.rawLabels?.length ?? 0)
+    ) {
+        return model;
+    }
+
+    const rebuilt = buildModelViewFromRaw(
+        filteredPaths,
+        filteredLabels,
+        model.transform,
+        model.geometryTransform,
+        model.labelStyle
+    );
+    return rebuilt ?? model;
+};

package/src/layout/options.ts

@@ -0,0 +1,17 @@
+import { ModelMetadata } from './metadata';
+
+export interface RenderLayoutOptions {
+    scaleDenominators?: number[];
+    maxViewports?: number;
+    allowRemoteAssets?: boolean;
+    allowDataUrls?: boolean;
+    qrContext?: {
+        host?: string | null;
+        containerName?: string | null;
+        floorName?: string | null;
+        planeHeight?: number | null;
+    };
+    legendSources?: Record<string, any[]>;
+    /** Optional metadata map keyed by productId referenced from path/label meta */
+    metadataById?: ModelMetadata;
+}

package/src/layout/presets.ts

@@ -0,0 +1,51 @@
+export const DEFAULT_SCALE_DENOMS = [2, 10, 25, 50, 100, 250, 500, 1000, 2500] as const;
+
+/**
+ * Example building class preset. Not auto-applied — consumers must include it
+ * in their template's `presets.includeClasses` if they want to use it.
+ *
+ * ```json
+ * { "presets": { "includeClasses": { "defaultBuilding": [...] } } }
+ * ```
+ */
+export const EXAMPLE_BUILDING_CLASSES: string[] = [
+    'space',
+    'ifcspace',
+    'wall',
+    'walls',
+    'ifcwall',
+    'ifcwallstandardcase',
+    'window',
+    'windows',
+    'ifcwindow',
+    'door',
+    'doors',
+    'ifcdoor',
+    'beam',
+    'ifcbeam',
+    'column',
+    'columns',
+    'ifccolumn',
+    'stair',
+    'stairs',
+    'ifcstair',
+    'slab',
+    'ifcslab'
+];
+
+const defaultScalePresets: Record<string, { preferredScales?: number[] }> = {
+    default: { preferredScales: Array.from(DEFAULT_SCALE_DENOMS) }
+};
+
+export interface ResolvedPresets {
+    includeClasses: Record<string, string[]>;
+    scales: Record<string, { preferredScales?: number[] }>;
+}
+
+export const resolvePresets = (presets?: {
+    includeClasses?: Record<string, string[]>;
+    scales?: Record<string, { preferredScales?: number[] }>;
+}): ResolvedPresets => ({
+    includeClasses: presets?.includeClasses ?? {},
+    scales: { ...defaultScalePresets, ...(presets?.scales ?? {}) }
+});

package/src/layout/qrRender.ts

@@ -0,0 +1,126 @@
+import { escapeAttr } from './renderUtils';
+import { interpolate } from './renderUtils';
+import { QrElement, SvgModelView } from './types';
+
+async function getQRCode(): Promise<typeof import('qrcode')> {
+    try {
+        return await import('qrcode');
+    } catch {
+        throw new Error('qrcode is required for QR code rendering. Install it: bun add qrcode');
+    }
+}
+
+export interface QrContext {
+    host?: string | null;
+    containerName?: string | null;
+    floorName?: string | null;
+    planeHeight?: number | null;
+}
+
+export const renderQrElements = async (
+    qrElements: QrElement[],
+    viewports: any[],
+    viewportScales: Record<string, { mmPerModelUnit: number }>,
+    models: Record<string, SvgModelView | undefined>,
+    options: { qrContext?: QrContext },
+    dataWithViewport: any,
+    warnings: string[]
+): Promise<string[]> => {
+    const parts: string[] = [];
+
+    for (const qr of qrElements) {
+        const boundViewportId = qr.viewport ?? viewports[0]?.id ?? null;
+        const viewportScale = boundViewportId ? viewportScales[boundViewportId] : null;
+        const boundViewportDef = boundViewportId ? viewports.find((v) => v.id === boundViewportId) : null;
+        // In v2, viewport id IS the model key
+        const boundModel = boundViewportDef ? (models[boundViewportDef.id] ?? null) : null;
+
+        let coordinate: { x: number; y: number; z: number } | null = null;
+        if (boundViewportDef && viewportScale && boundModel?.transform && (boundViewportDef.rotationDeg ?? 0) === 0) {
+            const mmPerModel = viewportScale.mmPerModelUnit;
+            const contentWidthMm = boundModel.widthModel * mmPerModel;
+            const contentHeightMm = boundModel.heightModel * mmPerModel;
+            const centerX =
+                boundViewportDef.align === 'topLeft'
+                    ? boundViewportDef.xMm + contentWidthMm * 0.5
+                    : boundViewportDef.xMm + boundViewportDef.widthMm * 0.5;
+            const centerY =
+                boundViewportDef.align === 'topLeft'
+                    ? boundViewportDef.yMm + contentHeightMm * 0.5
+                    : boundViewportDef.yMm + boundViewportDef.heightMm * 0.5;
+
+            const pointMmX = qr.xMm + qr.sizeMm * 0.5;
+            const pointMmY = qr.yMm + qr.sizeMm * 0.5;
+
+            const modelX = (pointMmX - centerX) / mmPerModel + boundModel.widthModel * 0.5;
+            const modelY = (pointMmY - centerY) / mmPerModel + boundModel.heightModel * 0.5;
+
+            const t = boundModel.transform;
+            const worldX = t.viewMinX + modelX;
+            const worldZ = t.viewMaxZ - modelY;
+            const planeHeight = options?.qrContext?.planeHeight ?? 0;
+            coordinate = { x: formatNumber(worldX), y: formatNumber(planeHeight ?? 0), z: formatNumber(worldZ) };
+        }
+
+        let payload: unknown = qr.dataTemplate ? interpolate(qr.dataTemplate, dataWithViewport) : null;
+        if (!payload || typeof payload === 'string') {
+            if (qr.role === 'anchor' && coordinate) {
+                const corner =
+                    qr.anchorCorner === 'bottom-left'
+                        ? 'bl'
+                        : qr.anchorCorner === 'bottom-right'
+                          ? 'br'
+                          : qr.anchorCorner === 'top-left'
+                            ? 'tl'
+                            : qr.anchorCorner === 'top-right'
+                              ? 'tr'
+                              : 'na';
+                payload = { v: 1, c: corner, p: coordinate };
+            } else if (qr.role === 'main') {
+                const cornerShort =
+                    qr.anchorCorner === 'bottom-left'
+                        ? 'bl'
+                        : qr.anchorCorner === 'bottom-right'
+                          ? 'br'
+                          : qr.anchorCorner === 'top-left'
+                            ? 'tl'
+                            : qr.anchorCorner === 'top-right'
+                              ? 'tr'
+                              : 'bl';
+                payload = {
+                    v: 1,
+                    c: cornerShort,
+                    h: options?.qrContext?.host ?? null,
+                    a: options?.qrContext?.containerName ?? null,
+                    fn: options?.qrContext?.floorName ?? null,
+                    p: coordinate
+                };
+            }
+        }
+
+        if (!payload) {
+            warnings.push(`QR '${qr.id}' has no payload.`);
+            continue;
+        }
+
+        try {
+            const QRCode = await getQRCode();
+            const dataUrl = await QRCode.toDataURL(typeof payload === 'string' ? payload : JSON.stringify(payload), {
+                margin: 0,
+                errorCorrectionLevel: 'M'
+            });
+            parts.push(
+                `<image href="${escapeAttr(dataUrl)}" x="${qr.xMm}" y="${qr.yMm}" width="${qr.sizeMm}" height="${qr.sizeMm}" />`
+            );
+        } catch (error) {
+            warnings.push(`Failed to generate QR '${qr.id}': ${(error as Error).message}`);
+        }
+    }
+
+    return parts;
+};
+
+const formatNumber = (value: number): number => {
+    if (!Number.isFinite(value)) return 0;
+    return Number.parseFloat(value.toFixed(3));
+};

package/src/layout/qrcode.d.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+declare module 'qrcode' { function toDataURL(text: string, options?: any): Promise<string>; }