@pascal-app/core 1.0.3 → 1.0.5

package/dist/systems/stair/stair-footprint.js

@@ -1,3 +1,6 @@
+import { resolveStairConstruction } from './stair-construction.js';
+import { resolveStairArcDimensions } from './stair-layout.js';
+import { resolveStairWinder, resolveStairWinderFootprint } from './stair-winder.js';
 /**
  * XZ rotation in the stair geometry convention (equivalent to rotating by
  * `-angle` in standard math): positive `angle` turns local +Z toward +X. Every
@@ -35,22 +38,31 @@ export function computeSegmentTransforms(segments) {
         let attachX = 0;
         let attachZ = 0;
         let rotationDelta = 0;
-        switch (segment.attachmentSide) {
-            case 'front':
-                attachX = 0;
-                attachZ = previous.length;
-                break;
-            case 'left':
-                attachX = previous.width / 2;
-                attachZ = previous.length / 2;
-                rotationDelta = Math.PI / 2;
-                break;
-            case 'right':
-                attachX = -previous.width / 2;
-                attachZ = previous.length / 2;
-                rotationDelta = -Math.PI / 2;
-                break;
+        const winder = previous.winder
+            ? resolveStairWinder({ ...previous, stepCount: previous.stepCount ?? 1 })
+            : null;
+        if (winder) {
+            attachX = winder.exit.position[0];
+            attachZ = winder.exit.position[2];
+            rotationDelta = winder.exit.rotation;
         }
+        else
+            switch (segment.attachmentSide) {
+                case 'front':
+                    attachX = 0;
+                    attachZ = previous.length;
+                    break;
+                case 'left':
+                    attachX = previous.width / 2;
+                    attachZ = previous.length / 2;
+                    rotationDelta = Math.PI / 2;
+                    break;
+                case 'right':
+                    attachX = -previous.width / 2;
+                    attachZ = previous.length / 2;
+                    rotationDelta = -Math.PI / 2;
+                    break;
+            }
         const [deltaX, deltaZ] = rotateXZ(attachX, attachZ, currentRot);
         currentX += deltaX;
         currentY += previous.height;
@@ -72,8 +84,9 @@ function emptyBox() {
  *  stair-local point by the stair's rotation and offsetting by its position. */
 function extendByLocal(box, stair, localX, localZ) {
     const [wx, wz] = rotateXZ(localX, localZ, stair.rotation ?? 0);
-    const x = stair.position[0] + wx;
-    const z = stair.position[2] + wz;
+    extend(box, stair.position[0] + wx, stair.position[2] + wz);
+}
+function extend(box, x, z) {
     if (x < box.minX)
         box.minX = x;
     if (x > box.maxX)
@@ -86,64 +99,63 @@ function extendByLocal(box, stair, localX, localZ) {
 function finiteBox(box) {
     return Number.isFinite(box.minX) && Number.isFinite(box.minZ) ? box : null;
 }
-/** Bounding box of a straight stair's segment chain, walking the children. */
-function straightStairAABB(stair, nodes) {
+/**
+ * The plan outline of each visible segment of a straight stair's chain (a flight with its nosing, a
+ * landing, a winder's own outline), in the stair's level frame: an L or U stair covers these, not
+ * its bounding box.
+ */
+export function stairSegmentFootprints(stair, nodes) {
     const segments = (stair.children ?? [])
         .map((childId) => nodes[childId])
-        .filter((segment) => segment?.type === 'stair-segment' && segment.visible !== false);
-    if (segments.length === 0)
-        return null;
+        .filter((segment) => segment?.type === 'stair-segment');
     const transforms = computeSegmentTransforms(segments);
-    const box = emptyBox();
-    segments.forEach((segment, index) => {
+    return segments.flatMap((segment, index) => {
         const transform = transforms[index];
-        if (!transform)
-            return;
+        if (!transform || segment.visible === false)
+            return [];
         const halfWidth = segment.width / 2;
+        const nose = segment.segmentType === 'landing'
+            ? 0
+            : (resolveStairConstruction(segment, stair)?.nosing ?? 0);
         // Segment-local footprint: X across the flight, Z along the run from the
         // attachment edge (0) to the far edge (length).
-        for (const [cornerX, cornerZ] of [
-            [-halfWidth, 0],
-            [halfWidth, 0],
+        const corners = resolveStairWinderFootprint(segment, stair) ?? [
+            [-halfWidth, -nose],
+            [halfWidth, -nose],
             [halfWidth, segment.length],
             [-halfWidth, segment.length],
-        ]) {
-            const [offsetX, offsetZ] = rotateXZ(cornerX, cornerZ, transform.rotation);
-            extendByLocal(box, stair, transform.position[0] + offsetX, transform.position[2] + offsetZ);
-        }
+        ];
+        return [
+            corners.map(([cornerX, cornerZ]) => {
+                const [offsetX, offsetZ] = rotateXZ(cornerX, cornerZ, transform.rotation);
+                const [x, z] = rotateXZ(transform.position[0] + offsetX, transform.position[2] + offsetZ, stair.rotation ?? 0);
+                return [stair.position[0] + x, stair.position[2] + z];
+            }),
+        ];
     });
+}
+/** Bounding box of a straight stair's segment chain, walking the children. */
+function straightStairAABB(stair, nodes) {
+    const box = emptyBox();
+    for (const outline of stairSegmentFootprints(stair, nodes))
+        for (const [x, z] of outline)
+            extend(box, x, z);
     return finiteBox(box);
 }
 const ARC_SAMPLES = 48;
-function getSpiralLandingSweep(stair, sweepAngle) {
-    if ((stair.topLandingMode ?? 'none') !== 'integrated')
-        return 0;
-    const innerRadius = Math.max(0.05, stair.innerRadius ?? 0.9);
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const landingDepth = Math.max(0.3, stair.topLandingDepth ?? Math.max(width * 0.9, 0.8));
-    return (Math.min(Math.PI * 0.75, landingDepth / Math.max(innerRadius + width / 2, 0.1)) *
-        Math.sign(sweepAngle || 1));
-}
 /** Bounding box of a curved / spiral stair's annular sector (plus the
  *  integrated spiral top landing when present). */
 function arcStairAABB(stair) {
-    const isSpiral = stair.stairType === 'spiral';
-    const minInnerRadius = isSpiral ? 0.05 : 0.2;
-    const innerRadius = Math.max(minInnerRadius, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9));
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const outerRadius = innerRadius + width;
-    const rawSweep = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
-    let sweep = rawSweep;
-    // A full revolution would make the arc degenerate; clamp just under 2π the
-    // same way the floor-plan emitter does so the sampled box stays correct.
-    if (Math.abs(sweep) >= Math.PI * 2)
-        sweep = Math.sign(sweep || 1) * (Math.PI * 2 - 0.001);
-    const half = sweep / 2;
+    const layout = resolveStairArcDimensions(stair, 0);
+    const { innerRadius, outerRadius } = layout;
+    const rawSweep = layout.sweepAngle;
+    const sweep = Math.sign(rawSweep || 1) * Math.min(Math.abs(rawSweep + layout.nosingSweep), Math.PI * 2);
+    const start = -rawSweep / 2 - layout.nosingSweep;
     const box = emptyBox();
     // Sample both rims across the sweep — the extremes can fall on either the
     // arc ends or an axis crossing in between, so we need the full sweep.
     for (let step = 0; step <= ARC_SAMPLES; step += 1) {
-        const angle = -half + (sweep * step) / ARC_SAMPLES;
+        const angle = start + (sweep * step) / ARC_SAMPLES;
         const cos = Math.cos(angle);
         const sin = Math.sin(angle);
         extendByLocal(box, stair, cos * innerRadius, sin * innerRadius);
@@ -151,8 +163,8 @@ function arcStairAABB(stair) {
     }
     // Integrated spiral top landing renders as an angular extension of the
     // annular stair body, not as a rectangular box outside the outer rim.
-    if (isSpiral && stair.topLandingMode === 'integrated') {
-        const landingSweep = getSpiralLandingSweep(stair, rawSweep);
+    if (layout.landingSweep) {
+        const landingSweep = layout.landingSweep;
         const landingSteps = Math.max(1, Math.ceil(Math.abs(landingSweep) / (Math.PI / 24)));
         for (let step = 0; step <= landingSteps; step += 1) {
             const angle = rawSweep / 2 + (landingSweep * step) / landingSteps;
@@ -176,3 +188,57 @@ export function stairFootprintAABB(stair, nodes) {
     }
     return arcStairAABB(stair);
 }
+export function stairArrivalOpening(stair, nodes) {
+    let start;
+    let end;
+    if (stair.stairType === 'straight') {
+        const segments = stair.children
+            .map((id) => nodes[id])
+            .filter((node) => node?.type === 'stair-segment');
+        const segment = segments.at(-1);
+        const transform = computeSegmentTransforms(segments).at(-1);
+        if (!segment || !transform)
+            return [];
+        const winder = resolveStairWinder(segment);
+        const point = (x) => {
+            const [localX, localZ] = winder
+                ? (() => {
+                    const [dx, dz] = rotateXZ(x, 0, winder.exit.rotation);
+                    return [winder.exit.position[0] + dx, winder.exit.position[2] + dz];
+                })()
+                : [x, segment.length];
+            const [dx, dz] = rotateXZ(localX, localZ, transform.rotation);
+            return [transform.position[0] + dx, transform.position[2] + dz];
+        };
+        start = point(-segment.width / 2);
+        end = point(segment.width / 2);
+    }
+    else {
+        const layout = resolveStairArcDimensions(stair, 0);
+        const inner = layout.innerRadius;
+        const outer = layout.outerRadius;
+        const angle = layout.sweepAngle / 2 + layout.landingSweep;
+        start = [Math.cos(angle) * inner, Math.sin(angle) * inner];
+        end = [Math.cos(angle) * outer, Math.sin(angle) * outer];
+    }
+    // Straddle the arrival line so wall-face clipping and edge tolerances do not close the gap.
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const nx = (-(end[1] - start[1]) / length) * 0.15;
+    const nz = ((end[0] - start[0]) / length) * 0.15;
+    return [
+        [start[0] + nx, start[1] + nz],
+        [end[0] + nx, end[1] + nz],
+        [end[0] - nx, end[1] - nz],
+        [start[0] - nx, start[1] - nz],
+    ].map(([x, z]) => {
+        const [dx, dz] = rotateXZ(x, z, stair.rotation);
+        return [stair.position[0] + dx, stair.position[2] + dz];
+    });
+}
+export function stairDeckLevelId(nodes, node) {
+    const stair = node?.type === 'stair-segment' ? nodes[node.parentId ?? ''] : node;
+    if (stair?.type !== 'stair' || !stair.deckSlabId)
+        return undefined;
+    const deck = nodes[stair.deckSlabId];
+    return deck?.type === 'slab' && deck.support === 'open' ? (deck.parentId ?? undefined) : undefined;
+}

package/dist/systems/stair/stair-layout.d.ts

@@ -0,0 +1,39 @@
+import type { StairNode } from '../../schema/index.js';
+export type StairArcStep = {
+    startAngle: number;
+    endAngle: number;
+    bottom: number;
+    top: number;
+};
+export declare function resolveStairArcDimensions(stair: StairNode, totalRise: number): {
+    stepCount: number;
+    innerRadius: number;
+    outerRadius: number;
+    width: number;
+    walkingRadius: number;
+    sweepAngle: number;
+    stepSweep: number;
+    thickness: number;
+    riserHeight: number;
+    going: number;
+    landingSweep: number;
+    nosingSweep: number;
+};
+/** Walking surfaces own the rise; tread thickness only locates their underside. */
+export declare function resolveStairArcLayout(stair: StairNode, totalRise: number): {
+    stepCount: number;
+    innerRadius: number;
+    outerRadius: number;
+    width: number;
+    walkingRadius: number;
+    sweepAngle: number;
+    stepSweep: number;
+    thickness: number;
+    riserHeight: number;
+    going: number;
+    landingSweep: number;
+    nosingSweep: number;
+    steps: StairArcStep[];
+    landing: StairArcStep | null;
+};
+//# sourceMappingURL=stair-layout.d.ts.map

package/dist/systems/stair/stair-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-layout.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG7C,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;EA8B5E;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;EAwBxE"}

package/dist/systems/stair/stair-layout.js

@@ -0,0 +1,58 @@
+import { measureStairDetail } from './stair-detail-budget.js';
+export function resolveStairArcDimensions(stair, totalRise) {
+    const spiral = stair.stairType === 'spiral';
+    const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
+    const innerRadius = Math.max(0.2, stair.innerRadius ?? 0.9);
+    const width = Math.max(stair.width ?? 1, 0.4);
+    const outerRadius = innerRadius + width;
+    const walkingRadius = innerRadius + width / 2;
+    const sweepAngle = stair.sweepAngle ?? (spiral ? Math.PI * 2 : Math.PI / 2);
+    const stepSweep = sweepAngle / stepCount;
+    const thickness = Math.max(stair.thickness ?? 0.25, 0.001);
+    const riserHeight = totalRise / stepCount;
+    const landingSweep = spiral && stair.topLandingMode === 'integrated'
+        ? Math.min(Math.PI * 2, Math.max(0.001, stair.topLandingDepth ?? 0.9) / walkingRadius) *
+            Math.sign(sweepAngle || 1)
+        : 0;
+    return {
+        stepCount,
+        innerRadius,
+        outerRadius,
+        width,
+        walkingRadius,
+        sweepAngle,
+        stepSweep,
+        thickness,
+        riserHeight,
+        going: Math.abs(stepSweep) * walkingRadius,
+        landingSweep,
+        nosingSweep: ((stair.construction?.nosing ?? 0) / walkingRadius) * Math.sign(sweepAngle || 1),
+    };
+}
+/** Walking surfaces own the rise; tread thickness only locates their underside. */
+export function resolveStairArcLayout(stair, totalRise) {
+    const detail = measureStairDetail(stair, []);
+    if (detail.error)
+        throw new RangeError(detail.error);
+    const dimensions = resolveStairArcDimensions(stair, totalRise);
+    const { stepCount, sweepAngle, stepSweep, riserHeight, thickness, landingSweep } = dimensions;
+    const spiral = stair.stairType === 'spiral';
+    const steps = Array.from({ length: stepCount }, (_, index) => {
+        const top = riserHeight * (index + 1);
+        return {
+            startAngle: -sweepAngle / 2 + stepSweep * index,
+            endAngle: -sweepAngle / 2 + stepSweep * (index + 1),
+            top,
+            bottom: !spiral && stair.fillToFloor ? 0 : top - thickness,
+        };
+    });
+    const landing = landingSweep
+        ? {
+            startAngle: sweepAngle / 2,
+            endAngle: sweepAngle / 2 + landingSweep,
+            top: totalRise,
+            bottom: totalRise - thickness,
+        }
+        : null;
+    return { ...dimensions, steps, landing };
+}