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

package/dist/hooks/spatial-grid/floor-placed-elevation.test.js

@@ -1,273 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from '../../registry';
-import { getFloorPlacedElevation, getFloorStackedPosition } from './floor-placed-elevation';
-import { spatialGridManager } from './spatial-grid-manager';
-const LEVEL_ID = 'level_test';
-function makeDefinition(kind, capabilities = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities,
-    };
-}
-function makeLevel() {
-    return {
-        id: LEVEL_ID,
-        type: 'level',
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        level: 0,
-    };
-}
-function makeFloorNode(overrides = {}) {
-    return {
-        id: 'item_test',
-        type: 'item',
-        object: 'node',
-        parentId: LEVEL_ID,
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        scale: [1, 1, 1],
-        asset: {
-            id: 'asset_test',
-            category: 'test',
-            name: 'Test',
-            thumbnail: '',
-            src: 'asset:test',
-            dimensions: [1, 1, 1],
-            source: 'library',
-        },
-        ...overrides,
-    };
-}
-function addSlab(polygon, elevation, id = `slab_${elevation}`) {
-    const slab = {
-        id,
-        type: 'slab',
-        object: 'node',
-        parentId: LEVEL_ID,
-        visible: true,
-        metadata: {},
-        children: [],
-        polygon,
-        holes: [],
-        holeMetadata: [],
-        elevation,
-        autoFromWalls: false,
-    };
-    spatialGridManager.handleNodeCreated(slab, LEVEL_ID);
-}
-function nodesFor(...nodes) {
-    return Object.fromEntries(nodes.map((node) => [node.id, node]));
-}
-describe('floor-placed elevation resolver', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-        spatialGridManager.clear();
-    });
-    test('returns 0 without a floorPlaced capability', () => {
-        registerNode(makeDefinition('item'));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBe(0);
-    });
-    test('returns 0 when applies returns false', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-                applies: () => false,
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBe(0);
-    });
-    test('clamps non-finite slab elevation to 0', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-            },
-        }));
-        const original = spatialGridManager.getSlabElevationForItem;
-        spatialGridManager.getSlabElevationForItem = (() => Number.NaN);
-        try {
-            const level = makeLevel();
-            const node = makeFloorNode();
-            expect(getFloorPlacedElevation({
-                node,
-                nodes: nodesFor(level, node),
-                position: [0, 0, 0],
-                rotation: [0, 0, 0],
-            })).toBe(0);
-        }
-        finally {
-            spatialGridManager.getSlabElevationForItem = original;
-        }
-    });
-    test('returns 0 for a non-level direct parent', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const level = makeLevel();
-        const shelf = {
-            id: 'shelf_test',
-            type: 'shelf',
-            parentId: LEVEL_ID,
-        };
-        const node = makeFloorNode({ parentId: shelf.id });
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, shelf, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBe(0);
-    });
-    test('returns 0 when the declared parent is missing', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const node = makeFloorNode({ parentId: 'missing_level' });
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-            levelId: LEVEL_ID,
-        })).toBe(0);
-    });
-    test('uses the pending rotated footprint', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: (node) => ({
-                    dimensions: [4, 1, 1],
-                    rotation: node.rotation,
-                }),
-            },
-        }));
-        addSlab([
-            [-0.2, 1.2],
-            [0.2, 1.2],
-            [0.2, 1.8],
-            [-0.2, 1.8],
-        ], 0.45);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, Math.PI / 2, 0],
-        })).toBeCloseTo(0.45);
-    });
-    test('returns slab overlap elevation and stacks Y onto canonical position', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: (node) => ({
-                    dimensions: [1, 1, 1],
-                    rotation: node.rotation,
-                }),
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.35);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0.1, 0],
-            rotation: [0, 0, 0],
-        })).toBeCloseTo(0.35);
-        const stacked = getFloorStackedPosition({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0.1, 0],
-            rotation: [0, 0, 0],
-        });
-        expect(stacked[0]).toBe(0);
-        expect(stacked[1]).toBeCloseTo(0.45);
-        expect(stacked[2]).toBe(0);
-    });
-    test('takes the max elevation across composite footprints', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprints: () => [
-                    { position: [0, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
-                    { position: [3, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
-                ],
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.2, 'slab_low');
-        addSlab([
-            [2.5, -0.5],
-            [3.5, -0.5],
-            [3.5, 0.5],
-            [2.5, 0.5],
-        ], 0.8, 'slab_high');
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBeCloseTo(0.8);
-    });
-});

package/dist/lib/space-detection-pause.test.d.ts

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

package/dist/lib/space-detection-pause.test.d.ts.map

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

package/dist/lib/space-detection-pause.test.js

@@ -1,42 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { isSpaceDetectionPaused, pauseSpaceDetection, resumeSpaceDetection, } from './space-detection';
-// The pause flag is module-level (matching the existing pauseSceneHistory
-// refcount in store/history-control.ts). Reset it before/after each test so
-// leftover depth from one case can't bleed into another.
-function drain() {
-    for (let i = 0; i < 64 && isSpaceDetectionPaused(); i += 1) {
-        resumeSpaceDetection();
-    }
-}
-beforeEach(drain);
-afterEach(drain);
-describe('space-detection pause primitive', () => {
-    test('defaults to not paused', () => {
-        expect(isSpaceDetectionPaused()).toBe(false);
-    });
-    test('pauseSpaceDetection flips the flag, resumeSpaceDetection clears it', () => {
-        pauseSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(true);
-        resumeSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(false);
-    });
-    test('refcount — pause depth survives mismatched resumes from a second source', () => {
-        pauseSpaceDetection();
-        pauseSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(true);
-        resumeSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(true);
-        resumeSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(false);
-    });
-    test('resume is a no-op when not currently paused', () => {
-        expect(isSpaceDetectionPaused()).toBe(false);
-        resumeSpaceDetection();
-        resumeSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(false);
-        pauseSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(true);
-        resumeSpaceDetection();
-        expect(isSpaceDetectionPaused()).toBe(false);
-    });
-});

package/dist/lib/space-detection.test.d.ts

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

package/dist/lib/space-detection.test.d.ts.map

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

package/dist/lib/space-detection.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { CeilingNode, SlabNode, WallNode } from '../schema';
-import { planAutoCeilingsForLevel } from './space-detection';
-const square = [
-    [0, 0],
-    [4, 0],
-    [4, 3],
-    [0, 3],
-];
-function roomPolygon() {
-    return square.map(([x, y]) => ({ x, y }));
-}
-function squareWalls(height = 2.5) {
-    return [
-        WallNode.parse({ start: [0, 0], end: [4, 0], height }),
-        WallNode.parse({ start: [4, 0], end: [4, 3], height }),
-        WallNode.parse({ start: [4, 3], end: [0, 3], height }),
-        WallNode.parse({ start: [0, 3], end: [0, 0], height }),
-    ];
-}
-function slab(elevation) {
-    return SlabNode.parse({
-        polygon: square,
-        elevation,
-        autoFromWalls: true,
-    });
-}
-describe('planAutoCeilingsForLevel', () => {
-    test('creates auto ceilings at the top of the room walls', () => {
-        const created = planAutoCeilingsForLevel([roomPolygon()], [], {
-            walls: squareWalls(),
-            slabs: [slab(0.05)],
-        }).create[0];
-        expect(created?.height).toBeCloseTo(2.55);
-    });
-    test('updates existing auto ceiling height when the slab elevation changes', () => {
-        const ceiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.55,
-            autoFromWalls: true,
-        });
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [ceiling], {
-            walls: squareWalls(),
-            slabs: [slab(0.4)],
-        });
-        expect(plan.update).toHaveLength(1);
-        expect(plan.update[0]?.id).toBe(ceiling.id);
-        expect(plan.update[0]?.data.polygon).toBeUndefined();
-        expect(plan.update[0]?.data.height).toBeCloseTo(2.9);
-    });
-    test('updates existing auto ceiling height when wall height changes', () => {
-        const ceiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.55,
-            autoFromWalls: true,
-        });
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [ceiling], {
-            walls: squareWalls(3),
-            slabs: [slab(0.05)],
-        });
-        expect(plan.update).toHaveLength(1);
-        expect(plan.update[0]?.data.height).toBeCloseTo(3.05);
-    });
-    test('does not replace a manual ceiling with an auto ceiling', () => {
-        const manualCeiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.5,
-            autoFromWalls: false,
-        });
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [manualCeiling], {
-            walls: squareWalls(),
-            slabs: [slab(0.4)],
-        });
-        expect(plan.create).toHaveLength(0);
-        expect(plan.update).toHaveLength(0);
-    });
-});

package/dist/registry/registry.test.d.ts

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

package/dist/registry/registry.test.d.ts.map

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

package/dist/registry/registry.test.js

@@ -1,183 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { getHostRefFields, isDrawnViaTool, isDrawnViaToolKind, isPresettable, isPresettableKind, loadPlugin, nodeRegistry, registerNode, } from './registry';
-// Re-registering a kind warns + replaces in dev (HMR) but throws in
-// production — see `registry._register`. `bun test` runs with
-// NODE_ENV=test (dev path), so the throw-path tests pin NODE_ENV to
-// 'production' for the duration of the call.
-async function inProduction(fn) {
-    const prev = process.env.NODE_ENV;
-    process.env.NODE_ENV = 'production';
-    try {
-        return await fn();
-    }
-    finally {
-        process.env.NODE_ENV = prev;
-    }
-}
-function makeDefinition(kind, overrides = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {},
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-        ...overrides,
-    };
-}
-describe('nodeRegistry', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('starts empty', () => {
-        expect(nodeRegistry.size).toBe(0);
-        expect(nodeRegistry.has('anything')).toBe(false);
-        expect(nodeRegistry.get('anything')).toBeUndefined();
-    });
-    test('registerNode adds a definition', () => {
-        const def = makeDefinition('column');
-        registerNode(def);
-        expect(nodeRegistry.size).toBe(1);
-        expect(nodeRegistry.has('column')).toBe(true);
-        expect(nodeRegistry.get('column')).toBe(def);
-    });
-    test('registerNode throws on duplicate kind in production', async () => {
-        await inProduction(() => {
-            registerNode(makeDefinition('column'));
-            expect(() => registerNode(makeDefinition('column'))).toThrow(/duplicate node kind/);
-        });
-    });
-    test('registerNode replaces on duplicate kind in dev (HMR)', () => {
-        const first = makeDefinition('column');
-        const second = makeDefinition('column');
-        registerNode(first);
-        registerNode(second);
-        expect(nodeRegistry.size).toBe(1);
-        expect(nodeRegistry.get('column')).toBe(second);
-    });
-    test('registerNode rejects empty kind', () => {
-        expect(() => registerNode(makeDefinition(''))).toThrow(/non-empty string/);
-    });
-    test('registerNode rejects invalid schemaVersion', () => {
-        expect(() => registerNode(makeDefinition('bad', { schemaVersion: 0 }))).toThrow(/schemaVersion/);
-        expect(() => registerNode(makeDefinition('bad', { schemaVersion: -1 }))).toThrow(/schemaVersion/);
-    });
-    test('entries() iterates registered definitions', () => {
-        registerNode(makeDefinition('a'));
-        registerNode(makeDefinition('b'));
-        const kinds = Array.from(nodeRegistry.entries(), ([k]) => k);
-        expect(kinds).toEqual(['a', 'b']);
-    });
-    test('schemas() returns all registered schemas', () => {
-        const a = makeDefinition('a');
-        const b = makeDefinition('b');
-        registerNode(a);
-        registerNode(b);
-        expect(nodeRegistry.schemas()).toEqual([a.schema, b.schema]);
-    });
-});
-describe('isPresettable', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('explicit true wins', () => {
-        const def = makeDefinition('explicit-true', { capabilities: { presettable: true } });
-        expect(isPresettable(def)).toBe(true);
-    });
-    test('explicit false wins even with parametrics', () => {
-        const def = makeDefinition('explicit-false', {
-            capabilities: { presettable: false },
-            parametrics: { groups: [] },
-        });
-        expect(isPresettable(def)).toBe(false);
-    });
-    test('defaults to true when parametrics exists', () => {
-        const def = makeDefinition('param', { parametrics: { groups: [] } });
-        expect(isPresettable(def)).toBe(true);
-    });
-    test('defaults to false without parametrics', () => {
-        const def = makeDefinition('no-param');
-        expect(isPresettable(def)).toBe(false);
-    });
-    test('isPresettableKind looks up the registry', () => {
-        registerNode(makeDefinition('shelfy', { parametrics: { groups: [] } }));
-        expect(isPresettableKind('shelfy')).toBe(true);
-        expect(isPresettableKind('unknown')).toBe(false);
-    });
-});
-describe('getHostRefFields', () => {
-    test('returns the declared hostRefFields verbatim', () => {
-        const def = makeDefinition('door', { capabilities: { hostRefFields: ['wallId'] } });
-        expect(getHostRefFields(def)).toEqual(['wallId']);
-    });
-    test('defaults to an empty array when none declared', () => {
-        const def = makeDefinition('shelf');
-        expect(getHostRefFields(def)).toEqual([]);
-    });
-});
-describe('isDrawnViaTool', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('true when capability set', () => {
-        const def = makeDefinition('fence', { capabilities: { drawTool: true } });
-        expect(isDrawnViaTool(def)).toBe(true);
-    });
-    test('false when unset or not exactly true', () => {
-        expect(isDrawnViaTool(makeDefinition('column'))).toBe(false);
-        expect(isDrawnViaTool(makeDefinition('off', { capabilities: { drawTool: false } }))).toBe(false);
-    });
-    test('isDrawnViaToolKind looks up the registry', () => {
-        registerNode(makeDefinition('fence', { capabilities: { drawTool: true } }));
-        expect(isDrawnViaToolKind('fence')).toBe(true);
-        expect(isDrawnViaToolKind('unknown')).toBe(false);
-    });
-});
-describe('loadPlugin', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('registers all nodes from a plugin', async () => {
-        const plugin = {
-            id: 'test:plugin',
-            apiVersion: 1,
-            nodes: [makeDefinition('a'), makeDefinition('b')],
-        };
-        await loadPlugin(plugin);
-        expect(nodeRegistry.size).toBe(2);
-        expect(nodeRegistry.has('a')).toBe(true);
-        expect(nodeRegistry.has('b')).toBe(true);
-    });
-    test('handles plugin with no nodes', async () => {
-        await loadPlugin({ id: 'empty', apiVersion: 1 });
-        expect(nodeRegistry.size).toBe(0);
-    });
-    test('handles plugin with empty nodes array', async () => {
-        await loadPlugin({ id: 'empty', apiVersion: 1, nodes: [] });
-        expect(nodeRegistry.size).toBe(0);
-    });
-    test('throws on apiVersion mismatch', async () => {
-        const plugin = {
-            id: 'old-plugin',
-            apiVersion: 99,
-            nodes: [],
-        };
-        await expect(loadPlugin(plugin)).rejects.toThrow(/apiVersion/);
-    });
-    test('propagates duplicate-kind error from a single plugin in production', async () => {
-        const plugin = {
-            id: 'broken',
-            apiVersion: 1,
-            nodes: [makeDefinition('dup'), makeDefinition('dup')],
-        };
-        await inProduction(() => expect(loadPlugin(plugin)).rejects.toThrow(/duplicate node kind/));
-    });
-    test('propagates duplicate-kind error across plugins in production', async () => {
-        await inProduction(async () => {
-            await loadPlugin({ id: 'a', apiVersion: 1, nodes: [makeDefinition('shared')] });
-            await expect(loadPlugin({ id: 'b', apiVersion: 1, nodes: [makeDefinition('shared')] })).rejects.toThrow(/duplicate node kind/);
-        });
-    });
-});

package/dist/registry/relations-resolver.test.d.ts

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

package/dist/registry/relations-resolver.test.d.ts.map

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