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

package/dist/lean-to-extension/canopy-joint.d.ts

@@ -0,0 +1,35 @@
+import { type AnyNode, type LeanToExtensionNode, type RoofSegmentTrim } from '@pascal-app/core';
+import type { LeanToCornerSide } from './corner-joint';
+export declare const FREESTANDING_CANOPY_JOINTS_KEY = "leanToFreestandingCanopyJoints";
+export type CanopySide = 'positive' | 'negative';
+export type FreestandingCanopyJoint = {
+    side: LeanToCornerSide;
+    kind: 'corner' | 'linear';
+    neighborId: string;
+    neighborSide: LeanToCornerSide;
+    innerCanopySide: CanopySide;
+    interiorAngle: number;
+    trimX: number;
+    trimZ: number;
+    gutterMitre: number;
+    sharedPostOwner: boolean;
+};
+export type CanopyRoofPlaneJointLayout = {
+    centerX: number;
+    trim: RoofSegmentTrim;
+    width: number;
+};
+export type CanopyGutterJointLayout = {
+    joints: Partial<Record<LeanToCornerSide, FreestandingCanopyJoint & {
+        gutterMitre: number;
+    }>>;
+    maxX: number;
+    minX: number;
+};
+export type FreestandingCanopyJointMetadata = Partial<Record<LeanToCornerSide, Pick<FreestandingCanopyJoint, 'kind' | 'innerCanopySide' | 'trimX' | 'trimZ' | 'gutterMitre' | 'sharedPostOwner'>>>;
+export declare function canopyCornerJointMetadata(joints: Partial<Record<LeanToCornerSide, FreestandingCanopyJoint>>): FreestandingCanopyJointMetadata;
+export declare function readFreestandingCanopyJointMetadata(leanTo: LeanToExtensionNode): FreestandingCanopyJointMetadata;
+export declare function resolveFreestandingCanopyJoints(leanTo: LeanToExtensionNode, nodes: Record<string, AnyNode> | undefined): Partial<Record<LeanToCornerSide, FreestandingCanopyJoint>>;
+export declare function resolveCanopyRoofPlaneJointLayout(leanTo: LeanToExtensionNode, nodes: Record<string, AnyNode> | undefined, planeSide: CanopySide): CanopyRoofPlaneJointLayout;
+export declare function resolveCanopyGutterJointLayout(leanTo: LeanToExtensionNode, nodes: Record<string, AnyNode> | undefined, planeSide: CanopySide): CanopyGutterJointLayout;
+//# sourceMappingURL=canopy-joint.d.ts.map

package/dist/lean-to-extension/canopy-joint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canopy-joint.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/canopy-joint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,mBAAmB,EAExB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAOtD,eAAO,MAAM,8BAA8B,mCAAmC,CAAA;AAI9E,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,CAAA;AAEhD,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,gBAAgB,CAAA;IACtB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,gBAAgB,CAAA;IAC9B,eAAe,EAAE,UAAU,CAAA;IAC3B,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,eAAe,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,uBAAuB,GAAG;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;IAC5F,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG,OAAO,CACnD,MAAM,CACJ,gBAAgB,EAChB,IAAI,CACF,uBAAuB,EACvB,MAAM,GAAG,iBAAiB,GAAG,OAAO,GAAG,OAAO,GAAG,aAAa,GAAG,iBAAiB,CACnF,CACF,CACF,CAAA;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,uBAAuB,CAAC,CAAC,GACjE,+BAA+B,CAcjC;AAED,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,mBAAmB,GAC1B,+BAA+B,CAOjC;AAkJD,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACzC,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,uBAAuB,CAAC,CAAC,CAoB5D;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,SAAS,EAAE,UAAU,GACpB,0BAA0B,CAsD5B;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,SAAS,EAAE,UAAU,GACpB,uBAAuB,CA0BzB"}

package/dist/lean-to-extension/canopy-joint.js

@@ -0,0 +1,234 @@
+import { normalizeRoofSegmentTrim, } from '@pascal-app/core';
+import { resolveLeanToLayout } from './layout';
+const ENDPOINT_TOLERANCE = 0.05;
+const PROFILE_TOLERANCE = 1e-4;
+const DIRECTION_TOLERANCE = 1e-6;
+export const FREESTANDING_CANOPY_JOINTS_KEY = 'leanToFreestandingCanopyJoints';
+export function canopyCornerJointMetadata(joints) {
+    const metadata = {};
+    for (const [side, joint] of Object.entries(joints)) {
+        if (!joint)
+            continue;
+        metadata[side] = {
+            kind: joint.kind,
+            innerCanopySide: joint.innerCanopySide,
+            trimX: joint.trimX,
+            trimZ: joint.trimZ,
+            gutterMitre: joint.gutterMitre,
+            sharedPostOwner: joint.sharedPostOwner,
+        };
+    }
+    return metadata;
+}
+export function readFreestandingCanopyJointMetadata(leanTo) {
+    const metadata = leanTo.metadata;
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return {};
+    const value = metadata[FREESTANDING_CANOPY_JOINTS_KEY];
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1];
+}
+function runAxis(node) {
+    return [Math.cos(node.rotation[1]), -Math.sin(node.rotation[1])];
+}
+function positiveCanopyAxis(node) {
+    return [Math.sin(node.rotation[1]), Math.cos(node.rotation[1])];
+}
+function endpoint(node, side) {
+    const axis = runAxis(node);
+    const sign = side === 'left' ? -1 : 1;
+    return [
+        node.position[0] + sign * axis[0] * (node.span / 2),
+        node.position[2] + sign * axis[1] * (node.span / 2),
+    ];
+}
+function inwardDirection(node, side) {
+    const axis = runAxis(node);
+    const sign = side === 'left' ? 1 : -1;
+    return [sign * axis[0], sign * axis[1]];
+}
+function distance(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+function sameRoofProfile(a, b) {
+    return (a.canopyForm === b.canopyForm &&
+        Math.abs(a.projection - b.projection) <= PROFILE_TOLERANCE &&
+        Math.abs(a.highOverhang - b.highOverhang) <= PROFILE_TOLERANCE &&
+        Math.abs(a.lowOverhang - b.lowOverhang) <= PROFILE_TOLERANCE &&
+        Math.abs(a.highEdgeHeight - b.highEdgeHeight) <= PROFILE_TOLERANCE &&
+        Math.abs(a.pitch - b.pitch) <= PROFILE_TOLERANCE &&
+        Math.abs(a.roofThickness - b.roofThickness) <= PROFILE_TOLERANCE);
+}
+function matchingEndpoint(candidate, point) {
+    const matches = ['left', 'right']
+        .map((side) => ({ distance: distance(endpoint(candidate, side), point), side }))
+        .filter((match) => match.distance <= ENDPOINT_TOLERANCE)
+        .sort((a, b) => a.distance - b.distance || a.side.localeCompare(b.side));
+    return matches[0] ?? null;
+}
+function jointAt(leanTo, side, candidate, neighborSide) {
+    const ownInward = inwardDirection(leanTo, side);
+    const neighborInward = inwardDirection(candidate, neighborSide);
+    const directionDot = Math.max(-1, Math.min(1, dot(ownInward, neighborInward)));
+    const interiorAngle = Math.acos(directionDot);
+    const layout = resolveLeanToLayout(leanTo);
+    const trimZ = layout.projection + Math.max(0, leanTo.lowOverhang);
+    if (interiorAngle >= Math.PI - DIRECTION_TOLERANCE) {
+        return {
+            side,
+            kind: 'linear',
+            neighborId: candidate.id,
+            neighborSide,
+            innerCanopySide: 'positive',
+            interiorAngle: Math.PI,
+            trimX: 0,
+            trimZ,
+            gutterMitre: 0,
+            sharedPostOwner: String(leanTo.id) < String(candidate.id),
+        };
+    }
+    if (interiorAngle <= DIRECTION_TOLERANCE)
+        return null;
+    const bisectorLength = Math.hypot(ownInward[0] + neighborInward[0], ownInward[1] + neighborInward[1]);
+    if (bisectorLength <= DIRECTION_TOLERANCE)
+        return null;
+    const bisector = [
+        (ownInward[0] + neighborInward[0]) / bisectorLength,
+        (ownInward[1] + neighborInward[1]) / bisectorLength,
+    ];
+    const lateral = dot(bisector, positiveCanopyAxis(leanTo));
+    if (Math.abs(lateral) <= DIRECTION_TOLERANCE)
+        return null;
+    const trimX = Math.abs((dot(bisector, runAxis(leanTo)) / lateral) * trimZ);
+    if (!Number.isFinite(trimX))
+        return null;
+    return {
+        side,
+        kind: 'corner',
+        neighborId: candidate.id,
+        neighborSide,
+        innerCanopySide: lateral > 0 ? 'positive' : 'negative',
+        interiorAngle,
+        trimX,
+        trimZ,
+        gutterMitre: -(Math.PI - interiorAngle) / 2,
+        sharedPostOwner: String(leanTo.id) < String(candidate.id),
+    };
+}
+function compatibleCanopyCandidates(leanTo, nodes) {
+    return Object.values(nodes).filter((candidate) => candidate.type === 'lean-to-extension' &&
+        candidate.id !== leanTo.id &&
+        candidate.parentId === leanTo.parentId &&
+        candidate.hostKind === 'freestanding' &&
+        candidate.autoMiterCorners &&
+        sameRoofProfile(leanTo, candidate));
+}
+function rankedJointMatches(leanTo, side, candidates) {
+    const ownEndpoint = endpoint(leanTo, side);
+    return candidates
+        .flatMap((candidate) => {
+        const match = matchingEndpoint(candidate, ownEndpoint);
+        if (!match)
+            return [];
+        const joint = jointAt(leanTo, side, candidate, match.side);
+        return joint ? [{ candidate, joint, ...match }] : [];
+    })
+        .sort((a, b) => a.distance - b.distance ||
+        String(a.candidate.id).localeCompare(String(b.candidate.id)) ||
+        a.side.localeCompare(b.side));
+}
+export function resolveFreestandingCanopyJoints(leanTo, nodes) {
+    if (!nodes || leanTo.hostKind !== 'freestanding' || !leanTo.autoMiterCorners)
+        return {};
+    const candidates = compatibleCanopyCandidates(leanTo, nodes);
+    const joints = {};
+    for (const side of ['left', 'right']) {
+        const matches = rankedJointMatches(leanTo, side, candidates);
+        for (const match of matches) {
+            const reciprocal = rankedJointMatches(match.candidate, match.side, [
+                ...compatibleCanopyCandidates(match.candidate, nodes),
+                ...(sameRoofProfile(leanTo, match.candidate) ? [leanTo] : []),
+            ])[0];
+            if (reciprocal?.candidate.id !== leanTo.id || reciprocal.side !== side)
+                continue;
+            joints[side] = match.joint;
+            break;
+        }
+    }
+    return joints;
+}
+export function resolveCanopyRoofPlaneJointLayout(leanTo, nodes, planeSide) {
+    const layout = resolveLeanToLayout(leanTo);
+    const depth = layout.projection + Math.max(0, leanTo.lowOverhang);
+    const joints = resolveFreestandingCanopyJoints(leanTo, nodes);
+    const extensions = { left: 0, right: 0 };
+    const baseTrims = { left: 0, right: 0 };
+    const diagonals = [];
+    const flipsX = (leanTo.canopyForm === 'gable' && planeSide === 'negative') ||
+        (leanTo.canopyForm === 'butterfly' && planeSide === 'positive');
+    const outerEdge = leanTo.canopyForm === 'gable' ? 'front' : 'back';
+    for (const [side, joint] of Object.entries(joints)) {
+        const overhang = side === 'left' ? leanTo.leftOverhang : leanTo.rightOverhang;
+        const segmentSide = flipsX ? (side === 'left' ? 'right' : 'left') : side;
+        if (joint.kind === 'linear') {
+            baseTrims[segmentSide] = overhang;
+            continue;
+        }
+        const inside = joint.innerCanopySide === planeSide;
+        if (inside) {
+            baseTrims[segmentSide] = overhang;
+        }
+        else {
+            const extension = joint.trimX - overhang;
+            if (extension >= 0)
+                extensions[side] = extension;
+            else
+                baseTrims[segmentSide] = -extension;
+        }
+        diagonals.push({
+            edge: inside ? outerEdge : outerEdge === 'front' ? 'back' : 'front',
+            segmentSide,
+            trimX: joint.trimX,
+            trimZ: joint.trimZ,
+        });
+    }
+    const width = layout.roofWidth + extensions.left + extensions.right;
+    const centerX = layout.roofCenterX + (extensions.right - extensions.left) / 2;
+    const trim = normalizeRoofSegmentTrim({ width, depth });
+    trim.left = baseTrims.left;
+    trim.right = baseTrims.right;
+    for (const diagonal of diagonals) {
+        const corner = `${diagonal.edge}${diagonal.segmentSide === 'left' ? 'Left' : 'Right'}`;
+        trim[`${corner}X`] = diagonal.trimX;
+        trim[`${corner}Z`] = diagonal.trimZ;
+    }
+    return { centerX, trim, width };
+}
+export function resolveCanopyGutterJointLayout(leanTo, nodes, planeSide) {
+    const joints = resolveFreestandingCanopyJoints(leanTo, nodes);
+    const resolvedJoints = {};
+    let minX = -leanTo.span / 2 - leanTo.leftOverhang;
+    let maxX = leanTo.span / 2 + leanTo.rightOverhang;
+    for (const [side, joint] of Object.entries(joints)) {
+        const butterfly = leanTo.canopyForm === 'butterfly';
+        const inside = joint.innerCanopySide === planeSide;
+        const endpointX = side === 'left' ? -leanTo.span / 2 : leanTo.span / 2;
+        const direction = side === 'left' ? -1 : 1;
+        const boundaryX = butterfly
+            ? endpointX
+            : endpointX + direction * (inside ? -joint.trimX : joint.trimX);
+        if (side === 'left')
+            minX = boundaryX;
+        else
+            maxX = boundaryX;
+        resolvedJoints[side] = {
+            ...joint,
+            gutterMitre: inside || butterfly ? joint.gutterMitre : -joint.gutterMitre,
+        };
+    }
+    return { joints: resolvedJoints, maxX, minX };
+}

package/dist/lean-to-extension/conical-host.d.ts

@@ -0,0 +1,15 @@
+import { type AnyNode, type AnyNodeId, LeanToExtensionNode, type RoofSegmentNode } from '@pascal-app/core';
+export type ConicalLeanToPlanHost = {
+    segment: RoofSegmentNode;
+    center: [number, number];
+    rotationY: number;
+    node: LeanToExtensionNode;
+};
+export declare function isClosedLoopLeanTo(leanTo: Pick<LeanToExtensionNode, 'hostKind'>): boolean;
+export declare function isConicalLeanToHostOccupied(segmentId: RoofSegmentNode['id'], nodes: Record<AnyNodeId, AnyNode>): boolean;
+export declare function resolveConicalLeanToPlacement(segment: RoofSegmentNode, source?: Partial<LeanToExtensionNode>): LeanToExtensionNode | null;
+export declare function resolveConicalLeanToSurfaceHit(segment: RoofSegmentNode, localPosition: readonly [number, number, number], normal?: readonly [number, number, number]): LeanToExtensionNode | null;
+export declare function findConicalLeanToHostInPlan(point: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, activeLevelId: AnyNodeId, options?: {
+    includeOccupied?: boolean;
+}): ConicalLeanToPlanHost | null;
+//# sourceMappingURL=conical-host.d.ts.map

package/dist/lean-to-extension/conical-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conical-host.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/conical-host.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,mBAAmB,EACnB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAKzB,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,eAAe,CAAA;IACxB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,mBAAmB,CAAA;CAC1B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,GAAG,OAAO,CAEzF;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,eAAe,CAAC,IAAI,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,OAAO,CAOT;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,eAAe,EACxB,MAAM,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACxC,mBAAmB,GAAG,IAAI,CAuC5B;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,eAAe,EACxB,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAChD,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACzC,mBAAmB,GAAG,IAAI,CAY5B;AAgCD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,EACxB,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,qBAAqB,GAAG,IAAI,CAiB9B"}

package/dist/lean-to-extension/conical-host.js

@@ -0,0 +1,113 @@
+import { findLevelAncestorId, LeanToExtensionNode, } from '@pascal-app/core';
+const CONICAL_WALL_HIT_TOLERANCE = 0.15;
+const CONICAL_PLAN_HIT_TOLERANCE = 0.35;
+export function isClosedLoopLeanTo(leanTo) {
+    return leanTo.hostKind === 'conical-roof';
+}
+export function isConicalLeanToHostOccupied(segmentId, nodes) {
+    return Object.values(nodes).some((node) => node.type === 'lean-to-extension' &&
+        node.hostKind === 'conical-roof' &&
+        node.parentId === segmentId);
+}
+export function resolveConicalLeanToPlacement(segment, source = {}) {
+    if (segment.roofType !== 'conical')
+        return null;
+    const radius = segment.width / 2;
+    const hostHeightOffset = source.hostHeightOffset ?? 0;
+    const highEdgeHeight = Math.max(0.8, Math.min(10, segment.wallHeight + hostHeightOffset));
+    const projection = source.projection ?? LeanToExtensionNode.shape.projection.parse(undefined);
+    const pitch = source.pitch ?? LeanToExtensionNode.shape.pitch.parse(undefined);
+    const lowEdgeHeight = highEdgeHeight - projection * Math.tan((pitch * Math.PI) / 180);
+    const parsed = LeanToExtensionNode.parse({
+        ...source,
+        parentId: segment.id,
+        hostKind: 'conical-roof',
+        hostHeightOffset,
+        position: [0, 0, radius],
+        rotation: [0, 0, 0],
+        span: 2 * Math.PI * radius,
+        autoSpan: true,
+        spanArcCenterZ: -radius,
+        spanArcRadius: radius,
+        highEdgeHeight,
+        lowEdgeHeight,
+        connectionMode: 'manual',
+        leftEndCondition: 'joined',
+        rightEndCondition: 'joined',
+        autoMiterCorners: false,
+        sideFlashing: false,
+        leftOverhang: 0,
+        rightOverhang: 0,
+    });
+    return {
+        ...parsed,
+        hostRoofId: undefined,
+        hostRoofSegmentId: undefined,
+        hostRoofEdge: undefined,
+        hostRoofEdgeRange: undefined,
+        connectionInset: 0,
+    };
+}
+export function resolveConicalLeanToSurfaceHit(segment, localPosition, normal) {
+    if (segment.roofType !== 'conical' || !normal)
+        return null;
+    const radius = segment.width / 2;
+    const radialDistance = Math.hypot(localPosition[0], localPosition[2]);
+    const hitsCylinderHeight = localPosition[1] >= -CONICAL_WALL_HIT_TOLERANCE &&
+        localPosition[1] <= segment.wallHeight + CONICAL_WALL_HIT_TOLERANCE;
+    const hitsCylinderRadius = Math.abs(radialDistance - radius) <= CONICAL_WALL_HIT_TOLERANCE;
+    const hasHorizontalNormal = Math.abs(normal[1]) <= 0.35;
+    return hitsCylinderHeight && hitsCylinderRadius && hasHorizontalNormal
+        ? resolveConicalLeanToPlacement(segment)
+        : null;
+}
+function resolveSegmentPlanPose(segment, nodes, activeLevelId) {
+    if (findLevelAncestorId(segment.id, nodes) !== activeLevelId)
+        return null;
+    const chain = [];
+    let current = segment;
+    const seen = new Set();
+    while (current && current.id !== activeLevelId && !seen.has(current.id)) {
+        seen.add(current.id);
+        chain.push(current);
+        current = current.parentId ? nodes[current.parentId] : undefined;
+    }
+    let x = 0;
+    let z = 0;
+    let rotationY = 0;
+    for (const node of chain.reverse()) {
+        if (node.type !== 'roof' && node.type !== 'roof-segment')
+            continue;
+        const cos = Math.cos(rotationY);
+        const sin = Math.sin(rotationY);
+        x += node.position[0] * cos + node.position[2] * sin;
+        z += -node.position[0] * sin + node.position[2] * cos;
+        rotationY += node.rotation;
+    }
+    return { center: [x, z], rotationY };
+}
+export function findConicalLeanToHostInPlan(point, nodes, activeLevelId, options) {
+    let closest = null;
+    for (const candidate of Object.values(nodes)) {
+        if (candidate.type !== 'roof-segment' || candidate.roofType !== 'conical')
+            continue;
+        if (!options?.includeOccupied && isConicalLeanToHostOccupied(candidate.id, nodes))
+            continue;
+        const pose = resolveSegmentPlanPose(candidate, nodes, activeLevelId);
+        if (!pose)
+            continue;
+        const distance = Math.hypot(point[0] - pose.center[0], point[1] - pose.center[1]);
+        if (distance > candidate.width / 2 + CONICAL_PLAN_HIT_TOLERANCE)
+            continue;
+        if (closest && distance >= closest.distance)
+            continue;
+        const node = resolveConicalLeanToPlacement(candidate);
+        if (!node)
+            continue;
+        closest = { segment: candidate, ...pose, node, distance };
+    }
+    if (!closest)
+        return null;
+    const { distance: _distance, ...host } = closest;
+    return host;
+}

package/dist/lean-to-extension/corner-joint.d.ts

@@ -0,0 +1,29 @@
+import { type AnyNode, type LeanToExtensionNode, WallNode } from '@pascal-app/core';
+export type LeanToCornerSide = 'left' | 'right';
+export type LeanToPlanPoint = [number, number];
+export type LeanToCornerKind = 'convex' | 'concave' | 'linear';
+export type LeanToFramingRetainedSide = 'front' | 'back';
+export type LeanToCornerJoint = {
+    side: LeanToCornerSide;
+    kind: LeanToCornerKind;
+    neighborId: string;
+    neighborSide: LeanToCornerSide;
+    roofExtension: number;
+    roofPiece: LeanToPlanPoint[];
+    roofPieces?: LeanToPlanPoint[][];
+    roofAdditionPieces?: LeanToPlanPoint[][];
+    mergeRoofPieces?: boolean;
+    seam: [LeanToPlanPoint, LeanToPlanPoint] | null;
+    framingRetainedSide?: LeanToFramingRetainedSide;
+    beamExtension: number;
+    gutterMitre: number;
+    sharedPostOwner: boolean;
+    sharedPostPosition: [number, number, number];
+};
+export declare const LEAN_TO_CORNER_JOINTS_KEY = "leanToCornerJoints";
+export declare function applyLeanToCornerRoofPieces(base: LeanToPlanPoint[], joints: Partial<Record<LeanToCornerSide, LeanToCornerJoint>>): LeanToPlanPoint[][];
+export declare function resolveLeanToCornerJoints(leanTo: LeanToExtensionNode, wall: WallNode | undefined, nodes: Record<string, AnyNode> | undefined): Partial<Record<LeanToCornerSide, LeanToCornerJoint>>;
+export type LeanToCornerJointMetadata = Partial<Record<LeanToCornerSide, Pick<LeanToCornerJoint, 'beamExtension' | 'gutterMitre' | 'seam' | 'framingRetainedSide' | 'sharedPostOwner'>>>;
+export declare function leanToCornerJointMetadata(joints: Partial<Record<LeanToCornerSide, LeanToCornerJoint>>): LeanToCornerJointMetadata;
+export declare function readLeanToCornerJointMetadata(leanTo: LeanToExtensionNode): LeanToCornerJointMetadata;
+//# sourceMappingURL=corner-joint.d.ts.map

package/dist/lean-to-extension/corner-joint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-joint.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/corner-joint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,mBAAmB,EAAiB,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAMlG,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAAA;AAC/C,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC9C,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAA;AAC9D,MAAM,MAAM,yBAAyB,GAAG,OAAO,GAAG,MAAM,CAAA;AAExD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,gBAAgB,CAAA;IACtB,IAAI,EAAE,gBAAgB,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,gBAAgB,CAAA;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,eAAe,EAAE,CAAA;IAC5B,UAAU,CAAC,EAAE,eAAe,EAAE,EAAE,CAAA;IAChC,kBAAkB,CAAC,EAAE,eAAe,EAAE,EAAE,CAAA;IACxC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,IAAI,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,GAAG,IAAI,CAAA;IAC/C,mBAAmB,CAAC,EAAE,yBAAyB,CAAA;IAC/C,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,OAAO,CAAA;IACxB,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,yBAAyB,uBAAuB,CAAA;AAojC7D,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EAAE,EACvB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,GAC3D,eAAe,EAAE,EAAE,CAsCrB;AAmMD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACzC,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,CAoUtD;AAED,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAC7C,MAAM,CACJ,gBAAgB,EAChB,IAAI,CACF,iBAAiB,EACjB,eAAe,GAAG,aAAa,GAAG,MAAM,GAAG,qBAAqB,GAAG,iBAAiB,CACrF,CACF,CACF,CAAA;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,GAC3D,yBAAyB,CAe3B;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,GAC1B,yBAAyB,CAO3B"}