@pascal-app/nodes 0.1.1

package/dist/shared/refrigerant-line-selection.js

@@ -0,0 +1,405 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { analyzePortConnectivity, pauseSceneHistory, resolveConnectivityUpdates, resumeSceneHistory, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DimensionPill, swallowNextClick, triggerSFX, useEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { createPortal, useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Plane, Raycaster, Vector2, Vector3 } from 'three';
+import { collectScenePorts, findNearestPortXZ, REFRIGERANT_PORT_SYSTEMS } from './ports';
+import { HandleCube, MoveChevron } from './selection-handles';
+const PORT_SNAP_RADIUS_M = 0.4;
+const ARROW_GAP = 0.28;
+const ARROW_MIN_OFFSET = 0.4;
+const INCHES_TO_METERS = 0.0254;
+const UP = new Vector3(0, 1, 0);
+function snap(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+function lineRadiusM(line) {
+    if (line.type === 'lineset') {
+        return (Math.max(line.suctionDiameter, line.liquidDiameter) * INCHES_TO_METERS) / 2;
+    }
+    return (line.diameter * INCHES_TO_METERS) / 2;
+}
+function selectedLineOfKind(kind, id) {
+    if (!id)
+        return null;
+    const node = useScene.getState().nodes[id];
+    if (kind === 'lineset' && node?.type === 'lineset')
+        return node;
+    if (kind === 'liquid-line' && node?.type === 'liquid-line')
+        return node;
+    return null;
+}
+export function createRefrigerantLineSelectionAffordance(kind) {
+    const RefrigerantLineSelectionAffordance = () => {
+        const selectedIds = useViewer((s) => s.selection.selectedIds);
+        const selectedId = selectedIds.length === 1 ? selectedIds[0] : undefined;
+        const line = useScene(() => selectedLineOfKind(kind, selectedId));
+        const lineId = line?.id ?? null;
+        const [target, setTarget] = useState(null);
+        useEffect(() => {
+            if (!lineId) {
+                setTarget(null);
+                return;
+            }
+            let frameId = 0;
+            const resolve = () => {
+                const next = sceneRegistry.nodes.get(lineId) ?? null;
+                setTarget((cur) => (cur === next ? cur : next));
+                if (!next)
+                    frameId = window.requestAnimationFrame(resolve);
+            };
+            resolve();
+            return () => window.cancelAnimationFrame(frameId);
+        }, [lineId]);
+        if (!line || !target)
+            return null;
+        const mount = target.parent ?? target;
+        return createPortal(_jsx(RefrigerantLineEndpointHandles, { line: line, target: target }), mount, undefined);
+    };
+    return RefrigerantLineSelectionAffordance;
+}
+function RefrigerantLineEndpointHandles({ line, target, }) {
+    const { camera, gl } = useThree();
+    const outerRef = useRef(null);
+    useFrame(() => {
+        const outer = outerRef.current;
+        if (!outer)
+            return;
+        outer.position.copy(target.position);
+        outer.quaternion.copy(target.quaternion);
+        outer.scale.copy(target.scale);
+    });
+    const unit = useViewer((s) => s.unit);
+    const [draggingIndex, setDraggingIndex] = useState(null);
+    const [openCluster, setOpenCluster] = useState(null);
+    const toggleCluster = (index) => setOpenCluster((cur) => (cur === index ? null : index));
+    const dragRef = useRef(null);
+    const followUpdates = (connectivity, path) => {
+        if (!connectivity)
+            return [];
+        const preview = { ...line, path };
+        return resolveConnectivityUpdates(connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+    };
+    const makeRay = (clientX, clientY) => {
+        const rect = gl.domElement.getBoundingClientRect();
+        const ndc = new Vector2(((clientX - rect.left) / rect.width) * 2 - 1, -((clientY - rect.top) / rect.height) * 2 + 1);
+        const raycaster = new Raycaster();
+        raycaster.setFromCamera(ndc, camera);
+        return raycaster.ray;
+    };
+    const intersect = (clientX, clientY, plane) => {
+        const hit = new Vector3();
+        return makeRay(clientX, clientY).intersectPlane(plane, hit) ? hit : null;
+    };
+    const intersectVerticalY = (clientX, clientY, anchorWorld) => {
+        const forward = camera.getWorldDirection(new Vector3());
+        forward.y = 0;
+        if (forward.lengthSq() < 1e-6)
+            forward.set(0, 0, 1);
+        forward.normalize();
+        const plane = new Plane().setFromNormalAndCoplanarPoint(forward, anchorWorld);
+        const hit = intersect(clientX, clientY, plane);
+        return hit ? toLocal(hit)[1] : null;
+    };
+    const swingHorizontal = (event, pivot, startPoint) => {
+        const r = Math.hypot(startPoint[0] - pivot[0], startPoint[1] - pivot[1], startPoint[2] - pivot[2]);
+        if (r < 1e-6)
+            return null;
+        const verticalN = (startPoint[1] - pivot[1]) / r;
+        const horizN = Math.sqrt(Math.max(0, 1 - verticalN * verticalN));
+        const plane = new Plane().setFromNormalAndCoplanarPoint(UP, toWorld(pivot));
+        const hit = intersect(event.clientX, event.clientY, plane);
+        if (!hit)
+            return null;
+        const local = toLocal(hit);
+        const bx = local[0] - pivot[0];
+        const bz = local[2] - pivot[2];
+        const blen = Math.hypot(bx, bz);
+        if (blen < 1e-6)
+            return null;
+        return [(bx / blen) * horizN, verticalN, (bz / blen) * horizN];
+    };
+    const swingVertical = (event, pivot, startPoint) => {
+        let hx = startPoint[0] - pivot[0];
+        let hz = startPoint[2] - pivot[2];
+        let hlen = Math.hypot(hx, hz);
+        if (hlen < 1e-6) {
+            const forward = camera.getWorldDirection(new Vector3());
+            hx = forward.x;
+            hz = forward.z;
+            hlen = Math.hypot(hx, hz);
+            if (hlen < 1e-6) {
+                hx = 0;
+                hz = 1;
+                hlen = 1;
+            }
+        }
+        const headingWorld = new Vector3(hx / hlen, 0, hz / hlen);
+        const normal = new Vector3().crossVectors(UP, headingWorld).normalize();
+        const plane = new Plane().setFromNormalAndCoplanarPoint(normal, toWorld(pivot));
+        const hit = intersect(event.clientX, event.clientY, plane);
+        if (!hit)
+            return null;
+        const local = toLocal(hit);
+        const ax = local[0] - pivot[0];
+        const ay = local[1] - pivot[1];
+        const az = local[2] - pivot[2];
+        const len = Math.hypot(ax, ay, az);
+        if (len < 1e-6)
+            return null;
+        return [ax / len, ay / len, az / len];
+    };
+    const toWorld = (p) => target.localToWorld(new Vector3(p[0], p[1], p[2]));
+    const toLocal = (world) => {
+        const local = target.worldToLocal(world.clone());
+        return [local.x, local.y, local.z];
+    };
+    const onHandleDown = (index, kind) => (e) => {
+        e.stopPropagation();
+        const initialPath = line.path.map((p) => [...p]);
+        const startPoint = initialPath[index];
+        const connectivity = analyzePortConnectivity(line, useScene.getState().nodes);
+        pauseSceneHistory(useScene);
+        useViewer.getState().setInputDragging(true);
+        document.body.style.cursor = kind.axis === 'y' ? 'ns-resize' : 'grabbing';
+        setDraggingIndex(index);
+        const isEndpoint = index === 0 || index === initialPath.length - 1;
+        const swings = kind.axis === 'y' ? kind.along !== true : !kind.along;
+        const neighborIndex = index === 0 ? 1 : index === initialPath.length - 1 ? index - 1 : null;
+        const pivot = neighborIndex !== null ? initialPath[neighborIndex] : null;
+        const radius = pivot
+            ? Math.hypot(startPoint[0] - pivot[0], startPoint[1] - pivot[1], startPoint[2] - pivot[2])
+            : 0;
+        const canSwing = swings && isEndpoint && pivot !== null && radius > 1e-6;
+        const onMove = (event) => {
+            const drag = dragRef.current;
+            if (!drag)
+                return;
+            const step = event.shiftKey ? 0 : useEditor.getState().gridSnapStep;
+            const detached = event.altKey;
+            let next = null;
+            if (canSwing && pivot) {
+                const aim = kind.axis === 'y'
+                    ? swingVertical(event, pivot, startPoint)
+                    : swingHorizontal(event, pivot, startPoint);
+                if (aim) {
+                    next = [
+                        snap(pivot[0] + aim[0] * radius, step),
+                        Math.max(0, snap(pivot[1] + aim[1] * radius, step)),
+                        snap(pivot[2] + aim[2] * radius, step),
+                    ];
+                }
+            }
+            else if (kind.axis === 'y') {
+                const y = intersectVerticalY(event.clientX, event.clientY, toWorld(startPoint));
+                if (y !== null)
+                    next = [startPoint[0], Math.max(0, snap(y, step)), startPoint[2]];
+            }
+            else {
+                const plane = new Plane().setFromNormalAndCoplanarPoint(UP, toWorld(startPoint));
+                const hit = intersect(event.clientX, event.clientY, plane);
+                if (hit) {
+                    const local = toLocal(hit);
+                    const [dx, dz] = kind.dir;
+                    const t = snap((local[0] - startPoint[0]) * dx + (local[2] - startPoint[2]) * dz, step);
+                    next = [startPoint[0] + t * dx, startPoint[1], startPoint[2] + t * dz];
+                }
+            }
+            if (!next)
+                return;
+            if (isEndpoint) {
+                const port = findNearestPortXZ([next[0], next[1], next[2]], collectScenePorts({ excludeNodeId: line.id, systems: REFRIGERANT_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
+                if (port)
+                    next = [port.position[0], port.position[1], port.position[2]];
+            }
+            if (next[0] === drag.current[0] && next[1] === drag.current[1] && next[2] === drag.current[2])
+                return;
+            drag.current = next;
+            drag.detached = detached;
+            if (step > 0)
+                triggerSFX('sfx:grid-snap');
+            const path = line.path.map((p, i) => (i === drag.index ? next : p));
+            useScene
+                .getState()
+                .updateNodes([
+                { id: line.id, data: { path } },
+                ...(detached ? [] : followUpdates(drag.connectivity, path)),
+            ]);
+        };
+        const onUp = () => {
+            const drag = dragRef.current;
+            if (!drag)
+                return;
+            swallowNextClick();
+            drag.cleanup();
+            dragRef.current = null;
+            setDraggingIndex(null);
+            const detached = drag.detached;
+            const finalPath = drag.initialPath.map((p, i) => i === drag.index ? drag.current : p);
+            const revert = detached
+                ? []
+                : (drag.connectivity?.connections ?? []).map((conn) => conn.kind === 'rigid-node'
+                    ? { id: conn.nodeId, data: { position: conn.startPosition } }
+                    : { id: conn.nodeId, data: { path: conn.startPath } });
+            useScene
+                .getState()
+                .updateNodes([
+                { id: line.id, data: { path: drag.initialPath } },
+                ...revert.filter((u) => useScene.getState().nodes[u.id]),
+            ]);
+            resumeSceneHistory(useScene);
+            const moved = finalPath[drag.index].some((v, axis) => v !== drag.initialPath[drag.index][axis]);
+            if (moved) {
+                useScene
+                    .getState()
+                    .updateNodes([
+                    { id: line.id, data: { path: finalPath } },
+                    ...(detached ? [] : followUpdates(drag.connectivity, finalPath)),
+                ]);
+            }
+        };
+        const cleanup = () => {
+            window.removeEventListener('pointermove', onMove);
+            window.removeEventListener('pointerup', onUp);
+            window.removeEventListener('pointercancel', onUp);
+            useViewer.getState().setInputDragging(false);
+            document.body.style.cursor = '';
+        };
+        dragRef.current = {
+            index,
+            initialPath,
+            current: startPoint,
+            cleanup,
+            connectivity,
+            detached: false,
+        };
+        window.addEventListener('pointermove', onMove);
+        window.addEventListener('pointerup', onUp);
+        window.addEventListener('pointercancel', onUp);
+    };
+    const endpointArrows = useMemo(() => getEndpointArrows(line), [line]);
+    const endpointIndices = useMemo(() => {
+        if (line.path.length < 2)
+            return [];
+        const last = line.path.length - 1;
+        return last === 0 ? [0] : [0, last];
+    }, [line.path.length]);
+    return (_jsxs("group", { ref: outerRef, children: [draggingIndex === null &&
+                endpointIndices.map((index) => {
+                    const point = line.path[index];
+                    return (_jsxs("group", { children: [_jsx(HandleCube, { active: openCluster === index, onClick: () => toggleCluster(index), position: point, rotationY: vertexYaw(line, index) }), openCluster === index &&
+                                endpointArrows
+                                    .filter((a) => a.index === index)
+                                    .map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: onHandleDown(a.index, a.kind), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key)))] }, `line-end-${index}`));
+                }), draggingIndex !== null &&
+                line.path[draggingIndex] &&
+                (() => {
+                    const point = line.path[draggingIndex];
+                    const origin = dragRef.current?.initialPath[draggingIndex] ?? point;
+                    const deltas = [point[0] - origin[0], point[1] - origin[1], point[2] - origin[2]];
+                    const axes = ['x', 'y', 'z'];
+                    const primary = axes.reduce((best, axis, i) => Math.abs(deltas[i]) > Math.abs(deltas[axes.indexOf(best)]) ? axis : best);
+                    return (_jsx(Html, { center: true, position: [point[0], point[1] + 0.35, point[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx(DimensionPill, { parts: axes.map((axis, i) => ({
+                                key: axis,
+                                prefix: axis.toUpperCase(),
+                                value: deltas[i],
+                                signed: true,
+                            })), primary: primary, unit: unit }) }));
+                })()] }));
+}
+function getEndpointArrows(line) {
+    const arrows = [];
+    const base = Math.max(lineRadiusM(line) + ARROW_GAP, ARROW_MIN_OFFSET);
+    const last = line.path.length - 1;
+    if (last < 1)
+        return arrows;
+    for (const i of [0, last]) {
+        const p = line.path[i];
+        const tangentXZ = vertexTangentXZ(line, i);
+        const verticalTangentY = tangentXZ ? null : vertexTangentY(line, i);
+        const t = tangentXZ ?? [1, 0];
+        const runYaw = Math.atan2(-t[1], t[0]);
+        const dirs = tangentXZ
+            ? [
+                { dir: [t[0], t[1]], along: true },
+                { dir: [-t[0], -t[1]], along: true },
+                { dir: [-t[1], t[0]], along: false },
+                { dir: [t[1], -t[0]], along: false },
+            ]
+            : [
+                { dir: [1, 0], along: false },
+                { dir: [-1, 0], along: false },
+                { dir: [0, 1], along: false },
+                { dir: [0, -1], along: false },
+            ];
+        const inward = tangentXZ && i === 0 ? [t[0], t[1]] : tangentXZ && i === last ? [-t[0], -t[1]] : null;
+        for (const { dir, along } of dirs) {
+            const [dx, dz] = dir;
+            if (inward && dx * inward[0] + dz * inward[1] > 0.999)
+                continue;
+            arrows.push({
+                key: `pt${i}-${dx.toFixed(3)}:${dz.toFixed(3)}`,
+                index: i,
+                kind: { axis: 'horizontal', dir: [dx, dz], along },
+                position: [p[0] + dx * base, p[1], p[2] + dz * base],
+                rotationY: Math.atan2(-dz, dx),
+                cursor: 'grab',
+            });
+        }
+        const inwardY = verticalTangentY && i === 0
+            ? verticalTangentY
+            : verticalTangentY && i === last
+                ? -verticalTangentY
+                : null;
+        for (const sign of [1, -1]) {
+            if (inwardY === sign)
+                continue;
+            arrows.push({
+                key: `pt${i}-${sign > 0 ? 'up' : 'down'}`,
+                index: i,
+                kind: { axis: 'y', along: verticalTangentY !== null },
+                position: [p[0], p[1] + sign * base, p[2]],
+                rotationY: runYaw,
+                vertical: sign > 0 ? 'up' : 'down',
+                cursor: 'ns-resize',
+            });
+        }
+    }
+    return arrows;
+}
+function vertexTangentXZ(line, i) {
+    const path = line.path;
+    const last = path.length - 1;
+    if (last < 1)
+        return null;
+    const neighbor = i === 0 ? path[1] : path[last - 1];
+    const point = path[i];
+    const dx = i === 0 ? neighbor[0] - point[0] : point[0] - neighbor[0];
+    const dz = i === 0 ? neighbor[2] - point[2] : point[2] - neighbor[2];
+    const len = Math.hypot(dx, dz);
+    return len < 1e-6 ? null : [dx / len, dz / len];
+}
+function vertexTangentY(line, i) {
+    const path = line.path;
+    const last = path.length - 1;
+    if (last < 1)
+        return null;
+    const neighbor = i === 0 ? path[1] : path[last - 1];
+    const point = path[i];
+    const dx = i === 0 ? neighbor[0] - point[0] : point[0] - neighbor[0];
+    const dy = i === 0 ? neighbor[1] - point[1] : point[1] - neighbor[1];
+    const dz = i === 0 ? neighbor[2] - point[2] : point[2] - neighbor[2];
+    if (Math.hypot(dx, dz) > 1e-6 || Math.abs(dy) < 1e-6)
+        return null;
+    return dy > 0 ? 1 : -1;
+}
+function vertexYaw(line, i) {
+    const t = vertexTangentXZ(line, i);
+    return t ? Math.atan2(-t[1], t[0]) : 0;
+}

package/dist/shared/relative-roof-drag.d.ts

@@ -0,0 +1,18 @@
+import { type RoofEvent, type RoofSegmentNode } from '@pascal-app/core';
+import { type RoofSegmentHit } from './roof-segment-hit';
+export type RelativeRoofDragTarget = {
+    segment: RoofSegmentNode;
+    localX: number;
+    localY: number;
+    localZ: number;
+    hit: RoofSegmentHit;
+};
+export declare function roofSegmentLocalToBuildingLocal(segmentId: string, position: [number, number, number]): [number, number, number];
+export declare function createRelativeRoofDrag(original: {
+    position: [number, number, number];
+    roofSegmentId?: string;
+}): {
+    resolve: (event: RoofEvent) => RelativeRoofDragTarget | null;
+};
+export declare function snapRelativeRoofDragTarget(target: RelativeRoofDragTarget, bypass?: boolean): RelativeRoofDragTarget;
+//# sourceMappingURL=relative-roof-drag.d.ts.map

package/dist/shared/relative-roof-drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative-roof-drag.d.ts","sourceRoot":"","sources":["../../src/shared/relative-roof-drag.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,KAAK,cAAc,EAAyB,MAAM,oBAAoB,CAAA;AAG/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,eAAe,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAYD,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACjC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAS1B;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE;IAC/C,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,GAAG;IACF,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,sBAAsB,GAAG,IAAI,CAAA;CAC7D,CAoEA;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,sBAAsB,EAC9B,MAAM,UAAQ,GACb,sBAAsB,CAYxB"}

package/dist/shared/relative-roof-drag.js

@@ -0,0 +1,83 @@
+import { sceneRegistry, } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import * as THREE from 'three';
+import { resolveRoofSegmentHit } from './roof-segment-hit';
+import { getSurfaceY } from './roof-surface';
+const ROOF_DRAG_SNAP_STEP_M = 0.05;
+export function roofSegmentLocalToBuildingLocal(segmentId, position) {
+    const segmentObj = sceneRegistry.nodes.get(segmentId);
+    if (!segmentObj)
+        return position;
+    const point = segmentObj.localToWorld(new THREE.Vector3(...position));
+    const buildingId = useViewer.getState().selection.buildingId;
+    const buildingObj = buildingId ? sceneRegistry.nodes.get(buildingId) : null;
+    if (buildingObj)
+        buildingObj.worldToLocal(point);
+    return [point.x, point.y, point.z];
+}
+export function createRelativeRoofDrag(original) {
+    let state = null;
+    const getPositionInSegment = (position, fromSegmentId, segment) => {
+        if (fromSegmentId === segment.id)
+            return position;
+        const fromSegmentObj = fromSegmentId
+            ? sceneRegistry.nodes.get(fromSegmentId)
+            : null;
+        const targetSegmentObj = sceneRegistry.nodes.get(segment.id);
+        if (!(fromSegmentObj && targetSegmentObj))
+            return position;
+        const point = fromSegmentObj.localToWorld(new THREE.Vector3(...position));
+        targetSegmentObj.worldToLocal(point);
+        return [point.x, point.y, point.z];
+    };
+    const getStartPositionForSegment = (segment, previousState) => {
+        if (previousState) {
+            return getPositionInSegment(previousState.current, previousState.segmentId, segment);
+        }
+        if (original.roofSegmentId === segment.id)
+            return original.position;
+        return getPositionInSegment(original.position, original.roofSegmentId, segment);
+    };
+    return {
+        resolve(event) {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return null;
+            if (!state || state.segmentId !== hit.segment.id) {
+                const start = getStartPositionForSegment(hit.segment, state);
+                state = {
+                    segmentId: hit.segment.id,
+                    anchor: [hit.localX, hit.localZ],
+                    start,
+                    current: start,
+                    surfaceOffsetY: start[1] - getSurfaceY(start[0], start[2], hit.segment),
+                };
+            }
+            const localX = state.start[0] + (hit.localX - state.anchor[0]);
+            const localZ = state.start[2] + (hit.localZ - state.anchor[1]);
+            const localY = getSurfaceY(localX, localZ, hit.segment) + state.surfaceOffsetY;
+            state.current = [localX, localY, localZ];
+            return {
+                segment: hit.segment,
+                localX,
+                localY,
+                localZ,
+                hit,
+            };
+        },
+    };
+}
+export function snapRelativeRoofDragTarget(target, bypass = false) {
+    if (bypass)
+        return target;
+    const localX = Math.round(target.localX / ROOF_DRAG_SNAP_STEP_M) * ROOF_DRAG_SNAP_STEP_M;
+    const localZ = Math.round(target.localZ / ROOF_DRAG_SNAP_STEP_M) * ROOF_DRAG_SNAP_STEP_M;
+    const surfaceOffsetY = target.localY - getSurfaceY(target.localX, target.localZ, target.segment);
+    const localY = getSurfaceY(localX, localZ, target.segment) + surfaceOffsetY;
+    return {
+        ...target,
+        localX,
+        localY,
+        localZ,
+    };
+}

package/dist/shared/ridge-snap.d.ts

@@ -0,0 +1,31 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+/**
+ * Shared ridge-line snap math for ridge-vent placement + move tools.
+ *
+ * Ridge vents must sit centered on a roof break line — off-line the cap's
+ * far half dips into the higher part of the slope ("goes inside" the roof).
+ * So the placement tools clamp the cursor onto the nearest generated ridge
+ * line, preserving the line's yaw for hip / lower-slope runs.
+ *
+ * Per roof type:
+ *   - gable / gambrel: ridge spans the full width.
+ *   - mansard: top ridge, upper hip runs, plus lower-slope runs on all
+ *     four steep lower faces.
+ *   - dutch: top ridge between the gablet waists plus four hip runs down
+ *     to the eave corners (the gablet ends are vertical walls, not ridges).
+ *   - hip: ridge is shortened by the hipped ends — spans width − depth.
+ *     A square hip (width ≤ depth) collapses to a single apex point.
+ *   - shed: no true ridge — snap to the high eave (z = -depth/2).
+ *   - flat: no ridge at all → return null.
+ */
+export declare const RIDGE_LIFT = 0.09;
+export type RidgeSnap = {
+    /** Segment-local X of the snapped ridge position. */
+    localX: number;
+    /** Segment-local Z of the snapped ridge position. */
+    localZ: number;
+    /** Segment-local yaw matching the snapped ridge line. */
+    rotation: number;
+};
+export declare function resolveRidgeSnap(segment: RoofSegmentNode, cursorLocalX: number, cursorLocalZ: number): RidgeSnap | null;
+//# sourceMappingURL=ridge-snap.d.ts.map

package/dist/shared/ridge-snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ridge-snap.d.ts","sourceRoot":"","sources":["../../src/shared/ridge-snap.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;GAkBG;AAIH,eAAO,MAAM,UAAU,OAAO,CAAA;AAE9B,MAAM,MAAM,SAAS,GAAG;IACtB,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAA;IACd,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAA;IACd,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,SAAS,GAAG,IAAI,CAsClB"}

package/dist/shared/ridge-snap.js

@@ -0,0 +1,61 @@
+import { getRidgeVentLinesForSegment, getRoofSegmentVisibleTopBounds, } from '@pascal-app/core';
+/**
+ * Shared ridge-line snap math for ridge-vent placement + move tools.
+ *
+ * Ridge vents must sit centered on a roof break line — off-line the cap's
+ * far half dips into the higher part of the slope ("goes inside" the roof).
+ * So the placement tools clamp the cursor onto the nearest generated ridge
+ * line, preserving the line's yaw for hip / lower-slope runs.
+ *
+ * Per roof type:
+ *   - gable / gambrel: ridge spans the full width.
+ *   - mansard: top ridge, upper hip runs, plus lower-slope runs on all
+ *     four steep lower faces.
+ *   - dutch: top ridge between the gablet waists plus four hip runs down
+ *     to the eave corners (the gablet ends are vertical walls, not ridges).
+ *   - hip: ridge is shortened by the hipped ends — spans width − depth.
+ *     A square hip (width ≤ depth) collapses to a single apex point.
+ *   - shed: no true ridge — snap to the high eave (z = -depth/2).
+ *   - flat: no ridge at all → return null.
+ */
+// Ridge vents seat directly onto the analytical roof surface; any visible
+// thickness belongs in the vent geometry itself, not in a renderer lift.
+export const RIDGE_LIFT = 0.09;
+export function resolveRidgeSnap(segment, cursorLocalX, cursorLocalZ) {
+    const roofType = segment.roofType ?? 'gable';
+    if (roofType === 'flat')
+        return null;
+    const lines = roofType === 'shed'
+        ? getShedHighEaveLine(segment)
+        : getRidgeVentLinesForSegment(segment).map(({ start, end }) => ({ start, end }));
+    if (lines.length === 0)
+        return null;
+    let best = null;
+    let bestDistanceSq = Number.POSITIVE_INFINITY;
+    for (const line of lines) {
+        const [sx, sz] = line.start;
+        const [ex, ez] = line.end;
+        const dx = ex - sx;
+        const dz = ez - sz;
+        const lengthSq = dx * dx + dz * dz;
+        const t = lengthSq <= 1e-8
+            ? 0
+            : Math.max(0, Math.min(1, ((cursorLocalX - sx) * dx + (cursorLocalZ - sz) * dz) / lengthSq));
+        const localX = sx + dx * t;
+        const localZ = sz + dz * t;
+        const distanceSq = (cursorLocalX - localX) ** 2 + (cursorLocalZ - localZ) ** 2;
+        if (distanceSq < bestDistanceSq) {
+            bestDistanceSq = distanceSq;
+            best = {
+                localX,
+                localZ,
+                rotation: Math.atan2(-dz, dx),
+            };
+        }
+    }
+    return best;
+}
+function getShedHighEaveLine(segment) {
+    const { minX, maxX, minZ } = getRoofSegmentVisibleTopBounds(segment);
+    return [{ start: [minX, minZ], end: [maxX, minZ] }];
+}

package/dist/shared/roof-attachment-fallback-preview.d.ts

@@ -0,0 +1,14 @@
+import { type RoofEvent } from '@pascal-app/core';
+import { type ReactNode } from 'react';
+type ValidTarget = 'roof' | 'gutter';
+export declare function RoofAttachmentFallbackPreview({ activeBuildingId, ghost, isValidRoofTarget, lift, onInvalidTarget, size, validTarget, }: {
+    activeBuildingId: string | null | undefined;
+    ghost?: ReactNode;
+    isValidRoofTarget?: (event: RoofEvent) => boolean;
+    lift?: number;
+    onInvalidTarget?: () => void;
+    size?: [number, number, number];
+    validTarget?: ValidTarget;
+}): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=roof-attachment-fallback-preview.d.ts.map

package/dist/shared/roof-attachment-fallback-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-attachment-fallback-preview.d.ts","sourceRoot":"","sources":["../../src/shared/roof-attachment-fallback-preview.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,OAAO,CAAA;AAInE,KAAK,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEpC,wBAAgB,6BAA6B,CAAC,EAC5C,gBAAgB,EAChB,KAAK,EACL,iBAAiB,EACjB,IAAQ,EACR,eAAe,EACf,IAAI,EACJ,WAAoB,GACrB,EAAE;IACD,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IAC3C,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAA;IACjD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,eAAe,CAAC,EAAE,MAAM,IAAI,CAAA;IAC5B,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B,sCAsFA"}