@pascal-app/nodes 0.1.1

package/dist/stair/floorplan-affordances.js

@@ -0,0 +1,266 @@
+import { useScene, } from '@pascal-app/core';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+// Minimums + max sweep mirror the 3D handles in
+// `packages/editor/src/components/editor/stair-segment-handles.tsx` so a 2D
+// drag can't push a stair past what the 3D drag would allow.
+const MIN_SEGMENT_WIDTH = 0.4;
+const MIN_SEGMENT_LENGTH = 0.4;
+const MIN_CURVED_WIDTH = 0.4;
+const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.05;
+const MIN_CURVED_INNER_RADIUS_CURVED = 0.2;
+const MIN_CURVED_SWEEP = Math.PI / 12;
+const MAX_CURVED_SWEEP = Math.PI * 2 - 0.05;
+function noopSession() {
+    return {
+        affectedIds: [],
+        apply() { },
+        canCommit() {
+            return false;
+        },
+    };
+}
+/**
+ * Straight-stair segment side arrow → segment `width`. Sister to the 3D
+ * `StairSegmentSideArrow` width drag (~line 235 of stair-segment-handles.tsx).
+ * Width grows symmetrically around the segment centerline — the chain
+ * rebuilds from the segment's `width` field, no opposite-edge anchor write
+ * required. `axisX` is the segment-local +X axis in plan coords, captured
+ * at emit-time so the projection stays valid through the drag.
+ */
+export const segmentWidthAffordance = {
+    start({ payload, nodes, initialPlanPoint }) {
+        const { segmentId, side, axisX } = payload;
+        const segmentNodeId = segmentId;
+        const segment = nodes[segmentNodeId];
+        if (segment?.type !== 'stair-segment')
+            return noopSession();
+        const initialWidth = segment.width;
+        const sign = side === 'right' ? 1 : -1;
+        const ax = axisX[0];
+        const ay = axisX[1];
+        const initialProj = initialPlanPoint[0] * ax + initialPlanPoint[1] * ay;
+        let lastWidth = initialWidth;
+        return {
+            affectedIds: [segmentNodeId],
+            apply({ planPoint }) {
+                const currentProj = planPoint[0] * ax + planPoint[1] * ay;
+                const delta = sign * (currentProj - initialProj);
+                const newWidth = Math.max(MIN_SEGMENT_WIDTH, initialWidth + delta);
+                lastWidth = newWidth;
+                useScene.getState().updateNode(segmentNodeId, { width: newWidth });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(segmentNodeId, { width: lastWidth });
+            },
+        };
+    },
+};
+/**
+ * Straight-stair segment length arrow → segment `length`. Sister to the 3D
+ * `StairSegmentLengthArrow` drag. The chain anchors each segment's back
+ * face, so length simply extends/contracts the front. `axisZ` is the
+ * segment-local +Z (run) direction in plan coords.
+ */
+export const segmentLengthAffordance = {
+    start({ payload, nodes, initialPlanPoint }) {
+        const { segmentId, axisZ } = payload;
+        const segmentNodeId = segmentId;
+        const segment = nodes[segmentNodeId];
+        if (segment?.type !== 'stair-segment')
+            return noopSession();
+        const initialLength = segment.length;
+        const az = axisZ[0];
+        const ay = axisZ[1];
+        const initialProj = initialPlanPoint[0] * az + initialPlanPoint[1] * ay;
+        let lastLength = initialLength;
+        return {
+            affectedIds: [segmentNodeId],
+            apply({ planPoint }) {
+                const currentProj = planPoint[0] * az + planPoint[1] * ay;
+                const delta = currentProj - initialProj;
+                const newLength = Math.max(MIN_SEGMENT_LENGTH, initialLength + delta);
+                lastLength = newLength;
+                useScene.getState().updateNode(segmentNodeId, { length: newLength });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(segmentNodeId, { length: lastLength });
+            },
+        };
+    },
+};
+/**
+ * Curved / spiral width arrow → stair `width`. Drag radially outward grows
+ * the body, anchored at the inner radius (matches the 3D
+ * `CurvedStairWidthArrow`). The sweep bisector matches the existing
+ * floor-plan emitter (`sectorStartAngle = -rotation - sweep/2`, bisector
+ * = -rotation).
+ */
+export const curvedStairWidthAffordance = {
+    start({ node, initialPlanPoint }) {
+        const stairId = node.id;
+        const initialWidth = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
+        const midAngle = -node.rotation;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const radialX = Math.cos(midAngle);
+        const radialZ = Math.sin(midAngle);
+        const initialRadial = (initialPlanPoint[0] - cx) * radialX + (initialPlanPoint[1] - cz) * radialZ;
+        let lastWidth = initialWidth;
+        return {
+            affectedIds: [stairId],
+            apply({ planPoint }) {
+                const currentRadial = (planPoint[0] - cx) * radialX + (planPoint[1] - cz) * radialZ;
+                const newWidth = Math.max(MIN_CURVED_WIDTH, initialWidth + (currentRadial - initialRadial));
+                lastWidth = newWidth;
+                useScene.getState().updateNode(stairId, { width: newWidth });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(stairId, { width: lastWidth });
+            },
+        };
+    },
+};
+/**
+ * Curved / spiral inner-radius arrow → stair `innerRadius` + `width`. Keeps
+ * the outer edge pinned (width absorbs the radial delta) so dragging only
+ * shifts the inner rim, matching the 3D `CurvedStairInnerRadiusArrow`.
+ */
+export const curvedStairInnerRadiusAffordance = {
+    start({ node, initialPlanPoint }) {
+        const stairId = node.id;
+        const isSpiral = node.stairType === 'spiral';
+        const minInnerRadius = isSpiral
+            ? MIN_CURVED_INNER_RADIUS_SPIRAL
+            : MIN_CURVED_INNER_RADIUS_CURVED;
+        const initialInnerRadius = Math.max(minInnerRadius, node.innerRadius ?? 0.9);
+        const initialWidth = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
+        const initialOuterRadius = initialInnerRadius + initialWidth;
+        const maxInnerRadius = initialOuterRadius - MIN_CURVED_WIDTH;
+        const midAngle = -node.rotation;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const radialX = Math.cos(midAngle);
+        const radialZ = Math.sin(midAngle);
+        const initialRadial = (initialPlanPoint[0] - cx) * radialX + (initialPlanPoint[1] - cz) * radialZ;
+        let lastInner = initialInnerRadius;
+        let lastWidth = initialWidth;
+        return {
+            affectedIds: [stairId],
+            apply({ planPoint }) {
+                const currentRadial = (planPoint[0] - cx) * radialX + (planPoint[1] - cz) * radialZ;
+                const innerDelta = currentRadial - initialRadial;
+                const newInner = Math.min(maxInnerRadius, Math.max(minInnerRadius, initialInnerRadius + innerDelta));
+                const newWidth = initialOuterRadius - newInner;
+                lastInner = newInner;
+                lastWidth = newWidth;
+                useScene.getState().updateNode(stairId, { innerRadius: newInner, width: newWidth });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(stairId, { innerRadius: lastInner, width: lastWidth });
+            },
+        };
+    },
+};
+/**
+ * Whole-stair rotation gizmo → stair `rotation`. Mirrors the 3D
+ * `stairRotateHandle` (arc-resize, curved-arrow shape). Angular drag
+ * around the stair's plan-space pivot — atan2 ticks CW visually, the
+ * stored `rotation` field is the schema's Y-axis radians, and the
+ * floorplan plots sectors at `-rotation`, so a positive cursor delta
+ * (CCW around the centre in standard math coords / CW on screen given
+ * inverted Y) should DECREASE `rotation`. Same `- delta` convention the
+ * 3D handle uses; cursor handedness across both views matches.
+ */
+export const stairRotateAffordance = {
+    start({ node, initialPlanPoint }) {
+        const stairId = node.id;
+        const initialRotation = node.rotation ?? 0;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastRotation = initialRotation;
+        return {
+            affectedIds: [stairId],
+            apply({ planPoint, modifiers }) {
+                const delta = rotateAffordanceDelta({
+                    center: [cx, cz],
+                    initialAngle,
+                    planPoint,
+                    free: modifiers.shiftKey,
+                });
+                const newRotation = initialRotation - delta;
+                lastRotation = newRotation;
+                useScene.getState().updateNode(stairId, { rotation: newRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(stairId, { rotation: lastRotation });
+            },
+        };
+    },
+};
+/**
+ * Curved / spiral sweep arrows → stair `sweepAngle` + `rotation`. Anchors
+ * the opposite edge world-fixed by nudging `rotation` by half the applied
+ * sweep delta — mirror of the 3D `CurvedStairSweepArrow`. Sign math derives
+ * from the floorplan convention `sectorStartAngle = -rotation - sweep/2`:
+ *
+ *   END handle  (sweep += Δ, fix start): ΔR = -Δ/2
+ *   START handle (sweep -= Δ, fix end):  ΔR = +Δ/2
+ */
+export const curvedStairSweepAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { end } = payload;
+        const stairId = node.id;
+        const initialSweep = node.sweepAngle ?? (node.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2);
+        const sweepSign = Math.sign(initialSweep) || 1;
+        const initialRotation = node.rotation;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastSweep = initialSweep;
+        let lastRotation = initialRotation;
+        return {
+            affectedIds: [stairId],
+            apply({ planPoint }) {
+                const currentAngle = Math.atan2(planPoint[1] - cz, planPoint[0] - cx);
+                let delta = currentAngle - initialAngle;
+                // Wrap to [-π, π] so a drag crossing ±π doesn't flip sign mid-gesture.
+                while (delta > Math.PI)
+                    delta -= 2 * Math.PI;
+                while (delta < -Math.PI)
+                    delta += 2 * Math.PI;
+                const sweepDelta = end === 'end' ? delta : -delta;
+                const targetSweep = initialSweep + sweepDelta;
+                const clampedAbs = Math.min(MAX_CURVED_SWEEP, Math.max(MIN_CURVED_SWEEP, Math.abs(targetSweep)));
+                const newSweep = sweepSign * clampedAbs;
+                const appliedDelta = newSweep - initialSweep;
+                const rotationShift = end === 'end' ? -appliedDelta / 2 : appliedDelta / 2;
+                const newRotation = initialRotation + rotationShift;
+                lastSweep = newSweep;
+                lastRotation = newRotation;
+                useScene.getState().updateNode(stairId, { sweepAngle: newSweep, rotation: newRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(stairId, { sweepAngle: lastSweep, rotation: lastRotation });
+            },
+        };
+    },
+};

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

@@ -0,0 +1,17 @@
+import { type FloorplanMoveTarget, type StairNode } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for stair.
+ *
+ * Existing stairs preserve the cursor grab offset, matching the 3D move
+ * tools; fresh catalog placement follows the cursor absolutely.
+ *
+ * Figma alignment is layered on the stair footprint edges; Alt bypasses.
+ * Guides are cleared by `FloorplanRegistryMoveOverlay`'s Path 1 teardown.
+ *
+ * The position is written straight to scene each tick (the stair has a real
+ * `position` field, unlike polygon kinds) and re-applied atomically via
+ * `commit()` so the overlay's deterministic revert → resume → commit path
+ * records a single undo step (same pattern door / window use).
+ */
+export declare const stairFloorplanMoveTarget: FloorplanMoveTarget<StairNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAIzB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAoDnE,CAAA"}

package/dist/stair/floorplan-move.js

@@ -0,0 +1,64 @@
+import { collectAlignmentAnchors, movingAlignmentAnchors, snapScalar, useScene, } from '@pascal-app/core';
+import { applyFloorplanAlignment, getSegmentGridStep } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+/**
+ * 2D floor-plan move handler for stair.
+ *
+ * Existing stairs preserve the cursor grab offset, matching the 3D move
+ * tools; fresh catalog placement follows the cursor absolutely.
+ *
+ * Figma alignment is layered on the stair footprint edges; Alt bypasses.
+ * Guides are cleared by `FloorplanRegistryMoveOverlay`'s Path 1 teardown.
+ *
+ * The position is written straight to scene each tick (the stair has a real
+ * `position` field, unlike polygon kinds) and re-applied atomically via
+ * `commit()` so the overlay's deterministic revert → resume → commit path
+ * records a single undo step (same pattern door / window use).
+ */
+export const stairFloorplanMoveTarget = ({ node, nodes }) => {
+    const startY = node.position[1];
+    const resolveCursor = createFloorplanCursorResolver({
+        original: [node.position[0], node.position[2]],
+        metadata: node.metadata,
+    });
+    // Alignment candidates gathered once — the scene is stable during the drag.
+    const candidates = collectAlignmentAnchors(nodes, node.id);
+    let lastValid = null;
+    const session = {
+        affectedIds: [node.id],
+        apply({ planPoint, modifiers }) {
+            // Snap the origin to the editor's current grid step (driven by
+            // `useEditor.gridSnapStep`). Shift bypasses the grid snap.
+            const step = getSegmentGridStep();
+            const snap = (value) => (modifiers.shiftKey ? value : snapScalar(value, step));
+            const [gx, gz] = resolveCursor(planPoint, { snap });
+            // Figma alignment on the actual stair footprint (Alt bypasses alignment; Shift all snap),
+            // matching the 3D move tool. Publishes guides via `useAlignmentGuides`.
+            const movingAnchors = movingAlignmentAnchors(node, nodes, gx, gz, node.rotation ?? 0);
+            const { point: aligned } = applyFloorplanAlignment([gx, gz], movingAnchors.length > 0
+                ? movingAnchors
+                : [{ nodeId: node.id, kind: 'corner', x: gx, z: gz }], candidates, { bypass: modifiers.altKey || modifiers.shiftKey });
+            const sx = aligned[0];
+            const sz = aligned[1];
+            if (lastValid && lastValid.position[0] === sx && lastValid.position[2] === sz)
+                return;
+            lastValid = { position: [sx, startY, sz] };
+            useScene.getState().updateNodes([{ id: node.id, data: lastValid }]);
+        },
+        canCommit() {
+            // No overlap / placement rules for stairs in 2D — any pointer-up
+            // position commits, as long as we actually moved. Mirrors the 3D
+            // move tool which also lets stairs land anywhere on the slab.
+            return lastValid !== null;
+        },
+        commit() {
+            // Own the atomic write so the overlay takes the deterministic
+            // commit-path (revert → resume → session.commit()). Same pattern
+            // door / window use.
+            if (!lastValid)
+                return;
+            useScene.getState().updateNodes([{ id: node.id, data: lastValid }]);
+        },
+    };
+    return session;
+};

package/dist/stair/floorplan.d.ts

@@ -0,0 +1,26 @@
+import type { FloorplanGeometry, GeometryContext, StairNode } from '@pascal-app/core';
+/**
+ * Stage C floor-plan emitter for stair. The stair is the parent; its
+ * children are the `stair-segment`s whose transforms are *cumulative*
+ * (each flight attaches to the previous segment's end via
+ * `computeFloorplanStairSegmentTransforms` — `attachmentSide` rotates
+ * the chain ±π/2, segment length advances along the chain). Because no
+ * individual segment can compute its polygon in isolation, the stair
+ * emits the whole stack as one registry entry; `stair-segment` itself
+ * has no `def.floorplan` (the registry layer renders the parent here
+ * and skips children that don't ship a builder).
+ *
+ * The actual cumulative walk + segment / arrow / inner-band / tread-bar
+ * geometry lives in `editor/src/lib/floorplan/stairs.ts` via
+ * `buildFloorplanStairEntry`. We re-export that from `@pascal-app/editor`
+ * and emit `FloorplanGeometry` primitives over its output — same shape
+ * pattern the legacy `<FloorplanStairLayer>` consumed, minus the
+ * per-pixel SVG drawing (the registry's `FloorplanGeometryRenderer`
+ * handles that). Curved + spiral stairs fall back to a single curved
+ * hit polygon (`buildFloorplanStairEntry` already returns it); the
+ * arc-band rendering with steps along the sweep is not yet ported —
+ * a follow-up will add either an `arc` primitive or expose the
+ * segment-sampler helpers so we can emit a stitched polyline.
+ */
+export declare function buildStairFloorplan(stair: StairNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,SAAS,EAEV,MAAM,kBAAkB,CAAA;AAgBzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAib1B"}