@pascal-app/nodes 0.1.1 → 1.0.0-beta.2

package/dist/spawn/renderer.js

@@ -1,29 +1,18 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useLiveTransforms, useRegistry, } from '@pascal-app/core';
 import { createDefaultMaterial, useNodeEvents, useViewer } from '@pascal-app/viewer';
 import { useMemo, useRef } from 'react';
 import { Color, Shape } from 'three';
 const SPAWN_COLOR = new Color('#818cf8');
+const disableRaycast = () => { };
 /**
- * Registry-driven spawn renderer. Behaviorally identical to the legacy
- * `@pascal-app/viewer/components/renderers/spawn/spawn-renderer.tsx` — same
- * geometry and event surface. When the spawn definition lands
- * in `builtinPlugin.nodes`, the Phase 0 dispatch shims switch the renderer
- * here and the legacy one is short-circuited.
- *
- * Lives in `@pascal-app/nodes` (not viewer) so the kind owns its own render
- * code. Phase 5's batch migration applies the same pattern to every node.
+ * Shared visible spawn model. Placement uses the same four meshes as the
+ * committed renderer so the orientation shown before click is authoritative.
  */
-const SpawnRenderer = ({ node }) => {
-    const ref = useRef(null);
+const SpawnVisual = ({ ghost = false, layers, node, }) => {
     const handlers = useNodeEvents(node, 'spawn');
-    const liveOverride = useLiveNodeOverrides((state) => state.get(node.id));
-    const effectiveNode = useMemo(() => (liveOverride ? { ...node, ...liveOverride } : node), [node, liveOverride]);
-    const liveTransform = useLiveTransforms((state) => state.get(node.id));
-    const walkthroughMode = useViewer((state) => state.walkthroughMode);
     const shading = useViewer((state) => state.shading);
-    useRegistry(node.id, 'spawn', ref);
     const material = useMemo(() => {
         const next = createDefaultMaterial('#818cf8', 0.42, shading);
         next.emissive?.copy(SPAWN_COLOR);
@@ -31,9 +20,14 @@ const SpawnRenderer = ({ node }) => {
             next.emissiveIntensity = 0.08;
         if ('metalness' in next)
             next.metalness = 0.03;
+        if (ghost) {
+            next.transparent = true;
+            next.opacity = 0.5;
+            next.depthWrite = false;
+        }
         next.needsUpdate = true;
         return next;
-    }, [shading]);
+    }, [ghost, shading]);
     const arrowShape = useMemo(() => {
         const shape = new Shape();
         shape.moveTo(0, 0.24);
@@ -42,6 +36,26 @@ const SpawnRenderer = ({ node }) => {
         shape.closePath();
         return shape;
     }, []);
-    return (_jsxs("group", { position: liveTransform?.position ?? effectiveNode.position, ref: ref, rotation: [0, liveTransform?.rotation ?? effectiveNode.rotation, 0], visible: !walkthroughMode && effectiveNode.visible !== false, children: [_jsxs("mesh", { position: [0, 0.09, 0], rotation: [-Math.PI / 2, 0, 0], ...handlers, children: [_jsx("ringGeometry", { args: [0.34, 0.48, 48] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { position: [0, 0.1, -0.52], rotation: [-Math.PI / 2, 0, 0], ...handlers, children: [_jsx("shapeGeometry", { args: [arrowShape] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { position: [0, 0.41, 0], ...handlers, children: [_jsx("boxGeometry", { args: [0.3, 0.54, 0.16] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { position: [0, 0.83, 0], ...handlers, children: [_jsx("boxGeometry", { args: [0.18, 0.18, 0.18] }), _jsx("primitive", { attach: "material", object: material })] })] }));
+    return (_jsxs(_Fragment, { children: [_jsxs("mesh", { layers: layers, position: [0, 0.09, 0], raycast: ghost ? disableRaycast : undefined, rotation: [-Math.PI / 2, 0, 0], ...(ghost ? {} : handlers), children: [_jsx("ringGeometry", { args: [0.34, 0.48, 48] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { layers: layers, position: [0, 0.1, -0.52], raycast: ghost ? disableRaycast : undefined, rotation: [-Math.PI / 2, 0, 0], ...(ghost ? {} : handlers), children: [_jsx("shapeGeometry", { args: [arrowShape] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { layers: layers, position: [0, 0.41, 0], raycast: ghost ? disableRaycast : undefined, ...(ghost ? {} : handlers), children: [_jsx("boxGeometry", { args: [0.3, 0.54, 0.16] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { layers: layers, position: [0, 0.83, 0], raycast: ghost ? disableRaycast : undefined, ...(ghost ? {} : handlers), children: [_jsx("boxGeometry", { args: [0.18, 0.18, 0.18] }), _jsx("primitive", { attach: "material", object: material })] })] }));
+};
+export const SpawnPreview = ({ layers, node }) => (_jsx(SpawnVisual, { ghost: true, layers: layers, node: node }));
+/**
+ * Registry-driven spawn renderer. Behaviorally identical to the legacy
+ * `@pascal-app/viewer/components/renderers/spawn/spawn-renderer.tsx` — same
+ * geometry and event surface. When the spawn definition lands
+ * in `builtinPlugin.nodes`, the Phase 0 dispatch shims switch the renderer
+ * here and the legacy one is short-circuited.
+ *
+ * Lives in `@pascal-app/nodes` (not viewer) so the kind owns its own render
+ * code. Phase 5's batch migration applies the same pattern to every node.
+ */
+const SpawnRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const liveOverride = useLiveNodeOverrides((state) => state.get(node.id));
+    const effectiveNode = useMemo(() => (liveOverride ? { ...node, ...liveOverride } : node), [node, liveOverride]);
+    const liveTransform = useLiveTransforms((state) => state.get(node.id));
+    const walkthroughMode = useViewer((state) => state.walkthroughMode);
+    useRegistry(node.id, 'spawn', ref);
+    return (_jsx("group", { position: liveTransform?.position ?? effectiveNode.position, ref: ref, rotation: [0, liveTransform?.rotation ?? effectiveNode.rotation, 0], visible: !walkthroughMode && effectiveNode.visible !== false, children: _jsx(SpawnVisual, { node: effectiveNode }) }));
 };
 export default SpawnRenderer;

package/dist/spawn/tool.d.ts

@@ -1,8 +1,8 @@
 /**
  * Registry-driven spawn placement tool. Reads `activeLevelId` from useViewer
  * directly (no props), broadcasts placement via store updates + SFX, and
- * uses the shared CursorSphere from @pascal-app/editor for visual parity
- * with legacy placement tools. Snapping is mode-driven (grid + Figma-style
+ * shows the real spawn model as a translucent placement ghost, and supports
+ * R/T yaw before commit. Snapping is mode-driven (grid + Figma-style
  * alignment "lines"), matching the shelf / column build tools.
  */
 declare const SpawnTool: () => import("react").JSX.Element | null;

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/spawn/tool.tsx"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,QAAA,MAAM,SAAS,0CAwGd,CAAA;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/spawn/tool.tsx"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,QAAA,MAAM,SAAS,0CA8Kd,CAAA;AAED,eAAe,SAAS,CAAA"}

package/dist/spawn/tool.js

@@ -1,10 +1,12 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { collectAlignmentAnchors, emitter, SpawnNode, useScene, } from '@pascal-app/core';
-import { CursorSphere, getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { collectAlignmentAnchors, emitter, resolveSupportSlabPatch, SpawnNode, useScene, } from '@pascal-app/core';
+import { EDITOR_LAYER, getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
-import { useEffect, useMemo, useRef } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, } from '../shared/floor-placement';
+import { SpawnPreview } from './renderer';
+const ROTATION_STEP = Math.PI / 4;
 function getExistingSpawnIds() {
     const nodes = useScene.getState().nodes;
     return Object.values(nodes)
@@ -15,23 +17,34 @@ function getExistingSpawnIds() {
 /**
  * Registry-driven spawn placement tool. Reads `activeLevelId` from useViewer
  * directly (no props), broadcasts placement via store updates + SFX, and
- * uses the shared CursorSphere from @pascal-app/editor for visual parity
- * with legacy placement tools. Snapping is mode-driven (grid + Figma-style
+ * shows the real spawn model as a translucent placement ghost, and supports
+ * R/T yaw before commit. Snapping is mode-driven (grid + Figma-style
  * alignment "lines"), matching the shelf / column build tools.
  */
 const SpawnTool = () => {
     const activeLevelId = useViewer((state) => state.selection.levelId);
     const cursorRef = useRef(null);
     const previousSnapRef = useRef(null);
+    const rotationRef = useRef(0);
+    const cursorVisibleRef = useRef(false);
+    const [cursorVisible, setCursorVisible] = useState(false);
     // Default spawn for the footprint anchors the alignment solver reads.
     const previewNode = useMemo(() => SpawnNode.parse({ name: 'Spawn Point', position: [0, 0, 0], rotation: 0 }), []);
     useEffect(() => {
         if (!activeLevelId)
             return;
         previousSnapRef.current = null;
+        rotationRef.current = 0;
+        cursorRef.current?.rotation.set(0, 0, 0);
+        cursorVisibleRef.current = false;
+        setCursorVisible(false);
         const lastCursorRef = { current: null };
         let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
         const onGridMove = (event) => {
+            if (!cursorVisibleRef.current) {
+                cursorVisibleRef.current = true;
+                setCursorVisible(true);
+            }
             const { position, guides } = resolveAlignedFloorPlacement({
                 node: previewNode,
                 rawX: event.localPosition[0],
@@ -46,11 +59,16 @@ const SpawnTool = () => {
             const visualPosition = getFloorStackPreviewPosition({
                 node: previewNode,
                 position,
-                rotation: 0,
+                rotation: rotationRef.current,
                 levelId: activeLevelId,
             });
             cursorRef.current?.position.set(...visualPosition);
             lastCursorRef.current = position;
+            usePlacementPreview.getState().set({
+                ...previewNode,
+                position,
+                rotation: rotationRef.current,
+            });
             const nextSnapKey = movementSfxStepKey({
                 coords: [position[0], position[2]],
                 gridSnapActive: isGridSnapActive(),
@@ -68,10 +86,18 @@ const SpawnTool = () => {
             const [existingSpawnId, ...duplicates] = getExistingSpawnIds();
             let placedId;
             if (existingSpawnId) {
+                const live = useScene.getState().nodes[existingSpawnId];
+                const effectiveSpawn = SpawnNode.parse({
+                    ...live,
+                    parentId: activeLevelId,
+                    position: next,
+                    rotation: rotationRef.current,
+                });
                 useScene.getState().updateNode(existingSpawnId, {
                     parentId: activeLevelId,
                     position: next,
-                    rotation: 0,
+                    rotation: rotationRef.current,
+                    ...resolveSupportSlabPatch(effectiveSpawn, useScene.getState().nodes),
                 });
                 if (duplicates.length > 0) {
                     useScene.getState().deleteNodes(duplicates);
@@ -82,28 +108,69 @@ const SpawnTool = () => {
                 const spawn = SpawnNode.parse({
                     name: 'Spawn Point',
                     position: next,
-                    rotation: 0,
+                    rotation: rotationRef.current,
+                    parentId: activeLevelId,
+                });
+                const committedSpawn = SpawnNode.parse({
+                    ...spawn,
+                    ...resolveSupportSlabPatch(spawn, useScene.getState().nodes),
                 });
-                useScene.getState().createNode(spawn, activeLevelId);
-                placedId = spawn.id;
+                useScene.getState().createNode(committedSpawn, activeLevelId);
+                placedId = committedSpawn.id;
             }
             useViewer.getState().setSelection({ selectedIds: [placedId] });
             triggerSFX('sfx:structure-build');
             alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
             useAlignmentGuides.getState().clear();
+            usePlacementPreview.getState().clear();
             useEditor.getState().setTool(null);
             useEditor.getState().setMode('select');
         };
+        const onKeyDown = (event) => {
+            const target = event.target;
+            if (event.repeat ||
+                event.metaKey ||
+                event.ctrlKey ||
+                event.altKey ||
+                target?.tagName === 'INPUT' ||
+                target?.tagName === 'TEXTAREA' ||
+                target?.isContentEditable) {
+                return;
+            }
+            let delta = 0;
+            if (event.key === 'r' || event.key === 'R')
+                delta = ROTATION_STEP;
+            else if (event.key === 't' || event.key === 'T')
+                delta = -ROTATION_STEP;
+            else
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            rotationRef.current += delta;
+            if (cursorRef.current)
+                cursorRef.current.rotation.y = rotationRef.current;
+            if (lastCursorRef.current) {
+                usePlacementPreview.getState().set({
+                    ...previewNode,
+                    position: lastCursorRef.current,
+                    rotation: rotationRef.current,
+                });
+            }
+            triggerSFX('sfx:item-rotate');
+        };
         emitter.on('grid:move', onGridMove);
         emitter.on('grid:click', onGridClick);
+        window.addEventListener('keydown', onKeyDown, true);
         return () => {
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
+            window.removeEventListener('keydown', onKeyDown, true);
             useAlignmentGuides.getState().clear();
+            usePlacementPreview.getState().clear();
         };
     }, [activeLevelId, previewNode]);
     if (!activeLevelId)
         return null;
-    return _jsx(CursorSphere, { color: "#818cf8", height: 2.2, ref: cursorRef });
+    return (_jsx("group", { ref: cursorRef, visible: cursorVisible, children: _jsx(SpawnPreview, { layers: EDITOR_LAYER, node: previewNode }) }));
 };
 export default SpawnTool;

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AAkZzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA0G5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAQpB,MAAM,kBAAkB,CAAA;AAuZzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAgH5D,CAAA"}

package/dist/stair/definition.js

@@ -1,4 +1,4 @@
-import { StairNode as StairNodeSchema, stairFootprintAABB, } from '@pascal-app/core';
+import { resolveStairTotalRise, StairNode as StairNodeSchema, stairFootprintAABB, useScene, } from '@pascal-app/core';
 const MIN_CURVED_RISE = 0.3;
 const MIN_CURVED_WIDTH = 0.4;
 const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.05;
@@ -21,10 +21,13 @@ const CURVED_INNER_RING_MIN = 0.05;
 const STAIR_ROTATE_CORNER_OFFSET = 0.4;
 const STAIR_ROTATE_RING_OFFSET = 0.08;
 const STAIR_MOVE_FRONT_OFFSET = 0.35;
+function readTotalRise(node) {
+    return Math.max(resolveStairTotalRise(node, useScene.getState().nodes), 0.1);
+}
 function readCurvedStairGeometry(node) {
     const isSpiral = node.stairType === 'spiral';
     const stepCount = Math.max(2, Math.round(node.stepCount ?? 10));
-    const totalRise = Math.max(node.totalRise ?? 2.5, 0.1);
+    const totalRise = readTotalRise(node);
     const width = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
     const minInnerRadius = isSpiral ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED;
     const innerRadius = Math.max(minInnerRadius, node.innerRadius ?? 0.9);
@@ -61,7 +64,7 @@ function fallbackStraightStairMoveBounds(node) {
         maxX: width / 2,
         minZ: 0,
         maxZ: depth,
-        height: Math.max(node.totalRise ?? 2.5, 0.1),
+        height: readTotalRise(node),
     };
 }
 function readStraightStairMoveBounds(node, sceneApi) {
@@ -119,7 +122,7 @@ function curvedRiseHandle() {
         axis: 'y',
         anchor: 'min',
         min: MIN_CURVED_RISE,
-        currentValue: (n) => Math.max(n.totalRise ?? 2.5, 0.1),
+        currentValue: readTotalRise,
         apply: (_n, newRise) => ({ totalRise: newRise }),
         placement: {
             position: (n) => {
@@ -255,7 +258,7 @@ function stairRotateGizmoPosition(n) {
         return [radius * Math.cos(angle), g.totalRise / 2, radius * Math.sin(angle)];
     }
     const width = Math.max(n.width ?? 1, MIN_CURVED_WIDTH);
-    const yMid = Math.max(n.totalRise ?? 2.5, 0.1) / 2;
+    const yMid = readTotalRise(n) / 2;
     return [width / 2 + STAIR_ROTATE_CORNER_OFFSET, yMid, -STAIR_ROTATE_CORNER_OFFSET];
 }
 function stairRotateHandle() {
@@ -290,7 +293,7 @@ function stairRotateHandle() {
                 return (Math.hypot(width / 2 + STAIR_ROTATE_CORNER_OFFSET, STAIR_ROTATE_CORNER_OFFSET) +
                     STAIR_ROTATE_RING_OFFSET);
             },
-            y: (n) => Math.max(n.totalRise ?? 2.5, 0.1) / 2,
+            y: (n) => readTotalRise(n) / 2,
         },
     };
 }
@@ -346,6 +349,11 @@ export const stairDefinition = {
     schemaVersion: 1,
     schema: StairNode,
     category: 'structure',
+    extensions: {
+        'pascal:editor/floorplan': {
+            linkedLevelIds: (node) => node.toLevelId && node.toLevelId !== node.parentId ? [node.toLevelId] : [],
+        },
+    },
     snapProfile: 'structural',
     // A footprint with a clear front: you approach a stair from the low end,
     // which sits on the -Z side of the run (the run ascends along +Z). Show the
@@ -377,7 +385,7 @@ export const stairDefinition = {
             const aabb = stairFootprintAABB(node, nodes);
             return aabb ? { shape: 'aabb', ...aabb } : null;
         },
-        duplicable: true,
+        duplicable: { subtree: true },
         deletable: true,
         floorPlaced: {
             footprints: (node, ctx) => ctx ? getStairFloorPlacedFootprints(node, ctx.nodes) : [],

package/dist/stair/destination.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, StairNode } from '@pascal-app/core';
+/**
+ * Computes the stair patch for a destination ("To") switch.
+ *
+ * Attaching to a deck clears any explicit custom rise (the rise follows the
+ * deck's elevation from now on) and disables the auto cutout — a deck stair
+ * lands ON its destination slab, not through it. Switching a deck-attached
+ * stair back to a level clears both again so the rise re-derives from the
+ * storey height, and restores `slabOpeningMode: 'destination'` — the
+ * placement default (the schema default is 'none', but the stair tool places
+ * ordinary stairs with 'destination', so that is what a level-destination
+ * stair regains). Plain level-to-level switches leave rise and opening mode
+ * alone.
+ */
+export declare function getStairDestinationUpdates(stair: StairNode, target: AnyNode | undefined, targetId: string): Partial<StairNode>;
+//# sourceMappingURL=destination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"destination.d.ts","sourceRoot":"","sources":["../../src/stair/destination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE1D;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,CAAC,CAUpB"}

package/dist/stair/destination.js

@@ -0,0 +1,24 @@
+/**
+ * Computes the stair patch for a destination ("To") switch.
+ *
+ * Attaching to a deck clears any explicit custom rise (the rise follows the
+ * deck's elevation from now on) and disables the auto cutout — a deck stair
+ * lands ON its destination slab, not through it. Switching a deck-attached
+ * stair back to a level clears both again so the rise re-derives from the
+ * storey height, and restores `slabOpeningMode: 'destination'` — the
+ * placement default (the schema default is 'none', but the stair tool places
+ * ordinary stairs with 'destination', so that is what a level-destination
+ * stair regains). Plain level-to-level switches leave rise and opening mode
+ * alone.
+ */
+export function getStairDestinationUpdates(stair, target, targetId) {
+    if (target?.type === 'slab') {
+        return { deckSlabId: targetId, totalRise: undefined, slabOpeningMode: 'none' };
+    }
+    const updates = { toLevelId: targetId, deckSlabId: undefined };
+    if (stair.deckSlabId) {
+        updates.totalRise = undefined;
+        updates.slabOpeningMode = 'destination';
+    }
+    return updates;
+}

package/dist/stair/documentation.d.ts

@@ -0,0 +1,8 @@
+import { type FloorplanGeometry, type GeometryContext, type StairNode } from '@pascal-app/core';
+import type { FloorplanStairArrowEntry, FloorplanStairEntry } from '@pascal-app/editor';
+export type StairPlanDirection = 'up' | 'down';
+export declare function resolveStairPlanDirection(stair: StairNode, activeLevelId: string | null | undefined): StairPlanDirection;
+export declare function resolveStraightStairDirectionArrow(entry: FloorplanStairEntry, direction: StairPlanDirection): FloorplanStairArrowEntry | null;
+export declare function stairPlanBreakStep(stepCount: number): number;
+export declare function buildStairDocumentation(stair: StairNode, entry: FloorplanStairEntry, ctx: GeometryContext): FloorplanGeometry[];
+//# sourceMappingURL=documentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"documentation.d.ts","sourceRoot":"","sources":["../../src/stair/documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,oBAAoB,CAAA;AAgB3B,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,MAAM,CAAA;AAE9C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,kBAAkB,CAUpB;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,kBAAkB,GAC5B,wBAAwB,GAAG,IAAI,CA0BjC;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAYrB"}

package/dist/stair/documentation.js

@@ -0,0 +1,245 @@
+import { resolveStairTotalRise, useScene, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { formatConstructionLength, } from '../shared/construction-length';
+const ANNOTATION_OFFSET = 0.28;
+const ANNOTATION_FONT_SIZE = 0.125;
+const DIRECTION_FONT_SIZE = 0.16;
+const BREAK_POSITION = 0.68;
+const BREAK_ZIGZAG = 0.07;
+const MIN_ARROW_HEAD = 0.14;
+const MAX_ARROW_HEAD = 0.24;
+export function resolveStairPlanDirection(stair, activeLevelId) {
+    if (activeLevelId &&
+        stair.toLevelId &&
+        stair.toLevelId !== stair.fromLevelId &&
+        activeLevelId === stair.toLevelId) {
+        return 'down';
+    }
+    return 'up';
+}
+export function resolveStraightStairDirectionArrow(entry, direction) {
+    const arrow = entry.arrow;
+    if (!arrow || direction === 'up')
+        return arrow;
+    const polyline = [...arrow.polyline].reverse();
+    const tip = polyline[polyline.length - 1];
+    const tail = polyline[polyline.length - 2];
+    if (!(tip && tail))
+        return null;
+    const bodyLength = distance(tail, tip);
+    if (bodyLength <= Number.EPSILON)
+        return null;
+    const headLength = clamp(bodyLength * 0.72, MIN_ARROW_HEAD, MAX_ARROW_HEAD);
+    const directionX = (tip.x - tail.x) / bodyLength;
+    const directionY = (tip.y - tail.y) / bodyLength;
+    const base = {
+        x: tip.x - directionX * headLength,
+        y: tip.y - directionY * headLength,
+    };
+    const halfWidth = headLength * 0.34;
+    return {
+        polyline,
+        head: [
+            tip,
+            { x: base.x - directionY * halfWidth, y: base.y + directionX * halfWidth },
+            { x: base.x + directionY * halfWidth, y: base.y - directionX * halfWidth },
+        ],
+    };
+}
+export function stairPlanBreakStep(stepCount) {
+    return Math.max(1, Math.ceil(Math.max(1, Math.round(stepCount)) * BREAK_POSITION));
+}
+export function buildStairDocumentation(stair, entry, ctx) {
+    const activeLevelId = ctx.parent?.type === 'level' ? ctx.parent.id : stair.parentId;
+    const direction = resolveStairPlanDirection(stair, activeLevelId);
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const floorplanContext = readFloorplanContext(ctx);
+    const profile = floorplanContext.purpose === 'document' ? 'document' : 'editor';
+    const metricNotation = floorplanContext.metricNotation;
+    const stroke = ctx.viewState?.palette.measurementStroke ?? '#334155';
+    return stair.stairType === 'straight'
+        ? buildStraightDocumentation(stair, entry, direction, unit, profile, metricNotation, stroke)
+        : buildCurvedDocumentation(stair, direction, unit, profile, metricNotation, stroke);
+}
+function buildStraightDocumentation(stair, entry, direction, unit, profile, metricNotation, stroke) {
+    const geometries = [];
+    const arrow = resolveStraightStairDirectionArrow(entry, direction);
+    const arrowStart = arrow?.polyline[0];
+    const arrowNext = arrow?.polyline[1];
+    if (arrowStart && arrowNext) {
+        const arrowDirection = normalizedDirection(arrowStart, arrowNext);
+        const labelPoint = arrowDirection
+            ? {
+                x: arrowStart.x - arrowDirection.y * 0.18,
+                y: arrowStart.y + arrowDirection.x * 0.18,
+            }
+            : arrowStart;
+        geometries.push(annotationText(labelPoint, direction === 'up' ? 'UP' : 'DN', DIRECTION_FONT_SIZE, stroke));
+    }
+    let railNotePlaced = false;
+    for (const segmentEntry of entry.segments) {
+        if (segmentEntry.segment.segmentType !== 'stair')
+            continue;
+        const frame = segmentFrame(segmentEntry);
+        if (!frame)
+            continue;
+        const segment = segmentEntry.segment;
+        const riserCount = Math.max(1, Math.round(segment.stepCount));
+        const riserHeight = segment.height / riserCount;
+        const treadDepth = segment.length / riserCount;
+        const rightAnchor = {
+            x: frame.rightMid.x + frame.widthDirection.x * ANNOTATION_OFFSET,
+            y: frame.rightMid.y + frame.widthDirection.y * ANNOTATION_OFFSET,
+        };
+        geometries.push(annotationText(rightAnchor, `${riserCount} R @ ${formatConstructionLength(riserHeight, unit, profile, { metricNotation })} · T ${formatConstructionLength(treadDepth, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(segment.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke), buildStraightBreakLine(segmentEntry, stroke));
+        if (!railNotePlaced && stair.railingMode !== 'none') {
+            const leftAnchor = {
+                x: frame.leftMid.x - frame.widthDirection.x * ANNOTATION_OFFSET,
+                y: frame.leftMid.y - frame.widthDirection.y * ANNOTATION_OFFSET,
+            };
+            geometries.push(annotationText(leftAnchor, `RAIL ${stair.railingMode.toLocaleUpperCase()} @ ${formatConstructionLength(stair.railingHeight, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke));
+            railNotePlaced = true;
+        }
+    }
+    return geometries;
+}
+function buildCurvedDocumentation(stair, direction, unit, profile, metricNotation, stroke) {
+    const stairType = stair.stairType === 'spiral' ? 'spiral' : 'curved';
+    const stepCount = Math.max(stairType === 'spiral' ? 6 : 4, Math.round(stair.stepCount));
+    const sweep = normalizedSweep(stair);
+    const startAngle = -stair.rotation - sweep / 2;
+    const endAngle = startAngle + sweep;
+    const innerRadius = Math.max(stairType === 'spiral' ? 0.05 : 0.2, stair.innerRadius);
+    const outerRadius = innerRadius + stair.width;
+    const walkingRadius = innerRadius + stair.width / 2;
+    const riserHeight = resolveStairTotalRise(stair, useScene.getState().nodes) / stepCount;
+    const treadDepth = (Math.abs(sweep) * walkingRadius) / stepCount;
+    const center = { x: stair.position[0], y: stair.position[2] };
+    const noteAngle = (startAngle + endAngle) / 2;
+    const notePoint = arcPoint(center, outerRadius + ANNOTATION_OFFSET, noteAngle);
+    const directionAngle = direction === 'up' ? startAngle + sweep * 0.18 : endAngle - sweep * 0.18;
+    const directionPoint = arcPoint(center, walkingRadius, directionAngle);
+    const breakAngle = startAngle + sweep * BREAK_POSITION;
+    const geometries = [
+        annotationText(notePoint, `${stepCount} R @ ${formatConstructionLength(riserHeight, unit, profile, { metricNotation })} · T(CL) ${formatConstructionLength(treadDepth, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(stair.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke),
+        annotationText(directionPoint, direction === 'up' ? 'UP' : 'DN', DIRECTION_FONT_SIZE, stroke),
+        buildCurvedBreakLine(center, innerRadius, outerRadius, breakAngle, stroke),
+    ];
+    if (stair.railingMode !== 'none') {
+        geometries.push(annotationText(arcPoint(center, outerRadius + ANNOTATION_OFFSET * 2, noteAngle), `RAIL ${stair.railingMode.toLocaleUpperCase()} @ ${formatConstructionLength(stair.railingHeight, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke));
+    }
+    return geometries;
+}
+function buildStraightBreakLine(segmentEntry, stroke) {
+    const [backLeft, backRight, frontRight, frontLeft] = segmentEntry.innerPolygon;
+    if (!(backLeft && backRight && frontRight && frontLeft)) {
+        return { kind: 'group', children: [] };
+    }
+    const left = interpolate(backLeft, frontLeft, BREAK_POSITION);
+    const right = interpolate(backRight, frontRight, BREAK_POSITION);
+    const travel = normalizedDirection(backLeft, frontLeft) ?? { x: 0, y: 1 };
+    return {
+        kind: 'polyline',
+        points: [
+            toTuple(left),
+            offset(interpolate(left, right, 0.42), travel, BREAK_ZIGZAG),
+            offset(interpolate(left, right, 0.5), travel, -BREAK_ZIGZAG),
+            offset(interpolate(left, right, 0.58), travel, BREAK_ZIGZAG),
+            toTuple(right),
+        ],
+        fill: 'none',
+        stroke,
+        strokeWidth: 1.5,
+        vectorEffect: 'non-scaling-stroke',
+        metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
+    };
+}
+function buildCurvedBreakLine(center, innerRadius, outerRadius, angle, stroke) {
+    const radial = { x: Math.cos(angle), y: Math.sin(angle) };
+    const tangent = { x: -radial.y, y: radial.x };
+    const pointAt = (t, tangentOffset = 0) => {
+        const radius = innerRadius + (outerRadius - innerRadius) * t;
+        return [
+            center.x + radial.x * radius + tangent.x * tangentOffset,
+            center.y + radial.y * radius + tangent.y * tangentOffset,
+        ];
+    };
+    return {
+        kind: 'polyline',
+        points: [
+            pointAt(0),
+            pointAt(0.42, BREAK_ZIGZAG),
+            pointAt(0.5, -BREAK_ZIGZAG),
+            pointAt(0.58, BREAK_ZIGZAG),
+            pointAt(1),
+        ],
+        fill: 'none',
+        stroke,
+        strokeWidth: 1.5,
+        vectorEffect: 'non-scaling-stroke',
+        metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
+    };
+}
+function annotationText(point, text, fontSize, fill) {
+    return {
+        kind: 'text',
+        x: point.x,
+        y: point.y,
+        text,
+        fontSize,
+        fill,
+        stroke: '#ffffff',
+        strokeWidth: fontSize * 0.22,
+        paintOrder: 'stroke',
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
+        fontWeight: 650,
+        textAnchor: 'middle',
+        dominantBaseline: 'central',
+        upright: true,
+        metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
+    };
+}
+function segmentFrame(segmentEntry) {
+    const [backLeft, backRight, frontRight, frontLeft] = segmentEntry.polygon;
+    if (!(backLeft && backRight && frontRight && frontLeft))
+        return null;
+    const widthDirection = normalizedDirection(backLeft, backRight);
+    if (!widthDirection)
+        return null;
+    return {
+        widthDirection,
+        leftMid: interpolate(backLeft, frontLeft, 0.5),
+        rightMid: interpolate(backRight, frontRight, 0.5),
+    };
+}
+function normalizedSweep(stair) {
+    const defaultSweep = stair.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2;
+    const sweep = stair.sweepAngle ?? defaultSweep;
+    if (Math.abs(sweep) < Math.PI * 2)
+        return sweep;
+    return Math.sign(sweep || 1) * (Math.PI * 2 - 0.001);
+}
+function arcPoint(center, radius, angle) {
+    return { x: center.x + Math.cos(angle) * radius, y: center.y + Math.sin(angle) * radius };
+}
+function normalizedDirection(start, end) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.hypot(dx, dy);
+    return length <= Number.EPSILON ? null : { x: dx / length, y: dy / length };
+}
+function interpolate(start, end, t) {
+    return { x: start.x + (end.x - start.x) * t, y: start.y + (end.y - start.y) * t };
+}
+function offset(point, direction, amount) {
+    return [point.x + direction.x * amount, point.y + direction.y * amount];
+}
+function toTuple(point) {
+    return [point.x, point.y];
+}
+function distance(first, second) {
+    return Math.hypot(second.x - first.x, second.y - first.y);
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

package/dist/stair/floor-stack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-stack.d.ts","sourceRoot":"","sources":["../../src/stair/floor-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,oBAAoB,EAAE,CAMxB;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,oBAAoB,EAAE,CA4BxB;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,gBAAgB,EAAE,CAgDpB"}
+{"version":3,"file":"floor-stack.d.ts","sourceRoot":"","sources":["../../src/stair/floor-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,oBAAoB,EAAE,CAUxB;AA+CD,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,oBAAoB,EAAE,CA4BxB;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,gBAAgB,EAAE,CAgDpB"}