@pascal-app/nodes 0.1.1

package/dist/fence/move-tool.js

@@ -0,0 +1,271 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { constrainWallMoveDeltaToAxis, emitter, getPerpendicularWallMoveAxis, isCurvedWall, isSplineFence, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, snapFenceDraftPoint, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * Phase 5 Stage D — fence whole-move tool.
+ *
+ * Live-drag pattern: preview data-driven reshapes through live node
+ * overrides. On commit we write the final position once for a single undo
+ * step.
+ * Straight fences use `constrainWallMoveDeltaToAxis` to keep side-moves
+ * perpendicular; curved fences translate freely because their path shape
+ * already carries direction.
+ *
+ * Wired via `def.affordanceTools.move`. The editor's `MoveTool`
+ * dispatcher picks this up before its legacy chain.
+ */
+function samePoint(a, b) {
+    return a[0] === b[0] && a[1] === b[1];
+}
+function getLinkedFenceSnapshots(args) {
+    const { fenceId, fenceParentId, originalStart, originalEnd } = args;
+    const { nodes } = useScene.getState();
+    const snapshots = [];
+    for (const node of Object.values(nodes)) {
+        if (!(node?.type === 'fence' && node.id !== fenceId))
+            continue;
+        if ((node.parentId ?? null) !== fenceParentId)
+            continue;
+        if (!(samePoint(node.start, originalStart) ||
+            samePoint(node.start, originalEnd) ||
+            samePoint(node.end, originalStart) ||
+            samePoint(node.end, originalEnd)))
+            continue;
+        snapshots.push({
+            id: node.id,
+            start: [...node.start],
+            end: [...node.end],
+            path: node.path?.map((point) => [...point]),
+        });
+    }
+    return snapshots;
+}
+function translatePath(path, deltaX, deltaZ) {
+    return path?.map((point) => [point[0] + deltaX, point[1] + deltaZ]);
+}
+function projectLinkedPath(path, start, end) {
+    if (!path || path.length === 0)
+        return path;
+    const nextPath = path.map((point) => [...point]);
+    nextPath[0] = start;
+    nextPath[nextPath.length - 1] = end;
+    return nextPath;
+}
+function getLinkedFenceUpdates(linkedFences, originalStart, originalEnd, nextStart, nextEnd) {
+    return linkedFences.map((fence) => {
+        const start = samePoint(fence.start, originalStart)
+            ? nextStart
+            : samePoint(fence.start, originalEnd)
+                ? nextEnd
+                : fence.start;
+        const end = samePoint(fence.end, originalStart)
+            ? nextStart
+            : samePoint(fence.end, originalEnd)
+                ? nextEnd
+                : fence.end;
+        return {
+            id: fence.id,
+            start,
+            end,
+            path: projectLinkedPath(fence.path, start, end),
+        };
+    });
+}
+export const MoveFenceTool = ({ node }) => {
+    const activatedAtRef = useRef(Date.now());
+    const previousGridPosRef = useRef(null);
+    const originalStartRef = useRef([...node.start]);
+    const originalEndRef = useRef([...node.end]);
+    const originalPathRef = useRef(node.path?.map((point) => [...point]));
+    const meta = typeof node.metadata === 'object' && node.metadata !== null && !Array.isArray(node.metadata)
+        ? node.metadata
+        : {};
+    const isNew = !!meta.isNew;
+    const linkedOriginalsRef = useRef(isNew
+        ? []
+        : getLinkedFenceSnapshots({
+            fenceId: node.id,
+            fenceParentId: node.parentId ?? null,
+            originalStart: node.start,
+            originalEnd: node.end,
+        }));
+    const dragAnchorRef = useRef(null);
+    const previewRef = useRef(null);
+    const canMoveFreely = isSplineFence(node) || isCurvedWall(node);
+    const moveAxisRef = useRef(canMoveFreely ? null : getPerpendicularWallMoveAxis(node.start, node.end));
+    const [cursorLocalPos, setCursorLocalPos] = useState(() => {
+        const centerX = (node.start[0] + node.end[0]) / 2;
+        const centerZ = (node.start[1] + node.end[1]) / 2;
+        return [centerX, 0, centerZ];
+    });
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    useEffect(() => {
+        const fenceId = node.id;
+        const originalStart = originalStartRef.current;
+        const originalEnd = originalEndRef.current;
+        const levelNode = node.parentId && useScene.getState().nodes[node.parentId]?.type === 'level'
+            ? useScene.getState().nodes[node.parentId]
+            : null;
+        const levelChildren = levelNode?.children ?? [];
+        const levelWalls = levelChildren
+            .map((childId) => useScene.getState().nodes[childId])
+            .filter((child) => child?.type === 'wall');
+        const levelFences = levelChildren
+            .map((childId) => useScene.getState().nodes[childId])
+            .filter((child) => child?.type === 'fence');
+        useScene.temporal.getState().pause();
+        let wasCommitted = false;
+        const applyNodePreview = (updates) => {
+            useLiveNodeOverrides
+                .getState()
+                .setMany(updates.map((entry) => [
+                entry.id,
+                { start: entry.start, end: entry.end, path: entry.path },
+            ]));
+            for (const entry of updates) {
+                useScene.getState().markDirty(entry.id);
+            }
+        };
+        const applyCommittedUpdates = (updates) => {
+            useScene.getState().updateNodes(updates.map((entry) => ({
+                id: entry.id,
+                data: { start: entry.start, end: entry.end, path: entry.path },
+            })));
+            for (const entry of updates) {
+                useScene.getState().markDirty(entry.id);
+            }
+        };
+        const restoreOriginal = () => {
+            const overrides = useLiveNodeOverrides.getState();
+            overrides.clear(fenceId);
+            for (const linkedFence of linkedOriginalsRef.current) {
+                overrides.clear(linkedFence.id);
+            }
+            useScene.getState().markDirty(fenceId);
+            for (const linkedFence of linkedOriginalsRef.current) {
+                useScene.getState().markDirty(linkedFence.id);
+            }
+        };
+        const applyPreview = (nextStart, nextEnd) => {
+            const deltaX = nextStart[0] - originalStart[0];
+            const deltaZ = nextStart[1] - originalStart[1];
+            const nextPath = translatePath(originalPathRef.current, deltaX, deltaZ);
+            previewRef.current = { start: nextStart, end: nextEnd, path: nextPath };
+            const centerX = (nextStart[0] + nextEnd[0]) / 2;
+            const centerZ = (nextStart[1] + nextEnd[1]) / 2;
+            setCursorLocalPos([centerX, 0, centerZ]);
+            const previewUpdates = [
+                { id: fenceId, start: nextStart, end: nextEnd, path: nextPath },
+                ...getLinkedFenceUpdates(linkedOriginalsRef.current, originalStart, originalEnd, nextStart, nextEnd),
+            ];
+            applyNodePreview(previewUpdates);
+        };
+        const onGridMove = (event) => {
+            const gridSnapActive = isGridSnapActive();
+            const magneticSnapActive = isMagneticSnapActive();
+            const [localX, localZ] = snapFenceDraftPoint({
+                point: [event.localPosition[0], event.localPosition[2]],
+                walls: levelWalls,
+                fences: levelFences,
+                ignoreFenceIds: [fenceId],
+                magnetic: magneticSnapActive,
+                step: gridSnapActive ? getSegmentGridStep() : 0,
+            });
+            if ((gridSnapActive || magneticSnapActive) &&
+                previousGridPosRef.current &&
+                (localX !== previousGridPosRef.current[0] || localZ !== previousGridPosRef.current[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousGridPosRef.current = [localX, localZ];
+            const anchor = dragAnchorRef.current ?? [localX, localZ];
+            dragAnchorRef.current = anchor;
+            const rawDeltaX = localX - anchor[0];
+            const rawDeltaZ = localZ - anchor[1];
+            const [deltaX, deltaZ] = canMoveFreely
+                ? [rawDeltaX, rawDeltaZ]
+                : constrainWallMoveDeltaToAxis(rawDeltaX, rawDeltaZ, moveAxisRef.current);
+            const nextStart = [originalStart[0] + deltaX, originalStart[1] + deltaZ];
+            const nextEnd = [originalEnd[0] + deltaX, originalEnd[1] + deltaZ];
+            applyPreview(nextStart, nextEnd);
+        };
+        const onGridClick = (event) => {
+            if (wasCommitted)
+                return;
+            if (Date.now() - activatedAtRef.current < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            wasCommitted = true;
+            const preview = previewRef.current;
+            if (!preview) {
+                exitMoveMode();
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            useScene.temporal.getState().resume();
+            applyCommittedUpdates([
+                { id: fenceId, start: preview.start, end: preview.end, path: preview.path },
+                ...getLinkedFenceUpdates(linkedOriginalsRef.current, originalStart, originalEnd, preview.start, preview.end),
+            ]);
+            restoreOriginal();
+            useScene.temporal.getState().pause();
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [fenceId] });
+            exitMoveMode();
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            activatedAtRef.current = 0;
+            onGridClick({ nativeEvent: event });
+        };
+        const onCancel = () => {
+            restoreOriginal();
+            useViewer.getState().setSelection({ selectedIds: [fenceId] });
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            // Claim teardown ownership so the 2D overlay doesn't redundantly
+            // revert the same baseline on its own cleanup. Mirrors wall's
+            // move-tool cancel path.
+            useEditor.getState().setMovingNodeOrigin('3d');
+            exitMoveMode();
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            if (!wasCommitted) {
+                // The 2D `FloorplanRegistryMoveOverlay` mounts in parallel with
+                // this 3D tool whenever the user enters fence move mode from the
+                // floor plan. When the 2D overlay commits via
+                // `fenceFloorplanMoveTarget.commit()` it calls
+                // `setMovingNode(null)`, which unmounts this tool. Our local
+                // `wasCommitted` is still false (its own `onGridClick` never
+                // ran), so a blind `restoreOriginal()` here would overwrite the
+                // just-committed new positions back to the originals — the
+                // "fence reverts on commit" symptom users see in the 2D view.
+                // The 2D overlay sets `movingNodeOrigin = '2d'` before clearing
+                // movingNode; respect that flag and skip the restore. Mirrors
+                // the wall move-tool's `finalisedBy2D` guard.
+                const finalisedBy2D = useEditor.getState().movingNodeOrigin === '2d';
+                if (!finalisedBy2D) {
+                    restoreOriginal();
+                }
+            }
+            useScene.temporal.getState().resume();
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+        };
+    }, [exitMoveMode, node, canMoveFreely]);
+    return (_jsx("group", { children: _jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }) }));
+};
+export default MoveFenceTool;

package/dist/fence/paint.d.ts

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

package/dist/fence/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/fence/paint.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU,4CAUrB,CAAA"}

package/dist/fence/paint.js

@@ -0,0 +1,17 @@
+import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+const FENCE_SLOT_IDS = new Set(['posts', 'infill', 'base', 'rail']);
+function resolveFenceRole(args) {
+    const slotId = args.hitObject?.userData?.slotId;
+    return typeof slotId === 'string' && FENCE_SLOT_IDS.has(slotId) ? slotId : null;
+}
+export const fencePaint = createSlotPaintCapability({
+    resolveRole: resolveFenceRole,
+    applyPreview: previewGeometrySlot,
+    legacyEffective: (node) => {
+        const fence = node;
+        if (fence.materialPreset || fence.material) {
+            return { material: fence.material, materialPreset: fence.materialPreset };
+        }
+        return null;
+    },
+});

package/dist/fence/parametrics.d.ts

@@ -0,0 +1,16 @@
+import { type ParametricDescriptor } from '@pascal-app/core';
+import type { FenceNode } from './schema';
+/**
+ * Inspector descriptor for fence. Mirrors the legacy `FencePanel`
+ * layout 1:1:
+ *  - **Style** (segmented controls): style, baseStyle, showInfill toggle.
+ *  - **Dimensions**: Length (derived from start/end), Curve (sagitta
+ *    with dynamic bounds), Height, Thickness.
+ *  - **Structure**: Base Height, Top Rail, Post Spacing, Post Size,
+ *    Post Cap + Slat Gap (horizontal-only), Ground Clear, Edge Inset.
+ *
+ * Length + Curve use the `custom` field kind because they don't map
+ * to single number fields with static bounds — see `inspector-editors.tsx`.
+ */
+export declare const fenceParametrics: ParametricDescriptor<FenceNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/fence/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/fence/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAuE5D,CAAA"}

package/dist/fence/parametrics.js

@@ -0,0 +1,86 @@
+import { isSplineFence } from '@pascal-app/core';
+import { FenceCurveEditor, FenceLengthEditor } from './inspector-editors';
+/**
+ * Inspector descriptor for fence. Mirrors the legacy `FencePanel`
+ * layout 1:1:
+ *  - **Style** (segmented controls): style, baseStyle, showInfill toggle.
+ *  - **Dimensions**: Length (derived from start/end), Curve (sagitta
+ *    with dynamic bounds), Height, Thickness.
+ *  - **Structure**: Base Height, Top Rail, Post Spacing, Post Size,
+ *    Post Cap + Slat Gap (horizontal-only), Ground Clear, Edge Inset.
+ *
+ * Length + Curve use the `custom` field kind because they don't map
+ * to single number fields with static bounds — see `inspector-editors.tsx`.
+ */
+export const fenceParametrics = {
+    groups: [
+        {
+            label: 'Style',
+            fields: [
+                {
+                    key: 'style',
+                    kind: 'enum',
+                    options: ['slat', 'rail', 'privacy', 'horizontal'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'baseStyle',
+                    kind: 'enum',
+                    options: ['grounded', 'floating'],
+                    display: 'segmented',
+                },
+                { key: 'showInfill', kind: 'boolean' },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                // Length / Curve drive start/end + the single sagitta — meaningless
+                // for a multi-point spline fence, so hide them when `path` is set.
+                {
+                    key: 'length',
+                    kind: 'custom',
+                    component: FenceLengthEditor,
+                    visibleIf: (n) => !isSplineFence(n),
+                },
+                {
+                    key: 'curve',
+                    kind: 'custom',
+                    component: FenceCurveEditor,
+                    visibleIf: (n) => !isSplineFence(n),
+                },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.4, max: 4, step: 0.05 },
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.03, max: 0.5, step: 0.005 },
+            ],
+        },
+        {
+            label: 'Structure',
+            fields: [
+                { key: 'baseHeight', kind: 'number', unit: 'm', min: 0.04, max: 1, step: 0.01 },
+                { key: 'topRailHeight', kind: 'number', unit: 'm', min: 0.01, max: 0.25, step: 0.005 },
+                { key: 'postSpacing', kind: 'number', unit: 'm', min: 0.05, max: 5, step: 0.01 },
+                { key: 'postSize', kind: 'number', unit: 'm', min: 0.01, max: 0.4, step: 0.005 },
+                {
+                    // Dropdown (not segmented) so the inspector renders its "Post Cap"
+                    // label — a bare segmented `None / Flat / Pyramid` switch reads
+                    // contextless.
+                    key: 'postCap',
+                    kind: 'enum',
+                    options: ['none', 'flat', 'pyramid'],
+                    visibleIf: (n) => n.style === 'horizontal',
+                },
+                {
+                    key: 'slatGap',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0,
+                    max: 0.1,
+                    step: 0.002,
+                    visibleIf: (n) => n.style === 'horizontal',
+                },
+                { key: 'groundClearance', kind: 'number', unit: 'm', min: 0, max: 0.6, step: 0.005 },
+                { key: 'edgeInset', kind: 'number', unit: 'm', min: 0.005, max: 0.25, step: 0.005 },
+            ],
+        },
+    ],
+};

package/dist/fence/schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fence schema re-export.
+ *
+ * Lives in `@pascal-app/core` for now (same as wall + door + window +
+ * spawn — the canonical schemas stay there until Phase 6 derives them
+ * from the registry). The registry definition consumes it here so the
+ * rest of the bundle imports a single canonical type.
+ */
+export { FenceNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/fence/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/fence/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/fence/schema.js

@@ -0,0 +1,9 @@
+/**
+ * Fence schema re-export.
+ *
+ * Lives in `@pascal-app/core` for now (same as wall + door + window +
+ * spawn — the canonical schemas stay there until Phase 6 derives them
+ * from the registry). The registry definition consumes it here so the
+ * rest of the bundle imports a single canonical type.
+ */
+export { FenceNode } from '@pascal-app/core';

package/dist/fence/slots.d.ts

@@ -0,0 +1,10 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+import type { FenceNode } from './schema';
+export type FenceSlotId = 'posts' | 'infill' | 'base' | 'rail';
+export declare const FENCE_POSTS_SLOT_DEFAULT = "library:preset-charcoal";
+export declare const FENCE_INFILL_SLOT_DEFAULT = "library:preset-charcoal";
+export declare const FENCE_BASE_SLOT_DEFAULT = "library:preset-greige";
+export declare const FENCE_RAIL_SLOT_DEFAULT = "library:preset-greige";
+export declare const FENCE_SLOT_DEFAULTS: Record<FenceSlotId, string>;
+export declare function fenceSlots(node: FenceNode): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

package/dist/fence/slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/fence/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAIzC,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAE9D,eAAO,MAAM,wBAAwB,4BAA4B,CAAA;AACjE,eAAO,MAAM,yBAAyB,4BAA4B,CAAA;AAClE,eAAO,MAAM,uBAAuB,0BAA0B,CAAA;AAC9D,eAAO,MAAM,uBAAuB,0BAA0B,CAAA;AAE9D,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAK3D,CAAA;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,EAAE,CAY7D"}

package/dist/fence/slots.js

@@ -0,0 +1,23 @@
+export const FENCE_POSTS_SLOT_DEFAULT = 'library:preset-charcoal';
+export const FENCE_INFILL_SLOT_DEFAULT = 'library:preset-charcoal';
+export const FENCE_BASE_SLOT_DEFAULT = 'library:preset-greige';
+export const FENCE_RAIL_SLOT_DEFAULT = 'library:preset-greige';
+export const FENCE_SLOT_DEFAULTS = {
+    posts: FENCE_POSTS_SLOT_DEFAULT,
+    infill: FENCE_INFILL_SLOT_DEFAULT,
+    base: FENCE_BASE_SLOT_DEFAULT,
+    rail: FENCE_RAIL_SLOT_DEFAULT,
+};
+export function fenceSlots(node) {
+    const slots = [
+        { slotId: 'posts', label: 'Posts', default: FENCE_POSTS_SLOT_DEFAULT },
+    ];
+    if (node.showInfill !== false) {
+        slots.push({ slotId: 'infill', label: 'Infill', default: FENCE_INFILL_SLOT_DEFAULT });
+    }
+    if (node.baseStyle !== 'floating') {
+        slots.push({ slotId: 'base', label: 'Base', default: FENCE_BASE_SLOT_DEFAULT });
+    }
+    slots.push({ slotId: 'rail', label: 'Rail', default: FENCE_RAIL_SLOT_DEFAULT });
+    return slots;
+}

package/dist/fence/tool.d.ts

@@ -0,0 +1,3 @@
+export declare const FenceTool: React.FC;
+export default FenceTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/fence/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AAqbA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAM7B,CAAA;AA+cD,eAAe,SAAS,CAAA"}