@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/stair/stair-click-guard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Guards for the stair tool's commit triggers.
+ *
+ * One physical validation click can reach the stair tool's commit handler
+ * twice: node-surface clicks (`slab:click`, `wall:click`, …) are synthesized
+ * on *pointerup* by the viewer (`use-node-events`), while `grid:click` rides
+ * the browser's native *click* event from a canvas-level DOM listener
+ * (`use-grid-events`) that deliberately ignores R3F stopPropagation — and
+ * after a single-continuation commit the tool's emitter subscriptions survive
+ * until React unmounts it, which lands only after that native click. Without
+ * these guards a validation click over any node surface (a deck or floor
+ * slab, a wall, another stair) created TWO stairs from one click.
+ *
+ * Same hazard and same countermeasures as
+ * `packages/nodes/src/shared/floor-placement.ts` (`stopPlacementCommitPropagation`)
+ * and the `committed` flag in `move-registry-node-tool.tsx` — reimplemented
+ * here because `@pascal-app/editor` cannot depend on `@pascal-app/nodes`.
+ */
+export type StairCommitGate = {
+    /** True while the armed session may still commit. */
+    shouldCommit: () => boolean;
+    /**
+     * Mark the session exited (single continuation): every further click
+     * trigger reaching the still-subscribed handler — the native follow-up
+     * click, a stray second node click — is refused.
+     */
+    markExited: () => void;
+};
+export declare function createStairCommitGate(): StairCommitGate;
+type ClickSwallowTarget = {
+    addEventListener: (type: string, listener: (event: Event) => void, options?: AddEventListenerOptions) => void;
+    removeEventListener: (type: string, listener: (event: Event) => void, options?: EventListenerOptions) => void;
+};
+/**
+ * Eat the one native browser `click` that follows a pointerup-synthesized
+ * node click, before it reaches the canvas `grid:click` listener (capture
+ * phase on window runs first). Needed in repeat continuation too, where the
+ * tool stays armed and the gate above must keep allowing one commit per
+ * gesture. Self-disarms after the click or `timeoutMs`, whichever first.
+ */
+export declare function swallowFollowUpBrowserClick(target?: ClickSwallowTarget | undefined, timeoutMs?: number): void;
+export {};
+//# sourceMappingURL=stair-click-guard.d.ts.map

package/dist/stair/stair-click-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-click-guard.d.ts","sourceRoot":"","sources":["../../src/stair/stair-click-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,eAAe,GAAG;IAC5B,qDAAqD;IACrD,YAAY,EAAE,MAAM,OAAO,CAAA;IAC3B;;;;OAIG;IACH,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB,CAAA;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAQvD;AAED,KAAK,kBAAkB,GAAG;IACxB,gBAAgB,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,CAAC,EAAE,uBAAuB,KAC9B,IAAI,CAAA;IACT,mBAAmB,EAAE,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,CAAC,EAAE,oBAAoB,KAC3B,IAAI,CAAA;CACV,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,GAAE,kBAAkB,GAAG,SAA8D,EAC3F,SAAS,SAAM,GACd,IAAI,CAQN"}

package/dist/stair/stair-click-guard.js

@@ -0,0 +1,44 @@
+/**
+ * Guards for the stair tool's commit triggers.
+ *
+ * One physical validation click can reach the stair tool's commit handler
+ * twice: node-surface clicks (`slab:click`, `wall:click`, …) are synthesized
+ * on *pointerup* by the viewer (`use-node-events`), while `grid:click` rides
+ * the browser's native *click* event from a canvas-level DOM listener
+ * (`use-grid-events`) that deliberately ignores R3F stopPropagation — and
+ * after a single-continuation commit the tool's emitter subscriptions survive
+ * until React unmounts it, which lands only after that native click. Without
+ * these guards a validation click over any node surface (a deck or floor
+ * slab, a wall, another stair) created TWO stairs from one click.
+ *
+ * Same hazard and same countermeasures as
+ * `packages/nodes/src/shared/floor-placement.ts` (`stopPlacementCommitPropagation`)
+ * and the `committed` flag in `move-registry-node-tool.tsx` — reimplemented
+ * here because `@pascal-app/editor` cannot depend on `@pascal-app/nodes`.
+ */
+export function createStairCommitGate() {
+    let exited = false;
+    return {
+        shouldCommit: () => !exited,
+        markExited: () => {
+            exited = true;
+        },
+    };
+}
+/**
+ * Eat the one native browser `click` that follows a pointerup-synthesized
+ * node click, before it reaches the canvas `grid:click` listener (capture
+ * phase on window runs first). Needed in repeat continuation too, where the
+ * tool stays armed and the gate above must keep allowing one commit per
+ * gesture. Self-disarms after the click or `timeoutMs`, whichever first.
+ */
+export function swallowFollowUpBrowserClick(target = typeof window === 'undefined' ? undefined : window, timeoutMs = 300) {
+    if (!target)
+        return;
+    const swallow = (event) => {
+        event.stopPropagation();
+        event.preventDefault();
+    };
+    target.addEventListener('click', swallow, { capture: true, once: true });
+    setTimeout(() => target.removeEventListener('click', swallow, { capture: true }), timeoutMs);
+}

package/dist/stair/stair-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-type.d.ts","sourceRoot":"","sources":["../../src/stair/stair-type.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAA;AAGzB,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;IAC3B,uFAAuF;IACvF,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAA;CACjC,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,eAAe,CAgBjB"}
+{"version":3,"file":"stair-type.d.ts","sourceRoot":"","sources":["../../src/stair/stair-type.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;IAC3B,uFAAuF;IACvF,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAA;CACjC,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,eAAe,CAgBjB"}

package/dist/stair/stair-type.js

@@ -1,5 +1,4 @@
-import { createStairFlightFromStair, } from '@pascal-app/core';
-import { DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE } from '@pascal-app/editor';
+import { createStairFlightFromStair, DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE, } from '@pascal-app/core';
 /**
  * Computes the stair patch for a type switch.
  *

package/dist/stair/surface-move-preview.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNodeId, type StairSurfaceSnap } from '@pascal-app/core';
+export declare function publishStairMovePreview(stairId: AnyNodeId, flightId: AnyNodeId | undefined, position: [number, number, number], rotation: number, snap: StairSurfaceSnap | null): void;
+export declare function clearStairMovePreview(stairId: AnyNodeId, flightId: AnyNodeId | undefined): void;
+//# sourceMappingURL=surface-move-preview.d.ts.map

package/dist/stair/surface-move-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-move-preview.d.ts","sourceRoot":"","sources":["../../src/stair/surface-move-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EAGtB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,gBAAgB,GAAG,IAAI,QAwC9B;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS,QAOxF"}

package/dist/stair/surface-move-preview.js

@@ -0,0 +1,53 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+export function publishStairMovePreview(stairId, flightId, position, rotation, snap) {
+    const overrides = useLiveNodeOverrides.getState();
+    if (snap) {
+        overrides.setMany([
+            [
+                stairId,
+                {
+                    position,
+                    rotation,
+                    totalRise: snap.totalRise,
+                    stepCount: snap.stepCount,
+                    destinationSurfaceId: snap.surfaceId,
+                    railingMode: 'none',
+                },
+            ],
+            ...(flightId
+                ? [
+                    [
+                        flightId,
+                        { height: snap.totalRise, length: snap.length, stepCount: snap.stepCount },
+                    ],
+                ]
+                : []),
+        ]);
+        useScene.getState().markDirty(stairId);
+        if (flightId)
+            useScene.getState().markDirty(flightId);
+        return;
+    }
+    const hadSnap = overrides.get(stairId)?.totalRise !== undefined ||
+        (flightId !== undefined && overrides.get(flightId) !== undefined);
+    overrides.clearFields(stairId, ['totalRise', 'stepCount', 'railingMode']);
+    if (flightId && overrides.get(flightId))
+        overrides.clear(flightId);
+    overrides.set(stairId, { position, rotation, destinationSurfaceId: undefined });
+    if (hadSnap) {
+        useScene.getState().markDirty(stairId);
+        if (flightId)
+            useScene.getState().markDirty(flightId);
+    }
+}
+export function clearStairMovePreview(stairId, flightId) {
+    const overrides = useLiveNodeOverrides.getState();
+    if (!overrides.get(stairId) && (!flightId || !overrides.get(flightId)))
+        return;
+    overrides.clear(stairId);
+    if (flightId)
+        overrides.clear(flightId);
+    useScene.getState().markDirty(stairId);
+    if (flightId)
+        useScene.getState().markDirty(flightId);
+}

package/dist/stair/surface-transition.d.ts

@@ -0,0 +1,9 @@
+import { type AnyNode, type StairNode } from '@pascal-app/core';
+type Point = [number, number];
+export type TransitionProfile = {
+    frontZ: number;
+    samples: Point[];
+};
+export declare function surfaceTransitionProfile(stair: StairNode, surface: AnyNode, length: number): TransitionProfile | null;
+export {};
+//# sourceMappingURL=surface-transition.d.ts.map

package/dist/stair/surface-transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-transition.d.ts","sourceRoot":"","sources":["../../src/stair/surface-transition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE7E,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AAEpE,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GACb,iBAAiB,GAAG,IAAI,CA2D1B"}

package/dist/stair/surface-transition.js

@@ -0,0 +1,61 @@
+import { nodeRegistry } from '@pascal-app/core';
+export function surfaceTransitionProfile(stair, surface, length) {
+    if (!Number.isFinite(length))
+        return null;
+    const boundary = nodeRegistry.get(surface.type)?.capabilities?.surfaces?.top?.boundary;
+    if (!boundary)
+        return null;
+    const surfaceOutline = boundary(surface, 0);
+    if (surfaceOutline.length < 3)
+        return null;
+    const pose = surface;
+    const surfacePosition = pose.position ?? [0, 0, 0];
+    const surfaceAngle = typeof pose.rotation === 'number' ? pose.rotation : (pose.rotation?.[1] ?? 0);
+    const attached = stair.parentId === stair.destinationSurfaceId;
+    const parentCos = Math.cos(surfaceAngle), parentSin = Math.sin(surfaceAngle);
+    const stairPosition = attached
+        ? [
+            surfacePosition[0] + parentCos * stair.position[0] + parentSin * stair.position[2],
+            surfacePosition[1] + stair.position[1],
+            surfacePosition[2] - parentSin * stair.position[0] + parentCos * stair.position[2],
+        ]
+        : stair.position;
+    const stairRotation = stair.rotation + (attached ? surfaceAngle : 0);
+    const cc = Math.cos(stairRotation), cs = Math.sin(stairRotation);
+    const highX = stairPosition[0] + cs * length;
+    const highZ = stairPosition[2] + cc * length;
+    const outline = surfaceOutline.map(([x, z]) => {
+        const dx = x - highX;
+        const dz = z - highZ;
+        return [dx * cc - dz * cs, dx * cs + dz * cc];
+    });
+    const halfWidth = stair.width / 2;
+    const samples = [];
+    const sampleXs = [
+        -halfWidth,
+        0,
+        halfWidth,
+        ...outline.map(([x]) => x).filter((x) => x > -halfWidth && x < halfWidth),
+    ]
+        .sort((a, b) => a - b)
+        .filter((x, index, values) => index === 0 || x - values[index - 1] > 1e-6);
+    for (const x of sampleXs) {
+        const crossings = [];
+        for (let edge = 0; edge < outline.length; edge++) {
+            const a = outline[edge], b = outline[(edge + 1) % outline.length];
+            const dx = b[0] - a[0];
+            if (Math.abs(dx) < 1e-8)
+                continue;
+            const t = (x - a[0]) / dx;
+            if (t >= 0 && t <= 1)
+                crossings.push(a[1] + (b[1] - a[1]) * t);
+        }
+        const boundary = crossings.sort((a, b) => Math.abs(a) - Math.abs(b))[0];
+        if (boundary === undefined || boundary < -0.12 || boundary > 0.7)
+            return null;
+        samples.push([x, boundary]);
+    }
+    if (samples.every(([, z]) => Math.abs(z) < 0.015))
+        return null;
+    return { frontZ: 0, samples };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/stair/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/stair/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;eAEjC,WAAW"}

package/dist/stair/tool.d.ts

@@ -0,0 +1,2 @@
+export default function StairTool(): import("react").JSX.Element;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/stair/tool.tsx"],"names":[],"mappings":"AA+TA,MAAM,CAAC,OAAO,UAAU,SAAS,gCA8dhC"}