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

package/dist/lean-to-extension/placement.js

@@ -0,0 +1,331 @@
+import { getLevelElevations, LeanToExtensionNode, } from '@pascal-app/core';
+import { findClosestWallAttachmentInPlan } from '../shared/wall-attach-target';
+import { canopyCornerJointMetadata, FREESTANDING_CANOPY_JOINTS_KEY, resolveFreestandingCanopyJoints, } from './canopy-joint';
+import { LEAN_TO_CORNER_JOINTS_KEY, leanToCornerJointMetadata, resolveLeanToCornerJoints, } from './corner-joint';
+import { isDualSlopeLeanToCanopy, leanToLowEdgeHeight, resolveLeanToPlanCenter, resolveLeanToWallPlacement, } from './layout';
+import { leanToPlacementConflicts, resolveLeanToEndAbutments } from './placement-validation';
+import { applyLeanToAvailableWallSpan, applyLeanToRoofAttachment, applyLeanToWallAutoSpan, clearLeanToRoofAttachment, resolveLeanToRoofAttachment, } from './roof-attachment';
+export function resolveLeanToCommitTarget(visibleTarget, clickTarget) {
+    return visibleTarget ?? clickTarget;
+}
+/** Apply transient corner data so the placement ghost matches the committed assembly. */
+export function resolveLeanToPreviewNode(node, wall, nodes) {
+    const joints = resolveLeanToCornerJoints(node, wall, nodes);
+    const canopyJoints = resolveFreestandingCanopyJoints(node, nodes);
+    if (Object.keys(joints).length === 0 && Object.keys(canopyJoints).length === 0)
+        return node;
+    return {
+        ...node,
+        leftEndCondition: joints.left || canopyJoints.left ? 'joined' : node.leftEndCondition,
+        rightEndCondition: joints.right || canopyJoints.right ? 'joined' : node.rightEndCondition,
+        metadata: {
+            ...(node.metadata && typeof node.metadata === 'object' ? node.metadata : {}),
+            [LEAN_TO_CORNER_JOINTS_KEY]: leanToCornerJointMetadata(joints),
+            [FREESTANDING_CANOPY_JOINTS_KEY]: canopyCornerJointMetadata(canopyJoints),
+        },
+    };
+}
+export function resolveLeanToWallPlanTarget(wall, localX, side, nodes) {
+    const wallPlacement = resolveLeanToWallPlacement(wall, localX, side);
+    if (!wallPlacement)
+        return null;
+    const attachment = resolveLeanToRoofAttachment(wallPlacement, wall, nodes);
+    const autoSpannedNode = attachment
+        ? applyLeanToRoofAttachment(wallPlacement, attachment)
+        : applyLeanToWallAutoSpan(clearLeanToRoofAttachment(wallPlacement), wall);
+    const attachedNode = applyLeanToAvailableWallSpan(autoSpannedNode, wall, nodes, wallPlacement.position[0]);
+    const node = resolveLeanToEndAbutments(attachedNode, wall, nodes);
+    const previewNode = resolveLeanToPreviewNode(node, wall, nodes);
+    return {
+        node: previewNode,
+        valid: leanToPlacementConflicts(node, wall, nodes).length === 0,
+        wall,
+    };
+}
+const PLACEMENT_ROTATION_STEP = Math.PI / 4;
+export const LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS = 0.5;
+// Continuous canopy runs must stay connected even when the user's active
+// snapping mode disables magnetic pull. Grid/angle modes still control cursor
+// quantization, but they must not turn a continuous chain into separate runs.
+export const LEAN_TO_RUN_CONNECT_SNAP_RADIUS = LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS;
+export function nextLeanToPlacementRotation(current, key, hasShortcutModifier = false) {
+    if (hasShortcutModifier)
+        return current;
+    const direction = key === 'r' || key === 'R' ? 1 : key === 't' || key === 'T' ? -1 : 0;
+    if (direction === 0)
+        return current;
+    return (Math.round(current / PLACEMENT_ROTATION_STEP) + direction) * PLACEMENT_ROTATION_STEP;
+}
+export function resolveLeanToPlanPosition(node, point) {
+    const [centerX, centerZ] = resolveLeanToPlanCenter(node);
+    const rotationY = node.rotation[1];
+    const cos = Math.cos(rotationY);
+    const sin = Math.sin(rotationY);
+    return [
+        point[0] - centerX * cos - centerZ * sin,
+        node.position[1],
+        point[1] + centerX * sin - centerZ * cos,
+    ];
+}
+export function resolveLeanToFreestandingPlacement(levelId, point, rotationY = 0, canopyForm = 'mono') {
+    const parsed = LeanToExtensionNode.parse({
+        name: canopyForm === 'gable'
+            ? 'Freestanding Gable Canopy'
+            : canopyForm === 'butterfly'
+                ? 'Freestanding Butterfly Canopy'
+                : 'Freestanding Lean-to Canopy',
+        parentId: levelId,
+        canopyForm,
+        hostKind: 'freestanding',
+        highSideMode: 'independent-high-beam',
+        connectionMode: 'manual',
+        autoSpan: false,
+        position: [0, 0, 0],
+        rotation: [0, rotationY, 0],
+    });
+    return {
+        ...parsed,
+        position: resolveLeanToPlanPosition(parsed, point),
+        hostRoofId: undefined,
+        hostRoofSegmentId: undefined,
+        hostRoofEdge: undefined,
+        hostRoofEdgeRange: undefined,
+        connectionInset: 0,
+    };
+}
+export function resolveLeanToFreestandingRunPlacement(levelId, start, end, flipProjection = false, canopyForm = 'mono') {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const span = Math.hypot(dx, dz);
+    // Keep exact-minimum diagonal runs valid. Floating-point distance can land a
+    // mathematically 0.5 m run a few ulps below the schema minimum.
+    if (span < 0.5 - 1e-9)
+        return null;
+    const from = flipProjection ? end : start;
+    const to = flipProjection ? start : end;
+    const rotationY = Math.atan2(-(to[1] - from[1]), to[0] - from[0]);
+    const midpoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+    const node = resolveLeanToFreestandingPlacement(levelId, midpoint, rotationY, canopyForm);
+    return {
+        ...node,
+        span,
+        position: [midpoint[0], node.position[1], midpoint[1]],
+    };
+}
+function freestandingRunEndpoint(node, side) {
+    const sign = side === 'left' ? -1 : 1;
+    const cos = Math.cos(node.rotation[1]);
+    const sin = Math.sin(node.rotation[1]);
+    return [
+        node.position[0] + sign * cos * (node.span / 2),
+        node.position[2] - sign * sin * (node.span / 2),
+    ];
+}
+export function resolveLeanToFreestandingRunEndpointSnap({ activeLevelId, canopyForm = 'mono', flipProjection = false, maxDistance = LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS, nodes, proposedEnd, start, }) {
+    let best = null;
+    for (const candidate of Object.values(nodes)) {
+        if (candidate.type !== 'lean-to-extension' ||
+            candidate.parentId !== activeLevelId ||
+            candidate.hostKind !== 'freestanding' ||
+            candidate.canopyForm !== canopyForm ||
+            !candidate.autoMiterCorners) {
+            continue;
+        }
+        const candidateEndpoints = {
+            left: freestandingRunEndpoint(candidate, 'left'),
+            right: freestandingRunEndpoint(candidate, 'right'),
+        };
+        if (Object.values(candidateEndpoints).some((point) => Math.hypot(point[0] - start[0], point[1] - start[1]) <= 1e-4)) {
+            continue;
+        }
+        for (const side of ['left', 'right']) {
+            if (candidate[side === 'left' ? 'leftEndCondition' : 'rightEndCondition'] === 'joined') {
+                continue;
+            }
+            const point = candidateEndpoints[side];
+            const distance = Math.hypot(point[0] - proposedEnd[0], point[1] - proposedEnd[1]);
+            if (distance > maxDistance || (best && distance >= best.distance))
+                continue;
+            const proposed = resolveLeanToFreestandingRunPlacement(activeLevelId, start, point, flipProjection, canopyForm);
+            if (!proposed)
+                continue;
+            const ownSide = flipProjection ? 'left' : 'right';
+            const joint = isDualSlopeLeanToCanopy(canopyForm)
+                ? resolveFreestandingCanopyJoints(proposed, nodes)[ownSide]
+                : resolveLeanToCornerJoints(proposed, undefined, nodes)[ownSide];
+            if (joint?.neighborId !== candidate.id || joint.neighborSide !== side)
+                continue;
+            best = { distance, nodeId: candidate.id, point, side };
+        }
+    }
+    if (!best)
+        return null;
+    return { nodeId: best.nodeId, point: best.point, side: best.side };
+}
+export function resolveLeanToFreestandingRunTarget({ activeLevelId, canopyForm = 'mono', end, flipProjection = false, nodes, start, }) {
+    const node = resolveLeanToFreestandingRunPlacement(activeLevelId, start, end, flipProjection, canopyForm);
+    if (!node)
+        return null;
+    return {
+        node: resolveLeanToPreviewNode(node, undefined, nodes),
+        valid: true,
+    };
+}
+export function resolveLeanToPlanPlacement({ activeLevelId, freestandingPoint, freestandingRotationY = 0, freestandingCanopyForm = 'mono', nodes, point, }) {
+    const hit = findClosestWallAttachmentInPlan(point, nodes, activeLevelId);
+    if (hit) {
+        const target = resolveLeanToWallPlanTarget(hit.wall, hit.localX, hit.side, nodes);
+        if (target)
+            return target;
+    }
+    const slabAttached = findLeanToSlabEdgePlacement(point, nodes, activeLevelId);
+    if (slabAttached)
+        return { node: slabAttached, valid: true };
+    return {
+        node: resolveLeanToFreestandingPlacement(activeLevelId, freestandingPoint, freestandingRotationY, freestandingCanopyForm),
+        valid: true,
+    };
+}
+export function nextLeanToCanopyForm(current, key) {
+    if (key !== 'f' && key !== 'F')
+        return current;
+    return current === 'mono' ? 'gable' : current === 'gable' ? 'butterfly' : 'mono';
+}
+export function resolveLeanToSlabEdgePlacement({ activeLevelId, edgeIndex, edgeT, nodes, slab, }) {
+    const activeLevel = getLevelElevations(nodes).get(activeLevelId);
+    const hostLevel = slab.parentId ? getLevelElevations(nodes).get(slab.parentId) : undefined;
+    if (!(activeLevel && hostLevel && activeLevel.buildingId === hostLevel.buildingId))
+        return null;
+    const start = slab.polygon[edgeIndex];
+    const end = slab.polygon[(edgeIndex + 1) % slab.polygon.length];
+    if (!(start && end))
+        return null;
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const edgeLength = Math.hypot(dx, dz);
+    if (edgeLength < 0.6)
+        return null;
+    const t = Math.max(0, Math.min(1, edgeT));
+    const area = slab.polygon.reduce((sum, point, index) => {
+        const next = slab.polygon[(index + 1) % slab.polygon.length];
+        return sum + point[0] * next[1] - next[0] * point[1];
+    }, 0);
+    const winding = area >= 0 ? 1 : -1;
+    const outwardX = (winding * dz) / edgeLength;
+    const outwardZ = (-winding * dx) / edgeLength;
+    const highEdgeHeight = hostLevel.baseY - activeLevel.baseY + slab.elevation - slab.thickness;
+    if (highEdgeHeight < 0.8 || highEdgeHeight > 10)
+        return null;
+    const parsed = LeanToExtensionNode.parse({
+        name: 'Slab-attached Lean-to Canopy',
+        parentId: activeLevelId,
+        hostKind: 'slab-edge',
+        hostSlabId: slab.id,
+        hostSlabEdgeIndex: edgeIndex,
+        hostSlabEdgeT: t,
+        highSideMode: 'wall-ledger',
+        connectionMode: 'manual',
+        autoSpan: true,
+        span: Math.max(0.5, edgeLength - 0.1),
+        position: [start[0] + dx * t, 0, start[1] + dz * t],
+        rotation: [0, Math.atan2(outwardX, outwardZ), 0],
+        highEdgeHeight,
+    });
+    return {
+        ...parsed,
+        hostRoofId: undefined,
+        hostRoofSegmentId: undefined,
+        hostRoofEdge: undefined,
+        hostRoofEdgeRange: undefined,
+        connectionInset: 0,
+        lowEdgeHeight: leanToLowEdgeHeight(parsed),
+    };
+}
+export function findLeanToSlabEdgePlacement(point, nodes, activeLevelId, maxDistance = 0.35) {
+    let best = null;
+    for (const candidate of Object.values(nodes)) {
+        if (candidate.type !== 'slab' || candidate.recessed || candidate.polygon.length < 2)
+            continue;
+        for (let edgeIndex = 0; edgeIndex < candidate.polygon.length; edgeIndex++) {
+            const start = candidate.polygon[edgeIndex];
+            const end = candidate.polygon[(edgeIndex + 1) % candidate.polygon.length];
+            const dx = end[0] - start[0];
+            const dz = end[1] - start[1];
+            const lengthSq = dx * dx + dz * dz;
+            if (lengthSq <= 1e-9)
+                continue;
+            const edgeT = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSq));
+            const edgeX = start[0] + dx * edgeT;
+            const edgeZ = start[1] + dz * edgeT;
+            const distance = Math.hypot(point[0] - edgeX, point[1] - edgeZ);
+            if (distance > maxDistance || (best && distance >= best.distance))
+                continue;
+            const node = resolveLeanToSlabEdgePlacement({
+                activeLevelId,
+                edgeIndex,
+                edgeT,
+                nodes,
+                slab: candidate,
+            });
+            if (node)
+                best = { distance, node };
+        }
+    }
+    return best?.node ?? null;
+}
+export function reconcileLeanToSlabEdgePlacement(node, nodes) {
+    if (node.hostKind !== 'slab-edge' ||
+        !node.parentId ||
+        !node.hostSlabId ||
+        node.hostSlabEdgeIndex === undefined ||
+        node.hostSlabEdgeT === undefined) {
+        return node;
+    }
+    const slab = nodes[node.hostSlabId];
+    if (slab?.type !== 'slab')
+        return node;
+    const resolved = resolveLeanToSlabEdgePlacement({
+        activeLevelId: node.parentId,
+        edgeIndex: node.hostSlabEdgeIndex,
+        edgeT: node.hostSlabEdgeT,
+        nodes,
+        slab,
+    });
+    if (!resolved)
+        return node;
+    const highEdgeHeight = resolved.highEdgeHeight + node.hostHeightOffset;
+    return {
+        ...node,
+        position: resolved.position,
+        rotation: resolved.rotation,
+        span: node.autoSpan ? resolved.span : node.span,
+        highEdgeHeight,
+        lowEdgeHeight: leanToLowEdgeHeight({ ...node, highEdgeHeight }),
+        highSideMode: 'wall-ledger',
+        connectionMode: 'manual',
+        hostRoofId: undefined,
+        hostRoofSegmentId: undefined,
+        hostRoofEdge: undefined,
+        hostRoofEdgeRange: undefined,
+        connectionInset: 0,
+    };
+}
+export function moveLeanToAlongSlabEdge(node, point, nodes) {
+    if (node.hostKind !== 'slab-edge' || !node.hostSlabId || node.hostSlabEdgeIndex === undefined) {
+        return null;
+    }
+    const slab = nodes[node.hostSlabId];
+    if (slab?.type !== 'slab')
+        return null;
+    const start = slab.polygon[node.hostSlabEdgeIndex];
+    const end = slab.polygon[(node.hostSlabEdgeIndex + 1) % slab.polygon.length];
+    if (!(start && end))
+        return null;
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSq = dx * dx + dz * dz;
+    if (lengthSq <= 1e-9)
+        return null;
+    const hostSlabEdgeT = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSq));
+    return reconcileLeanToSlabEdgePlacement({ ...node, hostSlabEdgeT }, nodes);
+}

package/dist/lean-to-extension/plan-footprint.d.ts

@@ -0,0 +1,10 @@
+import type { LeanToExtensionNode, WallNode } from '@pascal-app/core';
+export type LeanToPlanPoint = readonly [number, number];
+export type LeanToPlanFacet = readonly [
+    LeanToPlanPoint,
+    LeanToPlanPoint,
+    LeanToPlanPoint,
+    LeanToPlanPoint
+];
+export declare function leanToPlanFootprintFacets(node: LeanToExtensionNode, wall: WallNode): LeanToPlanFacet[];
+//# sourceMappingURL=plan-footprint.d.ts.map

package/dist/lean-to-extension/plan-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-footprint.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/plan-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAIrE,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACvD,MAAM,MAAM,eAAe,GAAG,SAAS;IACrC,eAAe;IACf,eAAe;IACf,eAAe;IACf,eAAe;CAChB,CAAA;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,QAAQ,GACb,eAAe,EAAE,CAwBnB"}

package/dist/lean-to-extension/plan-footprint.js

@@ -0,0 +1,27 @@
+import { bendLocalPoint, isCurvedLeanTo } from './arc';
+import { leanToWallLocalPose, resolveLeanToLayout } from './layout';
+export function leanToPlanFootprintFacets(node, wall) {
+    const layout = resolveLeanToLayout(node);
+    const pose = leanToWallLocalPose(wall, node, 0);
+    const cos = Math.cos(pose.rotationY);
+    const sin = Math.sin(pose.rotationY);
+    const toPlan = (localX, localZ) => {
+        const point = bendLocalPoint(node, localX, localZ);
+        return [
+            pose.position[0] + point.x * cos + point.y * sin,
+            pose.position[2] - point.x * sin + point.y * cos,
+        ];
+    };
+    const left = layout.span / 2 + node.leftOverhang;
+    const right = layout.span / 2 + node.rightOverhang;
+    const high = -node.highOverhang;
+    const low = layout.projection + node.lowOverhang;
+    const count = isCurvedLeanTo(node) ? Math.max(4, Math.min(32, Math.ceil(node.span / 0.4))) : 1;
+    const facets = [];
+    for (let index = 0; index < count; index++) {
+        const startX = -left + ((right + left) * index) / count;
+        const endX = -left + ((right + left) * (index + 1)) / count;
+        facets.push([toPlan(startX, high), toPlan(endX, high), toPlan(endX, low), toPlan(startX, low)]);
+    }
+    return facets;
+}

package/dist/lean-to-extension/preview-geometry.d.ts

@@ -0,0 +1,7 @@
+import type { LeanToExtensionNode } from '@pascal-app/core';
+import { type Group } from 'three';
+export declare const LEAN_TO_GHOST_COLOR = 7119871;
+export declare const LEAN_TO_INVALID_GHOST_COLOR = 15680580;
+export declare function buildLeanToExtensionPreviewGeometry(node: LeanToExtensionNode, invalid?: boolean): Group;
+export declare function disposeLeanToExtensionPreviewGeometry(root: Group): void;
+//# sourceMappingURL=preview-geometry.d.ts.map

package/dist/lean-to-extension/preview-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-geometry.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/preview-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAC3D,OAAO,EAAE,KAAK,KAAK,EAA0C,MAAM,OAAO,CAAA;AAG1E,eAAO,MAAM,mBAAmB,UAAa,CAAA;AAC7C,eAAO,MAAM,2BAA2B,WAAa,CAAA;AAErD,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,mBAAmB,EACzB,OAAO,UAAQ,GACd,KAAK,CAoBP;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,CASvE"}

package/dist/lean-to-extension/preview-geometry.js

@@ -0,0 +1,40 @@
+import { Mesh, MeshBasicMaterial } from 'three';
+import { buildLeanToExtensionGeometry } from './geometry';
+export const LEAN_TO_GHOST_COLOR = 0x6c_a3_ff;
+export const LEAN_TO_INVALID_GHOST_COLOR = 0xef_44_44;
+export function buildLeanToExtensionPreviewGeometry(node, invalid = false) {
+    const group = buildLeanToExtensionGeometry(node, undefined, 'rendered', false);
+    group.name = 'lean-to-extension-preview';
+    const material = new MeshBasicMaterial({
+        color: invalid ? LEAN_TO_INVALID_GHOST_COLOR : LEAN_TO_GHOST_COLOR,
+        depthTest: false,
+        depthWrite: false,
+        opacity: invalid ? 0.38 : 0.3,
+        transparent: true,
+    });
+    const replacedMaterials = new Set();
+    group.traverse((object) => {
+        if (!(object instanceof Mesh))
+            return;
+        const materials = Array.isArray(object.material) ? object.material : [object.material];
+        for (const source of materials)
+            replacedMaterials.add(source);
+        object.material = material;
+    });
+    for (const source of replacedMaterials)
+        source.dispose();
+    return group;
+}
+export function disposeLeanToExtensionPreviewGeometry(root) {
+    const materials = new Set();
+    root.traverse((object) => {
+        if (!(object instanceof Mesh))
+            return;
+        object.geometry.dispose();
+        const meshMaterials = Array.isArray(object.material) ? object.material : [object.material];
+        for (const material of meshMaterials)
+            materials.add(material);
+    });
+    for (const material of materials)
+        material.dispose();
+}

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

@@ -0,0 +1,7 @@
+import type { LeanToExtensionNode } from '@pascal-app/core';
+declare const LeanToExtensionPreview: ({ node, invalid, }: {
+    node: LeanToExtensionNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default LeanToExtensionPreview;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/preview.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAQ3D,QAAA,MAAM,sBAAsB,GAAI,oBAG7B;IACD,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,gCAkBA,CAAA;AAED,eAAe,sBAAsB,CAAA"}

package/dist/lean-to-extension/preview.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useEffect, useMemo } from 'react';
+import { buildLeanToExtensionPreviewGeometry, disposeLeanToExtensionPreviewGeometry, } from './preview-geometry';
+const LeanToExtensionPreview = ({ node, invalid, }) => {
+    const built = useMemo(() => {
+        const next = buildLeanToExtensionPreviewGeometry(node, invalid);
+        next.traverse((object) => {
+            object.layers.set(EDITOR_LAYER);
+            object.raycast = () => { };
+        });
+        return next;
+    }, [invalid, node]);
+    useEffect(() => () => {
+        disposeLeanToExtensionPreviewGeometry(built);
+    }, [built]);
+    return _jsx("primitive", { object: built });
+};
+export default LeanToExtensionPreview;

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

@@ -0,0 +1,6 @@
+import { type LeanToExtensionNode } from '@pascal-app/core';
+declare const LeanToExtensionRenderer: ({ node }: {
+    node: LeanToExtensionNode;
+}) => import("react").JSX.Element;
+export default LeanToExtensionRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAMzB,QAAA,MAAM,uBAAuB,GAAI,UAAU;IAAE,IAAI,EAAE,mBAAmB,CAAA;CAAE,gCA8CvE,CAAA;AAED,eAAe,uBAAuB,CAAA"}

package/dist/lean-to-extension/renderer.js

@@ -0,0 +1,34 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { NodeRenderer, useNodeEvents } from '@pascal-app/viewer';
+import { useLayoutEffect, useRef } from 'react';
+import { resolveLeanToParentPose } from './layout';
+const LeanToExtensionRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const handlers = useNodeEvents(node, 'lean-to-extension');
+    const liveTransform = useLiveTransforms((state) => state.get(node.id));
+    const liveOverride = useLiveNodeOverrides((state) => state.overrides.get(node.id));
+    const parent = useScene((state) => node.parentId ? state.nodes[node.parentId] : undefined);
+    useRegistry(node.id, node.type, ref);
+    useLayoutEffect(() => {
+        useScene.getState().markDirty(node.id);
+    }, [node.id]);
+    const overridePosition = liveOverride?.position;
+    const overrideRotation = liveOverride?.rotation;
+    const overrideVisible = liveOverride?.visible;
+    const effectiveNode = {
+        ...node,
+        position: liveTransform?.position ?? overridePosition ?? node.position,
+        rotation: [
+            overrideRotation?.[0] ?? node.rotation[0],
+            liveTransform?.rotation ?? overrideRotation?.[1] ?? node.rotation[1],
+            overrideRotation?.[2] ?? node.rotation[2],
+        ],
+    };
+    const pose = parent?.type === 'wall'
+        ? resolveLeanToParentPose(parent, effectiveNode)
+        : { position: effectiveNode.position, rotationY: effectiveNode.rotation[1] };
+    return (_jsx("group", { position: pose.position, ref: ref, rotation: [effectiveNode.rotation[0], pose.rotationY, effectiveNode.rotation[2]], visible: typeof overrideVisible === 'boolean' ? overrideVisible : effectiveNode.visible !== false, ...handlers, children: effectiveNode.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`))) }));
+};
+export default LeanToExtensionRenderer;

package/dist/lean-to-extension/roof-attachment.d.ts

@@ -0,0 +1,28 @@
+import { type AnyNode, type AnyNodeId, type LeanToExtensionNode, type LeanToRoofEdge, type RoofNode, type RoofSegmentNode, type WallNode } from '@pascal-app/core';
+export type LeanToRoofAttachment = {
+    roofId: RoofNode['id'];
+    roofSegmentId: RoofSegmentNode['id'];
+    edge: LeanToRoofEdge;
+    edgeRange: readonly [number, number];
+    highEdgeHeight: number;
+    planDistance: number;
+    overlap: number;
+    edgeSpan: number;
+    wallLocalCenterX: number;
+    deckThickness: number;
+    shingleThickness: number;
+};
+type ResolveOptions = {
+    roofSegmentId?: string;
+    edge?: LeanToRoofEdge;
+};
+export declare function resolveLeanToRoofAttachment(leanTo: LeanToExtensionNode, wall: WallNode, nodes: Record<AnyNodeId, AnyNode>, options?: ResolveOptions): LeanToRoofAttachment | null;
+export declare function applyLeanToRoofAttachment(leanTo: LeanToExtensionNode, attachment: LeanToRoofAttachment): LeanToExtensionNode;
+export declare function applyLeanToWallAutoSpan(leanTo: LeanToExtensionNode, wall: WallNode): LeanToExtensionNode;
+export declare function applyLeanToWallCornerSpan(leanTo: LeanToExtensionNode, wall: WallNode): LeanToExtensionNode;
+export declare function applyLeanToAvailableWallSpan(leanTo: LeanToExtensionNode, wall: WallNode, nodes: Record<AnyNodeId, AnyNode>, targetWallX: number): LeanToExtensionNode;
+export declare function detachLeanToFromRoof(leanTo: LeanToExtensionNode): LeanToExtensionNode;
+export declare function clearLeanToRoofAttachment(leanTo: LeanToExtensionNode): LeanToExtensionNode;
+export declare function resolveLeanToHostRoof(leanTo: LeanToExtensionNode, nodes: Record<AnyNodeId, AnyNode>): RoofNode | undefined;
+export {};
+//# sourceMappingURL=roof-attachment.d.ts.map

package/dist/lean-to-extension/roof-attachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-attachment.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/roof-attachment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAMd,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAYzB,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,aAAa,EAAE,eAAe,CAAC,IAAI,CAAC,CAAA;IACpC,IAAI,EAAE,cAAc,CAAA;IACpB,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,IAAI,CAAC,EAAE,cAAc,CAAA;CACtB,CAAA;AA2KD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,GAAE,cAAmB,GAC3B,oBAAoB,GAAG,IAAI,CA4G7B;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,UAAU,EAAE,oBAAoB,GAC/B,mBAAmB,CAuBrB;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,QAAQ,GACb,mBAAmB,CAUrB;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,QAAQ,GACb,mBAAmB,CA4BrB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,WAAW,EAAE,MAAM,GAClB,mBAAmB,CAgDrB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,CAUrF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,CAU1F;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,QAAQ,GAAG,SAAS,CAGtB"}