@pascal-app/core 0.9.2 → 1.0.0-beta.2

package/dist/services/alignment-anchors.test.js

@@ -1,383 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from '../registry';
-import { getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, } from '../systems/elevator/elevator-geometry';
-import { stairFootprintAABB } from '../systems/stair/stair-footprint';
-import { collectAlignmentAnchors, footprintAABB, footprintAABBFrom, movingAlignmentAnchors, movingFootprintAnchors, polygonAnchors, wallSegmentAnchors, } from './alignment-anchors';
-// Minimal floor-placed def whose footprint reads `dimensions` / `rotation`
-// straight off the node, so tests can drive the AABB math directly.
-function floorPlacedDef(kind, applies) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {
-            floorPlaced: {
-                footprint: (n) => ({
-                    dimensions: n.dimensions ?? [1, 1, 1],
-                    rotation: n.rotation ?? [0, 0, 0],
-                }),
-                ...(applies ? { applies } : {}),
-            },
-        },
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-    };
-}
-// Mirrors the real elevator/stair definitions, which expose their plan
-// footprint via the `alignmentFootprint` capability rather than a hardcoded
-// branch in the anchor bridge. The glue (shaft-outset box / stair AABB) is
-// reproduced here from the same core helpers production uses.
-function elevatorDef() {
-    return {
-        kind: 'elevator',
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal('elevator') }),
-        category: 'structure',
-        defaults: () => ({}),
-        capabilities: {
-            alignmentFootprint: (n) => {
-                const e = n;
-                const wall = getElevatorShaftWallThickness(e);
-                return {
-                    shape: 'box',
-                    dimensions: [getElevatorShaftWidth(e) + wall * 2, 1, getElevatorShaftDepth(e) + wall * 2],
-                    rotation: [0, e.rotation ?? 0, 0],
-                };
-            },
-        },
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-    };
-}
-function stairDef() {
-    return {
-        kind: 'stair',
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal('stair') }),
-        category: 'structure',
-        defaults: () => ({}),
-        capabilities: {
-            alignmentFootprint: (n, nodes) => {
-                const aabb = stairFootprintAABB(n, nodes);
-                return aabb ? { shape: 'aabb', ...aabb } : null;
-            },
-        },
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-    };
-}
-function plainDef(kind) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {},
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-    };
-}
-const node = (over) => over;
-describe('footprintAABBFrom', () => {
-    test('unrotated box is centred at position', () => {
-        const aabb = footprintAABBFrom([10, 0, 20], [2, 1, 4], 0);
-        expect(aabb).toEqual({ minX: 9, minZ: 18, maxX: 11, maxZ: 22 });
-    });
-    test('90° rotation swaps width and depth extents', () => {
-        const aabb = footprintAABBFrom([0, 0, 0], [2, 1, 4], Math.PI / 2);
-        expect(aabb.minX).toBeCloseTo(-2, 10);
-        expect(aabb.maxX).toBeCloseTo(2, 10);
-        expect(aabb.minZ).toBeCloseTo(-1, 10);
-        expect(aabb.maxZ).toBeCloseTo(1, 10);
-    });
-});
-describe('footprintAABB', () => {
-    beforeEach(() => nodeRegistry._reset());
-    test('reads dimensions + rotation from a floor-placed kind', () => {
-        registerNode(floorPlacedDef('box'));
-        const aabb = footprintAABB(node({ id: 'b1', type: 'box', position: [10, 0, 20], dimensions: [2, 1, 4] }));
-        expect(aabb).toEqual({ minX: 9, minZ: 18, maxX: 11, maxZ: 22 });
-    });
-    test('returns null for a kind without a footprint', () => {
-        registerNode(plainDef('wall'));
-        expect(footprintAABB(node({ id: 'w1', type: 'wall', position: [0, 0, 0] }))).toBeNull();
-    });
-    test('derives an elevator footprint from its OUTER SHAFT, not the cab', () => {
-        // Aligns to the visible shaft outline: cab 2×4 + 0.09 m wall each side →
-        // 2.18 × 4.18, centred at (10, 20). The cab corners alone would sit ~9 cm
-        // inside the drawn edge (past the 8 cm snap), so a guide never appeared.
-        // The footprint comes from the elevator's `alignmentFootprint` (box) cap.
-        registerNode(elevatorDef());
-        const aabb = footprintAABB(node({ id: 'e1', type: 'elevator', position: [10, 0, 20], width: 2, depth: 4, rotation: 0 }));
-        expect(aabb).toEqual({ minX: 8.91, minZ: 17.91, maxX: 11.09, maxZ: 22.09 });
-    });
-    test('returns null when the kind predicate excludes the node', () => {
-        registerNode(floorPlacedDef('lamp', (n) => !n.attached));
-        expect(footprintAABB(node({ id: 'l1', type: 'lamp', position: [0, 0, 0], attached: true }))).toBeNull();
-        expect(footprintAABB(node({ id: 'l2', type: 'lamp', position: [0, 0, 0], attached: false }))).not.toBeNull();
-    });
-});
-describe('movingFootprintAnchors', () => {
-    beforeEach(() => nodeRegistry._reset());
-    test('relocates the footprint corners around the proposed centre (edges only, no centre anchor)', () => {
-        registerNode(floorPlacedDef('box'));
-        const anchors = movingFootprintAnchors(node({ id: 'm', type: 'box', position: [0, 0, 0], dimensions: [2, 1, 4] }), 10, 20);
-        // 2×4 box centred at (10, 20): corners at x∈{9,11}, z∈{18,22}.
-        expect(anchors).toHaveLength(4);
-        expect(anchors.every((a) => a.kind === 'corner')).toBe(true);
-        expect(new Set(anchors.map((a) => a.x))).toEqual(new Set([9, 11]));
-        expect(new Set(anchors.map((a) => a.z))).toEqual(new Set([18, 22]));
-    });
-    test('rotationY override drives the AABB regardless of node rotation', () => {
-        registerNode(floorPlacedDef('box'));
-        const anchors = movingFootprintAnchors(node({
-            id: 'm',
-            type: 'box',
-            position: [0, 0, 0],
-            dimensions: [2, 1, 4],
-            rotation: [0, 0, 0],
-        }), 0, 0, Math.PI / 2);
-        const xs = anchors.map((a) => a.x);
-        // Rotated 90°, the 2×4 box spans ±2 in X (its depth) rather than ±1.
-        expect(Math.max(...xs)).toBeCloseTo(2, 10);
-        expect(Math.min(...xs)).toBeCloseTo(-2, 10);
-    });
-    test('returns empty for a footprintless kind', () => {
-        registerNode(plainDef('wall'));
-        expect(movingFootprintAnchors(node({ id: 'w', type: 'wall', position: [0, 0, 0] }), 1, 1)).toEqual([]);
-    });
-});
-describe('movingAlignmentAnchors', () => {
-    beforeEach(() => nodeRegistry._reset());
-    test('relocates a straight stair by its segment-chain footprint', () => {
-        registerNode(stairDef());
-        const nodes = {
-            st: node({
-                id: 'st',
-                type: 'stair',
-                position: [0, 0, 0],
-                rotation: 0,
-                stairType: 'straight',
-                width: 1,
-                children: ['seg'],
-            }),
-            seg: node({
-                id: 'seg',
-                type: 'stair-segment',
-                parentId: 'st',
-                width: 1,
-                length: 3,
-                height: 2.5,
-                attachmentSide: 'front',
-            }),
-        };
-        const anchors = movingAlignmentAnchors(nodes.st, nodes, 10, 20, 0);
-        expect(anchors).toHaveLength(4);
-        expect(new Set(anchors.map((a) => a.x))).toEqual(new Set([9.5, 10.5]));
-        expect(new Set(anchors.map((a) => a.z))).toEqual(new Set([20, 23]));
-    });
-    test('rotation override drives a moving straight stair footprint', () => {
-        registerNode(stairDef());
-        const nodes = {
-            st: node({
-                id: 'st',
-                type: 'stair',
-                position: [0, 0, 0],
-                rotation: 0,
-                stairType: 'straight',
-                width: 1,
-                children: ['seg'],
-            }),
-            seg: node({
-                id: 'seg',
-                type: 'stair-segment',
-                parentId: 'st',
-                width: 1,
-                length: 3,
-                height: 2.5,
-                attachmentSide: 'front',
-            }),
-        };
-        const anchors = movingAlignmentAnchors(nodes.st, nodes, 10, 20, Math.PI / 2);
-        const xs = anchors.map((a) => a.x);
-        const zs = anchors.map((a) => a.z);
-        expect(Math.min(...xs)).toBeCloseTo(10, 10);
-        expect(Math.max(...xs)).toBeCloseTo(13, 10);
-        expect(Math.min(...zs)).toBeCloseTo(19.5, 10);
-        expect(Math.max(...zs)).toBeCloseTo(20.5, 10);
-    });
-});
-describe('wallSegmentAnchors', () => {
-    test('returns both endpoints as corners and the chord midpoint as center', () => {
-        const anchors = wallSegmentAnchors('w', [0, 0], [4, 2]);
-        expect(anchors).toEqual([
-            { nodeId: 'w', kind: 'corner', x: 0, z: 0 },
-            { nodeId: 'w', kind: 'corner', x: 4, z: 2 },
-            { nodeId: 'w', kind: 'center', x: 2, z: 1 },
-        ]);
-    });
-    test('adds ±thickness/2 face corners on each endpoint when thickness is given', () => {
-        // Horizontal wall along +X: perpendicular is ±Z, so faces sit at z = ±0.1.
-        const anchors = wallSegmentAnchors('w', [0, 0], [4, 0], 0.2);
-        expect(anchors).toEqual([
-            { nodeId: 'w', kind: 'corner', x: 0, z: 0 },
-            { nodeId: 'w', kind: 'corner', x: 4, z: 0 },
-            { nodeId: 'w', kind: 'center', x: 2, z: 0 },
-            { nodeId: 'w', kind: 'corner', x: 0, z: 0.1 },
-            { nodeId: 'w', kind: 'corner', x: 0, z: -0.1 },
-            { nodeId: 'w', kind: 'corner', x: 4, z: 0.1 },
-            { nodeId: 'w', kind: 'corner', x: 4, z: -0.1 },
-        ]);
-    });
-    test('skips face corners for zero/degenerate input', () => {
-        expect(wallSegmentAnchors('w', [0, 0], [4, 0], 0)).toHaveLength(3);
-        expect(wallSegmentAnchors('w', [1, 1], [1, 1], 0.2)).toHaveLength(3);
-    });
-});
-describe('polygonAnchors', () => {
-    test('returns each vertex as a corner anchor', () => {
-        expect(polygonAnchors('s', [
-            [0, 0],
-            [2, 0],
-            [2, 3],
-        ])).toEqual([
-            { nodeId: 's', kind: 'corner', x: 0, z: 0 },
-            { nodeId: 's', kind: 'corner', x: 2, z: 0 },
-            { nodeId: 's', kind: 'corner', x: 2, z: 3 },
-        ]);
-    });
-});
-describe('collectAlignmentAnchors', () => {
-    beforeEach(() => nodeRegistry._reset());
-    test('unions footprint corners, segment anchors and polygon vertices, excluding the moving node', () => {
-        registerNode(floorPlacedDef('box'));
-        const nodes = {
-            moving: node({ id: 'moving', type: 'box', position: [0, 0, 0], dimensions: [1, 1, 1] }),
-            box: node({ id: 'box', type: 'box', position: [5, 0, 5], dimensions: [2, 1, 2] }),
-            wall: node({ id: 'wall', type: 'wall', start: [0, 0], end: [4, 0] }),
-            slab: node({
-                id: 'slab',
-                type: 'slab',
-                polygon: [
-                    [0, 0],
-                    [2, 0],
-                    [2, 2],
-                ],
-            }),
-        };
-        const anchors = collectAlignmentAnchors(nodes, 'moving');
-        const ids = anchors.map((a) => a.nodeId);
-        expect(ids).not.toContain('moving');
-        expect(ids.filter((id) => id === 'box')).toHaveLength(4); // corner anchors
-        expect(ids.filter((id) => id === 'wall')).toHaveLength(7); // endpoints + midpoint + 4 face corners
-        expect(ids.filter((id) => id === 'slab')).toHaveLength(3); // polygon vertices
-    });
-    test('levelId filter keeps only nodes resolving to that level (incl. nested)', () => {
-        registerNode(floorPlacedDef('box'));
-        registerNode(elevatorDef());
-        const nodes = {
-            b: node({ id: 'b', type: 'building' }),
-            L1: node({ id: 'L1', type: 'level', parentId: 'b' }),
-            L2: node({ id: 'L2', type: 'level', parentId: 'b' }),
-            moving: node({ id: 'moving', type: 'box', parentId: 'L1', position: [0, 0, 0] }),
-            sameFloor: node({ id: 'sameFloor', type: 'box', parentId: 'L1', position: [5, 0, 5] }),
-            // Item resting on `sameFloor` — resolves to L1 through the parent chain.
-            nested: node({ id: 'nested', type: 'box', parentId: 'sameFloor', position: [5, 0, 5] }),
-            otherFloor: node({ id: 'otherFloor', type: 'box', parentId: 'L2', position: [5, 0, 5] }),
-            // Building-scoped (parented to the building, no level ancestor) — spans
-            // every floor, so it stays in the pool regardless of the active level.
-            elevator: node({
-                id: 'elevator',
-                type: 'elevator',
-                parentId: 'b',
-                position: [9, 0, 9],
-                width: 1.6,
-                depth: 1.6,
-            }),
-        };
-        const ids = collectAlignmentAnchors(nodes, 'moving', 'L1').map((a) => a.nodeId);
-        expect(ids.filter((id) => id === 'sameFloor')).toHaveLength(4);
-        expect(ids.filter((id) => id === 'nested')).toHaveLength(4);
-        expect(ids.filter((id) => id === 'elevator')).toHaveLength(4);
-        expect(ids).not.toContain('otherFloor');
-    });
-    test('straight stair contributes its segment-chain footprint corners', () => {
-        registerNode(stairDef());
-        const nodes = {
-            st: node({
-                id: 'st',
-                type: 'stair',
-                position: [0, 0, 0],
-                rotation: 0,
-                stairType: 'straight',
-                width: 1,
-                children: ['seg'],
-            }),
-            // Single 1×3 flight; origin at the run start, extending +Z by length.
-            seg: node({
-                id: 'seg',
-                type: 'stair-segment',
-                parentId: 'st',
-                width: 1,
-                length: 3,
-                height: 2.5,
-                attachmentSide: 'front',
-            }),
-        };
-        const anchors = collectAlignmentAnchors(nodes, '').filter((a) => a.nodeId === 'st');
-        expect(anchors).toHaveLength(4);
-        expect(anchors.every((a) => a.kind === 'corner')).toBe(true);
-        expect(new Set(anchors.map((a) => a.x))).toEqual(new Set([-0.5, 0.5]));
-        expect(new Set(anchors.map((a) => a.z))).toEqual(new Set([0, 3]));
-    });
-    test('curved stair contributes its sector bounding-box corners', () => {
-        registerNode(stairDef());
-        const nodes = {
-            cs: node({
-                id: 'cs',
-                type: 'stair',
-                position: [0, 0, 0],
-                rotation: 0,
-                stairType: 'curved',
-                width: 1,
-                innerRadius: 1,
-                sweepAngle: Math.PI / 2,
-            }),
-        };
-        const anchors = collectAlignmentAnchors(nodes, '').filter((a) => a.nodeId === 'cs');
-        expect(anchors).toHaveLength(4);
-        // outerRadius = inner(1) + width(1) = 2, sweep π/2 centred on +X. Outer rim
-        // reaches X=2 at the bisector; min X is the inner rim's ±π/4 ends (cos45·1);
-        // Z spans ±(outer·sin45).
-        const xs = anchors.map((a) => a.x);
-        const zs = anchors.map((a) => a.z);
-        expect(Math.max(...xs)).toBeCloseTo(2, 5);
-        expect(Math.min(...xs)).toBeCloseTo(Math.SQRT1_2, 5);
-        expect(Math.max(...zs)).toBeCloseTo(Math.SQRT2, 5);
-        expect(Math.min(...zs)).toBeCloseTo(-Math.SQRT2, 5);
-    });
-    test('spiral stair contributes a full-circle bounding box', () => {
-        registerNode(stairDef());
-        const nodes = {
-            sp: node({
-                id: 'sp',
-                type: 'stair',
-                position: [5, 0, 5],
-                rotation: 0,
-                stairType: 'spiral',
-                width: 1,
-                innerRadius: 0.5,
-                sweepAngle: Math.PI * 2,
-            }),
-        };
-        const anchors = collectAlignmentAnchors(nodes, '').filter((a) => a.nodeId === 'sp');
-        expect(anchors).toHaveLength(4);
-        // outerRadius = inner(0.5) + width(1) = 1.5, a full revolution about (5, 5).
-        const xs = anchors.map((a) => a.x);
-        const zs = anchors.map((a) => a.z);
-        expect(Math.max(...xs)).toBeCloseTo(6.5, 2);
-        expect(Math.min(...xs)).toBeCloseTo(3.5, 2);
-        expect(Math.max(...zs)).toBeCloseTo(6.5, 2);
-        expect(Math.min(...zs)).toBeCloseTo(3.5, 2);
-    });
-});

package/dist/services/alignment.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=alignment.test.d.ts.map

package/dist/services/alignment.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"alignment.test.d.ts","sourceRoot":"","sources":["../../src/services/alignment.test.ts"],"names":[],"mappings":""}

package/dist/services/alignment.test.js

@@ -1,92 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { bboxAnchors, resolveAlignment } from './alignment';
-function center(nodeId, x, z) {
-    return { nodeId, kind: 'center', x, z };
-}
-function corner(nodeId, x, z) {
-    return { nodeId, kind: 'corner', x, z };
-}
-describe('resolveAlignment', () => {
-    test('returns empty when no candidates within threshold', () => {
-        const result = resolveAlignment({
-            moving: [center('m', 0, 0)],
-            candidates: [center('a', 1, 1)],
-            threshold: 0.5,
-        });
-        expect(result.guides).toEqual([]);
-        expect(result.snap).toBeNull();
-    });
-    test('snaps moving anchor onto candidate X when within threshold', () => {
-        const result = resolveAlignment({
-            moving: [center('m', 0.03, 5)],
-            candidates: [center('a', 0, 2)],
-            threshold: 0.1,
-        });
-        expect(result.snap).toEqual({ dx: -0.03, dz: 0 });
-        expect(result.guides).toHaveLength(1);
-        expect(result.guides[0].axis).toBe('x');
-        expect(result.guides[0].coord).toBe(0);
-        expect(result.guides[0].from.z).toBe(2);
-        expect(result.guides[0].to.z).toBe(5);
-    });
-    test('snaps both axes when both match', () => {
-        const result = resolveAlignment({
-            moving: [center('m', 0.03, 0.04)],
-            candidates: [center('a', 0, 0)],
-            threshold: 0.1,
-        });
-        expect(result.snap).toEqual({ dx: -0.03, dz: -0.04 });
-        expect(result.guides).toHaveLength(2);
-    });
-    test('picks closest candidate per axis', () => {
-        const result = resolveAlignment({
-            moving: [center('m', 0.08, 0)],
-            candidates: [center('a', 0, 5), center('b', 0.1, 5), center('c', 0.05, 10)],
-            threshold: 0.1,
-        });
-        // |0.1 - 0.08| = 0.02 wins over |0.05 - 0.08| = 0.03 and |0 - 0.08| = 0.08
-        expect(result.snap?.dx).toBeCloseTo(0.02, 10);
-        expect(result.guides[0].candidateNodeId).toBe('b');
-    });
-    test('ties on the matched axis break toward the nearest perpendicular anchor', () => {
-        const result = resolveAlignment({
-            moving: [corner('m', 0.02, 4)],
-            candidates: [corner('far', 0, 0), corner('near', 0, 5)],
-            threshold: 0.1,
-        });
-        // Both share X (Δx = 0.02); 'near' (z=5) is closer to the moving z=4 than
-        // 'far' (z=0), so the guide connects to the nearest real anchor.
-        expect(result.guides[0].candidateNodeId).toBe('near');
-    });
-    test('threshold = 0 disables alignment', () => {
-        const result = resolveAlignment({
-            moving: [center('m', 0, 0)],
-            candidates: [center('a', 0, 0)],
-            threshold: 0,
-        });
-        expect(result.guides).toEqual([]);
-        expect(result.snap).toBeNull();
-    });
-    test('distance is the perpendicular gap to the matched axis', () => {
-        const result = resolveAlignment({
-            moving: [center('m', 0.02, 3)],
-            candidates: [center('a', 0, 0)],
-            threshold: 0.1,
-        });
-        // After snap: moving at (0, 3). X guide runs along x=0 from z=0 to z=3.
-        expect(result.guides[0].distance).toBeCloseTo(3, 10);
-    });
-});
-describe('bboxAnchors', () => {
-    test('returns 9 anchors with correct kinds and positions', () => {
-        const anchors = bboxAnchors('node', 0, 0, 2, 4);
-        expect(anchors).toHaveLength(9);
-        const corners = anchors.filter((a) => a.kind === 'corner');
-        const edges = anchors.filter((a) => a.kind === 'edge-mid');
-        const centers = anchors.filter((a) => a.kind === 'center');
-        expect(corners).toHaveLength(4);
-        expect(edges).toHaveLength(4);
-        expect(centers).toHaveLength(1);
-        expect(centers[0]).toEqual({ nodeId: 'node', kind: 'center', x: 1, z: 2 });
-    });
-});

package/dist/services/drag-session.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=drag-session.test.d.ts.map

package/dist/services/drag-session.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drag-session.test.d.ts","sourceRoot":"","sources":["../../src/services/drag-session.test.ts"],"names":[],"mappings":""}