@pascal-app/viewer 1.1.0 → 1.1.1

package/dist/ui/floorplan/floorplan-dimension-renderer.js

@@ -0,0 +1,280 @@
+'use client';
+import { createElement as _createElement } from "react";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { resolveFloorplanLabelAngle } from './floorplan-label-angle';
+const EXTENSION_START_GAP = 0.075;
+const TICK_HALF_LENGTH = 0.09;
+const LABEL_FONT_SIZE = 0.15;
+const LABEL_BASELINE_OFFSET = 0.12;
+const LABEL_CHARACTER_WIDTH_RATIO = 0.62;
+const LABEL_END_GAP = 0.075;
+const DOCUMENT_EXTENSION_START_GAP_PT = 3;
+const DOCUMENT_EXTENSION_OVERSHOOT_PT = 4;
+const DOCUMENT_TICK_HALF_LENGTH_PT = 4.5;
+const DOCUMENT_LABEL_FONT_SIZE_PT = 8;
+const DOCUMENT_LABEL_BASELINE_OFFSET_PT = 5;
+const DOCUMENT_LABEL_END_GAP_PT = 3;
+const LINE_STROKE_WIDTH_PX = 0.9;
+const TICK_STROKE_WIDTH_PX = 1.35;
+const PDF_LINE_STROKE_WIDTH_PT = 0.5;
+const PDF_TICK_STROKE_WIDTH_PT = 0.75;
+const SQRT_ONE_HALF = Math.SQRT1_2;
+/**
+ * Click-to-type dimensions (WS3).
+ *
+ * On screen, under an editing host (`FloorplanDimensionHitsProvider` set to
+ * true), the label plate carries an invisible hit rect plus the data the
+ * editing layer needs to drive geometry from a typed value. The editor's
+ * layer picks it up by DOM delegation, so every producer of `dimension` /
+ * `dimension-string` geometry — wall automatic dimensions, contextual
+ * dimensions, manual construction-dimension nodes — becomes editable without
+ * each one wiring up a callback. Read-only plans carry no hit rects.
+ *
+ * Witness points are the measured feature points in level-plan metres; the
+ * value is the length the label actually reads (dimension-line points when
+ * the producer supplied them, witness points otherwise).
+ */
+export const FLOORPLAN_DIMENSION_HIT_ATTRIBUTE = 'data-floorplan-dimension-hit';
+const DimensionHitsContext = createContext(false);
+/** Whether the dimension labels below it carry typeable hit rects; off unless a host sets it. */
+export const FloorplanDimensionHitsProvider = DimensionHitsContext.Provider;
+export function floorplanDimensionAnnotationPriority(offsetDistance) {
+    return 100 + Math.round(Math.abs(offsetDistance) * 100);
+}
+export function computeArchitecturalDimensionLayout(geometry, sceneRotationDeg, annotationUnitsPerPoint) {
+    const extensionStartGap = annotationUnitsPerPoint
+        ? DOCUMENT_EXTENSION_START_GAP_PT * annotationUnitsPerPoint
+        : (geometry.extensionStartGap ?? EXTENSION_START_GAP);
+    const extensionOvershoot = annotationUnitsPerPoint
+        ? DOCUMENT_EXTENSION_OVERSHOOT_PT * annotationUnitsPerPoint
+        : geometry.extensionOvershoot;
+    const tickHalfLength = annotationUnitsPerPoint
+        ? DOCUMENT_TICK_HALF_LENGTH_PT * annotationUnitsPerPoint
+        : TICK_HALF_LENGTH;
+    const labelFontSize = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
+        : LABEL_FONT_SIZE;
+    const labelEndGap = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_END_GAP_PT * annotationUnitsPerPoint
+        : LABEL_END_GAP;
+    const offsetX = geometry.offsetNormal[0] * geometry.offsetDistance;
+    const offsetY = geometry.offsetNormal[1] * geometry.offsetDistance;
+    const dimensionStart = geometry.dimensionStart ?? [
+        geometry.start[0] + offsetX,
+        geometry.start[1] + offsetY,
+    ];
+    const dimensionEnd = geometry.dimensionEnd ?? [
+        geometry.end[0] + offsetX,
+        geometry.end[1] + offsetY,
+    ];
+    const dx = dimensionEnd[0] - dimensionStart[0];
+    const dy = dimensionEnd[1] - dimensionStart[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 1e-6)
+        return null;
+    const dirX = dx / length;
+    const dirY = dy / length;
+    const startOffsetDistance = dot(subtract(dimensionStart, geometry.start), geometry.offsetNormal);
+    const endOffsetDistance = dot(subtract(dimensionEnd, geometry.end), geometry.offsetNormal);
+    const startExtensionGap = Math.min(extensionStartGap, Math.max(0, startOffsetDistance - 0.01));
+    const endExtensionGap = Math.min(extensionStartGap, Math.max(0, endOffsetDistance - 0.01));
+    // A 45-degree architectural slash. Every terminator within one string uses
+    // this same vector instead of rotating independently around its endpoint.
+    const tickHalfVector = [
+        (dirX + dirY) * tickHalfLength * SQRT_ONE_HALF,
+        (dirY - dirX) * tickHalfLength * SQRT_ONE_HALF,
+    ];
+    const labelWidth = Math.max(labelFontSize, geometry.text.length * labelFontSize * LABEL_CHARACTER_WIDTH_RATIO);
+    const labelPlacement = length >= labelWidth + labelEndGap * 2 ? 'inside' : 'outside-end';
+    const direction = [dirX, dirY];
+    const labelPoint = labelPlacement === 'inside'
+        ? [
+            (dimensionStart[0] + dimensionEnd[0]) / 2,
+            (dimensionStart[1] + dimensionEnd[1]) / 2,
+        ]
+        : addScaled(dimensionEnd, direction, labelEndGap + labelWidth / 2);
+    const dimensionLineEnd = labelPlacement === 'inside'
+        ? dimensionEnd
+        : addScaled(dimensionEnd, direction, labelEndGap * 2 + labelWidth);
+    const outsideStartLabelPoint = labelPlacement === 'outside-end'
+        ? addScaled(dimensionStart, direction, -(labelEndGap + labelWidth / 2))
+        : undefined;
+    const outsideStartDimensionLineStart = labelPlacement === 'outside-end'
+        ? addScaled(dimensionStart, direction, -(labelEndGap * 2 + labelWidth))
+        : undefined;
+    return {
+        dimensionStart,
+        dimensionEnd,
+        dimensionLineStart: dimensionStart,
+        dimensionLineEnd,
+        extensionStart: addScaled(geometry.start, geometry.offsetNormal, startExtensionGap),
+        extensionEnd: addScaled(geometry.end, geometry.offsetNormal, endExtensionGap),
+        extensionStartTip: addScaled(dimensionStart, geometry.offsetNormal, extensionOvershoot),
+        extensionEndTip: addScaled(dimensionEnd, geometry.offsetNormal, extensionOvershoot),
+        tickHalfVector,
+        labelPoint,
+        labelAngleDeg: resolveFloorplanLabelAngle(Math.atan2(dy, dx), sceneRotationDeg),
+        labelPlacement,
+        outsideStartLabelPoint,
+        outsideStartDimensionLineStart,
+    };
+}
+function subtract(left, right) {
+    return [left[0] - right[0], left[1] - right[1]];
+}
+function dot(left, right) {
+    return left[0] * right[0] + left[1] * right[1];
+}
+function addScaled(point, direction, distance) {
+    return [point[0] + direction[0] * distance, point[1] + direction[1] * distance];
+}
+export function FloorplanDimensionRenderer({ geometry, sceneRotationDeg = 0, stroke = geometry.stroke ?? '#334155', annotationUnitsPerPoint, renderMode = 'screen', onSelect, }) {
+    const layout = computeArchitecturalDimensionLayout(geometry, sceneRotationDeg, annotationUnitsPerPoint);
+    if (!layout)
+        return null;
+    const labelFontSize = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
+        : LABEL_FONT_SIZE;
+    const labelBaselineOffset = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_BASELINE_OFFSET_PT * annotationUnitsPerPoint
+        : LABEL_BASELINE_OFFSET;
+    const labelY = geometry.textPosition === 'centered' ? labelFontSize * 0.35 : -labelBaselineOffset;
+    const lineProps = {
+        stroke,
+        strokeLinecap: 'butt',
+        strokeWidth: renderMode === 'pdf' ? PDF_LINE_STROKE_WIDTH_PT : LINE_STROKE_WIDTH_PX,
+        vectorEffect: 'non-scaling-stroke',
+    };
+    const tickStrokeWidth = renderMode === 'pdf' ? PDF_TICK_STROKE_WIDTH_PT : TICK_STROKE_WIDTH_PX;
+    const terminator = geometry.terminator ?? 'architectural-tick';
+    const labelTransform = `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]}) rotate(${layout.labelAngleDeg})`;
+    const outsideStartLocalShift = layout.outsideStartLabelPoint
+        ? rotateVector(subtract(layout.outsideStartLabelPoint, layout.labelPoint), (-layout.labelAngleDeg * Math.PI) / 180)
+        : undefined;
+    return (_jsxs("g", { "data-floorplan-dimension": "", onClick: onSelect
+            ? (event) => {
+                event.stopPropagation();
+                onSelect();
+            }
+            : undefined, pointerEvents: onSelect ? 'auto' : 'none', children: [_jsx("line", { ...lineProps, x1: layout.extensionStart[0], x2: layout.extensionStartTip[0], y1: layout.extensionStart[1], y2: layout.extensionStartTip[1] }), _jsx("line", { ...lineProps, x1: layout.extensionEnd[0], x2: layout.extensionEndTip[0], y1: layout.extensionEnd[1], y2: layout.extensionEndTip[1] }), _jsx("line", { ...lineProps, "data-floorplan-dimension-default-x1": layout.dimensionLineStart[0], "data-floorplan-dimension-default-x2": layout.dimensionLineEnd[0], "data-floorplan-dimension-default-y1": layout.dimensionLineStart[1], "data-floorplan-dimension-default-y2": layout.dimensionLineEnd[1], "data-floorplan-dimension-line": "", "data-floorplan-dimension-outside-start-x1": layout.outsideStartDimensionLineStart?.[0], "data-floorplan-dimension-outside-start-x2": layout.dimensionEnd[0], "data-floorplan-dimension-outside-start-y1": layout.outsideStartDimensionLineStart?.[1], "data-floorplan-dimension-outside-start-y2": layout.dimensionEnd[1], x1: layout.dimensionLineStart[0], x2: layout.dimensionLineEnd[0], y1: layout.dimensionLineStart[1], y2: layout.dimensionLineEnd[1] }), renderTerminator(terminator, layout.dimensionStart, layout.dimensionEnd, layout, lineProps, tickStrokeWidth), renderTerminator(terminator, layout.dimensionEnd, layout.dimensionStart, layout, lineProps, tickStrokeWidth), layout.labelPlacement === 'outside-end' && annotationUnitsPerPoint !== undefined ? (_jsx("line", { ...lineProps, "data-floorplan-dimension-leader": "", visibility: "hidden", x1: layout.dimensionEnd[0], x2: layout.labelPoint[0], y1: layout.dimensionEnd[1], y2: layout.labelPoint[1] })) : null, _jsx("g", { "data-floorplan-annotation-angle-radians": Math.atan2(geometry.end[1] - geometry.start[1], geometry.end[0] - geometry.start[0]), "data-floorplan-annotation-default-transform": labelTransform, "data-floorplan-annotation-label": "", "data-floorplan-annotation-priority": floorplanDimensionAnnotationPriority(geometry.offsetDistance), "data-floorplan-annotation-transform-before-rotation": `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]})`, "data-floorplan-dimension-label-placement": layout.labelPlacement, "data-floorplan-dimension-outside-start-local-x": outsideStartLocalShift?.[0], "data-floorplan-dimension-outside-start-local-y": outsideStartLocalShift?.[1], "data-floorplan-dimension-start-x": layout.dimensionStart[0], "data-floorplan-dimension-start-y": layout.dimensionStart[1], "data-floorplan-dimension-end-x": layout.dimensionEnd[0], "data-floorplan-dimension-end-y": layout.dimensionEnd[1], "data-floorplan-dimension-text": geometry.text, "data-floorplan-dimension-value": dimensionLabelValue(layout), "data-floorplan-dimension-witness-start-x": geometry.start[0], "data-floorplan-dimension-witness-start-y": geometry.start[1], "data-floorplan-dimension-witness-end-x": geometry.end[0], "data-floorplan-dimension-witness-end-y": geometry.end[1], transform: labelTransform, children: _jsx(DimensionLabel, { fontSize: labelFontSize, 
+                    // `overridden` is declared on the geometry union in
+                    // packages/core/src/registry/types.ts; the cast keeps this file
+                    // compiling against a core dist built before that field landed.
+                    overridden: geometry.overridden === true, renderMode: renderMode, stroke: stroke, text: geometry.text, y: labelY }) })] }));
+}
+export function FloorplanDimensionStringRenderer({ geometry, sceneRotationDeg = 0, stroke = geometry.stroke ?? '#334155', annotationUnitsPerPoint, renderMode = 'screen', }) {
+    const segmentLayouts = geometry.segments.flatMap((segment, index) => {
+        const segmentGeometry = {
+            kind: 'dimension',
+            start: segment.start,
+            end: segment.end,
+            dimensionStart: segment.dimensionStart,
+            dimensionEnd: segment.dimensionEnd,
+            offsetNormal: geometry.offsetNormal,
+            offsetDistance: geometry.offsetDistance,
+            extensionOvershoot: geometry.extensionOvershoot,
+            extensionStartGap: geometry.extensionStartGap,
+            terminator: geometry.terminator,
+            textPosition: geometry.textPosition,
+            text: segment.text,
+            stroke: geometry.stroke,
+        };
+        const layout = computeArchitecturalDimensionLayout(segmentGeometry, sceneRotationDeg, annotationUnitsPerPoint);
+        return layout ? [{ index, layout, segment: segmentGeometry }] : [];
+    });
+    if (segmentLayouts.length === 0)
+        return null;
+    const labelFontSize = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
+        : LABEL_FONT_SIZE;
+    const labelBaselineOffset = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_BASELINE_OFFSET_PT * annotationUnitsPerPoint
+        : LABEL_BASELINE_OFFSET;
+    const labelY = geometry.textPosition === 'centered' ? labelFontSize * 0.35 : -labelBaselineOffset;
+    const lineProps = {
+        stroke,
+        strokeLinecap: 'butt',
+        strokeWidth: renderMode === 'pdf' ? PDF_LINE_STROKE_WIDTH_PT : LINE_STROKE_WIDTH_PX,
+        vectorEffect: 'non-scaling-stroke',
+    };
+    const tickStrokeWidth = renderMode === 'pdf' ? PDF_TICK_STROKE_WIDTH_PT : TICK_STROKE_WIDTH_PX;
+    const extensionLines = new Map();
+    const ticks = new Map();
+    for (const { layout } of segmentLayouts) {
+        extensionLines.set(pointKey(layout.dimensionStart), {
+            start: layout.extensionStart,
+            tip: layout.extensionStartTip,
+        });
+        extensionLines.set(pointKey(layout.dimensionEnd), {
+            start: layout.extensionEnd,
+            tip: layout.extensionEndTip,
+        });
+        ticks.set(pointKey(layout.dimensionStart), {
+            point: layout.dimensionStart,
+            toward: layout.dimensionEnd,
+            tickHalfVector: layout.tickHalfVector,
+        });
+        ticks.set(pointKey(layout.dimensionEnd), {
+            point: layout.dimensionEnd,
+            toward: layout.dimensionStart,
+            tickHalfVector: layout.tickHalfVector,
+        });
+    }
+    const terminator = geometry.terminator ?? 'architectural-tick';
+    return (_jsxs("g", { "data-floorplan-dimension-string": "", pointerEvents: "none", children: [[...extensionLines.values()].map((line, index) => (_createElement("line", { ...lineProps, key: `extension-${index}`, x1: line.start[0], x2: line.tip[0], y1: line.start[1], y2: line.tip[1] }))), segmentLayouts.map(({ index, layout }) => (_createElement("line", { ...lineProps, "data-floorplan-dimension-default-x1": layout.dimensionLineStart[0], "data-floorplan-dimension-default-x2": layout.dimensionLineEnd[0], "data-floorplan-dimension-default-y1": layout.dimensionLineStart[1], "data-floorplan-dimension-default-y2": layout.dimensionLineEnd[1], "data-floorplan-dimension-line": "", "data-floorplan-dimension-outside-start-x1": layout.outsideStartDimensionLineStart?.[0], "data-floorplan-dimension-outside-start-x2": layout.dimensionEnd[0], "data-floorplan-dimension-outside-start-y1": layout.outsideStartDimensionLineStart?.[1], "data-floorplan-dimension-outside-start-y2": layout.dimensionEnd[1], key: `dimension-line-${index}`, x1: layout.dimensionLineStart[0], x2: layout.dimensionLineEnd[0], y1: layout.dimensionLineStart[1], y2: layout.dimensionLineEnd[1] }))), [...ticks.values()].map(({ point, toward, tickHalfVector }, index) => renderTerminator(terminator, point, toward, { tickHalfVector }, lineProps, tickStrokeWidth, `tick-${index}`)), segmentLayouts.map(({ index, layout, segment }) => {
+                const labelTransform = `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]}) rotate(${layout.labelAngleDeg})`;
+                const outsideStartLocalShift = layout.outsideStartLabelPoint
+                    ? rotateVector(subtract(layout.outsideStartLabelPoint, layout.labelPoint), (-layout.labelAngleDeg * Math.PI) / 180)
+                    : undefined;
+                return (_jsxs("g", { children: [layout.labelPlacement === 'outside-end' && annotationUnitsPerPoint !== undefined ? (_jsx("line", { ...lineProps, "data-floorplan-dimension-leader": "", visibility: "hidden", x1: layout.dimensionEnd[0], x2: layout.labelPoint[0], y1: layout.dimensionEnd[1], y2: layout.labelPoint[1] })) : null, _jsx("g", { "data-floorplan-annotation-angle-radians": Math.atan2(segment.end[1] - segment.start[1], segment.end[0] - segment.start[0]), "data-floorplan-annotation-default-transform": labelTransform, "data-floorplan-annotation-label": "", "data-floorplan-annotation-priority": floorplanDimensionAnnotationPriority(geometry.offsetDistance), "data-floorplan-annotation-transform-before-rotation": `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]})`, "data-floorplan-dimension-label-placement": layout.labelPlacement, "data-floorplan-dimension-outside-start-local-x": outsideStartLocalShift?.[0], "data-floorplan-dimension-outside-start-local-y": outsideStartLocalShift?.[1], "data-floorplan-dimension-start-x": layout.dimensionStart[0], "data-floorplan-dimension-start-y": layout.dimensionStart[1], "data-floorplan-dimension-end-x": layout.dimensionEnd[0], "data-floorplan-dimension-end-y": layout.dimensionEnd[1], "data-floorplan-dimension-text": segment.text, "data-floorplan-dimension-value": dimensionLabelValue(layout), "data-floorplan-dimension-witness-start-x": segment.start[0], "data-floorplan-dimension-witness-start-y": segment.start[1], "data-floorplan-dimension-witness-end-x": segment.end[0], "data-floorplan-dimension-witness-end-y": segment.end[1], transform: labelTransform, children: _jsx(DimensionLabel, { fontSize: labelFontSize, renderMode: renderMode, stroke: stroke, text: segment.text, y: labelY }) })] }, `label-${index}`));
+            })] }));
+}
+/** The length the label reads — the dimension-line span, offset cancels out. */
+function dimensionLabelValue(layout) {
+    return Math.hypot(layout.dimensionEnd[0] - layout.dimensionStart[0], layout.dimensionEnd[1] - layout.dimensionStart[1]);
+}
+function rotateVector(vector, radians) {
+    const cosine = Math.cos(radians);
+    const sine = Math.sin(radians);
+    return [vector[0] * cosine - vector[1] * sine, vector[0] * sine + vector[1] * cosine];
+}
+function DimensionLabel({ text, y, fontSize, stroke, renderMode, overridden = false, }) {
+    const width = Math.max(fontSize, text.length * fontSize * LABEL_CHARACTER_WIDTH_RATIO);
+    const plateWidth = width + fontSize * 0.5;
+    const plateHeight = fontSize * 1.2;
+    const plateY = y - fontSize * 0.82;
+    const editable = useContext(DimensionHitsContext);
+    return (_jsxs(_Fragment, { children: [renderMode === 'pdf' ? (_jsx("rect", { "data-floorplan-dimension-label-plate": "", fill: "#ffffff", height: plateHeight, rx: fontSize * 0.12, ry: fontSize * 0.12, width: plateWidth, x: -plateWidth / 2, y: plateY })) : null, _jsx("text", { fill: stroke, fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace", fontSize: fontSize, fontWeight: 500, paintOrder: renderMode === 'pdf' ? undefined : 'stroke', stroke: renderMode === 'pdf' ? undefined : '#ffffff', strokeLinejoin: renderMode === 'pdf' ? undefined : 'round', strokeWidth: renderMode === 'pdf' ? undefined : 3, textAnchor: "middle", vectorEffect: renderMode === 'pdf' ? undefined : 'non-scaling-stroke', x: 0, y: y, children: text }), overridden && renderMode !== 'pdf' ? (_jsx("text", { fill: stroke, fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace", fontSize: fontSize * 0.62, opacity: 0.75, paintOrder: "stroke", stroke: "#ffffff", strokeLinejoin: "round", strokeWidth: 2, textAnchor: "middle", vectorEffect: "non-scaling-stroke", x: 0, y: y + fontSize * 0.86, children: "override" })) : null, renderMode === 'pdf' || !editable ? null : (_jsx("rect", { [FLOORPLAN_DIMENSION_HIT_ATTRIBUTE]: '', cursor: "text", fill: "transparent", height: plateHeight, pointerEvents: "all", width: plateWidth, x: -plateWidth / 2, y: plateY }))] }));
+}
+function renderTerminator(terminator, point, toward, layout, lineProps, tickStrokeWidth, key) {
+    const direction = normalized(point, toward);
+    if (!direction)
+        return null;
+    const tickHalfLength = Math.hypot(layout.tickHalfVector[0], layout.tickHalfVector[1]);
+    if (terminator === 'dot') {
+        return (_jsx("circle", { fill: lineProps.stroke, r: tickHalfLength * 0.45, vectorEffect: "non-scaling-stroke", cx: point[0], cy: point[1] }, key));
+    }
+    if (terminator === 'filled-arrow' || terminator === 'open-arrow') {
+        const base = addScaled(point, direction, tickHalfLength * 1.7);
+        const normal = [-direction[1], direction[0]];
+        const wing = tickHalfLength * 0.65;
+        const left = [base[0] + normal[0] * wing, base[1] + normal[1] * wing];
+        const right = [base[0] - normal[0] * wing, base[1] - normal[1] * wing];
+        if (terminator === 'filled-arrow') {
+            return (_jsx("polygon", { fill: lineProps.stroke, points: `${point[0]},${point[1]} ${left[0]},${left[1]} ${right[0]},${right[1]}`, vectorEffect: "non-scaling-stroke" }, key));
+        }
+        return (_jsxs("g", { children: [_jsx("line", { ...lineProps, strokeWidth: tickStrokeWidth, x1: point[0], x2: left[0], y1: point[1], y2: left[1] }), _jsx("line", { ...lineProps, strokeWidth: tickStrokeWidth, x1: point[0], x2: right[0], y1: point[1], y2: right[1] })] }, key));
+    }
+    const [tickX, tickY] = layout.tickHalfVector;
+    return (_createElement("line", { ...lineProps, key: key, strokeWidth: tickStrokeWidth, x1: point[0] - tickX, x2: point[0] + tickX, y1: point[1] - tickY, y2: point[1] + tickY }));
+}
+function normalized(start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const magnitude = Math.hypot(dx, dy);
+    return magnitude <= 1e-6 ? null : [dx / magnitude, dy / magnitude];
+}
+function pointKey(point) {
+    return `${point[0].toFixed(6)},${point[1].toFixed(6)}`;
+}

package/dist/ui/floorplan/floorplan-geometry-renderer.d.ts

@@ -0,0 +1,54 @@
+import { type FloorplanGeometry } from '@pascal-app/core';
+type FloorplanRenderMode = 'screen' | 'pdf';
+/**
+ * Pure-data → SVG converter. Walks a `FloorplanGeometry` tree returned by
+ * `def.floorplan(node, ctx)` and emits the matching React-SVG nodes.
+ *
+ * Coordinates are level-local meters. The wrapping floor-plan panel
+ * applies the world→SVG transform via its viewBox, so kinds emit
+ * geometry in the same units they reason about in 3D.
+ *
+ * Group transforms compose: `transform={translate(x y) rotate(deg)}`.
+ * Rotations are radians at the data layer (consistent with three.js
+ * conventions used by `def.geometry`) and converted to degrees for SVG
+ * here — kinds never touch units.
+ *
+ * Styling props map straight onto SVG attributes. Builders that need
+ * theme colors should declare them inline or expose them as registry
+ * tokens later (deferred until a real need surfaces — AI-authored kinds
+ * can pick safe defaults today).
+ */
+export declare const FloorplanGeometryRenderer: import("react").MemoExoticComponent<({ geometry, pointerEventsOverride, sceneRotationDeg, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode, }: {
+    geometry: FloorplanGeometry;
+    pointerEventsOverride?: string;
+    sceneRotationDeg?: number;
+    annotationUnitsPerPoint?: number;
+    screenUnitsPerPixel?: number;
+    renderMode?: FloorplanRenderMode;
+}) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null>;
+export declare function resolveDocumentFloorplanAnnotationStyle(geometry: FloorplanGeometry & {
+    kind: Exclude<FloorplanGeometry['kind'], 'group'>;
+}, annotationUnitsPerPoint?: number): {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    vectorEffect?: 'non-scaling-stroke';
+};
+export declare function documentRectGeometryAttrs(geometry: Extract<FloorplanGeometry, {
+    kind: 'rect';
+}>, annotationUnitsPerPoint?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number | undefined;
+    ry: number | undefined;
+};
+export declare function documentCircleGeometryAttrs(geometry: Extract<FloorplanGeometry, {
+    kind: 'circle';
+}>, annotationUnitsPerPoint?: number): {
+    r: number;
+};
+export declare function resolveDocumentAnnotationGroupChildren(children: FloorplanGeometry[], annotationUnitsPerPoint?: number): FloorplanGeometry[];
+export {};
+//# sourceMappingURL=floorplan-geometry-renderer.d.ts.map

package/dist/ui/floorplan/floorplan-geometry-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-geometry-renderer.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-geometry-renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,iBAAiB,EAKvB,MAAM,kBAAkB,CAAA;AAmBzB,KAAK,mBAAmB,GAAG,QAAQ,GAAG,KAAK,CAAA;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,yBAAyB,yJAOnC;IACD,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,UAAU,CAAC,EAAE,mBAAmB,CAAA;CACjC,uGAUC,CAAA;AAyDF,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,iBAAiB,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAA;CAAE,EACnF,uBAAuB,CAAC,EAAE,MAAM,GAC/B;IACD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,oBAAoB,CAAA;CACpC,CA6BA;AAiCD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACtD,uBAAuB,CAAC,EAAE,MAAM;;;;;;;EAyBjC;AAMD,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EACxD,uBAAuB,CAAC,EAAE,MAAM;;EAMjC;AAMD,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,uBAAuB,CAAC,EAAE,MAAM,GAC/B,iBAAiB,EAAE,CA0BrB"}