@twinfinity/printing 5.0.3-ci.28538-beta

package/dist/sections.js

@@ -0,0 +1,839 @@
+/**
+ * Resolve a dotted property path (e.g. "BIP.spacetype") against a product.
+ * Handles both the new T8 API (propertySets → .properties → .value) and
+ * legacy BimIfcObject (properties.sets / properties.data).
+ *
+ * Returns the resolved value, or undefined if not found.
+ */
+export function resolveProductProperty(product, path) {
+    const p = product;
+    const parts = path.split('.');
+    if (parts.length < 2)
+        return undefined;
+    const [setName, ...propParts] = parts;
+    const propName = propParts.join('.');
+    // New T8 API: propertySets['BIP'].properties['spacetype'].value
+    const pset = p?.propertySets?.[setName];
+    if (pset) {
+        const prop = pset.properties?.[propName];
+        if (prop !== undefined) {
+            return prop?.value !== undefined ? prop.value : prop;
+        }
+    }
+    // Legacy: properties.sets['BIP']['spacetype']
+    const legacyPset = p?.properties?.sets?.[setName];
+    if (legacyPset) {
+        const val = legacyPset[propName];
+        if (val !== undefined) {
+            return val?.value !== undefined ? val.value : val;
+        }
+    }
+    // Fallback: properties.data['BIP']['spacetype'] (old printing code path)
+    let value = p?.properties?.data;
+    if (value) {
+        for (const part of parts) {
+            value = value?.[part];
+            if (value === undefined)
+                break;
+        }
+        if (value !== undefined) {
+            return value?.value !== undefined ? value.value : value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Sample the actual rendered color of a product's first mesh.
+ * Uses BimProductMesh.copyColorTo/getColorComponent for accurate colors
+ * (includes overrides, highlights). Falls back to style.surfaceColor/color.
+ */
+const sampleProductColorRgba = (product) => {
+    const p = product;
+    const meshes = (p?.meshes ?? p?.productMeshes);
+    if (!meshes || !meshes.length)
+        return undefined;
+    const rgba = new Uint8Array(4);
+    for (const mesh of meshes) {
+        try {
+            // BimProductMesh: read actual rendered color via copyColorTo or getColorComponent
+            if (typeof mesh.copyColorTo === 'function') {
+                mesh.copyColorTo(rgba, 0);
+            }
+            else if (typeof mesh.getColorComponent === 'function') {
+                rgba[0] = mesh.getColorComponent(0); // Red
+                rgba[1] = mesh.getColorComponent(1); // Green
+                rgba[2] = mesh.getColorComponent(2); // Blue
+                rgba[3] = mesh.getColorComponent(3); // Alpha
+            }
+            else {
+                // ModelMesh fallback: read from style
+                const style = mesh.style;
+                const c = style?.surfaceColor ?? style?.color;
+                if (c)
+                    return { r: c[0], g: c[1], b: c[2], a: (c[3] ?? 255) / 255 };
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        const [r, g, b, a] = rgba;
+        if (a === 0 && r === 0 && g === 0 && b === 0)
+            continue;
+        return { r, g, b, a: a / 255 };
+    }
+    return undefined;
+};
+/** Base SVG display width in layout units. */
+export const BASE_WIDTH = 240;
+/** Minimum SVG display height in layout units. */
+export const MIN_HEIGHT = 140;
+/** Margin ratio applied around section bounds (fraction of world extent). */
+export const SECTION_MARGIN_RATIO = 0.05;
+/** Maximum zoom factor for viewport clamping. */
+export const MAX_ZOOM_FACTOR = 12;
+/** Multiplicative step for zooming in. */
+export const ZOOM_IN_STEP = 0.8;
+/** Multiplicative step for zooming out. */
+export const ZOOM_OUT_STEP = 1 / ZOOM_IN_STEP;
+const OUTLINE_THICKNESS_SCALE = 0.5;
+/** Clamp a number to a min/max range. */
+export function clampValue(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+/**
+ * Extract product metadata for path/label attribution.
+ * Casts to `any` once here to avoid scattering `as any` across the codebase.
+ * BimIfcObject's runtime shape exposes these fields but the public typings
+ * don't always surface them.
+ */
+function extractProductMeta(product) {
+    const p = product;
+    return {
+        productId: p?.gid ?? p?.id ?? String(product),
+        ifcClass: p?.class?.type ?? null,
+        ifcClassId: p?.class?.id ?? null,
+        properties: p?.properties?.data ?? p?.properties ?? null
+    };
+}
+/** Default fill opacity when a fill rule omits `fillOpacity`. */
+export const DEFAULT_FILL_OPACITY = 0.35;
+/** Convert plane section polylines to SVG path data with fill colors and stroke styles. */
+export function createSectionSvg(perProduct, viewport, strokeWidthHint, labels, options) {
+    if (!perProduct.length) {
+        return null;
+    }
+    const polylines = perProduct.flatMap((entry) => entry.polylines);
+    const hasSegments = perProduct.some((entry) => entry.segments && entry.segments.length > 0);
+    if (!polylines.length && !hasSegments) {
+        return null;
+    }
+    const planeNormal = options?.planeNormal;
+    const axes = getProjectionAxes(planeNormal);
+    let viewMinX;
+    let viewMaxX;
+    let viewMinZ;
+    let viewMaxZ;
+    if (viewport) {
+        viewMinX = viewport.viewMinX;
+        viewMaxX = viewport.viewMaxX;
+        viewMinZ = viewport.viewMinZ;
+        viewMaxZ = viewport.viewMaxZ;
+    }
+    else {
+        let minU = Number.POSITIVE_INFINITY;
+        let maxU = Number.NEGATIVE_INFINITY;
+        let minV = Number.POSITIVE_INFINITY;
+        let maxV = Number.NEGATIVE_INFINITY;
+        polylines.forEach((polyline) => {
+            polyline.points.forEach((point) => {
+                if (!point) {
+                    return;
+                }
+                const u = axes.getU(point);
+                const v = axes.getV(point);
+                if (!Number.isFinite(u) || !Number.isFinite(v)) {
+                    return;
+                }
+                if (u < minU)
+                    minU = u;
+                if (u > maxU)
+                    maxU = u;
+                if (v < minV)
+                    minV = v;
+                if (v > maxV)
+                    maxV = v;
+            });
+        });
+        // Also include segments in bounding box calculation
+        perProduct.forEach((entry) => {
+            if (entry.segments && entry.segments.length) {
+                entry.segments.forEach((segment) => {
+                    const [p1, p2] = segment;
+                    const u1 = axes.getU(p1);
+                    const v1 = axes.getV(p1);
+                    const u2 = axes.getU(p2);
+                    const v2 = axes.getV(p2);
+                    if (Number.isFinite(u1) && Number.isFinite(v1)) {
+                        if (u1 < minU)
+                            minU = u1;
+                        if (u1 > maxU)
+                            maxU = u1;
+                        if (v1 < minV)
+                            minV = v1;
+                        if (v1 > maxV)
+                            maxV = v1;
+                    }
+                    if (Number.isFinite(u2) && Number.isFinite(v2)) {
+                        if (u2 < minU)
+                            minU = u2;
+                        if (u2 > maxU)
+                            maxU = u2;
+                        if (v2 < minV)
+                            minV = v2;
+                        if (v2 > maxV)
+                            maxV = v2;
+                    }
+                });
+            }
+        });
+        if (!Number.isFinite(minU) || !Number.isFinite(maxU) || !Number.isFinite(minV) || !Number.isFinite(maxV)) {
+            return null;
+        }
+        if (maxU - minU < 1e-3) {
+            minU -= 0.5;
+            maxU += 0.5;
+        }
+        if (maxV - minV < 1e-3) {
+            minV -= 0.5;
+            maxV += 0.5;
+        }
+        const worldWidth = maxU - minU;
+        const worldHeight = maxV - minV;
+        const marginU = Math.max(worldWidth * SECTION_MARGIN_RATIO, 0.5);
+        const marginV = Math.max(worldHeight * SECTION_MARGIN_RATIO, 0.5);
+        viewMinX = minU - marginU;
+        viewMaxX = maxU + marginU;
+        viewMinZ = minV - marginV;
+        viewMaxZ = maxV + marginV;
+    }
+    const viewWidth = viewMaxX - viewMinX;
+    const viewHeight = viewMaxZ - viewMinZ;
+    if (!Number.isFinite(viewWidth) || !Number.isFinite(viewHeight) || viewWidth <= 1e-6 || viewHeight <= 1e-6) {
+        return null;
+    }
+    const autoStrokeBase = Math.max(Math.min(viewWidth, viewHeight) * 0.008, 0.08);
+    const autoStroke = Math.max(autoStrokeBase * OUTLINE_THICKNESS_SCALE, 0.02);
+    const strokeWidth = Math.max(strokeWidthHint ?? autoStroke, 0.02);
+    const geometryTransform = buildGeometryTransform(viewMinX, viewMaxX, viewMinZ, viewMaxZ);
+    const includeMeta = !!options?.includeMeta;
+    const createFills = options?.createFills !== false; // Default to true for backward compatibility
+    const allPaths = [];
+    if (includeMeta) {
+        perProduct.forEach((entry, idx) => {
+            // Skip entries with neither polylines nor segments
+            if (!entry.polylines.length && (!entry.segments || !entry.segments.length)) {
+                return;
+            }
+            const colorInfo = sampleProductColorRgba(entry.product);
+            const fillColor = colorInfo ? `rgb(${colorInfo.r},${colorInfo.g},${colorInfo.b})` : '#ffffff';
+            const fillOpacity = colorInfo ? clampValue(colorInfo.a, 0, 1) : 1;
+            const meta = extractProductMeta(entry.product);
+            const closedSubpaths = [];
+            const holeSubpaths = [];
+            const openSubpaths = [];
+            entry.polylines.forEach((polyline) => {
+                const pathData = getCachedPolylinePath(polyline, planeNormal);
+                if (!pathData) {
+                    return;
+                }
+                if (pathData.closed) {
+                    if (pathData.hole) {
+                        holeSubpaths.push(pathData.d);
+                    }
+                    else {
+                        closedSubpaths.push(pathData.d);
+                    }
+                }
+                else {
+                    openSubpaths.push(pathData.d);
+                }
+            });
+            // Only create fill paths if createFills is true
+            if (createFills && (closedSubpaths.length || holeSubpaths.length)) {
+                const fillSubpaths = closedSubpaths.length ? closedSubpaths.concat(holeSubpaths) : holeSubpaths;
+                allPaths.push({
+                    key: `fill-${idx}`,
+                    d: fillSubpaths.join(' '),
+                    fill: fillColor,
+                    fillOpacity: clampValue(fillOpacity, 0, 1),
+                    stroke: '#1f2937',
+                    strokeWidth,
+                    fillRule: 'evenodd',
+                    meta: meta ? { ...meta, isFill: true } : undefined
+                });
+            }
+            if (openSubpaths.length) {
+                allPaths.push({
+                    key: `outline-${idx}`,
+                    d: openSubpaths.join(' '),
+                    fill: 'none',
+                    fillOpacity: 1,
+                    stroke: '#1f2937',
+                    strokeWidth,
+                    meta: meta ? { ...meta, isOutline: true } : undefined
+                });
+            }
+            // Render segments (cut edges) as strokes
+            if (entry.segments && entry.segments.length) {
+                const segmentPaths = [];
+                for (const segment of entry.segments) {
+                    const path = segmentToPath(segment, planeNormal);
+                    if (path)
+                        segmentPaths.push(path);
+                }
+                if (segmentPaths.length) {
+                    allPaths.push({
+                        key: `segments-${idx}`,
+                        d: segmentPaths.join(' '),
+                        fill: 'none',
+                        fillOpacity: 1,
+                        stroke: '#1f2937',
+                        strokeWidth,
+                        meta: meta ? { ...meta, isSegment: true } : undefined
+                    });
+                }
+            }
+        });
+    }
+    else {
+        const fillGroups = new Map();
+        const openSubpaths = [];
+        const allSegmentPaths = [];
+        perProduct.forEach((entry) => {
+            // Process segments first (always render, even without polylines)
+            if (entry.segments && entry.segments.length) {
+                for (const segment of entry.segments) {
+                    const path = segmentToPath(segment, planeNormal);
+                    if (path)
+                        allSegmentPaths.push(path);
+                }
+            }
+            if (!entry.polylines.length) {
+                return;
+            }
+            const colorInfo = sampleProductColorRgba(entry.product);
+            const fillColor = colorInfo ? `rgb(${colorInfo.r},${colorInfo.g},${colorInfo.b})` : '#ffffff';
+            const fillOpacity = colorInfo ? clampValue(colorInfo.a, 0, 1) : 1;
+            const groupKey = `${fillColor}|${Math.round(fillOpacity * 1000)}`;
+            let group = fillGroups.get(groupKey);
+            if (!group) {
+                group = {
+                    color: fillColor,
+                    opacity: fillOpacity,
+                    closed: [],
+                    holes: []
+                };
+                fillGroups.set(groupKey, group);
+            }
+            entry.polylines.forEach((polyline) => {
+                const pathData = getCachedPolylinePath(polyline, planeNormal);
+                if (!pathData) {
+                    return;
+                }
+                if (pathData.closed) {
+                    if (pathData.hole) {
+                        group.holes.push(pathData.d);
+                    }
+                    else {
+                        group.closed.push(pathData.d);
+                    }
+                    return;
+                }
+                openSubpaths.push(pathData.d);
+            });
+        });
+        let groupIndex = 0;
+        fillGroups.forEach((group) => {
+            const fillSubpaths = group.closed.length ? group.closed.concat(group.holes) : group.holes;
+            if (!fillSubpaths.length) {
+                return;
+            }
+            allPaths.push({
+                key: `fill-${groupIndex++}`,
+                d: fillSubpaths.join(' '),
+                fill: group.color,
+                fillOpacity: clampValue(group.opacity, 0, 1),
+                stroke: '#1f2937',
+                strokeWidth,
+                fillRule: 'evenodd'
+            });
+        });
+        if (openSubpaths.length) {
+            allPaths.push({
+                key: 'outlines',
+                d: openSubpaths.join(' '),
+                fill: 'none',
+                fillOpacity: 1,
+                stroke: '#1f2937',
+                strokeWidth
+            });
+        }
+        // Render all segments (collected above in forEach loop)
+        if (allSegmentPaths.length) {
+            allPaths.push({
+                key: 'segments',
+                d: allSegmentPaths.join(' '),
+                fill: 'none',
+                fillOpacity: 1,
+                stroke: '#1f2937',
+                strokeWidth
+            });
+        }
+    }
+    if (!allPaths.length) {
+        return null;
+    }
+    const displayWidth = BASE_WIDTH;
+    const displayHeight = Math.max(MIN_HEIGHT, (viewHeight / viewWidth) * BASE_WIDTH);
+    return {
+        paths: allPaths,
+        transform: {
+            viewMinX,
+            viewMaxX,
+            viewMinZ,
+            viewMaxZ,
+            viewWidth,
+            viewHeight,
+            displayWidth,
+            displayHeight
+        },
+        strokeWidth,
+        geometryTransform,
+        labels: labels?.length
+            ? labels
+                .filter((label) => {
+                if (!Number.isFinite(label.x) || !Number.isFinite(label.z)) {
+                    return false;
+                }
+                return label.x >= viewMinX && label.x <= viewMaxX && label.z >= viewMinZ && label.z <= viewMaxZ;
+            })
+                .map((label) => ({
+                key: label.key,
+                text: label.text,
+                x: label.x,
+                y: label.y,
+                z: label.z,
+                fontSize: label.fontSize,
+                meta: includeMeta ? (label.meta ?? {}) : undefined
+            }))
+            : []
+    };
+}
+/**
+ * Build a complete SectionRenderState from plane section entries, with optional
+ * fill-rule-based separation, ordering, and label generation.
+ *
+ * When `fills` rules are provided, entries matching a fill rule are rendered
+ * below non-matching entries, with their fill opacity set by the matching rule.
+ */
+export function buildSectionStateForEntries(perProduct, options) {
+    if (!perProduct.length) {
+        return null;
+    }
+    const fills = options.fills;
+    const includeMeta = !!options?.includeMeta;
+    const includeLabels = options?.includeLabels ?? false;
+    const viewport = options?.viewport;
+    const strokeWidth = options?.strokeWidth;
+    const labelFontSize = includeLabels && typeof options?.labelFontSize === 'number' ? options.labelFontSize : null;
+    const buildLabels = options?.buildLabels;
+    // Point-in-polygon test (ray casting algorithm)
+    const pointInPolygon = (polygon, x, z) => {
+        let inside = false;
+        for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+            const xi = polygon[i].x;
+            const zi = polygon[i].z;
+            const xj = polygon[j].x;
+            const zj = polygon[j].z;
+            const intersect = zi > z !== zj > z && x < ((xj - xi) * (z - zi)) / (zj - zi) + xi;
+            if (intersect)
+                inside = !inside;
+        }
+        return inside;
+    };
+    // Calculate centroid from entry's polylines
+    const getCentroid = (entry) => {
+        const polylines = entry.polylines;
+        if (!polylines.length)
+            return null;
+        let sumX = 0;
+        let sumZ = 0;
+        let count = 0;
+        for (const polyline of polylines) {
+            for (const point of polyline.points) {
+                sumX += point[0];
+                sumZ += point[2];
+                count++;
+            }
+        }
+        if (count === 0)
+            return null;
+        return { x: sumX / count, z: sumZ / count };
+    };
+    // Spatial matcher for clip filter - checks if product centroid is inside clip polygon
+    const isInsideClipPolygon = (entry) => {
+        if (!options?.clipPolygon?.length)
+            return true;
+        const centroid = getCentroid(entry);
+        if (!centroid)
+            return false;
+        // Check if centroid is inside any of the clip polygons
+        return options.clipPolygon.some((polygon) => pointInPolygon(polygon, centroid.x, centroid.z));
+    };
+    // Match an entry against fill rules. Returns the first matching rule, or undefined.
+    const matchFillRule = (entry) => {
+        if (!fills?.length)
+            return undefined;
+        const product = entry.product;
+        for (const rule of fills) {
+            // If rule requires clip filter match, check if product centroid is inside clip polygon
+            if (rule.matchClipFilter && !isInsideClipPolygon(entry)) {
+                continue;
+            }
+            // Check class match
+            let classMatches;
+            if (rule.class) {
+                const classes = Array.isArray(rule.class) ? rule.class : [rule.class];
+                const cls = product.class;
+                classMatches = classes.some((c) => {
+                    if (cls?.is)
+                        return cls.is(c);
+                    const pName = (product.className ?? '').toLowerCase();
+                    return pName === c.toLowerCase() || pName === `ifc${c.toLowerCase()}`;
+                });
+                if (!classMatches)
+                    continue;
+            }
+            // Check where condition (property-based filter)
+            if (rule.where && Object.keys(rule.where).length > 0) {
+                let whereMatches = true;
+                for (const [path, expected] of Object.entries(rule.where)) {
+                    const actualValue = resolveProductProperty(product, path);
+                    if (actualValue === undefined) {
+                        whereMatches = false;
+                        break;
+                    }
+                    const normalize = (v) => (typeof v === 'string' ? v.toLowerCase().trim() : v);
+                    if (Array.isArray(expected)) {
+                        if (!expected.some((exp) => normalize(exp) === normalize(actualValue))) {
+                            whereMatches = false;
+                            break;
+                        }
+                    }
+                    else {
+                        if (normalize(actualValue) !== normalize(expected)) {
+                            whereMatches = false;
+                            break;
+                        }
+                    }
+                }
+                if (!whereMatches)
+                    continue;
+            }
+            return rule;
+        }
+        return undefined;
+    };
+    const hasFills = !!fills?.length;
+    // Split entries by fill rule match
+    const fillEntries = [];
+    const fillOpacities = []; // parallel to fillEntries
+    const nonFillEntries = [];
+    for (const entry of perProduct) {
+        const rule = hasFills ? matchFillRule(entry) : undefined;
+        if (rule) {
+            const opacity = rule.fillOpacity ?? DEFAULT_FILL_OPACITY;
+            // Skip entries with zero opacity - don't render them at all
+            if (opacity > 0) {
+                fillEntries.push(entry);
+                fillOpacities.push(opacity);
+            }
+        }
+        else {
+            nonFillEntries.push(entry);
+        }
+    }
+    // Build labels from fill-matched entries (e.g. spaces)
+    const fillLabels = includeLabels && fillEntries.length && labelFontSize !== null && buildLabels
+        ? buildLabels(fillEntries.map((entry) => entry.product), labelFontSize)
+        : undefined;
+    // When fill rules are present, render fill and non-fill groups separately
+    // so we can adjust opacity and control ordering.
+    // When no fill rules, render everything in one pass (unchanged behavior).
+    if (hasFills && (fillEntries.length > 0 || nonFillEntries.length > 0)) {
+        const nonFillState = nonFillEntries.length > 0
+            ? createSectionSvg(nonFillEntries, viewport, strokeWidth, undefined, {
+                includeMeta,
+                planeNormal: options.planeNormal
+            })
+            : null;
+        const fillState = fillEntries.length > 0
+            ? createSectionSvg(fillEntries, viewport, strokeWidth, includeLabels ? fillLabels : undefined, {
+                includeMeta,
+                planeNormal: options.planeNormal
+            })
+            : null;
+        const baseState = nonFillState ?? fillState ?? null;
+        if (!baseState)
+            return null;
+        // Adjust fill opacity per-entry. When includeMeta is true, each entry has
+        // its own path, so we can apply per-entry opacity. When false, paths are
+        // grouped by color — apply the minimum matching opacity.
+        const adjustedFillPaths = fillState?.paths.map((path, idx) => {
+            // When fill rules match, use the rule opacity directly (don't multiply by material alpha).
+            // Material alpha was useful for auto-coloring, but fill rules should have full control.
+            const ruleOpacity = idx < fillOpacities.length ? fillOpacities[idx] : (fills[0]?.fillOpacity ?? 0.35);
+            const finalOpacity = clampValue(ruleOpacity, 0, 1);
+            return {
+                ...path,
+                fillOpacity: finalOpacity
+            };
+        }) ?? [];
+        const nonFillPaths = nonFillState?.paths ?? [];
+        // Fill-matched entries always render below non-fill entries
+        const mergedPaths = [...adjustedFillPaths, ...nonFillPaths];
+        const merged = {
+            ...baseState,
+            paths: mergedPaths,
+            labels: includeLabels ? (fillState?.labels ?? fillLabels ?? []) : []
+        };
+        return merged;
+    }
+    // No fill rules — create paths with fills for highlight support, but set opacity to 0
+    const state = createSectionSvg(perProduct, viewport, strokeWidth, includeLabels ? fillLabels : undefined, {
+        includeMeta,
+        createFills: true,
+        planeNormal: options.planeNormal
+    });
+    if (!state)
+        return null;
+    // Set all fill opacities to 0 when no fill rules exist (but keep paths for highlight support)
+    const pathsWithZeroFillOpacity = state.paths.map((path) => ({
+        ...path,
+        fillOpacity: 0
+    }));
+    return {
+        ...state,
+        paths: pathsWithZeroFillOpacity,
+        labels: includeLabels ? (state.labels ?? []) : []
+    };
+}
+/** Extract the viewport bounding box from a TransformInfo. */
+export function extractViewWindow(transform) {
+    return {
+        viewMinX: transform.viewMinX,
+        viewMaxX: transform.viewMaxX,
+        viewMinZ: transform.viewMinZ,
+        viewMaxZ: transform.viewMaxZ
+    };
+}
+/** Compare two viewport windows for equality within a tolerance. */
+export function windowsEqual(a, b, epsilon = 1e-4) {
+    return (Math.abs(a.viewMinX - b.viewMinX) <= epsilon &&
+        Math.abs(a.viewMaxX - b.viewMaxX) <= epsilon &&
+        Math.abs(a.viewMinZ - b.viewMinZ) <= epsilon &&
+        Math.abs(a.viewMaxZ - b.viewMaxZ) <= epsilon);
+}
+/** Constrain a viewport window within base bounds, preserving aspect ratio. */
+export function clampViewWindow(base, candidate) {
+    const baseWidth = base.viewWidth;
+    const baseHeight = base.viewHeight;
+    const aspect = baseWidth / baseHeight;
+    let width = candidate.viewMaxX - candidate.viewMinX;
+    if (!Number.isFinite(width) || width <= 1e-6) {
+        width = baseWidth;
+    }
+    width = clampValue(width, baseWidth / MAX_ZOOM_FACTOR, baseWidth);
+    const height = width / aspect;
+    let centerX = (candidate.viewMinX + candidate.viewMaxX) * 0.5;
+    if (!Number.isFinite(centerX)) {
+        centerX = (base.viewMinX + base.viewMaxX) * 0.5;
+    }
+    let centerZ = (candidate.viewMinZ + candidate.viewMaxZ) * 0.5;
+    if (!Number.isFinite(centerZ)) {
+        centerZ = (base.viewMinZ + base.viewMaxZ) * 0.5;
+    }
+    let minX = centerX - width * 0.5;
+    let maxX = minX + width;
+    if (minX < base.viewMinX) {
+        minX = base.viewMinX;
+        maxX = minX + width;
+    }
+    if (maxX > base.viewMaxX) {
+        maxX = base.viewMaxX;
+        minX = maxX - width;
+    }
+    let minZ = centerZ - height * 0.5;
+    let maxZ = minZ + height;
+    if (minZ < base.viewMinZ) {
+        minZ = base.viewMinZ;
+        maxZ = minZ + height;
+    }
+    if (maxZ > base.viewMaxZ) {
+        maxZ = base.viewMaxZ;
+        minZ = maxZ - height;
+    }
+    return {
+        viewMinX: minX,
+        viewMaxX: maxX,
+        viewMinZ: minZ,
+        viewMaxZ: maxZ
+    };
+}
+/** Adjust stroke width proportionally to zoom level. */
+export function strokeWidthForWindow(baseStroke, baseTransform, window) {
+    const baseWidth = baseTransform.viewWidth;
+    const currentWidth = window.viewMaxX - window.viewMinX;
+    if (!Number.isFinite(baseWidth) || baseWidth <= 1e-6 || !Number.isFinite(currentWidth) || currentWidth <= 1e-6) {
+        return baseStroke;
+    }
+    const ratio = clampValue(currentWidth / baseWidth, 1 / MAX_ZOOM_FACTOR, 1);
+    const scaled = baseStroke * ratio;
+    return Math.max(scaled, baseStroke / (MAX_ZOOM_FACTOR + 1));
+}
+const polylinePathCache = new WeakMap();
+/**
+ * Determine which axes to use for 2D projection based on plane normal.
+ * Returns accessor functions for horizontal and vertical SVG coordinates.
+ */
+function getProjectionAxes(planeNormal) {
+    if (!planeNormal) {
+        // Default: horizontal plan (looking down Y axis) -> X,Z
+        return {
+            getU: (p) => p[0],
+            getV: (p) => p[2],
+            axisNames: 'XZ'
+        };
+    }
+    // Normalize and find dominant axis
+    const absX = Math.abs(planeNormal[0]);
+    const absY = Math.abs(planeNormal[1]);
+    const absZ = Math.abs(planeNormal[2]);
+    if (absY > absX && absY > absZ) {
+        // Horizontal plan (normal ~ Y axis) -> looking down Y, use X,Z
+        return {
+            getU: (p) => p[0],
+            getV: (p) => p[2],
+            axisNames: 'XZ'
+        };
+    }
+    else if (absZ > absX) {
+        // Vertical section perpendicular to Z -> looking along Z, use X,Y
+        return {
+            getU: (p) => p[0],
+            getV: (p) => p[1],
+            axisNames: 'XY'
+        };
+    }
+    else {
+        // Vertical section perpendicular to X -> looking along X, use Z,Y
+        return {
+            getU: (p) => p[2],
+            getV: (p) => p[1],
+            axisNames: 'ZY'
+        };
+    }
+}
+/**
+ * Convert a segment (pair of points) to an SVG path string.
+ */
+function segmentToPath(segment, planeNormal) {
+    const [p1, p2] = segment;
+    const axes = getProjectionAxes(planeNormal);
+    const u1 = axes.getU(p1);
+    const v1 = axes.getV(p1);
+    const u2 = axes.getU(p2);
+    const v2 = axes.getV(p2);
+    if (!Number.isFinite(u1) || !Number.isFinite(v1) || !Number.isFinite(u2) || !Number.isFinite(v2)) {
+        return '';
+    }
+    return `M${formatNumber(u1)} ${formatNumber(v1)} L${formatNumber(u2)} ${formatNumber(v2)}`;
+}
+function getCachedPolylinePath(polyline, planeNormal) {
+    if (!polyline.points.length) {
+        return null;
+    }
+    const signature = computePointsSignature(polyline.points, polyline.closed, planeNormal);
+    const cached = polylinePathCache.get(polyline);
+    if (cached && cached.pointsRef === polyline.points && cached.signature === signature) {
+        return cached.data;
+    }
+    const axes = getProjectionAxes(planeNormal);
+    const commands = [];
+    polyline.points.forEach((point, index) => {
+        const prefix = index === 0 ? 'M' : 'L';
+        const u = axes.getU(point);
+        const v = axes.getV(point);
+        commands.push(`${prefix}${formatNumber(u)} ${formatNumber(v)}`);
+    });
+    if (commands.length < 2) {
+        return null;
+    }
+    let closed = false;
+    let hole = false;
+    if (polyline.closed && commands.length > 2) {
+        const area = signedArea(polyline.points, axes);
+        hole = area < 0;
+        closed = true;
+        commands.push('Z');
+    }
+    const data = { d: commands.join(' '), closed, hole };
+    polylinePathCache.set(polyline, { pointsRef: polyline.points, signature, data });
+    return data;
+}
+function signedArea(points, axes) {
+    if (points.length < 3) {
+        return 0;
+    }
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        const u1 = axes.getU(current);
+        const v1 = axes.getV(current);
+        const u2 = axes.getU(next);
+        const v2 = axes.getV(next);
+        area += u1 * v2 - u2 * v1;
+    }
+    return area * 0.5;
+}
+function formatNumber(value) {
+    if (!Number.isFinite(value)) {
+        return '0';
+    }
+    const formatted = value.toFixed(3);
+    return formatted.replace(/\.?0+$/, '');
+}
+function buildGeometryTransform(viewMinX, viewMaxX, viewMinZ, viewMaxZ) {
+    const translateX = formatNumber(-viewMinX);
+    const translateY = formatNumber(viewMaxZ);
+    return `matrix(1 0 0 -1 ${translateX} ${translateY})`;
+}
+function computePointsSignature(points, closed, planeNormal) {
+    const axes = getProjectionAxes(planeNormal);
+    // FNV-1a-inspired hash — compact fixed-size key instead of concatenating all coordinates
+    let hash = 2166136261 ^ (points.length * 16777619) ^ (closed ? 1 : 0);
+    for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        if (!point)
+            continue;
+        const u = axes.getU(point);
+        const v = axes.getV(point);
+        // Mix in coordinate bits (multiply by large prime, XOR)
+        hash = Math.imul(hash ^ ((u * 1e4) | 0), 16777619);
+        hash = Math.imul(hash ^ ((v * 1e4) | 0), 16777619);
+    }
+    return hash;
+}
+//# sourceMappingURL=sections.js.map