@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/stair/use-stair-render-data.d.ts

@@ -0,0 +1,319 @@
+import { type StairNode } from '@pascal-app/core';
+export declare function useStairTotalRise(stair: StairNode): number;
+export declare function useStairRenderData(stair: StairNode): {
+    stair: {
+        object: "node";
+        name?: string | undefined;
+        parentId: string | null;
+        visible: boolean;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "orthographic" | "perspective";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        metadata: Record<string, unknown>;
+        provenance?: {
+            refs: {
+                ns?: string | undefined;
+                id: string;
+                role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+            }[];
+            lineage?: {
+                op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        id: `stair_${string}`;
+        type: "stair";
+        material?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        railingMaterial?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        railingMaterialPreset?: string | undefined;
+        treadMaterial?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        treadMaterialPreset?: string | undefined;
+        sideMaterial?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        sideMaterialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        position: [number, number, number];
+        rotation: number;
+        supportSlabId?: string | undefined;
+        stairType: "curved" | "spiral" | "straight";
+        fromLevelId: string | null;
+        toLevelId: string | null;
+        deckSlabId?: string | undefined;
+        slabOpeningMode: "destination" | "none";
+        openingOffset: number;
+        width: number;
+        totalRise?: number | undefined;
+        designTargets?: {
+            maxRiserHeight: number;
+            minimumGoing: number;
+            targetGoing: number;
+            minimumHeadroom: number;
+        } | undefined;
+        uniformRisers?: boolean | undefined;
+        stepCount: number;
+        autoSurfaceSnap?: boolean | undefined;
+        destinationSurfaceId?: string | undefined;
+        thickness: number;
+        fillToFloor: boolean;
+        construction?: {
+            mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
+            waistThickness: number;
+            treadThickness: number;
+            riserThickness: number;
+            nosing: number;
+            finishThickness: number;
+            closedRisers: boolean;
+            stringerWidth: number;
+            stringerDepth: number;
+        } | undefined;
+        innerRadius: number;
+        sweepAngle: number;
+        topLandingMode: "integrated" | "none";
+        topLandingDepth: number;
+        showCenterColumn: boolean;
+        showStepSupports: boolean;
+        railingMode: "both" | "left" | "none" | "right";
+        railingHeight: number;
+        railingStyle?: "balusters" | "boards" | "cable" | "glass" | "metal" | "post-and-rail" | undefined;
+        railingPath?: "continuous" | "original" | undefined;
+        handrail?: {
+            mode: "both" | "left" | "none" | "right";
+            height: number;
+            diameter: number;
+            offset: number;
+            bottom?: {
+                extension: number;
+                return: "floor" | "none" | "post" | "wall";
+                returnLength: number;
+            } | undefined;
+            top?: {
+                extension: number;
+                return: "floor" | "none" | "post" | "wall";
+                returnLength: number;
+            } | undefined;
+        } | undefined;
+        railingTopPost?: boolean | undefined;
+        railingTopReach?: number | undefined;
+        railingPostThrough?: boolean | undefined;
+        children: `sseg_${string}`[];
+    };
+    segments: {
+        object: "node";
+        name?: string | undefined;
+        parentId: string | null;
+        visible: boolean;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "orthographic" | "perspective";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        metadata: Record<string, unknown>;
+        provenance?: {
+            refs: {
+                ns?: string | undefined;
+                id: string;
+                role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+            }[];
+            lineage?: {
+                op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        id: `sseg_${string}`;
+        type: "stair-segment";
+        material?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        position: [number, number, number];
+        rotation: number;
+        segmentType: "landing" | "stair";
+        width: number;
+        length: number;
+        height: number;
+        stepCount: number;
+        attachmentSide: "front" | "left" | "right";
+        fillToFloor: boolean;
+        construction?: {
+            mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
+            waistThickness: number;
+            treadThickness: number;
+            riserThickness: number;
+            nosing: number;
+            finishThickness: number;
+            closedRisers: boolean;
+            stringerWidth: number;
+            stringerDepth: number;
+        } | undefined;
+        winder?: {
+            turn: "left" | "right";
+            innerGap: number;
+            walkingLineOffset: number;
+            division: "equal-angle" | "equal-going";
+        } | undefined;
+        thickness: number;
+    }[];
+    nodes: {
+        [k: string]: {
+            object: "node";
+            name?: string | undefined;
+            parentId: string | null;
+            visible: boolean;
+            camera?: {
+                position: [number, number, number];
+                target: [number, number, number];
+                mode: "orthographic" | "perspective";
+                fov?: number | undefined;
+                zoom?: number | undefined;
+            } | undefined;
+            metadata: Record<string, unknown>;
+            provenance?: {
+                refs: {
+                    ns?: string | undefined;
+                    id: string;
+                    role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+                }[];
+                lineage?: {
+                    op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                    fromIds: string[];
+                } | undefined;
+            } | undefined;
+            id: `sseg_${string}`;
+            type: "stair-segment";
+            material?: {
+                id?: string | undefined;
+                preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+                properties?: {
+                    color: string;
+                    roughness: number;
+                    metalness: number;
+                    opacity: number;
+                    transparent: boolean;
+                    side: "back" | "double" | "front";
+                } | undefined;
+                texture?: {
+                    url: string;
+                    repeat?: [number, number] | undefined;
+                    scale?: number | undefined;
+                } | undefined;
+            } | undefined;
+            materialPreset?: string | undefined;
+            slots?: Record<string, string> | undefined;
+            position: [number, number, number];
+            rotation: number;
+            segmentType: "landing" | "stair";
+            width: number;
+            length: number;
+            height: number;
+            stepCount: number;
+            attachmentSide: "front" | "left" | "right";
+            fillToFloor: boolean;
+            construction?: {
+                mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
+                waistThickness: number;
+                treadThickness: number;
+                riserThickness: number;
+                nosing: number;
+                finishThickness: number;
+                closedRisers: boolean;
+                stringerWidth: number;
+                stringerDepth: number;
+            } | undefined;
+            winder?: {
+                turn: "left" | "right";
+                innerGap: number;
+                walkingLineOffset: number;
+                division: "equal-angle" | "equal-going";
+            } | undefined;
+            thickness: number;
+        };
+    };
+    totalRise: number;
+};
+export type StairRenderData = ReturnType<typeof useStairRenderData>;
+//# sourceMappingURL=use-stair-render-data.d.ts.map

package/dist/stair/use-stair-render-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stair-render-data.d.ts","sourceRoot":"","sources":["../../src/stair/use-stair-render-data.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,UAkCjD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBlD;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/stair/use-stair-render-data.js

@@ -0,0 +1,73 @@
+'use client';
+import { resolveStairTotalRise, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { useMemo, useSyncExternalStore } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+const effectiveNodesMemo = new WeakMap();
+function effectiveRiseNodes(nodes, overrides) {
+    if (!overrides.size)
+        return nodes;
+    let cache = effectiveNodesMemo.get(nodes);
+    if (!cache) {
+        cache = new WeakMap();
+        effectiveNodesMemo.set(nodes, cache);
+    }
+    const cached = cache.get(overrides);
+    if (cached)
+        return cached;
+    const effective = { ...nodes };
+    for (const [id, override] of overrides) {
+        const node = nodes[id];
+        if (node)
+            effective[id] = { ...node, ...override };
+    }
+    cache.set(overrides, effective);
+    return effective;
+}
+export function useStairTotalRise(stair) {
+    const selector = useMemo(() => {
+        let lastNodes;
+        let rise = 0;
+        const snapshot = () => {
+            if (stair.totalRise !== undefined)
+                return stair.totalRise;
+            const nodes = effectiveRiseNodes(useScene.getState().nodes, useLiveNodeOverrides.getState().overrides);
+            if (nodes !== lastNodes) {
+                rise = resolveStairTotalRise(stair, nodes);
+                lastNodes = nodes;
+            }
+            return rise;
+        };
+        const subscribe = (onChange) => {
+            let previous = snapshot();
+            const check = () => {
+                const current = snapshot();
+                if (Object.is(previous, current))
+                    return;
+                previous = current;
+                onChange();
+            };
+            const scene = useScene.subscribe(check);
+            const live = useLiveNodeOverrides.subscribe(check);
+            return () => {
+                scene();
+                live();
+            };
+        };
+        return { snapshot, subscribe };
+    }, [stair]);
+    return useSyncExternalStore(selector.subscribe, selector.snapshot, selector.snapshot);
+}
+export function useStairRenderData(stair) {
+    const children = useScene(useShallow((state) => stair.children.map((id) => state.nodes[id])));
+    const overrides = useLiveNodeOverrides(useShallow((state) => stair.children.map((id) => state.overrides.get(id))));
+    const segments = useMemo(() => children
+        .map((child, index) => {
+        const override = overrides[index];
+        return child && override ? { ...child, ...override } : child;
+    })
+        .filter((child) => child?.type === 'stair-segment'), [children, overrides]);
+    const totalRise = useStairTotalRise(stair);
+    const resolvedStair = useMemo(() => (stair.totalRise === totalRise ? stair : { ...stair, totalRise }), [stair, totalRise]);
+    const nodes = useMemo(() => Object.fromEntries(segments.map((segment) => [segment.id, segment])), [segments]);
+    return { stair: resolvedStair, segments, nodes, totalRise };
+}

package/dist/stair-segment/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { StairSegmentNode } from './schema';
+import { StairSegmentNode } from './schema.js';
 /**
  * Stair segment — Stage A. Child of a stair node; per-flight geometry.
  * Built by `StairSystem` registered on the parent stair definition.

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA2F3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAiD1E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA6H3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAoD1E,CAAA"}

package/dist/stair-segment/definition.js

@@ -1,16 +1,37 @@
-import { StairSegmentNode as StairSegmentNodeSchema, } from '@pascal-app/core';
-import { stairSegmentParametrics } from './parametrics';
-import { StairSegmentNode } from './schema';
+import { planStairFlightHeightEdit, resolveStairWinder, StairSegmentNode as StairSegmentNodeSchema, stairSegmentSlots, } from '@pascal-app/core';
+import { stairSegmentPaint } from '../stair/paint.js';
+import { stairSegmentParametrics } from './parametrics.js';
+import { StairSegmentNode } from './schema.js';
 const SIDE_HANDLE_OFFSET = 0.24;
 const LENGTH_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
-const MIN_SEGMENT_WIDTH = 0.4;
-const MIN_SEGMENT_LENGTH = 0.4;
-const MIN_SEGMENT_HEIGHT = 0.1;
+const MIN_SEGMENT_WIDTH = 0.001;
+const MIN_SEGMENT_LENGTH = 0.001;
+const MIN_SEGMENT_HEIGHT = 0.001;
 // Width grows symmetrically around the chain centerline — the chain owns
 // segment.position so writing a new center here would be clobbered next
 // frame by `syncSegmentMeshTransforms`. We just write `width` and let the
 // chain re-center.
+function footprintBounds(node) {
+    let footprint;
+    try {
+        footprint = resolveStairWinder(node)?.footprint;
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+    }
+    footprint ??= [
+        [-node.width / 2, 0],
+        [node.width / 2, node.length],
+    ];
+    return {
+        minX: Math.min(...footprint.map(([x]) => x)),
+        maxX: Math.max(...footprint.map(([x]) => x)),
+        minZ: Math.min(...footprint.map(([, z]) => z)),
+        maxZ: Math.max(...footprint.map(([, z]) => z)),
+    };
+}
 function stairSegmentWidthHandle(side) {
     return {
         kind: 'linear-resize',
@@ -24,9 +45,11 @@ function stairSegmentWidthHandle(side) {
         apply: (_n, newValue) => ({ width: newValue }),
         placement: {
             position: (n) => [
-                (side === 'right' ? 1 : -1) * (n.width / 2 + SIDE_HANDLE_OFFSET),
+                side === 'right'
+                    ? footprintBounds(n).maxX + SIDE_HANDLE_OFFSET
+                    : footprintBounds(n).minX - SIDE_HANDLE_OFFSET,
                 n.height / 2,
-                n.length / 2,
+                (footprintBounds(n).minZ + footprintBounds(n).maxZ) / 2,
             ],
             rotationY: () => (side === 'right' ? 0 : Math.PI),
         },
@@ -68,8 +91,21 @@ function stairSegmentHeightHandle() {
         min: MIN_SEGMENT_HEIGHT,
         currentValue: (n) => n.height,
         apply: (_n, newValue) => ({ height: newValue }),
+        previewOverrides: (node, height, scene) => planStairFlightHeightEdit(node, height, scene.nodes())
+            .slice(1)
+            .map(({ id, data }) => [id, data]),
+        commit: (node, patch, scene) => {
+            if (patch.height === undefined)
+                return;
+            const updates = planStairFlightHeightEdit(node, patch.height, scene.nodes());
+            scene.applyChanges?.({ update: updates });
+        },
         placement: {
-            position: (n) => [0, n.height + HEIGHT_HANDLE_OFFSET, n.length / 2],
+            position: (n) => [
+                (footprintBounds(n).minX + footprintBounds(n).maxX) / 2,
+                n.height + HEIGHT_HANDLE_OFFSET,
+                (footprintBounds(n).minZ + footprintBounds(n).maxZ) / 2,
+            ],
         },
         portal: 'grandparent',
     };
@@ -78,7 +114,7 @@ function stairSegmentHandles(node) {
     const handles = [
         stairSegmentWidthHandle('left'),
         stairSegmentWidthHandle('right'),
-        stairSegmentLengthHandle(),
+        ...(node.winder ? [] : [stairSegmentLengthHandle()]),
     ];
     if (node.segmentType === 'stair') {
         handles.push(stairSegmentHeightHandle());
@@ -91,7 +127,7 @@ function stairSegmentHandles(node) {
  */
 export const stairSegmentDefinition = {
     kind: 'stair-segment',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: StairSegmentNode,
     category: 'structure',
     surfaceRole: 'joinery',
@@ -107,19 +143,21 @@ export const stairSegmentDefinition = {
         selectable: { hitVolume: 'bbox' },
         duplicable: false,
         deletable: true,
+        slots: stairSegmentSlots,
+        paint: stairSegmentPaint,
     },
     // Bespoke move shared with roof / roof-segment / stair via
     // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
     // affordance lookup rather than a hardcoded dispatcher arm.
     affordanceTools: {
-        move: () => import('../shared/move-roof-tool'),
+        move: () => import('../shared/move-roof-tool.js'),
     },
     parametrics: stairSegmentParametrics,
     handles: stairSegmentHandles,
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     presentation: {
         label: 'Stair Segment',
@@ -129,6 +167,6 @@ export const stairSegmentDefinition = {
         paletteOrder: 111,
     },
     mcp: {
-        description: 'A single stair flight with run + rise + tread parameters.',
+        description: 'A straight flight, landing or quarter-turn winder. Winders use an inner gap, walking-line offset and equal-going or equal-angle division; length applies only to straight flights.',
     },
 };

package/dist/stair-segment/index.d.ts

@@ -1,2 +1,2 @@
-export { stairSegmentDefinition } from './definition';
+export { stairSegmentDefinition } from './definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/stair-segment/index.js

@@ -1 +1 @@
-export { stairSegmentDefinition } from './definition';
+export { stairSegmentDefinition } from './definition.js';

package/dist/stair-segment/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair-segment/panel.tsx"],"names":[],"mappings":"AAwCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,uCAmUxC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair-segment/panel.tsx"],"names":[],"mappings":"AA2CA,MAAM,CAAC,OAAO,UAAU,iBAAiB,uCAqXxC"}