@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/lean-to-extension/floorplan-move.js

@@ -0,0 +1,157 @@
+import { isCurvedWall, sampleWallCenterline, useLiveNodeOverrides, } from '@pascal-app/core';
+import { getSegmentGridStep, isGridSnapActive } from '@pascal-app/editor';
+import { resolveLeanToEdgeSnapTargets, resolveLeanToMoveProposal } from './layout';
+import { leanToManagedPreviewOverrides } from './managed-preview';
+import { moveLeanToAlongSlabEdge, resolveLeanToPlanPosition } from './placement';
+import { leanToPlacementConflicts, resolveLeanToEndAbutments } from './placement-validation';
+// Arc-length along the wall centerline to the point on it nearest the
+// cursor. position[0] is measured as arc-length on a curved host, so the
+// straight chord projection would drift the further the cursor is from the
+// chord — sample the centerline polyline and walk it instead.
+function arcLengthUnderPoint(wall, planPoint) {
+    const samples = sampleWallCenterline(wall);
+    let bestDistanceSq = Number.POSITIVE_INFINITY;
+    let bestArcLength = 0;
+    let accumulated = 0;
+    for (let i = 0; i < samples.length - 1; i++) {
+        const a = samples[i];
+        const b = samples[i + 1];
+        const dx = b.x - a.x;
+        const dz = b.y - a.y;
+        const segLengthSq = dx * dx + dz * dz;
+        const t = segLengthSq <= 1e-12
+            ? 0
+            : Math.max(0, Math.min(1, ((planPoint[0] - a.x) * dx + (planPoint[1] - a.y) * dz) / segLengthSq));
+        const px = a.x + dx * t;
+        const pz = a.y + dz * t;
+        const distanceSq = (planPoint[0] - px) ** 2 + (planPoint[1] - pz) ** 2;
+        if (distanceSq < bestDistanceSq) {
+            bestDistanceSq = distanceSq;
+            bestArcLength = accumulated + Math.sqrt(segLengthSq) * t;
+        }
+        accumulated += Math.sqrt(segLengthSq);
+    }
+    return bestArcLength;
+}
+export const leanToFloorplanMoveTarget = ({ node, sceneApi, }) => {
+    const nodeId = node.id;
+    const wall = node.parentId ? sceneApi?.get(node.parentId) : undefined;
+    let lastPatch = null;
+    const previewIds = new Set(sceneApi ? leanToManagedPreviewOverrides(node, {}, sceneApi).map(([id]) => id) : []);
+    return {
+        affectedIds: [nodeId, ...previewIds],
+        apply({ planPoint, modifiers }) {
+            if (!sceneApi)
+                return;
+            if (node.hostKind === 'freestanding') {
+                const step = !modifiers.altKey && isGridSnapActive() ? getSegmentGridStep() : 0;
+                const snap = (value) => (step > 0 ? Math.round(value / step) * step : value);
+                const patch = {
+                    position: resolveLeanToPlanPosition(node, [snap(planPoint[0]), snap(planPoint[1])]),
+                };
+                const previewEntries = [
+                    [nodeId, patch],
+                    ...leanToManagedPreviewOverrides(node, patch, sceneApi),
+                ];
+                useLiveNodeOverrides.getState().setMany(previewEntries);
+                for (const [id] of previewEntries) {
+                    previewIds.add(id);
+                    sceneApi.markDirty(id);
+                }
+                lastPatch = patch;
+                return;
+            }
+            if (node.hostKind === 'slab-edge') {
+                const resolved = moveLeanToAlongSlabEdge(node, planPoint, sceneApi.nodes());
+                if (!resolved)
+                    return;
+                const patch = {
+                    hostSlabEdgeT: resolved.hostSlabEdgeT,
+                    position: resolved.position,
+                    rotation: resolved.rotation,
+                    span: resolved.span,
+                    highEdgeHeight: resolved.highEdgeHeight,
+                    lowEdgeHeight: resolved.lowEdgeHeight,
+                };
+                const previewEntries = [
+                    [nodeId, patch],
+                    ...leanToManagedPreviewOverrides(node, patch, sceneApi),
+                ];
+                useLiveNodeOverrides.getState().setMany(previewEntries);
+                for (const [id] of previewEntries) {
+                    previewIds.add(id);
+                    sceneApi.markDirty(id);
+                }
+                lastPatch = patch;
+                return;
+            }
+            if (wall?.type !== 'wall')
+                return;
+            const rawLocalX = isCurvedWall(wall)
+                ? arcLengthUnderPoint(wall, planPoint)
+                : (() => {
+                    const dx = wall.end[0] - wall.start[0];
+                    const dz = wall.end[1] - wall.start[1];
+                    const length = Math.max(1e-6, Math.hypot(dx, dz));
+                    return (((planPoint[0] - wall.start[0]) * dx + (planPoint[1] - wall.start[1]) * dz) / length);
+                })();
+            const step = !modifiers.altKey && isGridSnapActive() ? getSegmentGridStep() : 0;
+            const nodes = sceneApi.nodes();
+            const proposal = resolveLeanToMoveProposal({
+                node,
+                wall,
+                rawLocalX,
+                rawHighEdgeHeight: node.highEdgeHeight,
+                snapStep: step,
+                edgeSnapTargets: modifiers.altKey ? [] : resolveLeanToEdgeSnapTargets(node, wall, nodes),
+            });
+            const position = [
+                proposal.centerX,
+                node.position[1],
+                node.position[2],
+            ];
+            const connectionOffset = node.connectionMode === 'auto'
+                ? Math.max(-1, Math.min(1, node.connectionOffset + proposal.highEdgeHeight - node.highEdgeHeight))
+                : node.connectionOffset;
+            const candidate = resolveLeanToEndAbutments({
+                ...node,
+                position,
+                highEdgeHeight: proposal.highEdgeHeight,
+                lowEdgeHeight: proposal.lowEdgeHeight,
+                connectionOffset,
+                autoSpan: false,
+            }, wall, nodes);
+            const patch = {
+                position,
+                highEdgeHeight: proposal.highEdgeHeight,
+                lowEdgeHeight: proposal.lowEdgeHeight,
+                connectionOffset,
+                autoSpan: false,
+                leftEndCondition: candidate.leftEndCondition,
+                rightEndCondition: candidate.rightEndCondition,
+                downspoutPosition: candidate.downspoutPosition,
+            };
+            const previewEntries = [
+                [nodeId, patch],
+                ...leanToManagedPreviewOverrides(node, patch, sceneApi),
+            ];
+            useLiveNodeOverrides.getState().setMany(previewEntries);
+            for (const [id] of previewEntries) {
+                previewIds.add(id);
+                sceneApi.markDirty(id);
+            }
+            lastPatch =
+                modifiers.altKey || leanToPlacementConflicts(candidate, wall, nodes).length === 0
+                    ? patch
+                    : null;
+        },
+        canCommit: () => lastPatch !== null,
+        commit() {
+            if (!(lastPatch && sceneApi))
+                return;
+            for (const id of [nodeId, ...previewIds])
+                useLiveNodeOverrides.getState().clear(id);
+            sceneApi.update(nodeId, lastPatch);
+        },
+    };
+};

package/dist/lean-to-extension/floorplan-tool.d.ts

@@ -0,0 +1,4 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+declare const FloorplanLeanToExtensionTool: ({ activeLevelId, finishTool, sceneApi, selectNode, }: FloorplanToolContext) => import("react").JSX.Element | null;
+export default FloorplanLeanToExtensionTool;
+//# sourceMappingURL=floorplan-tool.d.ts.map

package/dist/lean-to-extension/floorplan-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/floorplan-tool.tsx"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,oBAAoB,EAQ1B,MAAM,oBAAoB,CAAA;AAoC3B,QAAA,MAAM,4BAA4B,GAAI,sDAKnC,oBAAoB,uCAubtB,CAAA;AAED,eAAe,4BAA4B,CAAA"}

package/dist/lean-to-extension/floorplan-tool.js

@@ -0,0 +1,385 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from '@pascal-app/core';
+import { getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { bendLocalPoint, isCurvedLeanTo } from './arc';
+import { createLeanToAssembly } from './assembly';
+import { findConicalLeanToHostInPlan, isConicalLeanToHostOccupied, } from './conical-host';
+import { leanToFacetCount } from './geometry';
+import { resolveLeanToSpanArc } from './layout';
+import { LEAN_TO_RUN_CONNECT_SNAP_RADIUS, LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS, nextLeanToCanopyForm, nextLeanToPlacementRotation, resolveLeanToCommitTarget, resolveLeanToFreestandingRunEndpointSnap, resolveLeanToFreestandingRunTarget, resolveLeanToPlanPlacement, } from './placement';
+import { resolveLeanToHostRoof } from './roof-attachment';
+function clientToPlanPoint(group, clientX, clientY) {
+    const matrix = group.getScreenCTM();
+    if (!matrix)
+        return null;
+    const local = new DOMPoint(clientX, clientY).matrixTransform(matrix.inverse());
+    return [local.x, local.y];
+}
+const FloorplanLeanToExtensionTool = ({ activeLevelId, finishTool, sceneApi, selectNode, }) => {
+    const groupRef = useRef(null);
+    const targetRef = useRef(null);
+    const rotationRef = useRef(0);
+    const formRef = useRef('mono');
+    const chainStartRef = useRef(null);
+    const chainEndRef = useRef(null);
+    const chainEndSnappedRef = useRef(false);
+    const chainFlipRef = useRef(false);
+    const [target, setTarget] = useState(null);
+    const [chainAnchor, setChainAnchor] = useState(null);
+    const [runSnap, setRunSnap] = useState(null);
+    const clearTarget = useCallback(() => {
+        targetRef.current = null;
+        setTarget(null);
+    }, []);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        const group = groupRef.current;
+        const svg = group?.ownerSVGElement;
+        if (!(group && svg))
+            return;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'lean-to-extension' });
+        rotationRef.current = 0;
+        formRef.current = 'mono';
+        chainStartRef.current = null;
+        chainEndRef.current = null;
+        chainEndSnappedRef.current = false;
+        chainFlipRef.current = false;
+        let lastFreestandingEvent = null;
+        let lastRunSnapKey = null;
+        const isContinuous = () => useEditor.getState().getContinuation('canopy') === 'continuous';
+        const snappedEventPoint = (event) => {
+            const point = clientToPlanPoint(group, event.clientX, event.clientY);
+            if (!point)
+                return null;
+            const step = !event.altKey && isGridSnapActive() ? getSegmentGridStep() : 0;
+            const snap = (value) => (step > 0 ? Math.round(value / step) * step : value);
+            return [snap(point[0]), snap(point[1])];
+        };
+        const finishRun = () => {
+            chainStartRef.current = null;
+            chainEndRef.current = null;
+            chainEndSnappedRef.current = false;
+            chainFlipRef.current = false;
+            setChainAnchor(null);
+            setRunSnap(null);
+            lastRunSnapKey = null;
+            clearTarget();
+        };
+        const consume = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            event.stopImmediatePropagation();
+        };
+        const resolveEvent = (event) => {
+            const point = clientToPlanPoint(group, event.clientX, event.clientY);
+            if (!point)
+                return null;
+            const nodes = sceneApi.nodes();
+            if (chainStartRef.current && isContinuous()) {
+                const proposedEnd = snappedEventPoint(event);
+                if (!proposedEnd)
+                    return null;
+                const snap = event.altKey
+                    ? null
+                    : resolveLeanToFreestandingRunEndpointSnap({
+                        activeLevelId,
+                        canopyForm: formRef.current,
+                        flipProjection: chainFlipRef.current,
+                        maxDistance: isMagneticSnapActive()
+                            ? LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS
+                            : LEAN_TO_RUN_CONNECT_SNAP_RADIUS,
+                        nodes,
+                        proposedEnd,
+                        start: chainStartRef.current,
+                    });
+                const snapKey = snap ? `${snap.nodeId}:${snap.side}` : null;
+                if (snapKey && snapKey !== lastRunSnapKey)
+                    triggerSFX('sfx:grid-snap');
+                lastRunSnapKey = snapKey;
+                setRunSnap(snap?.point ?? null);
+                const end = snap?.point ?? proposedEnd;
+                chainEndRef.current = end;
+                chainEndSnappedRef.current = Boolean(snap);
+                return resolveLeanToFreestandingRunTarget({
+                    activeLevelId,
+                    canopyForm: formRef.current,
+                    start: chainStartRef.current,
+                    end,
+                    flipProjection: chainFlipRef.current,
+                    nodes,
+                });
+            }
+            if (chainStartRef.current)
+                finishRun();
+            const conicalHost = findConicalLeanToHostInPlan(point, nodes, activeLevelId, {
+                includeOccupied: true,
+            });
+            if (conicalHost) {
+                return {
+                    node: conicalHost.node,
+                    valid: !isConicalLeanToHostOccupied(conicalHost.segment.id, nodes),
+                    conicalHost,
+                };
+            }
+            const snappedPoint = snappedEventPoint(event) ?? point;
+            return resolveLeanToPlanPlacement({
+                activeLevelId,
+                freestandingPoint: snappedPoint,
+                freestandingRotationY: rotationRef.current,
+                freestandingCanopyForm: formRef.current,
+                nodes,
+                point,
+            });
+        };
+        const update = (event) => {
+            consume(event);
+            const node = resolveEvent(event);
+            lastFreestandingEvent = node?.node.hostKind === 'freestanding' ? event : null;
+            targetRef.current = node;
+            setTarget(node);
+        };
+        const onPointerDown = (event) => {
+            if (event.button === 0)
+                consume(event);
+        };
+        const commit = (event) => {
+            if (event.button !== 0)
+                return;
+            consume(event);
+            const clicked = resolveEvent(event);
+            if (isContinuous() && !chainStartRef.current && clicked?.node.hostKind === 'freestanding') {
+                const point = snappedEventPoint(event);
+                if (!point)
+                    return;
+                chainStartRef.current = point;
+                chainEndRef.current = null;
+                chainEndSnappedRef.current = false;
+                setChainAnchor(point);
+                clearTarget();
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            const resolved = resolveLeanToCommitTarget(targetRef.current, clicked);
+            if (!resolved?.valid)
+                return;
+            const committedEnd = chainEndRef.current;
+            const closesLoop = chainEndSnappedRef.current;
+            const { node } = resolved;
+            const nodes = sceneApi.nodes();
+            const assembly = createLeanToAssembly(node, resolveLeanToHostRoof(node, nodes), nodes);
+            sceneApi.createMany?.([
+                { node: assembly.extension, parentId: node.parentId },
+                ...assembly.children.map((child) => ({
+                    node: child,
+                    parentId: child.parentId ?? undefined,
+                })),
+            ]);
+            selectNode(assembly.extension.id);
+            triggerSFX('sfx:structure-build');
+            if (chainStartRef.current) {
+                if (closesLoop) {
+                    finishRun();
+                    return;
+                }
+                if (committedEnd) {
+                    chainStartRef.current = committedEnd;
+                    chainEndRef.current = null;
+                    chainEndSnappedRef.current = false;
+                    setChainAnchor(committedEnd);
+                }
+                setRunSnap(null);
+                lastRunSnapKey = null;
+                clearTarget();
+            }
+            else if (!isContinuous()) {
+                finishTool();
+            }
+        };
+        const onKeyDown = (event) => {
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                markToolCancelConsumed();
+                if (chainStartRef.current)
+                    finishRun();
+                else
+                    finishTool();
+                return;
+            }
+            if (event.target instanceof HTMLInputElement ||
+                event.target instanceof HTMLTextAreaElement ||
+                (event.target instanceof HTMLElement && event.target.isContentEditable)) {
+                return;
+            }
+            if (chainStartRef.current &&
+                (event.key === 'r' || event.key === 'R' || event.key === 't' || event.key === 'T')) {
+                event.preventDefault();
+                chainFlipRef.current = !chainFlipRef.current;
+                triggerSFX('sfx:item-rotate');
+                if (lastFreestandingEvent) {
+                    const resolved = resolveEvent(lastFreestandingEvent);
+                    targetRef.current = resolved;
+                    setTarget(resolved);
+                }
+                return;
+            }
+            const nextRotation = nextLeanToPlacementRotation(rotationRef.current, event.key, event.metaKey || event.ctrlKey);
+            const nextForm = nextLeanToCanopyForm(formRef.current, event.key);
+            if (nextRotation === rotationRef.current && nextForm === formRef.current)
+                return;
+            event.preventDefault();
+            rotationRef.current = nextRotation;
+            formRef.current = nextForm;
+            triggerSFX('sfx:item-rotate');
+            if (lastFreestandingEvent) {
+                const resolved = resolveEvent(lastFreestandingEvent);
+                targetRef.current = resolved;
+                setTarget(resolved);
+            }
+        };
+        const onPointerLeave = (event) => {
+            lastFreestandingEvent = null;
+            clearTarget();
+            setChainAnchor(null);
+            setRunSnap(null);
+        };
+        svg.addEventListener('pointerdown', onPointerDown, true);
+        svg.addEventListener('pointermove', update, true);
+        svg.addEventListener('pointerleave', onPointerLeave, true);
+        svg.addEventListener('click', commit, true);
+        window.addEventListener('keydown', onKeyDown, true);
+        return () => {
+            svg.removeEventListener('pointerdown', onPointerDown, true);
+            svg.removeEventListener('pointermove', update, true);
+            svg.removeEventListener('pointerleave', onPointerLeave, true);
+            svg.removeEventListener('click', commit, true);
+            window.removeEventListener('keydown', onKeyDown, true);
+            clearTarget();
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'drafting' && scope.tool === 'lean-to-extension');
+        };
+    }, [activeLevelId, clearTarget, finishTool, sceneApi, selectNode]);
+    if (!activeLevelId)
+        return null;
+    const anchorMarker = chainAnchor ? (_jsx("circle", { cx: chainAnchor[0], cy: chainAnchor[1], fill: "#0ea5e9", pointerEvents: "none", r: 0.12, stroke: "white", strokeWidth: 1.5, vectorEffect: "non-scaling-stroke" })) : null;
+    const snapMarker = runSnap ? (_jsx("circle", { cx: runSnap[0], cy: runSnap[1], fill: "rgba(34, 197, 94, 0.2)", pointerEvents: "none", r: 0.2, stroke: "#22c55e", strokeWidth: 2, vectorEffect: "non-scaling-stroke" })) : null;
+    if (target?.conicalHost) {
+        const { center, segment } = target.conicalHost;
+        const innerRadius = Math.max(0.01, segment.width / 2 - target.node.highOverhang);
+        const outerRadius = segment.width / 2 + target.node.projection + target.node.lowOverhang;
+        const points = [];
+        const facets = leanToFacetCount(target.node);
+        for (let index = 0; index <= facets; index++) {
+            const angle = (index / facets) * Math.PI * 2;
+            points.push([
+                center[0] + Math.sin(angle) * innerRadius,
+                center[1] + Math.cos(angle) * innerRadius,
+            ]);
+        }
+        for (let index = facets; index >= 0; index--) {
+            const angle = (index / facets) * Math.PI * 2;
+            points.push([
+                center[0] + Math.sin(angle) * outerRadius,
+                center[1] + Math.cos(angle) * outerRadius,
+            ]);
+        }
+        return (_jsxs("g", { ref: groupRef, children: [anchorMarker, snapMarker, _jsx("polygon", { fill: target.valid ? 'rgba(14, 165, 233, 0.2)' : 'rgba(239, 68, 68, 0.2)', fillRule: "evenodd", pointerEvents: "none", points: points.map((point) => point.join(',')).join(' '), stroke: target.valid ? '#0ea5e9' : '#ef4444', strokeDasharray: "6 4", strokeWidth: 2, vectorEffect: "non-scaling-stroke" })] }));
+    }
+    const node = target?.node;
+    const wall = node?.parentId ? sceneApi.get(node.parentId) : null;
+    if (node && (node.hostKind === 'slab-edge' || node.hostKind === 'freestanding')) {
+        const cos = Math.cos(node.rotation[1]);
+        const sin = Math.sin(node.rotation[1]);
+        const toWorld = (localX, localZ) => [
+            node.position[0] + localX * cos + localZ * sin,
+            node.position[2] - localX * sin + localZ * cos,
+        ];
+        const back = node.canopyForm === 'gable' || node.canopyForm === 'butterfly'
+            ? -(node.projection + node.lowOverhang)
+            : -node.highOverhang;
+        const points = [
+            toWorld(-(node.span / 2 + node.leftOverhang), back),
+            toWorld(node.span / 2 + node.rightOverhang, back),
+            toWorld(node.span / 2 + node.rightOverhang, node.projection + node.lowOverhang),
+            toWorld(-(node.span / 2 + node.leftOverhang), node.projection + node.lowOverhang),
+        ];
+        return (_jsxs("g", { ref: groupRef, children: [anchorMarker, snapMarker, _jsx("polygon", { fill: target.valid ? 'rgba(14, 165, 233, 0.2)' : 'rgba(239, 68, 68, 0.2)', pointerEvents: "none", points: points.map((point) => point.join(',')).join(' '), stroke: target.valid ? '#0ea5e9' : '#ef4444', strokeDasharray: "6 4", strokeWidth: 2, vectorEffect: "non-scaling-stroke" })] }));
+    }
+    if (!(node && wall?.type === 'wall')) {
+        return (_jsxs("g", { ref: groupRef, children: [anchorMarker, snapMarker] }));
+    }
+    const sign = Math.cos(node.rotation[1]) >= 0 ? 1 : -1;
+    // Recompute the local arc from the final placed span/position so the preview
+    // footprint bends the same way reconciliation will store it.
+    const spanArc = resolveLeanToSpanArc(wall, node);
+    const previewNode = {
+        ...node,
+        spanArcCenterZ: spanArc?.centerZ,
+        spanArcRadius: spanArc?.radius,
+    };
+    const curved = isCurvedLeanTo(previewNode) && isCurvedWall(wall);
+    let originX;
+    let originZ;
+    let alongX;
+    let alongZ;
+    let perpX;
+    let perpZ;
+    if (curved) {
+        const arcLength = getWallCurveLength(wall);
+        const t = Math.max(0, Math.min(1, arcLength > 1e-6 ? node.position[0] / arcLength : 0));
+        const frame = getWallCurveFrameAt(wall, t);
+        alongX = frame.tangent.x;
+        alongZ = frame.tangent.y;
+        perpX = frame.normal.x;
+        perpZ = frame.normal.y;
+        originX = frame.point.x + perpX * node.position[2];
+        originZ = frame.point.y + perpZ * node.position[2];
+    }
+    else {
+        const dx = wall.end[0] - wall.start[0];
+        const dz = wall.end[1] - wall.start[1];
+        const length = Math.hypot(dx, dz);
+        alongX = dx / length;
+        alongZ = dz / length;
+        perpX = -alongZ;
+        perpZ = alongX;
+        originX = wall.start[0] + alongX * node.position[0] + perpX * node.position[2];
+        originZ = wall.start[1] + alongZ * node.position[0] + perpZ * node.position[2];
+    }
+    const localAlongX = alongX * sign;
+    const localAlongZ = alongZ * sign;
+    const outX = perpX * sign;
+    const outZ = perpZ * sign;
+    const toWorld = (localX, localZ) => {
+        if (curved) {
+            const bent = bendLocalPoint(previewNode, localX, localZ);
+            return [
+                originX + localAlongX * bent.x + outX * bent.y,
+                originZ + localAlongZ * bent.x + outZ * bent.y,
+            ];
+        }
+        return [
+            originX + localAlongX * localX + outX * localZ,
+            originZ + localAlongZ * localX + outZ * localZ,
+        ];
+    };
+    const left = node.span / 2 + node.leftOverhang;
+    const right = node.span / 2 + node.rightOverhang;
+    const high = node.highOverhang;
+    const low = node.projection + node.lowOverhang;
+    const facets = curved ? leanToFacetCount(previewNode) : 1;
+    const highEdge = [];
+    const lowEdge = [];
+    for (let i = 0; i <= facets; i++) {
+        const localX = -left + ((right + left) * i) / facets;
+        highEdge.push(toWorld(localX, -high));
+        lowEdge.push(toWorld(localX, low));
+    }
+    const points = [...highEdge, ...lowEdge.reverse()];
+    return (_jsxs("g", { ref: groupRef, children: [anchorMarker, snapMarker, _jsx("polygon", { fill: target.valid ? 'rgba(14, 165, 233, 0.2)' : 'rgba(239, 68, 68, 0.2)', pointerEvents: "none", points: points.map((point) => point.join(',')).join(' '), stroke: target.valid ? '#0ea5e9' : '#ef4444', strokeDasharray: "6 4", strokeWidth: 2, vectorEffect: "non-scaling-stroke" })] }));
+};
+export default FloorplanLeanToExtensionTool;

package/dist/lean-to-extension/floorplan.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanGeometry, type GeometryContext, type LeanToExtensionNode } from '@pascal-app/core';
+export declare function buildLeanToExtensionFloorplan(node: LeanToExtensionNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/lean-to-extension/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AA4OzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAkK1B"}