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

package/dist/systems/elevator/elevator-opening-sync.test.js

@@ -1,146 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { BuildingNode, CeilingNode, ElevatorNode, LevelNode, SlabNode } from '../../schema';
-import { syncAutoElevatorOpenings } from './elevator-opening-sync';
-describe('syncAutoElevatorOpenings', () => {
-    test('does not add elevator holes when a manual surface hole already covers them', () => {
-        const building = BuildingNode.parse({ name: 'Building' });
-        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
-        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
-        const elevator = ElevatorNode.parse({
-            name: 'Elevator',
-            parentId: building.id,
-            position: [2, 0, 1.5],
-            width: 1.6,
-            depth: 1.6,
-        });
-        const buildingWithChildren = {
-            ...building,
-            children: [ground.id, upper.id, elevator.id],
-        };
-        const manualOpening = [
-            [1, 0.5],
-            [3, 0.5],
-            [3, 2.5],
-            [1, 2.5],
-        ];
-        const sourceCeiling = CeilingNode.parse({
-            name: 'Source Ceiling',
-            parentId: ground.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const upperSlab = SlabNode.parse({
-            name: 'Upper Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, sourceCeiling, upperSlab].map((node) => [
-            node.id,
-            node,
-        ]));
-        const updates = syncAutoElevatorOpenings(nodes);
-        expect(updates.find((update) => update.id === upperSlab.id)).toBeUndefined();
-        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
-    });
-    test('adds elevator holes when an existing manual hole is too small', () => {
-        const building = BuildingNode.parse({ name: 'Building' });
-        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
-        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
-        const elevator = ElevatorNode.parse({
-            name: 'Elevator',
-            parentId: building.id,
-            position: [2, 0, 1.5],
-            width: 1.6,
-            depth: 1.6,
-        });
-        const buildingWithChildren = {
-            ...building,
-            children: [ground.id, upper.id, elevator.id],
-        };
-        const smallManualOpening = [
-            [1.7, 1.2],
-            [2.3, 1.2],
-            [2.3, 1.8],
-            [1.7, 1.8],
-        ];
-        const upperSlab = SlabNode.parse({
-            name: 'Upper Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [smallManualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, upperSlab].map((node) => [node.id, node]));
-        const updates = syncAutoElevatorOpenings(nodes);
-        const slabUpdate = updates.find((update) => update.id === upperSlab.id);
-        expect(slabUpdate?.data.holes).toHaveLength(2);
-        expect(slabUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
-        expect(slabUpdate?.data.holeMetadata).toEqual([
-            { source: 'manual' },
-            { source: 'elevator', elevatorId: elevator.id },
-        ]);
-    });
-    test('removes stale auto elevator holes when a manual hole overlaps the elevator opening', () => {
-        const building = BuildingNode.parse({ name: 'Building' });
-        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
-        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
-        const elevator = ElevatorNode.parse({
-            name: 'Elevator',
-            parentId: building.id,
-            position: [2, 0, 1.5],
-            width: 1.6,
-            depth: 1.6,
-        });
-        const buildingWithChildren = {
-            ...building,
-            children: [ground.id, upper.id, elevator.id],
-        };
-        const manualOpening = [
-            [1, 0.5],
-            [3, 0.5],
-            [3, 2.5],
-            [1, 2.5],
-        ];
-        const staleAutoOpening = [
-            [1.12, 0.62],
-            [2.88, 0.62],
-            [2.88, 2.38],
-            [1.12, 2.38],
-        ];
-        const upperSlab = SlabNode.parse({
-            name: 'Upper Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening, staleAutoOpening],
-            holeMetadata: [{ source: 'manual' }, { source: 'elevator', elevatorId: elevator.id }],
-        });
-        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, upperSlab].map((node) => [node.id, node]));
-        const updates = syncAutoElevatorOpenings(nodes);
-        const slabUpdate = updates.find((update) => update.id === upperSlab.id);
-        expect(slabUpdate?.data.holes).toEqual([manualOpening]);
-        expect(slabUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
-    });
-});

package/dist/systems/elevator/elevator-runtime.test.d.ts

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

package/dist/systems/elevator/elevator-runtime.test.d.ts.map

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

package/dist/systems/elevator/elevator-runtime.test.js

@@ -1,64 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { ElevatorNode } from '../../schema';
-import { createElevatorInteractiveState, openElevatorDoorState, queueElevatorRequest, stepElevatorRuntimeState, } from './elevator-runtime';
-const groundLevelId = 'level_ground';
-const upperLevelId = 'level_upper';
-const entries = [
-    { id: groundLevelId, label: '0', baseY: 0 },
-    { id: upperLevelId, label: '1', baseY: 2.5 },
-];
-const elevator = ElevatorNode.parse({
-    speed: 10,
-    doorDurationMs: 100,
-    dwellMs: 0,
-});
-describe('elevator runtime helpers', () => {
-    test('queues level requests without duplicating the target', () => {
-        const state = createElevatorInteractiveState(groundLevelId, 0);
-        const queued = queueElevatorRequest(state, upperLevelId);
-        const duplicated = queueElevatorRequest(queued, upperLevelId);
-        expect(queued.queue).toEqual([upperLevelId]);
-        expect(queued.requestedStops).toEqual([upperLevelId]);
-        expect(duplicated.queue).toEqual([upperLevelId]);
-        expect(duplicated.requestedStops).toEqual([upperLevelId]);
-    });
-    test('opens doors only when the elevator is not moving', () => {
-        const idle = createElevatorInteractiveState(groundLevelId, 0);
-        const moving = { ...idle, phase: 'moving' };
-        expect(openElevatorDoorState(idle).phase).toBe('opening');
-        expect(openElevatorDoorState(moving)).toBe(moving);
-    });
-    test('moves to a queued level and clears the served request on arrival', () => {
-        const queued = queueElevatorRequest(createElevatorInteractiveState(groundLevelId, 0), upperLevelId);
-        const moving = stepElevatorRuntimeState({
-            defaultEntry: entries[0],
-            delta: 0.016,
-            elevator,
-            entries,
-            now: 0,
-            state: queued,
-        });
-        const arrived = stepElevatorRuntimeState({
-            defaultEntry: entries[0],
-            delta: 1,
-            elevator,
-            entries,
-            now: 100,
-            state: moving,
-        });
-        const open = stepElevatorRuntimeState({
-            defaultEntry: entries[0],
-            delta: 1,
-            elevator,
-            entries,
-            now: 200,
-            state: arrived,
-        });
-        expect(moving.phase).toBe('moving');
-        expect(arrived.currentLevelId).toBe(upperLevelId);
-        expect(arrived.phase).toBe('opening');
-        expect(open.phase).toBe('open');
-        expect(open.queue).toEqual([]);
-        expect(open.requestedStops).toEqual([upperLevelId]);
-    });
-});

package/dist/systems/fence/fence-spline.test.d.ts

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

package/dist/systems/fence/fence-spline.test.d.ts.map

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

package/dist/systems/fence/fence-spline.test.js

@@ -1,136 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { getFenceControlHandle, getFenceSplineFrameAt, getFenceSplineLength, getTwoPointFenceCurveTangents, isSplineFence, sampleFenceSpline, } from './fence-spline';
-describe('isSplineFence', () => {
-    test('false without a path or with < 2 points', () => {
-        expect(isSplineFence({ path: undefined })).toBe(false);
-        expect(isSplineFence({ path: [[0, 0]] })).toBe(false);
-    });
-    test('true with >= 2 points', () => {
-        expect(isSplineFence({
-            path: [
-                [0, 0],
-                [1, 0],
-            ],
-        })).toBe(true);
-    });
-});
-describe('sampleFenceSpline', () => {
-    test('honors the control points as on-curve anchors', () => {
-        const path = [
-            [0, 0],
-            [2, 2],
-            [4, 0],
-        ];
-        const sampled = sampleFenceSpline(path, undefined, 8);
-        // First and last sample equal the path endpoints exactly.
-        expect(sampled[0]).toEqual({ x: 0, y: 0 });
-        expect(sampled[sampled.length - 1]).toEqual({ x: 4, y: 0 });
-        // The interior control point is interpolated: some sample lands on (2, 2).
-        const hitsMiddle = sampled.some((p) => Math.hypot(p.x - 2, p.y - 2) < 1e-6);
-        expect(hitsMiddle).toBe(true);
-    });
-    test('two-point path with no tangents is a straight segment', () => {
-        expect(sampleFenceSpline([
-            [0, 0],
-            [3, 0],
-        ], undefined, 8)).toEqual([
-            { x: 0, y: 0 },
-            { x: 3, y: 0 },
-        ]);
-    });
-    test('a stored tangent bends an otherwise straight two-point span', () => {
-        const path = [
-            [0, 0],
-            [4, 0],
-        ];
-        // Pull the first point's handle up — the span should bow off the X axis.
-        const sampled = sampleFenceSpline(path, [[0, 2], null], 12);
-        expect(sampled[0]).toEqual({ x: 0, y: 0 });
-        expect(sampled[sampled.length - 1]).toEqual({ x: 4, y: 0 });
-        const maxY = Math.max(...sampled.map((p) => Math.abs(p.y)));
-        expect(maxY).toBeGreaterThan(0.1);
-    });
-    test('generated two-point curve tangents create a gentle arc', () => {
-        const path = [
-            [0, 0],
-            [4, 0],
-        ];
-        const sampled = sampleFenceSpline(path, getTwoPointFenceCurveTangents(path), 16);
-        expect(sampled[0]).toEqual({ x: 0, y: 0 });
-        expect(sampled[sampled.length - 1]).toEqual({ x: 4, y: 0 });
-        const maxY = Math.max(...sampled.map((p) => p.y));
-        expect(maxY).toBeGreaterThan(0.4);
-    });
-    test('produces a smooth (no-cusp) curve on uneven spacing', () => {
-        const path = [
-            [0, 0],
-            [1, 0.2],
-            [5, 0.3],
-            [6, 0],
-        ];
-        const sampled = sampleFenceSpline(path, undefined, 16);
-        let maxTurn = 0;
-        for (let i = 2; i < sampled.length; i += 1) {
-            const a = sampled[i - 2];
-            const b = sampled[i - 1];
-            const c = sampled[i];
-            const t1 = Math.atan2(b.y - a.y, b.x - a.x);
-            const t2 = Math.atan2(c.y - b.y, c.x - b.x);
-            let d = Math.abs(t2 - t1);
-            if (d > Math.PI)
-                d = 2 * Math.PI - d;
-            maxTurn = Math.max(maxTurn, d);
-        }
-        expect(maxTurn).toBeLessThan(Math.PI / 2);
-    });
-});
-describe('getFenceControlHandle', () => {
-    test('returns the stored tangent when present', () => {
-        expect(getFenceControlHandle([
-            [0, 0],
-            [4, 0],
-        ], [[1, 2], null], 0)).toEqual({ x: 1, y: 2 });
-    });
-    test('falls back to the automatic distance-aware tangent', () => {
-        const path = [
-            [0, 0],
-            [3, 0],
-            [6, 0],
-        ];
-        expect(getFenceControlHandle(path, undefined, 1)).toEqual({ x: 1, y: 0 });
-    });
-});
-describe('getFenceSplineFrameAt', () => {
-    const path = [
-        [0, 0],
-        [2, 0],
-        [4, 0],
-    ];
-    test('t=0 / t=1 land on the endpoints', () => {
-        expect(getFenceSplineFrameAt(path, 0).point).toEqual({ x: 0, y: 0 });
-        expect(getFenceSplineFrameAt(path, 1).point).toEqual({ x: 4, y: 0 });
-    });
-    test('returns a unit tangent and perpendicular normal', () => {
-        const frame = getFenceSplineFrameAt(path, 0.5);
-        expect(Math.hypot(frame.tangent.x, frame.tangent.y)).toBeCloseTo(1, 5);
-        const dot = frame.tangent.x * frame.normal.x + frame.tangent.y * frame.normal.y;
-        expect(dot).toBeCloseTo(0, 5);
-    });
-});
-describe('getFenceSplineLength', () => {
-    test('roughly matches the straight distance for a straight path', () => {
-        expect(getFenceSplineLength([
-            [0, 0],
-            [3, 4],
-        ], undefined, 8)).toBeCloseTo(5, 5);
-    });
-    test('a curved path is longer than its endpoint chord', () => {
-        const path = [
-            [0, 0],
-            [2, 2],
-            [4, 0],
-        ];
-        const chord = Math.hypot(4, 0);
-        expect(getFenceSplineLength(path, undefined, 16)).toBeGreaterThan(chord);
-    });
-});

package/dist/systems/stair/stair-opening-preview.test.d.ts

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

package/dist/systems/stair/stair-opening-preview.test.d.ts.map

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

package/dist/systems/stair/stair-opening-preview.test.js

@@ -1,80 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { BuildingNode, LevelNode, SlabNode, StairNode, StairSegmentNode } from '../../schema';
-import { getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview';
-import { syncAutoStairOpenings } from './stair-opening-sync';
-describe('stair opening previews', () => {
-    test('computes auto openings from live stair transforms', () => {
-        const building = BuildingNode.parse({ name: 'Building' });
-        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
-        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
-        const slab = SlabNode.parse({
-            name: 'Upper Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [5, 0],
-                [5, 4],
-                [0, 4],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_live',
-            width: 1,
-            length: 3,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_live',
-            name: 'Live Stair',
-            parentId: ground.id,
-            position: [1, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, slab, stair, { ...segment, parentId: stair.id }].map((node) => [
-            node.id,
-            node,
-        ]));
-        const liveTransforms = new Map([
-            [stair.id, { position: [3, 0, 0.2], rotation: 0 }],
-        ]);
-        const liveOverrides = new Map();
-        expect(hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, new Set())).toBe(true);
-        const previewNodes = getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, new Set());
-        const updates = syncAutoStairOpenings(previewNodes);
-        const hole = updates.find((update) => update.id === slab.id)?.data.holes?.[0];
-        expect(hole).toBeDefined();
-        expect(Math.max(...hole.map(([x]) => x))).toBeGreaterThan(3.4);
-    });
-    test('ignores its own live surface overrides as preview inputs', () => {
-        const slab = SlabNode.parse({
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 4],
-                [0, 4],
-            ],
-        });
-        const nodes = { [slab.id]: slab };
-        const liveOverrides = new Map([
-            [
-                slab.id,
-                {
-                    holes: [
-                        [
-                            [1, 1],
-                            [2, 1],
-                            [2, 2],
-                            [1, 2],
-                        ],
-                    ],
-                },
-            ],
-        ]);
-        expect(hasLiveStairOpeningInputs(nodes, new Map(), liveOverrides, new Set([slab.id]))).toBe(false);
-    });
-});

package/dist/systems/stair/stair-opening-sync.test.d.ts

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

package/dist/systems/stair/stair-opening-sync.test.d.ts.map

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