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

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

@@ -0,0 +1,93 @@
+import { isManagedLeanToNode, isManagedLeanToPost, leanToCanopyCornerPostLayoutPatch, leanToCornerPostIndex, leanToCornerPostLayoutPatch, leanToDownspoutLayoutPatch, leanToGutterLayoutPatch, leanToPostLayoutPatch, leanToRoofSegmentLayoutPatch, managedLeanToPostIndex, managedLeanToPostSide, managedLeanToRoofPlane, resolveLeanToPostBaseY, resolveLeanToPostBaseYAtLocalPosition, resolveLeanToPostGutterSetback, } from './assembly';
+import { resolveFreestandingCanopyJoints } from './canopy-joint';
+import { resolveLeanToCornerJoints } from './corner-joint';
+import { isDualSlopeLeanToCanopy } from './layout';
+export function leanToManagedPreviewOverrides(node, patch, sceneApi) {
+    const next = { ...node, ...patch };
+    const nodes = sceneApi.nodes();
+    const entries = [];
+    const wall = next.parentId ? nodes[next.parentId] : undefined;
+    const cornerJoints = resolveLeanToCornerJoints(next, wall?.type === 'wall' ? wall : undefined, nodes);
+    const canopyJoints = resolveFreestandingCanopyJoints(next, nodes);
+    for (const childId of next.children) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        if (child.type === 'column' && isManagedLeanToPost(child, next.id)) {
+            const index = managedLeanToPostIndex(child);
+            if (index === null)
+                continue;
+            const side = managedLeanToPostSide(child);
+            const cornerSide = index === leanToCornerPostIndex('left')
+                ? 'left'
+                : index === leanToCornerPostIndex('right')
+                    ? 'right'
+                    : null;
+            if (cornerSide) {
+                const gutterSetback = resolveLeanToPostGutterSetback(next, child);
+                const cornerJoint = cornerJoints[cornerSide];
+                const canopyJoint = canopyJoints[cornerSide];
+                const ungroundedPatch = cornerJoint
+                    ? leanToCornerPostLayoutPatch(next, cornerJoint, 0, gutterSetback)
+                    : canopyJoint
+                        ? leanToCanopyCornerPostLayoutPatch(next, canopyJoint, side, 0, gutterSetback)
+                        : null;
+                if (!ungroundedPatch)
+                    continue;
+                const baseY = resolveLeanToPostBaseYAtLocalPosition(next, wall?.type === 'wall' ? wall : undefined, nodes, ungroundedPatch.position);
+                entries.push([
+                    child.id,
+                    (cornerJoint
+                        ? leanToCornerPostLayoutPatch(next, cornerJoint, baseY, gutterSetback)
+                        : leanToCanopyCornerPostLayoutPatch(next, canopyJoint, side, baseY, gutterSetback)),
+                ]);
+                continue;
+            }
+            const baseY = wall?.type === 'wall' ? resolveLeanToPostBaseY(next, wall, nodes, index, side) : 0;
+            const gutterSetback = side === 'low' || (side === 'high' && isDualSlopeLeanToCanopy(next.canopyForm))
+                ? resolveLeanToPostGutterSetback(next, child)
+                : 0;
+            entries.push([
+                child.id,
+                leanToPostLayoutPatch(next, index, baseY, gutterSetback, side),
+            ]);
+            continue;
+        }
+        if (child.type !== 'roof' || !isManagedLeanToNode(child, next.id, 'roof'))
+            continue;
+        const segments = child.children
+            .map((id) => nodes[id])
+            .filter((candidate) => candidate?.type === 'roof-segment' &&
+            isManagedLeanToNode(candidate, next.id, 'roof-segment'));
+        const segment = segments.find((candidate) => managedLeanToRoofPlane(candidate) === 'primary');
+        for (const candidate of segments) {
+            const plane = managedLeanToRoofPlane(candidate);
+            const candidatePatch = leanToRoofSegmentLayoutPatch(next, nodes, plane);
+            entries.push([candidate.id, candidatePatch]);
+        }
+        if (!segment)
+            continue;
+        const nextSegment = {
+            ...segment,
+            ...leanToRoofSegmentLayoutPatch(next, nodes, 'primary'),
+        };
+        const gutter = segment.children
+            .map((id) => nodes[id])
+            .find((candidate) => candidate?.type === 'gutter' && isManagedLeanToNode(candidate, next.id, 'gutter'));
+        if (gutter?.type !== 'gutter')
+            continue;
+        const gutterPatch = leanToGutterLayoutPatch(nextSegment, next, gutter, nodes);
+        entries.push([gutter.id, gutterPatch]);
+        const nextGutter = { ...gutter, ...gutterPatch };
+        const downspout = segment.children
+            .map((id) => nodes[id])
+            .find((candidate) => candidate?.type === 'downspout' && isManagedLeanToNode(candidate, next.id, 'downspout'));
+        if (downspout?.type === 'downspout') {
+            entries.push([
+                downspout.id,
+                leanToDownspoutLayoutPatch(nextSegment, nextGutter, next, downspout),
+            ]);
+        }
+    }
+    return entries;
+}

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

@@ -0,0 +1,8 @@
+import { type LeanToExtensionNode, type SceneApi } from '@pascal-app/core';
+type MoveLeanToExtensionProps = {
+    node: LeanToExtensionNode;
+    sceneApi: SceneApi;
+};
+declare const MoveLeanToExtensionTool: ({ node, sceneApi }: MoveLeanToExtensionProps) => import("react").JSX.Element | null;
+export default MoveLeanToExtensionTool;
+//# sourceMappingURL=move-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAazB,KAAK,wBAAwB,GAAG;IAC9B,IAAI,EAAE,mBAAmB,CAAA;IACzB,QAAQ,EAAE,QAAQ,CAAA;CACnB,CAAA;AASD,QAAA,MAAM,uBAAuB,GAAI,oBAAoB,wBAAwB,uCA0N5E,CAAA;AAED,eAAe,uBAAuB,CAAA"}

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

@@ -0,0 +1,202 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, getLevelElevations, getWallBaseElevationForNodes, sceneRegistry, useLiveNodeOverrides, } from '@pascal-app/core';
+import { isGridSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
+import { useLayoutEffect, useState } from 'react';
+import { leanToExtensionGeometryKey } from './geometry';
+import { leanToWallLocalPose, resolveLeanToEdgeSnapTargets, resolveLeanToMoveProposal, } from './layout';
+import { moveLeanToAlongSlabEdge, resolveLeanToPlanPosition } from './placement';
+import { leanToPlacementConflicts, resolveLeanToEndAbutments } from './placement-validation';
+import LeanToExtensionPreview from './preview';
+const MoveLeanToExtensionTool = ({ node, sceneApi }) => {
+    const [preview, setPreview] = useState(null);
+    useLayoutEffect(() => {
+        const parent = node.parentId ? sceneApi.get(node.parentId) : undefined;
+        const wall = parent?.type === 'wall' ? parent : null;
+        const levelHosted = parent?.type === 'level' &&
+            (node.hostKind === 'freestanding' || node.hostKind === 'slab-edge');
+        if (!(wall || levelHosted))
+            return;
+        let lastPatch = null;
+        let dragStartLocalY = null;
+        const movedObject = sceneRegistry.nodes.get(node.id);
+        const movedObjectVisible = movedObject?.visible;
+        if (movedObject)
+            movedObject.visible = false;
+        const restoreRaycasts = [];
+        movedObject?.traverse((child) => {
+            const original = child.raycast;
+            child.raycast = () => { };
+            restoreRaycasts.push(() => {
+                child.raycast = original;
+            });
+        });
+        const liveOverrides = useLiveNodeOverrides.getState();
+        const previousVisibleOverride = liveOverrides.get(node.id)?.visible;
+        liveOverrides.set(node.id, { visible: false });
+        const resolveBaseY = () => {
+            if (!wall)
+                return 0;
+            const nodes = sceneApi.nodes();
+            const levelY = wall.parentId ? (getLevelElevations(nodes).get(wall.parentId)?.baseY ?? 0) : 0;
+            return levelY + getWallBaseElevationForNodes(wall, nodes);
+        };
+        const publishPatch = (patch, valid = true) => {
+            const candidate = { ...node, ...patch };
+            const pose = wall
+                ? leanToWallLocalPose(wall, candidate, resolveBaseY())
+                : { position: candidate.position, rotationY: candidate.rotation[1] };
+            setPreview((current) => ({
+                node: current &&
+                    leanToExtensionGeometryKey(current.node) === leanToExtensionGeometryKey(candidate)
+                    ? current.node
+                    : candidate,
+                ...pose,
+                valid,
+            }));
+            lastPatch = valid ? patch : null;
+            return valid ? patch : null;
+        };
+        publishPatch({});
+        const restoreSource = () => {
+            if (movedObject && movedObjectVisible !== undefined)
+                movedObject.visible = movedObjectVisible;
+            const overrides = useLiveNodeOverrides.getState();
+            if (previousVisibleOverride === undefined) {
+                overrides.clearFields(node.id, ['visible']);
+            }
+            else {
+                overrides.set(node.id, { visible: previousVisibleOverride });
+            }
+        };
+        const commit = () => {
+            if (!lastPatch)
+                return;
+            sceneApi.update(node.id, lastPatch);
+            triggerSFX('sfx:structure-build');
+            useEditor.getState().setMovingNode(null);
+        };
+        const cleanUp = () => {
+            restoreSource();
+            for (const restore of restoreRaycasts)
+                restore();
+            lastPatch = null;
+        };
+        if (wall) {
+            const resolvePatch = (event) => {
+                if (event.node.id !== wall.id)
+                    return null;
+                dragStartLocalY ??= event.localPosition[1];
+                const rawHighEdgeHeight = Math.max(0.8, Math.min(10, node.highEdgeHeight + event.localPosition[1] - dragStartLocalY));
+                const gridStep = !event.nativeEvent.altKey && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+                const nodes = sceneApi.nodes();
+                const proposal = resolveLeanToMoveProposal({
+                    node,
+                    wall,
+                    rawLocalX: event.localPosition[0],
+                    rawHighEdgeHeight,
+                    snapStep: gridStep,
+                    edgeSnapTargets: event.nativeEvent.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,
+                };
+                if (!event.nativeEvent.altKey &&
+                    leanToPlacementConflicts(candidate, wall, nodes).length > 0) {
+                    publishPatch(patch, false);
+                    return null;
+                }
+                return publishPatch(patch);
+            };
+            const onMove = (event) => {
+                resolvePatch(event);
+            };
+            const onClick = (event) => {
+                if (!resolvePatch(event))
+                    return;
+                event.stopPropagation();
+                commit();
+            };
+            emitter.on('wall:move', onMove);
+            emitter.on('wall:enter', onMove);
+            emitter.on('wall:click', onClick);
+            return () => {
+                emitter.off('wall:move', onMove);
+                emitter.off('wall:enter', onMove);
+                emitter.off('wall:click', onClick);
+                cleanUp();
+            };
+        }
+        if (parent?.type === 'level' &&
+            (node.hostKind === 'freestanding' || node.hostKind === 'slab-edge')) {
+            const resolvePatch = (event) => {
+                if (node.hostKind === 'slab-edge') {
+                    const resolved = moveLeanToAlongSlabEdge(node, [event.localPosition[0], event.localPosition[2]], sceneApi.nodes());
+                    if (!resolved)
+                        return null;
+                    return publishPatch({
+                        hostSlabEdgeT: resolved.hostSlabEdgeT,
+                        position: resolved.position,
+                        rotation: resolved.rotation,
+                        span: resolved.span,
+                        highEdgeHeight: resolved.highEdgeHeight,
+                        lowEdgeHeight: resolved.lowEdgeHeight,
+                    });
+                }
+                const step = !event.nativeEvent.altKey && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+                const snap = (value) => (step > 0 ? Math.round(value / step) * step : value);
+                return publishPatch({
+                    position: resolveLeanToPlanPosition(node, [
+                        snap(event.localPosition[0]),
+                        snap(event.localPosition[2]),
+                    ]),
+                });
+            };
+            const onMove = (event) => {
+                resolvePatch(event);
+            };
+            const onClick = (event) => {
+                if (!resolvePatch(event))
+                    return;
+                commit();
+            };
+            emitter.on('grid:move', onMove);
+            emitter.on('grid:click', onClick);
+            return () => {
+                emitter.off('grid:move', onMove);
+                emitter.off('grid:click', onClick);
+                cleanUp();
+            };
+        }
+        return cleanUp;
+    }, [node, sceneApi]);
+    if (!preview)
+        return null;
+    return (_jsx("group", { position: preview.position, rotation: [0, preview.rotationY, 0], children: _jsx(LeanToExtensionPreview, { invalid: !preview.valid, node: preview.node }) }));
+};
+export default MoveLeanToExtensionTool;

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

@@ -0,0 +1,2 @@
+export declare const leanToPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/paint.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,WAAW,4CAMtB,CAAA"}

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

@@ -0,0 +1,16 @@
+import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+const SLOT_IDS = new Set([
+    'flashing',
+    'ledger',
+    'beam',
+    'framing',
+    'posts',
+    'footings',
+]);
+export const leanToPaint = createSlotPaintCapability({
+    resolveRole: ({ hitObject }) => {
+        const slotId = hitObject?.userData?.slotId;
+        return typeof slotId === 'string' && SLOT_IDS.has(slotId) ? slotId : null;
+    },
+    applyPreview: previewGeometrySlot,
+});

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

@@ -0,0 +1,4 @@
+import type { LeanToExtensionNode, ParametricDescriptor } from '@pascal-app/core';
+export declare function deriveLeanToResizePatch(previous: LeanToExtensionNode, patch: Partial<LeanToExtensionNode>): Partial<LeanToExtensionNode>;
+export declare const leanToExtensionParametrics: ParametricDescriptor<LeanToExtensionNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAYjF,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAClC,OAAO,CAAC,mBAAmB,CAAC,CA4C9B;AAED,eAAO,MAAM,0BAA0B,EAAE,oBAAoB,CAAC,mBAAmB,CAmgBhF,CAAA"}