@twinfinity/printing 6.1.1-beta → 6.1.2-ci.30738-beta

package/src/layout/slabModelView.ts

@@ -0,0 +1,196 @@
+import type { Vec3, SlabSectionGeometry, PlaneBasis, SectionPath } from '@twinfinity/geometry';
+import type { SvgModelView, ViewportLineStyles, ViewportLineStyle, ProductPolylineEntry } from './types';
+import { resolveCategoryLineStyle } from './renderDrawing';
+import { escapeAttr } from './renderUtils';
+
+/** Per-product line attribution (SlabSection with `trackProducts: true`).
+ *  Structurally typed — any `{ product, cutLines?, visibleLines?, … }` works. */
+export type SlabPerProductEntry = { product: unknown } & { [K in keyof SlabSectionGeometry]?: Vec3[][] };
+
+type Pt2 = { x: number; y: number };
+type LineCategory = keyof SlabSectionGeometry;
+
+// Paint order (SVG paints later paths on top): hidden categories first, so occluded
+// linework can never cover visible geometry — same order printToSvg uses.
+const CATEGORIES: LineCategory[] = [
+    'hiddenLines',
+    'outlineHidden',
+    'silhouettesHidden',
+    'visibleLines',
+    'outlineVisible',
+    'silhouettesVisible',
+    'featureEdges',
+    'cutLines',
+    'stairArrows'
+];
+
+function resolveStyle(category: LineCategory, lineStyles?: ViewportLineStyles): Required<ViewportLineStyle> {
+    return resolveCategoryLineStyle(category, lineStyles);
+}
+
+function projectPolyline(poly: Vec3[], basis: PlaneBasis): Pt2[] {
+    const ox = basis.origin[0],
+        oy = basis.origin[1],
+        oz = basis.origin[2];
+    const rx = basis.right[0],
+        ry = basis.right[1],
+        rz = basis.right[2];
+    const ux = basis.up[0],
+        uy = basis.up[1],
+        uz = basis.up[2];
+    const pts: Pt2[] = [];
+    for (let i = 0; i < poly.length; i++) {
+        const p = poly[i];
+        const dx = p[0] - ox,
+            dy = p[1] - oy,
+            dz = p[2] - oz;
+        pts.push({ x: dx * rx + dy * ry + dz * rz, y: dx * ux + dy * uy + dz * uz });
+    }
+    return pts;
+}
+
+function fmt(v: number): string {
+    return v.toFixed(6).replace(/\.?0+$/, '');
+}
+
+function buildPathD(projected: Pt2[][]): string {
+    const parts: string[] = [];
+    for (const poly of projected) {
+        if (poly.length === 0) continue;
+        parts.push(`M ${fmt(poly[0].x)} ${fmt(poly[0].y)}`);
+        for (let i = 1; i < poly.length; i++) {
+            parts.push(`L ${fmt(poly[i].x)} ${fmt(poly[i].y)}`);
+        }
+    }
+    return parts.join(' ');
+}
+
+/**
+ * Convert SlabSection geometry into an SvgModelView for the print-layout engine
+ * (`renderDrawing({ models })`). Returns null when the geometry is empty or
+ * degenerate. Use a (0,0,1) up hint when building the plane basis for standard
+ * north-up floor plans.
+ *
+ * When the geometry carries `perProduct` attribution (SlabSection option
+ * `trackProducts: true`), the model also gets `rawPaths` with per-product gid
+ * metadata — required for the renderer's gid-based features (highlight, clip
+ * include/exclude, render-time includeClasses): without rawPaths,
+ * filterModelForViewport returns the model untouched and those settings
+ * silently do nothing.
+ */
+export function slabSectionToModelView(
+    geometry: SlabSectionGeometry & { perProduct?: SlabPerProductEntry[] },
+    planeBasis: PlaneBasis,
+    lineStyles?: ViewportLineStyles
+): SvgModelView | null {
+    const projected: Record<string, Pt2[][]> = {};
+    let minX = Infinity,
+        maxX = -Infinity;
+    let minY = Infinity,
+        maxY = -Infinity;
+
+    for (const cat of CATEGORIES) {
+        const polys = geometry[cat];
+        const result: Pt2[][] = [];
+        for (const poly of polys) {
+            if (poly.length === 0) continue;
+            const pts = projectPolyline(poly, planeBasis);
+            for (const pt of pts) {
+                if (pt.x < minX) minX = pt.x;
+                if (pt.x > maxX) maxX = pt.x;
+                if (pt.y < minY) minY = pt.y;
+                if (pt.y > maxY) maxY = pt.y;
+            }
+            result.push(pts);
+        }
+        projected[cat] = result;
+    }
+
+    const viewWidth = maxX - minX;
+    const viewHeight = maxY - minY;
+    if (!Number.isFinite(viewWidth) || viewWidth <= 1e-6 || !Number.isFinite(viewHeight) || viewHeight <= 1e-6) {
+        return null;
+    }
+
+    // Map projected (x,y) to SVG coords: SVG_x = x - minX, SVG_y = maxY - y (flip).
+    const geometryTransform = `matrix(1 0 0 -1 ${fmt(-minX)} ${fmt(maxY)})`;
+
+    const svgParts: string[] = [`<g transform="${escapeAttr(geometryTransform)}">`];
+    for (const cat of CATEGORIES) {
+        const style = resolveStyle(cat, lineStyles);
+        if (style.enabled === false) continue;
+        const d = buildPathD(projected[cat]);
+        if (!d) continue;
+        let pathEl = `<path d="${d}" fill="none" stroke="${escapeAttr(style.color)}" stroke-width="${style.widthMm}"`;
+        if (style.dash) pathEl += ` stroke-dasharray="${escapeAttr(style.dash)}"`;
+        pathEl += ` stroke-linejoin="round" stroke-linecap="round"/>`;
+        svgParts.push(pathEl);
+    }
+    svgParts.push('</g>');
+
+    // Per-product rawPaths (same projection + styles as the merged groupSvg)
+    // so gid-based features can filter/restyle and rebuild the model.
+    let rawPaths: SectionPath[] | undefined;
+    if (geometry.perProduct?.length) {
+        rawPaths = [];
+        for (const entry of geometry.perProduct) {
+            const gid = (entry.product as { gid?: string } | undefined)?.gid;
+            if (!gid) continue;
+            for (const cat of CATEGORIES) {
+                const style = resolveStyle(cat, lineStyles);
+                if (style.enabled === false) continue;
+                const polys = entry[cat];
+                if (!polys?.length) continue;
+                const d = buildPathD(polys.filter((p) => p.length > 0).map((p) => projectPolyline(p, planeBasis)));
+                if (!d) continue;
+                rawPaths.push({
+                    key: `${gid}:${cat}`,
+                    d,
+                    fill: null,
+                    fillOpacity: 1,
+                    stroke: style.color,
+                    strokeWidth: style.widthMm,
+                    dash: style.dash || undefined,
+                    meta: { gid, isSegment: true, category: cat }
+                });
+            }
+        }
+        if (rawPaths.length === 0) rawPaths = undefined;
+    }
+
+    return {
+        groupSvg: `<g>${svgParts.join('')}</g>`,
+        widthModel: viewWidth,
+        heightModel: viewHeight,
+        transform: {
+            viewMinX: minX,
+            viewMaxX: maxX,
+            viewMinZ: minY,
+            viewMaxZ: maxY,
+            viewWidth,
+            viewHeight
+        },
+        geometryTransform,
+        rawPaths
+    };
+}
+
+/**
+ * Build `options.productEntries` for renderDrawing from SlabSection
+ * per-product attribution: each product's cut polylines in world x/z. Labels,
+ * legend, clip and highlight items are derived from these entries — the
+ * polylines must be in WORLD coordinates (use a zero lateral section origin so
+ * the projected space equals world x/z).
+ */
+export function slabPerProductToEntries(perProduct: SlabPerProductEntry[]): ProductPolylineEntry[] {
+    return perProduct
+        .map((entry) => ({
+            product: entry.product,
+            polylines: (entry.cutLines ?? [])
+                .filter((poly) => poly.length > 0)
+                .map((poly) => ({
+                    points: poly.map((pt) => ({ x: pt[0], z: pt[2] }))
+                }))
+        }))
+        .filter((e) => e.polylines.length > 0);
+}

package/src/layout/templateVariables.ts

@@ -11,6 +11,7 @@
  */
 
 import type { LayoutTemplate, TemplateVariableDef, TemplateVariableInfo } from './types';
+import { applyPlaceholderFilter } from './renderUtils';
 
 /**
  * Extract all variable definitions from a template.
@@ -263,14 +264,28 @@ export function resolveTemplateValues(
  * // }
  * ```
  */
-export function applyTemplateVariables(template: LayoutTemplate, values: Record<string, any>): LayoutTemplate {
+export function applyTemplateVariables(
+    template: LayoutTemplate,
+    values: Record<string, any>,
+    warnings?: string[]
+): LayoutTemplate {
     // Deep clone to avoid mutation
     const resolved: LayoutTemplate = JSON.parse(JSON.stringify(template));
 
-    // Recursively replace {{vars.*}} in all string values
+    // Recursively replace {{vars.*}} in all string values.
+    // A value that is EXACTLY one placeholder (no surrounding text, no
+    // format filter) substitutes the variable's RAW value, preserving its
+    // type — this is what lets number variables drive numeric template
+    // fields like a viewport's cutHeight ("cutHeight": "{{vars.cutHeight}}").
+    // Mixed strings keep normal stringified interpolation.
+    const WHOLE_VALUE_RE = /^\{\{\s*vars\.(\w+)\s*\}\}$/;
     function replaceInValue(obj: any): any {
         if (typeof obj === 'string') {
-            return interpolateVariables(obj, values);
+            const whole = WHOLE_VALUE_RE.exec(obj);
+            if (whole && whole[1] in values && typeof values[whole[1]] !== 'string') {
+                return values[whole[1]];
+            }
+            return interpolateVariables(obj, values, warnings);
         }
         if (Array.isArray(obj)) {
             return obj.map(replaceInValue);
@@ -287,8 +302,8 @@ export function applyTemplateVariables(template: LayoutTemplate, values: Record<
 
     // Apply to all template properties that might contain variable references
     resolved.elements = replaceInValue(resolved.elements);
-    if (resolved.assets) {
-        resolved.assets = replaceInValue(resolved.assets);
+    if (resolved.resources) {
+        resolved.resources = replaceInValue(resolved.resources);
     }
 
     return resolved;
@@ -304,14 +319,15 @@ export function applyTemplateVariables(template: LayoutTemplate, values: Record<
  * @param values - Variable values
  * @returns String with all {{vars.*}} replaced
  */
-function interpolateVariables(str: string, values: Record<string, any>): string {
-    return str.replace(/\{\{vars\.(\w+)\}\}/g, (match, varName) => {
+function interpolateVariables(str: string, values: Record<string, any>, warnings?: string[]): string {
+    return str.replace(/\{\{\s*vars\.(\w+)\s*(\|[^}]*)?\}\}/g, (match, varName, filterPart) => {
         if (varName in values) {
             const value = values[varName];
+            const filter = filterPart ? String(filterPart).slice(1).trim() : null;
             // Convert to string (handles numbers, booleans, etc.)
-            return String(value);
+            return String(applyPlaceholderFilter(value, filter, warnings, str));
         }
-        console.warn(`[templateVariables] Variable '${varName}' not found - keeping placeholder`);
+        warnings?.push(`Variable '${varName}' has no value — placeholder kept.`);
         return match; // Keep {{vars.varName}} as-is
     });
 }