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

package/src/printToSvg.ts

@@ -1,188 +1,188 @@
-import type { SlabSectionGeometry, Vec3 } from '@twinfinity/geometry';
-import type { PrintToSvgOptions, SvgRenderStyles, SvgPlaneBasis } from './types';
-import { DEFAULT_SVG_STYLES } from './types';
-
-type Pt2 = { x: number; y: number };
-type Bounds = { minX: number; maxX: number; minY: number; maxY: number };
-
-/**
- * Render SlabSectionGeometry to an SVG string.
- *
- * @param geometry The computed slab section geometry
- * @param options Rendering options (viewBox, styles, planeBasis, etc.)
- * @returns Complete SVG string
- */
-export function printToSvg(geometry: SlabSectionGeometry, options: PrintToSvgOptions = {}): string {
-    if (!geometry) throw new Error('geometry is required');
-
-    if (
-        options.boundsPadding !== undefined &&
-        (typeof options.boundsPadding !== 'number' || options.boundsPadding < 0)
-    ) {
-        throw new Error('boundsPadding must be a non-negative number');
-    }
-
-    if (options.viewBox) {
-        if (!Array.isArray(options.viewBox) || options.viewBox.length !== 4) {
-            throw new Error('viewBox must be an array of 4 numbers [minX, minY, width, height]');
-        }
-        for (let i = 0; i < 4; i++) {
-            if (typeof options.viewBox[i] !== 'number' || !Number.isFinite(options.viewBox[i])) {
-                throw new Error(`viewBox[${i}] must be a finite number`);
-            }
-        }
-    }
-
-    const styles = mergeStyles(options.styles);
-    const includeXml = options.includeXmlDeclaration ?? true;
-
-    // Project all polylines to 2D once
-    const proj = {
-        hiddenLines: projectPolylines(geometry.hiddenLines, options.planeBasis),
-        outlineHidden: projectPolylines(geometry.outlineHidden, options.planeBasis),
-        visibleLines: projectPolylines(geometry.visibleLines, options.planeBasis),
-        outlineVisible: projectPolylines(geometry.outlineVisible, options.planeBasis),
-        silhouettes: projectPolylines(geometry.silhouettes, options.planeBasis),
-        featureEdges: projectPolylines(geometry.featureEdges, options.planeBasis),
-        cutLines: projectPolylines(geometry.cutLines, options.planeBasis),
-        stairArrows: projectPolylines(geometry.stairArrows, options.planeBasis)
-    };
-
-    const bounds = options.bounds ?? computeBoundsFromProjected(proj);
-    const viewBox = options.viewBox ?? boundsToViewBox(bounds, options.boundsPadding ?? 0.05);
-
-    const parts: string[] = [];
-
-    if (includeXml) parts.push('<?xml version="1.0" encoding="UTF-8"?>');
-
-    const [minX, minY, width, height] = viewBox;
-    parts.push(
-        `<svg xmlns="http://www.w3.org/2000/svg" ` +
-            `viewBox="${minX} ${minY} ${width} ${height}" ` +
-            `width="${width}" height="${height}">`
-    );
-
-    if (options.backgroundColor) {
-        parts.push(
-            `<rect x="${minX}" y="${minY}" width="${width}" height="${height}" fill="${options.backgroundColor}"/>`
-        );
-    }
-
-    parts.push('<g fill="none" stroke-linecap="round" stroke-linejoin="round">');
-
-    const categories: Array<[keyof typeof proj, keyof Required<SvgRenderStyles>]> = [
-        ['hiddenLines', 'hiddenLines'],
-        ['outlineHidden', 'outlineHidden'],
-        ['visibleLines', 'visibleLines'],
-        ['outlineVisible', 'outlineVisible'],
-        ['silhouettes', 'silhouettes'],
-        ['featureEdges', 'featureEdges'],
-        ['cutLines', 'cutLines'],
-        ['stairArrows', 'stairArrows']
-    ];
-
-    for (const [key, styleKey] of categories) {
-        const style = styles[styleKey];
-        if (style.enabled) renderProjectedCategory(parts, proj[key], style, bounds);
-    }
-
-    parts.push('</g>');
-    parts.push('</svg>');
-    return parts.join('\n');
-}
-
-function projectPolylines(polylines: Vec3[][], planeBasis?: SvgPlaneBasis): Pt2[][] {
-    const result: Pt2[][] = [];
-    for (const polyline of polylines) {
-        if (polyline.length === 0) continue;
-        const projected: Pt2[] = [];
-        for (const point of polyline) {
-            if (!Number.isFinite(point[0]) || !Number.isFinite(point[1]) || !Number.isFinite(point[2])) continue;
-            if (planeBasis) {
-                const dx = point[0] - planeBasis.origin.x;
-                const dy = point[1] - planeBasis.origin.y;
-                const dz = point[2] - planeBasis.origin.z;
-                projected.push({
-                    x: dx * planeBasis.right.x + dy * planeBasis.right.y + dz * planeBasis.right.z,
-                    y: dx * planeBasis.up.x + dy * planeBasis.up.y + dz * planeBasis.up.z
-                });
-            } else {
-                projected.push({ x: point[0], y: -point[2] });
-            }
-        }
-        if (projected.length > 0) result.push(projected);
-    }
-    return result;
-}
-
-function computeBoundsFromProjected(categories: Record<string, Pt2[][]>): Bounds {
-    let minX = Infinity,
-        minY = Infinity,
-        maxX = -Infinity,
-        maxY = -Infinity;
-    for (const polylines of Object.values(categories)) {
-        for (const polyline of polylines) {
-            for (const pt of polyline) {
-                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;
-            }
-        }
-    }
-    if (!Number.isFinite(minX)) return { minX: 0, maxX: 1, minY: 0, maxY: 1 };
-    return { minX, maxX, minY, maxY };
-}
-
-function renderProjectedCategory(
-    parts: string[],
-    polylines: Pt2[][],
-    style: { stroke?: string; strokeWidth?: number; strokeDasharray?: string; opacity?: number },
-    bounds: Bounds
-): void {
-    if (!polylines.length) return;
-    const pathData = projectedToPathData(polylines, bounds);
-    if (!pathData) return;
-
-    let pathElement = `<path d="${pathData}"`;
-    if (style.stroke) pathElement += ` stroke="${style.stroke}"`;
-    if (style.strokeWidth !== undefined) pathElement += ` stroke-width="${style.strokeWidth}"`;
-    if (style.strokeDasharray) pathElement += ` stroke-dasharray="${style.strokeDasharray}"`;
-    if (style.opacity !== undefined && style.opacity !== 1) pathElement += ` opacity="${style.opacity}"`;
-    pathElement += '/>';
-    parts.push(pathElement);
-}
-
-function projectedToPathData(polylines: Pt2[][], bounds: Bounds): string {
-    const parts: string[] = [];
-    const ox = bounds.minX;
-    const oy = bounds.maxY;
-    for (const polyline of polylines) {
-        if (polyline.length === 0) continue;
-        parts.push(`M ${(polyline[0].x - ox).toFixed(6)} ${(oy - polyline[0].y).toFixed(6)}`);
-        for (let i = 1; i < polyline.length; i++) {
-            parts.push(`L ${(polyline[i].x - ox).toFixed(6)} ${(oy - polyline[i].y).toFixed(6)}`);
-        }
-    }
-    return parts.join(' ');
-}
-
-function boundsToViewBox(bounds: Bounds, padding: number): [number, number, number, number] {
-    const width = bounds.maxX - bounds.minX;
-    const height = bounds.maxY - bounds.minY;
-    const padAmount = Math.max(width, height) * padding;
-    return [-padAmount, -padAmount, width + padAmount * 2, height + padAmount * 2];
-}
-
-function mergeStyles(userStyles?: SvgRenderStyles): Required<SvgRenderStyles> {
-    return {
-        cutLines: { ...DEFAULT_SVG_STYLES.cutLines, ...userStyles?.cutLines },
-        visibleLines: { ...DEFAULT_SVG_STYLES.visibleLines, ...userStyles?.visibleLines },
-        hiddenLines: { ...DEFAULT_SVG_STYLES.hiddenLines, ...userStyles?.hiddenLines },
-        silhouettes: { ...DEFAULT_SVG_STYLES.silhouettes, ...userStyles?.silhouettes },
-        featureEdges: { ...DEFAULT_SVG_STYLES.featureEdges, ...userStyles?.featureEdges },
-        stairArrows: { ...DEFAULT_SVG_STYLES.stairArrows, ...userStyles?.stairArrows },
-        outlineVisible: { ...DEFAULT_SVG_STYLES.outlineVisible, ...userStyles?.outlineVisible },
-        outlineHidden: { ...DEFAULT_SVG_STYLES.outlineHidden, ...userStyles?.outlineHidden }
-    };
-}
+import type { SlabSectionGeometry, Vec3 } from '@twinfinity/geometry';
+import type { PrintToSvgOptions, SvgRenderStyles, SvgPlaneBasis } from './types';
+import { DEFAULT_SVG_STYLES } from './types';
+
+type Pt2 = { x: number; y: number };
+type Bounds = { minX: number; maxX: number; minY: number; maxY: number };
+
+/**
+ * Render SlabSectionGeometry to an SVG string.
+ *
+ * @param geometry The computed slab section geometry
+ * @param options Rendering options (viewBox, styles, planeBasis, etc.)
+ * @returns Complete SVG string
+ */
+export function printToSvg(geometry: SlabSectionGeometry, options: PrintToSvgOptions = {}): string {
+    if (!geometry) throw new Error('geometry is required');
+
+    if (
+        options.boundsPadding !== undefined &&
+        (typeof options.boundsPadding !== 'number' || options.boundsPadding < 0)
+    ) {
+        throw new Error('boundsPadding must be a non-negative number');
+    }
+
+    if (options.viewBox) {
+        if (!Array.isArray(options.viewBox) || options.viewBox.length !== 4) {
+            throw new Error('viewBox must be an array of 4 numbers [minX, minY, width, height]');
+        }
+        for (let i = 0; i < 4; i++) {
+            if (typeof options.viewBox[i] !== 'number' || !Number.isFinite(options.viewBox[i])) {
+                throw new Error(`viewBox[${i}] must be a finite number`);
+            }
+        }
+    }
+
+    const styles = mergeStyles(options.styles);
+    const includeXml = options.includeXmlDeclaration ?? true;
+
+    // Project all polylines to 2D once
+    const proj = {
+        hiddenLines: projectPolylines(geometry.hiddenLines, options.planeBasis),
+        outlineHidden: projectPolylines(geometry.outlineHidden, options.planeBasis),
+        visibleLines: projectPolylines(geometry.visibleLines, options.planeBasis),
+        outlineVisible: projectPolylines(geometry.outlineVisible, options.planeBasis),
+        silhouettes: projectPolylines(geometry.silhouettes, options.planeBasis),
+        featureEdges: projectPolylines(geometry.featureEdges, options.planeBasis),
+        cutLines: projectPolylines(geometry.cutLines, options.planeBasis),
+        stairArrows: projectPolylines(geometry.stairArrows, options.planeBasis)
+    };
+
+    const bounds = options.bounds ?? computeBoundsFromProjected(proj);
+    const viewBox = options.viewBox ?? boundsToViewBox(bounds, options.boundsPadding ?? 0.05);
+
+    const parts: string[] = [];
+
+    if (includeXml) parts.push('<?xml version="1.0" encoding="UTF-8"?>');
+
+    const [minX, minY, width, height] = viewBox;
+    parts.push(
+        `<svg xmlns="http://www.w3.org/2000/svg" ` +
+            `viewBox="${minX} ${minY} ${width} ${height}" ` +
+            `width="${width}" height="${height}">`
+    );
+
+    if (options.backgroundColor) {
+        parts.push(
+            `<rect x="${minX}" y="${minY}" width="${width}" height="${height}" fill="${options.backgroundColor}"/>`
+        );
+    }
+
+    parts.push('<g fill="none" stroke-linecap="round" stroke-linejoin="round">');
+
+    const categories: Array<[keyof typeof proj, keyof Required<SvgRenderStyles>]> = [
+        ['hiddenLines', 'hiddenLines'],
+        ['outlineHidden', 'outlineHidden'],
+        ['visibleLines', 'visibleLines'],
+        ['outlineVisible', 'outlineVisible'],
+        ['silhouettes', 'silhouettes'],
+        ['featureEdges', 'featureEdges'],
+        ['cutLines', 'cutLines'],
+        ['stairArrows', 'stairArrows']
+    ];
+
+    for (const [key, styleKey] of categories) {
+        const style = styles[styleKey];
+        if (style.enabled) renderProjectedCategory(parts, proj[key], style, bounds);
+    }
+
+    parts.push('</g>');
+    parts.push('</svg>');
+    return parts.join('\n');
+}
+
+function projectPolylines(polylines: Vec3[][], planeBasis?: SvgPlaneBasis): Pt2[][] {
+    const result: Pt2[][] = [];
+    for (const polyline of polylines) {
+        if (polyline.length === 0) continue;
+        const projected: Pt2[] = [];
+        for (const point of polyline) {
+            if (!Number.isFinite(point[0]) || !Number.isFinite(point[1]) || !Number.isFinite(point[2])) continue;
+            if (planeBasis) {
+                const dx = point[0] - planeBasis.origin.x;
+                const dy = point[1] - planeBasis.origin.y;
+                const dz = point[2] - planeBasis.origin.z;
+                projected.push({
+                    x: dx * planeBasis.right.x + dy * planeBasis.right.y + dz * planeBasis.right.z,
+                    y: dx * planeBasis.up.x + dy * planeBasis.up.y + dz * planeBasis.up.z
+                });
+            } else {
+                projected.push({ x: point[0], y: -point[2] });
+            }
+        }
+        if (projected.length > 0) result.push(projected);
+    }
+    return result;
+}
+
+function computeBoundsFromProjected(categories: Record<string, Pt2[][]>): Bounds {
+    let minX = Infinity,
+        minY = Infinity,
+        maxX = -Infinity,
+        maxY = -Infinity;
+    for (const polylines of Object.values(categories)) {
+        for (const polyline of polylines) {
+            for (const pt of polyline) {
+                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;
+            }
+        }
+    }
+    if (!Number.isFinite(minX)) return { minX: 0, maxX: 1, minY: 0, maxY: 1 };
+    return { minX, maxX, minY, maxY };
+}
+
+function renderProjectedCategory(
+    parts: string[],
+    polylines: Pt2[][],
+    style: { stroke?: string; strokeWidth?: number; strokeDasharray?: string; opacity?: number },
+    bounds: Bounds
+): void {
+    if (!polylines.length) return;
+    const pathData = projectedToPathData(polylines, bounds);
+    if (!pathData) return;
+
+    let pathElement = `<path d="${pathData}"`;
+    if (style.stroke) pathElement += ` stroke="${style.stroke}"`;
+    if (style.strokeWidth !== undefined) pathElement += ` stroke-width="${style.strokeWidth}"`;
+    if (style.strokeDasharray) pathElement += ` stroke-dasharray="${style.strokeDasharray}"`;
+    if (style.opacity !== undefined && style.opacity !== 1) pathElement += ` opacity="${style.opacity}"`;
+    pathElement += '/>';
+    parts.push(pathElement);
+}
+
+function projectedToPathData(polylines: Pt2[][], bounds: Bounds): string {
+    const parts: string[] = [];
+    const ox = bounds.minX;
+    const oy = bounds.maxY;
+    for (const polyline of polylines) {
+        if (polyline.length === 0) continue;
+        parts.push(`M ${(polyline[0].x - ox).toFixed(6)} ${(oy - polyline[0].y).toFixed(6)}`);
+        for (let i = 1; i < polyline.length; i++) {
+            parts.push(`L ${(polyline[i].x - ox).toFixed(6)} ${(oy - polyline[i].y).toFixed(6)}`);
+        }
+    }
+    return parts.join(' ');
+}
+
+function boundsToViewBox(bounds: Bounds, padding: number): [number, number, number, number] {
+    const width = bounds.maxX - bounds.minX;
+    const height = bounds.maxY - bounds.minY;
+    const padAmount = Math.max(width, height) * padding;
+    return [-padAmount, -padAmount, width + padAmount * 2, height + padAmount * 2];
+}
+
+function mergeStyles(userStyles?: SvgRenderStyles): Required<SvgRenderStyles> {
+    return {
+        cutLines: { ...DEFAULT_SVG_STYLES.cutLines, ...userStyles?.cutLines },
+        visibleLines: { ...DEFAULT_SVG_STYLES.visibleLines, ...userStyles?.visibleLines },
+        hiddenLines: { ...DEFAULT_SVG_STYLES.hiddenLines, ...userStyles?.hiddenLines },
+        silhouettes: { ...DEFAULT_SVG_STYLES.silhouettes, ...userStyles?.silhouettes },
+        featureEdges: { ...DEFAULT_SVG_STYLES.featureEdges, ...userStyles?.featureEdges },
+        stairArrows: { ...DEFAULT_SVG_STYLES.stairArrows, ...userStyles?.stairArrows },
+        outlineVisible: { ...DEFAULT_SVG_STYLES.outlineVisible, ...userStyles?.outlineVisible },
+        outlineHidden: { ...DEFAULT_SVG_STYLES.outlineHidden, ...userStyles?.outlineHidden }
+    };
+}