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

package/dist/store/use-scene-elevator-migration.test.d.ts

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

package/dist/store/use-scene-elevator-migration.test.d.ts.map

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

package/dist/store/use-scene-elevator-migration.test.js

@@ -1,109 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import useScene from './use-scene';
-describe('scene elevator migrations', () => {
-    beforeEach(() => {
-        useScene.setState({
-            nodes: {},
-            rootNodeIds: [],
-            dirtyNodes: new Set(),
-            collections: {},
-        });
-        useScene.temporal.getState().clear();
-    });
-    test('normalizes legacy level-parented elevators into building-scoped nodes', () => {
-        useScene.getState().setScene({
-            site_test: {
-                object: 'node',
-                id: 'site_test',
-                type: 'site',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['building_test'],
-            },
-            building_test: {
-                object: 'node',
-                id: 'building_test',
-                type: 'building',
-                parentId: 'site_test',
-                visible: true,
-                metadata: {},
-                children: ['level_test'],
-            },
-            level_test: {
-                object: 'node',
-                id: 'level_test',
-                type: 'level',
-                parentId: 'building_test',
-                visible: true,
-                metadata: {},
-                children: ['elevator_test'],
-                level: 0,
-            },
-            elevator_test: {
-                object: 'node',
-                id: 'elevator_test',
-                type: 'elevator',
-                parentId: 'level_test',
-                visible: true,
-                metadata: {},
-            },
-        }, ['site_test']);
-        const nodes = useScene.getState().nodes;
-        const elevator = nodes.elevator_test;
-        const level = nodes.level_test;
-        const building = nodes.building_test;
-        expect(elevator.parentId).toBe('building_test');
-        expect(elevator.position).toEqual([0, 0, 0]);
-        expect(elevator.rotation).toBe(0);
-        expect(level.children).not.toContain('elevator_test');
-        expect(building.children).toContain('elevator_test');
-    });
-    test('migrates level-parented elevators when the level parentId is missing', () => {
-        useScene.getState().setScene({
-            site_test: {
-                object: 'node',
-                id: 'site_test',
-                type: 'site',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['building_test'],
-            },
-            building_test: {
-                object: 'node',
-                id: 'building_test',
-                type: 'building',
-                parentId: 'site_test',
-                visible: true,
-                metadata: {},
-                children: ['level_test'],
-            },
-            level_test: {
-                object: 'node',
-                id: 'level_test',
-                type: 'level',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['elevator_test'],
-                level: 0,
-            },
-            elevator_test: {
-                object: 'node',
-                id: 'elevator_test',
-                type: 'elevator',
-                parentId: 'level_test',
-                visible: true,
-                metadata: {},
-            },
-        }, ['site_test']);
-        const nodes = useScene.getState().nodes;
-        const elevator = nodes.elevator_test;
-        const level = nodes.level_test;
-        const building = nodes.building_test;
-        expect(elevator.parentId).toBe('building_test');
-        expect(level.children).not.toContain('elevator_test');
-        expect(building.children).toContain('elevator_test');
-    });
-});

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

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

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

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

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/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":""}