@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/fence/definition.edit.js

@@ -0,0 +1,282 @@
+import { getFenceControlHandle, getFenceSpanMode, isSplineFence, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, REGISTERED_DRAFT_SNAP_EXTENSION, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { fenceBaseElevation } from './definition.render.js';
+import { snapFenceDraftPoint } from './drafting.js';
+import { buildFenceFloorplan } from './floorplan.js';
+import { fenceControlPointAffordance, fenceCurveAffordance, fenceMoveEndpointAffordance, fenceTangentAffordance, fenceThicknessAffordance, } from './floorplan-affordances.js';
+import { fenceFloorplanMoveTarget } from './floorplan-move.js';
+import { fencePaint } from './paint.js';
+import { fencePanelModel } from './panel-model.js';
+import { fenceParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.27;
+const SIDE_HANDLE_MIN_OFFSET = 0.33;
+const SIDE_HANDLE_TOP_INSET = 0.08;
+const SIDE_HANDLE_MIN_HEIGHT = 0.4;
+const HEIGHT_HANDLE_OFFSET = 0.45;
+const MIN_FENCE_HEIGHT = 0.3;
+function fenceMidpointFrame(n) {
+    const dx = n.end[0] - n.start[0];
+    const dz = n.end[1] - n.start[1];
+    const len = Math.max(Math.hypot(dx, dz), 1e-6);
+    return {
+        midX: (n.start[0] + n.end[0]) / 2,
+        midZ: (n.start[1] + n.end[1]) / 2,
+        normalX: -dz / len,
+        normalZ: dx / len,
+    };
+}
+function fenceElevationGuideSource(n) {
+    const { midX, midZ } = fenceMidpointFrame(n);
+    return {
+        nodeId: n.id,
+        levelId: n.parentId,
+        anchor: [midX, midZ],
+    };
+}
+// Side-move arrows: click to hand the fence to its move tool. Same shape
+// as wall — front + back faces, positioned past the fence thickness near
+// the top so they don't compete with endpoint pickers in the floating
+// menu (which is where fence endpoint move lives today).
+function fenceSideMoveHandle(side) {
+    const sign = side === 'front' ? 1 : -1;
+    return {
+        kind: 'tap-action',
+        onActivate: (node, _scene, editor) => editor.engageMove(node),
+        placement: {
+            position: (n, sceneApi) => {
+                const { midX, midZ, normalX, normalZ } = fenceMidpointFrame(n);
+                const offset = Math.max((n.thickness ?? 0.1) / 2 + SIDE_HANDLE_OFFSET, SIDE_HANDLE_MIN_OFFSET);
+                const h = n.height ?? 1.8;
+                const handleY = fenceBaseElevation(n, sceneApi, [midX, midZ]) +
+                    Math.max(h - SIDE_HANDLE_TOP_INSET, SIDE_HANDLE_MIN_HEIGHT);
+                return [midX + sign * normalX * offset, handleY, midZ + sign * normalZ * offset];
+            },
+            rotationY: (n) => {
+                const { normalX, normalZ } = fenceMidpointFrame(n);
+                return Math.atan2(-sign * normalZ, sign * normalX);
+            },
+        },
+        // The move itself is constrained by `MoveFenceTool`; keep the visual as a
+        // one-direction chevron instead of the generic four-way move cross.
+        cursor: 'ew-resize',
+    };
+}
+// Height arrow — anchored at the floor (Y=0), grows upward. Sits over
+// the fence midpoint at the top edge with enough clearance to clear the
+// side-move arrows that hug the rail. `rotationY` orients the chevron's
+// broad face along the fence's perpendicular (same direction the front
+// side-move arrow points), so the chevron reads frontally when viewing
+// the fence from either side rather than going edge-on.
+function fenceHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_FENCE_HEIGHT,
+        // Drives the floating dimension pill (H · L · T) and suppresses the
+        // arrow's own inline chip, matching the wall height handle.
+        measureLabel: 'height',
+        currentValue: (n) => n.height ?? 1.8,
+        apply: (_n, newHeight) => ({ height: newHeight }),
+        placement: {
+            position: (n, sceneApi) => {
+                const { midX, midZ } = fenceMidpointFrame(n);
+                return [
+                    midX,
+                    fenceBaseElevation(n, sceneApi, [midX, midZ]) + (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET,
+                    midZ,
+                ];
+            },
+            rotationY: (n) => {
+                const { normalX, normalZ } = fenceMidpointFrame(n);
+                return Math.atan2(-normalZ, normalX);
+            },
+        },
+    };
+}
+function fenceElevationHandle(currentBase) {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        gridSnap: true,
+        currentValue: () => currentBase,
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(fenceElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(fenceElevationGuideSource(n), fenceBaseElevation(n, sceneApi), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (initial, newBase, sceneApi) => {
+            // The offset is measured from the support WITHOUT the current offset —
+            // including the ground, so dragging a fence's base to an absolute height
+            // on a hillside stores the delta from that hillside and the fence keeps
+            // following it.
+            const { midX, midZ } = fenceMidpointFrame(initial);
+            const supportBase = fenceBaseElevation({ ...initial, supportOffset: undefined }, sceneApi, [
+                midX,
+                midZ,
+            ]);
+            const nextOffset = newBase - supportBase;
+            return {
+                supportOffset: Math.abs(nextOffset) < 1e-6 ? undefined : nextOffset,
+            };
+        },
+        placement: {
+            position: (n, sceneApi) => {
+                const { midX, midZ } = fenceMidpointFrame(n);
+                return [midX, fenceBaseElevation(n, sceneApi, [midX, midZ]), midZ];
+            },
+        },
+    };
+}
+// Corner picker — dashed vertical leader + billboarded hex disc at the
+// endpoint. Tap engages the endpoint-move flow (sister to the wall
+// pickers). nodeHeight controls the leader's vertical reach so the
+// dashes span the full fence height.
+function fenceCornerPicker(endpoint) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.height ?? 1.8,
+        onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
+        placement: {
+            position: (n, sceneApi) => {
+                const corner = endpoint === 'start' ? n.start : n.end;
+                return [corner[0], fenceBaseElevation(n, sceneApi, corner), corner[1]];
+            },
+        },
+    };
+}
+const TANGENT_HANDLE_ARM_SCALE = 3;
+function fenceControlPointPicker(index) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.height ?? 1.8,
+        onActivate: (node, _scene, editor) => editor.engageControlPointMove(node, index),
+        placement: {
+            position: (n, sceneApi) => {
+                const point = n.path?.[index] ?? n.start;
+                return [point[0], fenceBaseElevation(n, sceneApi, point), point[1]];
+            },
+        },
+    };
+}
+function fenceTangentPicker(index, side) {
+    const sign = side === 'out' ? 1 : -1;
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        round: true,
+        cursor: 'move',
+        nodeHeight: (n) => (n.height ?? 1.8) * 0.6,
+        onActivate: (node, _scene, editor) => editor.engageTangentMove(node, index, side),
+        placement: {
+            position: (n, sceneApi) => {
+                const point = n.path?.[index] ?? n.start;
+                const baseElevation = fenceBaseElevation(n, sceneApi, point);
+                if (!n.path)
+                    return [point[0], baseElevation, point[1]];
+                const handle = getFenceControlHandle(n.path, n.tangents, index);
+                return [
+                    point[0] + sign * handle.x * TANGENT_HANDLE_ARM_SCALE,
+                    baseElevation,
+                    point[1] + sign * handle.y * TANGENT_HANDLE_ARM_SCALE,
+                ];
+            },
+        },
+    };
+}
+const fenceHandles = (node, sceneApi) => {
+    const { midX, midZ } = fenceMidpointFrame(node);
+    const elevationHandle = fenceElevationHandle(fenceBaseElevation(node, sceneApi, [midX, midZ]));
+    if (isSplineFence(node) && node.path) {
+        return [
+            elevationHandle,
+            fenceHeightHandle(),
+            ...node.path.flatMap((_, index) => {
+                const path = node.path;
+                return [
+                    fenceControlPointPicker(index),
+                    ...(index < path.length - 1 &&
+                        getFenceSpanMode(path, node.tangents, node.spanModes, index) === 'curve'
+                        ? [fenceTangentPicker(index, 'out')]
+                        : []),
+                    ...(index > 0 &&
+                        getFenceSpanMode(path, node.tangents, node.spanModes, index - 1) === 'curve'
+                        ? [fenceTangentPicker(index, 'in')]
+                        : []),
+                ];
+            }),
+        ];
+    }
+    return [
+        fenceSideMoveHandle('front'),
+        fenceSideMoveHandle('back'),
+        elevationHandle,
+        fenceHeightHandle(),
+        fenceCornerPicker('start'),
+        fenceCornerPicker('end'),
+    ];
+};
+export const fenceEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        [PANEL_MODEL_EXTENSION]: fencePanelModel,
+        [REGISTERED_DRAFT_SNAP_EXTENSION]: snapFenceDraftPoint,
+    },
+    capabilities: {
+        paint: fencePaint,
+    },
+    parametrics: fenceParametrics,
+    handles: fenceHandles,
+    // Stage D: kind-owned placement tool. Two-click flow (start → end)
+    // with live preview, length / angle HUD, snap to walls / fences /
+    // grid. Mounted by ToolManager when `useEditor.tool === 'fence'`
+    // via the registry's getRegistryTool() — falls back to the legacy
+    // tools[phase][tool] map when missing.
+    tool: () => import('./tool.js'),
+    floorplanDependencies: (node) => (node.children ?? []),
+    // Stage C: floor-plan rendering. FloorplanRegistryLayer iterates kinds
+    // with `floorplan` set and renders via FloorplanGeometryRenderer.
+    // Legacy `floorplanFenceEntries` short-circuits to [] when fence is
+    // registered (see floorplan-panel.tsx).
+    floorplan: buildFenceFloorplan,
+    // 2D drag affordances — sister to `actions/move-endpoint.ts`. The 3D
+    // DragAction drives R3F grid events through `createDragSession`; these
+    // drive SVG pointer events through the floor-plan registry
+    // dispatcher's snapshot + single-undo dance. `move-endpoint` keeps the
+    // legacy fence endpoint semantics; `curve` mirrors the wall sagitta
+    // drag (publishes `curveOffset` overrides per tick, commits on
+    // pointer-up).
+    floorplanAffordances: {
+        'move-endpoint': fenceMoveEndpointAffordance,
+        'move-control-point': fenceControlPointAffordance,
+        'move-tangent': fenceTangentAffordance,
+        curve: fenceCurveAffordance,
+        thickness: fenceThicknessAffordance,
+    },
+    // Body move on the fence is driven by the two `move-arrow` chevrons
+    // the floor-plan builder emits at the midpoint. Pointer-down enters
+    // movingNode mode; the registry overlay routes through this target
+    // for the live preview + commit. Translates the dragged fence and
+    // cascades the shared endpoints of any linked fences, ALT detaches.
+    floorplanMoveTarget: fenceFloorplanMoveTarget,
+    // Stage D — all four fence drag-affordances live in this folder.
+    // curve / move-endpoint / move are 1:1 ports of the legacy tools
+    // (same snap pipeline, same history dance, same cursor render),
+    // relocated under `@pascal-app/nodes` and dispatched via
+    // `def.affordanceTools`. Placement lives in `def.tool` (see below).
+    affordanceTools: {
+        curve: () => import('./curve-tool.js'),
+        'move-endpoint': () => import('./move-endpoint-tool.js'),
+        'move-control-point': () => import('./move-control-point-tool.js'),
+        'move-tangent': () => import('./move-tangent-tool.js'),
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Set fence start / end' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};