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

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

@@ -1,446 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { BuildingNode, CeilingNode, LevelNode, SlabNode, StairNode, StairSegmentNode, } from '../../schema';
-import { syncAutoStairOpenings } from './stair-opening-sync';
-describe('syncAutoStairOpenings', () => {
-    test('only applies stair holes to destination slabs that overlap the 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 landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const bedroomSlab = SlabNode.parse({
-            name: 'Bedroom Slab',
-            parentId: upper.id,
-            polygon: [
-                [4, 0],
-                [8, 0],
-                [8, 3],
-                [4, 3],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([
-            building,
-            ground,
-            upper,
-            landingSlab,
-            bedroomSlab,
-            stair,
-            { ...segment, parentId: stair.id },
-        ].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        const bedroomUpdate = updates.find((update) => update.id === bedroomSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(1);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-        expect(bedroomUpdate).toBeUndefined();
-    });
-    test('applies stair holes to a later destination slab when the configured offset overhangs the slab edge', () => {
-        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 landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_edge',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_edge',
-            name: 'Edge Stair',
-            parentId: ground.id,
-            position: [2, 0, 0],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            openingOffset: 0.08,
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        const hole = landingUpdate?.data.holes?.[0];
-        expect(hole).toBeDefined();
-        expect(Math.min(...hole.map(([, z]) => z))).toBeCloseTo(-0.08);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('does not apply stair holes to slabs on another building with a matching level number', () => {
-        const buildingA = BuildingNode.parse({ name: 'Building A' });
-        const groundA = LevelNode.parse({ name: 'Ground A', level: 0, parentId: buildingA.id });
-        const upperA = LevelNode.parse({ name: 'Upper A', level: 1, parentId: buildingA.id });
-        const buildingB = BuildingNode.parse({ name: 'Building B' });
-        const upperB = LevelNode.parse({ name: 'Upper B', level: 1, parentId: buildingB.id });
-        const slabA = SlabNode.parse({
-            name: 'Upper A Slab',
-            parentId: upperA.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const slabB = SlabNode.parse({
-            name: 'Upper B Slab',
-            parentId: upperB.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_scoped',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_scoped',
-            name: 'Scoped Stair',
-            parentId: groundA.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: groundA.id,
-            toLevelId: upperA.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([
-            buildingA,
-            groundA,
-            upperA,
-            buildingB,
-            upperB,
-            slabA,
-            slabB,
-            stair,
-            { ...segment, parentId: stair.id },
-        ].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        expect(updates.find((update) => update.id === slabA.id)?.data.holes).toHaveLength(1);
-        expect(updates.find((update) => update.id === slabB.id)).toBeUndefined();
-    });
-    test('uses the parent level when a stair has stale from-level data', () => {
-        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 landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 8],
-                [0, 8],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_stale_from',
-            width: 1,
-            length: 6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_stale_from',
-            name: 'Stale From Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: 'default',
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        const hole = landingUpdate?.data.holes?.[0];
-        expect(hole).toBeDefined();
-        expect(Math.min(...hole.map(([, z]) => z))).toBeGreaterThan(0.9);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('infers the destination level when a destination stair has blank level fields', () => {
-        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 landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 8],
-                [0, 8],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_blank_levels',
-            width: 1,
-            length: 6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_blank_levels',
-            name: 'Blank Level Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: '',
-            toLevelId: '',
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(1);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('infers the destination level when a destination stair targets its source level', () => {
-        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 landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 8],
-                [0, 8],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_self_target',
-            width: 1,
-            length: 6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_self_target',
-            name: 'Self Target Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: ground.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(1);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('does not add stair 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 manualOpening = [
-            [1.0, 0.0],
-            [3.0, 0.0],
-            [3.0, 3.0],
-            [1.0, 3.0],
-        ];
-        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 landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([
-            building,
-            ground,
-            upper,
-            sourceCeiling,
-            landingSlab,
-            stair,
-            { ...segment, parentId: stair.id },
-        ].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        expect(updates.find((update) => update.id === landingSlab.id)).toBeUndefined();
-        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
-    });
-    test('adds stair 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 smallManualOpening = [
-            [1.8, 1.6],
-            [2.2, 1.6],
-            [2.2, 2.1],
-            [1.8, 2.1],
-        ];
-        const landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [smallManualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(2);
-        expect(landingUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
-        expect(landingUpdate?.data.holeMetadata).toEqual([
-            { source: 'manual' },
-            { source: 'stair', stairId: stair.id },
-        ]);
-    });
-    test('removes stale auto stair holes when a manual hole overlaps the stair 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 manualOpening = [
-            [1.0, 0.0],
-            [3.0, 0.0],
-            [3.0, 3.0],
-            [1.0, 3.0],
-        ];
-        const staleAutoOpening = [
-            [1.5, 1],
-            [2.5, 1],
-            [2.5, 2.8],
-            [1.5, 2.8],
-        ];
-        const landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening, staleAutoOpening],
-            holeMetadata: [{ source: 'manual' }, { source: 'stair', stairId: 'stair_main' }],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toEqual([manualOpening]);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
-    });
-});

package/dist/utils/clone-scene-graph.test.d.ts

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

package/dist/utils/clone-scene-graph.test.d.ts.map

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

package/dist/utils/clone-scene-graph.test.js

@@ -1,59 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { forkSceneGraph } from './clone-scene-graph';
-function makeNode(id, type, extra = {}) {
-    return {
-        object: 'node',
-        id,
-        type,
-        parentId: null,
-        visible: true,
-        metadata: {},
-        ...extra,
-    };
-}
-function makeSceneGraph() {
-    const site = makeNode('site_1', 'site', { children: ['level_1'] });
-    const level = makeNode('level_1', 'level', {
-        parentId: 'site_1',
-        children: ['wall_1', 'scan_1', 'guide_1'],
-    });
-    const wall = makeNode('wall_1', 'wall', { parentId: 'level_1' });
-    const scan = makeNode('scan_1', 'scan', { parentId: 'level_1', url: 'scan.glb' });
-    const guide = makeNode('guide_1', 'guide', { parentId: 'level_1', url: 'guide.png' });
-    return {
-        nodes: {
-            ['site_1']: site,
-            ['level_1']: level,
-            ['wall_1']: wall,
-            ['scan_1']: scan,
-            ['guide_1']: guide,
-        },
-        rootNodeIds: ['site_1'],
-        collections: {
-            ['collection_1']: {
-                id: 'collection_1',
-                name: 'References',
-                nodeIds: ['scan_1', 'guide_1'],
-            },
-        },
-    };
-}
-describe('forkSceneGraph', () => {
-    test('strips scan and guide nodes by default', () => {
-        const forked = forkSceneGraph(makeSceneGraph());
-        const nodes = Object.values(forked.nodes);
-        expect(nodes.some((node) => node.type === 'scan')).toBe(false);
-        expect(nodes.some((node) => node.type === 'guide')).toBe(false);
-        expect(nodes.some((node) => node.type === 'wall')).toBe(true);
-        expect(forked.collections).toEqual({});
-    });
-    test('preserves scan and guide nodes when requested', () => {
-        const forked = forkSceneGraph(makeSceneGraph(), { preserveScans: true });
-        const nodes = Object.values(forked.nodes);
-        expect(nodes.some((node) => node.type === 'scan')).toBe(true);
-        expect(nodes.some((node) => node.type === 'guide')).toBe(true);
-        expect(nodes.map((node) => node.id)).not.toContain('scan_1');
-        expect(nodes.map((node) => node.id)).not.toContain('guide_1');
-        expect(Object.values(forked.collections ?? {}).flatMap((collection) => collection.nodeIds)).toHaveLength(2);
-    });
-});