@pascal-app/nodes 0.1.1

package/dist/door/floorplan-affordances.js

@@ -0,0 +1,102 @@
+import { useScene, } from '@pascal-app/core';
+const MIN_DOOR_WIDTH = 0.3;
+/**
+ * 2D drag affordance for the door's width side-arrows. Sister to the 3D
+ * `DoorSideArrow` width drag in `packages/editor/src/components/editor/
+ * door-side-handles.tsx` — both anchor at the opposite door edge and clamp
+ * to wall bounds.
+ *
+ * Payload encodes which edge the user grabbed:
+ *   - `'start'`: arrow at the door edge closer to `wall.start`. The
+ *     opposite edge (toward `wall.end`) stays fixed.
+ *   - `'end'`: arrow at the edge closer to `wall.end`. The wall-start
+ *     edge stays fixed.
+ *
+ * Uses the scene-write preview pattern (writes directly to `useScene`
+ * each tick): the registry layer's `effectiveNode` only merges live
+ * overrides for walls, so an override-based preview wouldn't show on
+ * doors. The dispatcher snapshots / pauses history at start, so per-tick
+ * scene writes still collapse to one undoable entry on commit.
+ */
+export const doorWidthAffordance = {
+    start({ node, payload, nodes, initialPlanPoint }) {
+        const { side } = payload;
+        const doorId = node.id;
+        const wall = node.wallId ? nodes[node.wallId] : undefined;
+        const initialWidth = node.width;
+        const initialDoorX = node.position[0];
+        const initialDoorY = node.position[1];
+        const initialDoorZ = node.position[2];
+        // Anchor (wall-local X) is the door edge OPPOSITE to the dragged
+        // side. Grow direction along the wall: +1 for 'end' (drag outward
+        // toward wall.end), -1 for 'start' (drag outward toward wall.start).
+        const growDir = side === 'end' ? 1 : -1;
+        const anchorX = side === 'end' ? initialDoorX - initialWidth / 2 : initialDoorX + initialWidth / 2;
+        // Wall axis (level-local) for projecting pointer movement to a
+        // wall-local X delta.
+        const wallStart = wall ? wall.start : [0, 0];
+        const wallEnd = wall ? wall.end : [1, 0];
+        const dx = wallEnd[0] - wallStart[0];
+        const dz = wallEnd[1] - wallStart[1];
+        const wallLength = Math.hypot(dx, dz) || 1;
+        const dirX = dx / wallLength;
+        const dirZ = dz / wallLength;
+        // Max width keeps the dragged edge inside the wall span. With the
+        // anchor fixed, the moving edge is `anchorX ± width`, so the largest
+        // legal width is the headroom on the grow side.
+        const maxWidth = growDir > 0 ? wallLength - anchorX : anchorX;
+        const projectToWallLocalX = (planPoint) => {
+            return (planPoint[0] - wallStart[0]) * dirX + (planPoint[1] - wallStart[1]) * dirZ;
+        };
+        // Initial pointer in wall-local X — anchored to where the user
+        // actually pressed, so any subtle offset between the arrow's visual
+        // origin and the click point doesn't pre-bias the width delta.
+        const initialPointerLocalX = projectToWallLocalX(initialPlanPoint);
+        let lastWidth = initialWidth;
+        let lastDoorX = initialDoorX;
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint }) {
+                const currentLocalX = projectToWallLocalX(planPoint);
+                const delta = (currentLocalX - initialPointerLocalX) * growDir;
+                const newWidth = Math.min(Math.max(MIN_DOOR_WIDTH, initialWidth + delta), Math.max(MIN_DOOR_WIDTH, maxWidth));
+                const newDoorX = anchorX + growDir * (newWidth / 2);
+                lastWidth = newWidth;
+                lastDoorX = newDoorX;
+                // Scene-write preview so the 2D plan + 3D viewer both pick up
+                // the change immediately. The dispatcher paused history at
+                // session start, so per-tick writes don't pollute undo.
+                useScene.getState().updateNodes([
+                    {
+                        id: doorId,
+                        data: {
+                            width: newWidth,
+                            position: [newDoorX, initialDoorY, initialDoorZ],
+                        },
+                    },
+                ]);
+            },
+            canCommit() {
+                // Width is always clamped to >= MIN_DOOR_WIDTH inside apply, so
+                // any committed state is legal.
+                return true;
+            },
+            commit() {
+                // Atomic, tracked final write. Owning the commit ourselves
+                // bypasses the dispatcher's diff path (which only re-applies
+                // fields that differ from the pre-drag snapshot — if the user
+                // drags back to the original size by accident, the diff is empty
+                // and the door would otherwise revert to its starting state).
+                useScene.getState().updateNodes([
+                    {
+                        id: doorId,
+                        data: {
+                            width: lastWidth,
+                            position: [lastDoorX, initialDoorY, initialDoorZ],
+                        },
+                    },
+                ]);
+            },
+        };
+    },
+};

package/dist/door/floorplan-move.d.ts

@@ -0,0 +1,18 @@
+import { type DoorNode, type FloorplanMoveTarget } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for door — kicks in when the user clicks
+ * "Move" on the door inspector (or action menu) and the floor-plan
+ * view is active. Pointer in plan space → snap to nearest wall →
+ * project onto wall axis → snap local-X to 0.5m grid → clamp inside
+ * wall bounds → commit via `useScene.updateNodes`.
+ *
+ * Mirrors the 3D `move-tool.tsx` behaviour minus the R3F event plumbing:
+ *   - Re-parents on transition between walls (parentId + wallId).
+ *   - Adapts `side` + `rotation` from the wall normal under the pointer.
+ *   - hasWallChildOverlap blocks committing overlapping placements.
+ *
+ * Curved walls are skipped by `findClosestWallInPlan` — same guardrail
+ * as the 3D port and the legacy `DoorTool` / `MoveDoorTool`.
+ */
+export declare const doorFloorplanMoveTarget: FloorplanMoveTarget<DoorNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/door/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAoPjE,CAAA"}

package/dist/door/floorplan-move.js

@@ -0,0 +1,239 @@
+import { useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
+import { isGridSnapActive, isMagneticSnapActive, snapToHalf, triggerSFX, useEditor, usePlacementPreview, } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host';
+import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target';
+import { clampToWall, hasWallChildOverlap } from './door-math';
+/**
+ * 2D floor-plan move handler for door — kicks in when the user clicks
+ * "Move" on the door inspector (or action menu) and the floor-plan
+ * view is active. Pointer in plan space → snap to nearest wall →
+ * project onto wall axis → snap local-X to 0.5m grid → clamp inside
+ * wall bounds → commit via `useScene.updateNodes`.
+ *
+ * Mirrors the 3D `move-tool.tsx` behaviour minus the R3F event plumbing:
+ *   - Re-parents on transition between walls (parentId + wallId).
+ *   - Adapts `side` + `rotation` from the wall normal under the pointer.
+ *   - hasWallChildOverlap blocks committing overlapping placements.
+ *
+ * Curved walls are skipped by `findClosestWallInPlan` — same guardrail
+ * as the 3D port and the legacy `DoorTool` / `MoveDoorTool`.
+ */
+export const doorFloorplanMoveTarget = ({ node }) => {
+    const nodeId = node.id;
+    // Snapshot of the door's "valid" state at move-start — used by
+    // canCommit to decide whether the current snapped position is OK.
+    // The level that owns the wall-snap candidates — resolves the wall-hosted,
+    // roof-hosted, and fresh-placement parentings (see `getOpeningHostLevelId`).
+    // Cached at start because the parent chain doesn't change during a move.
+    const startLevelId = getOpeningHostLevelId(node, useScene.getState().nodes);
+    const originalWall = node.parentId
+        ? useScene.getState().nodes[node.parentId]
+        : undefined;
+    const resolveCursor = createFloorplanCursorResolver({
+        original: originalWall?.type === 'wall'
+            ? projectWallLocalPointToPlan(originalWall, node.position[0])
+            : (getRoofHostedOpeningPlanPoint(node, useScene.getState().nodes) ?? [node.position[0], 0]),
+        metadata: node.metadata,
+        // Absolute: query the wall snap with the TRUE cursor, not the door's
+        // original wall position plus a grab delta. A wall-hosted opening always
+        // belongs to the wall nearest the cursor (the user's rule), and the 3D
+        // move snaps on the wall literally under the ray — relative mode would
+        // anchor the search to the old wall and resist hopping to a closer one
+        // across a thin gap, picking the "far" wall the user reported. It also
+        // makes the 2D Voronoi overlay (classified by cursor) predict the snap.
+        mode: 'absolute',
+    });
+    // Track the last successful placement so `commit()` can write it
+    // atomically — see the comment on `commit` below for why we don't
+    // rely on the dispatcher's diff path.
+    let lastValid = null;
+    // R flips the door's facing (front ↔ back) mid-placement. `apply` re-derives
+    // the wall-facing side every move, so the flip is a persistent XOR applied on
+    // top of the wall hit, plus a π rotation offset (matching the committed R).
+    let flipped = false;
+    // Remember the last apply args so the overlay's R keydown can re-run `apply`
+    // (which has no event of its own) to show the flip immediately.
+    let lastApply = null;
+    // Whether the cursor is currently over a wall. Off-wall the door free-follows
+    // the cursor as a ghost (like the 3D move) and is NOT committable — a door
+    // needs a wall. Starts true so a click before any move keeps the door put.
+    let onWall = true;
+    // Alt force-place (last apply's modifier) — lets `canCommit` allow an
+    // overlapping placement, matching the 3D move. Read in `canCommit` so an Alt-
+    // held commit over a collision lands instead of reverting.
+    let forcePlace = false;
+    let liveTransformActive = useLiveTransforms.getState().transforms.has(nodeId);
+    let liveOverrideKey = null;
+    let placementPreviewActive = usePlacementPreview.getState().node?.id === nodeId;
+    const setLiveOverride = (key, values) => {
+        if (liveOverrideKey === key)
+            return;
+        liveOverrideKey = key;
+        useLiveNodeOverrides.getState().set(nodeId, values);
+    };
+    // Move SFX — parity with the 3D `MoveDoorTool`: ONE soft `sfx:grid-snap` click
+    // each time the door's PLACED position crosses a step. Keyed on the SNAPPED
+    // position, quantized by the live grid step in grid mode else a gentle fixed
+    // cadence — so grid mode ticks once per cell (not on every micro mouse-move
+    // while the door sits in a cell) while lines/off still tick as the door moves.
+    const FREE_STEP_M = 0.1;
+    let lastStepKey = null;
+    const tickGridStep = (...coords) => {
+        const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : FREE_STEP_M;
+        const key = coords.map((c) => Math.round(c / step)).join(',');
+        if (key !== lastStepKey) {
+            lastStepKey = key;
+            triggerSFX('sfx:grid-snap');
+        }
+    };
+    // Off-wall: float the faithful door symbol at the cursor (via a synthetic
+    // wall fed to the placement-preview layer) and hide the real node, so the
+    // ghost follows the cursor in 2D instead of the door staying frozen on its
+    // old wall. Mirrors the fresh-placement free-follow.
+    const freeFollow = (planPoint) => {
+        onWall = false;
+        lastValid = null;
+        if (liveTransformActive) {
+            useLiveTransforms.getState().clear(nodeId);
+            liveTransformActive = false;
+        }
+        setLiveOverride('free-follow', { visible: false });
+        const half = node.width / 2 + 0.5;
+        const wall = WallNodeSchema.parse({
+            start: [planPoint[0] - half, planPoint[1]],
+            end: [planPoint[0] + half, planPoint[1]],
+            thickness: 0.1,
+        });
+        // Reflect the R-flip on the floating ghost so its swing-arc faces the side
+        // that will be committed (the synthetic wall is plan-X aligned, so a back
+        // facing is a π yaw; the symbol builder also reads `side`).
+        const ghostSide = flipped
+            ? node.side === 'front'
+                ? 'back'
+                : 'front'
+            : node.side;
+        const ghost = {
+            ...node,
+            side: ghostSide,
+            parentId: wall.id,
+            wallId: wall.id,
+            roofSegmentId: undefined,
+            roofFace: undefined,
+            position: [half, node.position[1], 0],
+            rotation: [0, flipped ? Math.PI : 0, 0],
+            visible: true,
+        };
+        usePlacementPreview.getState().set(ghost, wall);
+        placementPreviewActive = true;
+    };
+    const session = {
+        affectedIds: [nodeId],
+        flipSide() {
+            flipped = !flipped;
+            if (lastApply)
+                this.apply(lastApply);
+        },
+        apply({ planPoint, modifiers }) {
+            lastApply = { planPoint, modifiers };
+            forcePlace = modifiers.altKey === true;
+            const nodes = useScene.getState().nodes;
+            const resolvedPlanPoint = resolveCursor(planPoint);
+            const hit = findClosestWallInPlan(resolvedPlanPoint, nodes, startLevelId);
+            if (!hit) {
+                // Off any wall — free-follow the cursor (not committable). Click per grid
+                // cell as the ghost slides over open floor.
+                tickGridStep(resolvedPlanPoint[0], resolvedPlanPoint[1]);
+                freeFollow(resolvedPlanPoint);
+                return;
+            }
+            // Back on a wall — drop the free-follow ghost + reveal the real node.
+            onWall = true;
+            if (placementPreviewActive) {
+                usePlacementPreview.getState().clear();
+                placementPreviewActive = false;
+            }
+            // Figma-style along-wall alignment first (edge-to-edge with other
+            // openings / wall ends); it competes with — and wins over — the grid
+            // snap. Follows the magnetic ("lines") mode; the grid component lives in
+            // `snapToHalf` (mode-aware → raw when grid is off).
+            const neighborX = !isMagneticSnapActive()
+                ? null
+                : snapLocalXToNeighbors({
+                    wall: hit.wall,
+                    localX: hit.localX,
+                    width: node.width,
+                    selfId: nodeId,
+                    nodes,
+                });
+            const snappedLocalX = neighborX ?? snapToHalf(hit.localX);
+            const { clampedX, clampedY } = clampToWall(hit.wall, snappedLocalX, node.width, node.height);
+            // One click per real position step, keyed on the SNAPPED along-wall value
+            // so it ticks only when the door actually moves to a new cell.
+            tickGridStep(clampedX);
+            // Apply the R-flip on top of the wall-derived side.
+            const side = flipped ? (hit.side === 'front' ? 'back' : 'front') : hit.side;
+            const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
+            lastValid = {
+                position: [clampedX, clampedY, 0],
+                rotation: [0, itemRotation, 0],
+                side,
+                parentId: hit.wall.id,
+                wallId: hit.wall.id,
+                // Re-anchoring to a wall ends any roof-segment hosting; the
+                // overlay's snapshot restores it if the move is reverted.
+                roofSegmentId: undefined,
+                roofFace: undefined,
+                visible: true,
+            };
+            setLiveOverride(`wall:${hit.wall.id}:${side}`, {
+                parentId: hit.wall.id,
+                wallId: hit.wall.id,
+                side,
+                roofSegmentId: undefined,
+                roofFace: undefined,
+                visible: true,
+            });
+            useLiveTransforms.getState().set(nodeId, {
+                position: lastValid.position,
+                rotation: itemRotation,
+            });
+            liveTransformActive = true;
+        },
+        canCommit() {
+            // Off-wall the door is free-following in mid-air — not placeable. The
+            // overlay then reverts to the pre-move snapshot (door returns to its
+            // original wall), matching the 3D move where an open-floor click commits
+            // nothing.
+            if (!onWall || !lastValid)
+                return false;
+            const live = useScene.getState().nodes[nodeId];
+            if (live?.type !== 'door')
+                return false;
+            // Block commit if the door overlaps another wall child — UNLESS Alt
+            // force-places (same `placeable` rule as the 3D move + the shared
+            // `resolveOpeningPlacement`).
+            const collides = hasWallChildOverlap(lastValid.parentId, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            return resolveOpeningPlacement({ collides, forcePlace }).placeable;
+        },
+        commit() {
+            // Own the atomic write so the overlay takes the deterministic
+            // commit-path (revert → resume → session.commit()). The dispatcher's
+            // diff path would otherwise re-derive the final state by comparing
+            // the post-apply scene to the snapshot — that works most of the
+            // time, but produces an empty diff (and silent revert) when the
+            // committed move happens to land on the same `parentId` AND has
+            // been re-applied with identical data. Owning commit removes that
+            // foot-gun without forcing the dispatcher to track per-key writes.
+            if (!lastValid)
+                return;
+            useScene.getState().updateNodes([
+                {
+                    id: nodeId,
+                    data: lastValid,
+                },
+            ]);
+        },
+    };
+    return session;
+};

package/dist/door/floorplan.d.ts

@@ -0,0 +1,37 @@
+import type { DoorNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for door. 1:1 visual port of the legacy
+ * floorplan-panel door rendering:
+ *
+ *   1. The door footprint rectangle in the wall cutout (themed
+ *      accent stroke when selected).
+ *   2. The door swing arc — a fixed quarter-circle from the hinge to
+ *      the door's fully-open (90°) position, oriented by `hingesSide`
+ *      and `swingDirection`. The angle is intentionally constant so the
+ *      plan symbol stays static regardless of the door's live open-close
+ *      state. Renders as a wedge of low-opacity fill so the swept area
+ *      reads at a glance.
+ *   3. The door leaf — a thick line from the hinge to the open
+ *      position, terminating at the arc end.
+ *
+ * Double / french doors render two mirrored half-width leaves hinged at
+ * the opposite outer ends, each with its own dashed arc, meeting
+ * perpendicular at the centre — the standard double-door plan sign.
+ *
+ * Folding / bifold doors render a static zigzag accordion of panels
+ * across the opening (porting the 3D folding geometry's panel layout),
+ * with no swing arc.
+ *   4. Center line through the cutout (matches the legacy's
+ *      `getOpeningCenterLine` segment for visual continuity).
+ *
+ * Requires `ctx.parent` to be a wall (door.parentId is the wall it's
+ * mounted on). Returns null when the parent isn't a wall (orphaned
+ * doors during placement etc.).
+ *
+ * Skipped vs the full legacy for now: hinge / strike cubes (small
+ * indicator squares at the rotation pivots), rounded-opening shape
+ * variants, panic bar markers. Those are rare visual variations the
+ * follow-up port can revisit.
+ */
+export declare function buildDoorFloorplan(node: DoorNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/door/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA0qBjG"}