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

package/dist/registry/relations-resolver.test.js

@@ -1,183 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from './registry';
-import { cascadeDirty, collectDescendants } from './relations-resolver';
-const id = (s) => s;
-function makeDef(kind, relations, overrides = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {},
-        relations,
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-        ...overrides,
-    };
-}
-function makeNode(kind, idStr, extra = {}) {
-    return {
-        id: id(idStr),
-        type: kind,
-        parentId: null,
-        visible: true,
-        ...extra,
-    };
-}
-function makeFakeScene(nodes) {
-    return {
-        get: ((nid) => nodes[nid]),
-        nodes: () => nodes,
-        update: () => { },
-        upsert: () => id(''),
-        delete: () => { },
-        restore: () => { },
-        restoreAll: () => { },
-        markDirty: () => { },
-        pauseHistory: () => { },
-        resumeHistory: () => { },
-        getSubtree: () => null,
-        cloneNodesInto: () => null,
-    };
-}
-describe('cascadeDirty', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('starting node alone when registry is empty', () => {
-        const scene = makeFakeScene({ a: makeNode('unknown', 'a') });
-        const dirty = cascadeDirty(id('a'), { scene });
-        expect(Array.from(dirty)).toEqual([id('a')]);
-    });
-    test('starting node alone when no relations declared', () => {
-        registerNode(makeDef('thing'));
-        const scene = makeFakeScene({ a: makeNode('thing', 'a') });
-        const dirty = cascadeDirty(id('a'), { scene });
-        expect(Array.from(dirty)).toEqual([id('a')]);
-    });
-    test('hosts cascade marks matching children dirty', () => {
-        registerNode(makeDef('wall', { hosts: ['door', 'window'] }));
-        registerNode(makeDef('door'));
-        registerNode(makeDef('window'));
-        registerNode(makeDef('lamp'));
-        const wall = makeNode('wall', 'w1', {
-            children: [id('d1'), id('w2'), id('l1')],
-        });
-        const scene = makeFakeScene({
-            w1: wall,
-            d1: makeNode('door', 'd1', { parentId: id('w1') }),
-            w2: makeNode('window', 'w2', { parentId: id('w1') }),
-            l1: makeNode('lamp', 'l1', { parentId: id('w1') }), // not in hosts list
-        });
-        const dirty = cascadeDirty(id('w1'), { scene });
-        const ids = Array.from(dirty).sort();
-        expect(ids).toEqual([id('d1'), id('w1'), id('w2')]); // l1 excluded
-    });
-    test('hosts cascade is recursive but bounded by maxDepth', () => {
-        registerNode(makeDef('a', { hosts: ['a'] })); // a hosts more a
-        const nodes = {};
-        for (let i = 0; i < 25; i++) {
-            const childId = i < 24 ? id(`a${i + 1}`) : undefined;
-            nodes[`a${i}`] = makeNode('a', `a${i}`, {
-                children: childId ? [childId] : [],
-            });
-        }
-        const scene = makeFakeScene(nodes);
-        const dirty = cascadeDirty(id('a0'), { scene, maxDepth: 5 });
-        expect(dirty.size).toBe(6); // a0 + 5 descendants
-    });
-    test('affectsSpatial cascade uses spatialQuery to find neighbors', () => {
-        registerNode(makeDef('wall', { affectsSpatial: ['slab', 'zone'] }));
-        registerNode(makeDef('slab'));
-        registerNode(makeDef('zone'));
-        const scene = makeFakeScene({
-            w1: makeNode('wall', 'w1'),
-            s1: makeNode('slab', 's1'),
-            z1: makeNode('zone', 'z1'),
-            unrelated: makeNode('door', 'unrelated'),
-        });
-        const spatialQuery = (node, kinds) => {
-            if (node.id !== id('w1'))
-                return [];
-            const matches = [];
-            if (kinds.includes('slab'))
-                matches.push(id('s1'));
-            if (kinds.includes('zone'))
-                matches.push(id('z1'));
-            return matches;
-        };
-        const dirty = cascadeDirty(id('w1'), { scene, spatialQuery });
-        expect(Array.from(dirty).sort()).toEqual([id('s1'), id('w1'), id('z1')]);
-    });
-    test('affectsSpatial is a no-op when no spatialQuery is provided', () => {
-        registerNode(makeDef('wall', { affectsSpatial: ['slab'] }));
-        const scene = makeFakeScene({ w1: makeNode('wall', 'w1') });
-        const dirty = cascadeDirty(id('w1'), { scene });
-        expect(Array.from(dirty)).toEqual([id('w1')]); // spatial branch silently skipped
-    });
-    test('cycle in hosts cascade does not loop forever', () => {
-        registerNode(makeDef('a', { hosts: ['a'] }));
-        const nodes = {
-            a1: makeNode('a', 'a1', { children: [id('a2')] }),
-            a2: makeNode('a', 'a2', { children: [id('a1')] }), // cycle
-        };
-        const scene = makeFakeScene(nodes);
-        const dirty = cascadeDirty(id('a1'), { scene });
-        expect(dirty.size).toBe(2);
-        expect(dirty.has(id('a1'))).toBe(true);
-        expect(dirty.has(id('a2'))).toBe(true);
-    });
-    test('custom childQuery overrides the default node.children lookup', () => {
-        registerNode(makeDef('wall', { hosts: ['door'] }));
-        registerNode(makeDef('door'));
-        const scene = makeFakeScene({
-            w1: makeNode('wall', 'w1'), // no children field
-            d1: makeNode('door', 'd1', { parentId: id('w1') }),
-        });
-        // childQuery iterates the scene to find parentId matches — what you would
-        // do for kinds that don't carry an explicit children array.
-        const childQuery = (node) => {
-            const result = [];
-            for (const candidate of [id('d1')]) {
-                const c = scene.get(candidate);
-                if (c && c.parentId === node.id)
-                    result.push(c.id);
-            }
-            return result;
-        };
-        const dirty = cascadeDirty(id('w1'), { scene, childQuery });
-        expect(Array.from(dirty).sort()).toEqual([id('d1'), id('w1')]);
-    });
-});
-describe('collectDescendants', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('returns just the start when no children', () => {
-        const scene = makeFakeScene({ a: makeNode('thing', 'a') });
-        const result = collectDescendants(id('a'), { scene });
-        expect(Array.from(result)).toEqual([id('a')]);
-    });
-    test('returns full subtree regardless of relations declarations', () => {
-        // No def registered — descendants still found via the children array.
-        const scene = makeFakeScene({
-            root: makeNode('thing', 'root', { children: [id('c1'), id('c2')] }),
-            c1: makeNode('thing', 'c1', { children: [id('g1')] }),
-            c2: makeNode('thing', 'c2'),
-            g1: makeNode('thing', 'g1'),
-        });
-        const result = collectDescendants(id('root'), { scene });
-        expect(Array.from(result).sort()).toEqual([id('c1'), id('c2'), id('g1'), id('root')]);
-    });
-    test('respects maxDepth', () => {
-        const scene = makeFakeScene({
-            a: makeNode('thing', 'a', { children: [id('b')] }),
-            b: makeNode('thing', 'b', { children: [id('c')] }),
-            c: makeNode('thing', 'c', { children: [id('d')] }),
-            d: makeNode('thing', 'd'),
-        });
-        const result = collectDescendants(id('a'), { scene, maxDepth: 2 });
-        expect(Array.from(result).sort()).toEqual([id('a'), id('b'), id('c')]); // d truncated
-    });
-});

package/dist/registry/scene-api.test.d.ts

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

package/dist/registry/scene-api.test.d.ts.map

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

package/dist/registry/scene-api.test.js

@@ -1,183 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { resetSceneHistoryPauseDepth } from '../store/history-control';
-import { createSceneApi } from './scene-api';
-function makeFakeStore(initial = {}) {
-    const state = {
-        nodes: { ...initial },
-        rootNodeIds: [],
-        dirtyNodes: new Set(),
-        createNode(node) {
-            state.nodes[node.id] = node;
-        },
-        updateNode(id, data) {
-            const existing = state.nodes[id];
-            if (existing)
-                state.nodes[id] = { ...existing, ...data };
-        },
-        deleteNode(id) {
-            delete state.nodes[id];
-        },
-        markDirty(id) {
-            state.dirtyNodes.add(id);
-        },
-    };
-    let paused = 0;
-    const temporal = {
-        getState: () => ({
-            pause: () => {
-                paused += 1;
-            },
-            resume: () => {
-                paused -= 1;
-            },
-        }),
-    };
-    const store = {
-        getState: () => state,
-        temporal,
-        _state: state,
-        _pausedCount: () => paused,
-    };
-    return store;
-}
-function makeNode(id, extra = {}) {
-    return { id, type: 'site', parentId: null, visible: true, ...extra };
-}
-// Tests use short string IDs ("a", "b") for readability. The store's
-// AnyNodeId is a branded template-literal type — cast at the boundary.
-const id = (s) => s;
-const nodes = (store) => store._state.nodes;
-describe('SceneApi', () => {
-    beforeEach(() => {
-        resetSceneHistoryPauseDepth();
-    });
-    test('get reads node from store', () => {
-        const store = makeFakeStore({ a: makeNode('a') });
-        const api = createSceneApi(store);
-        expect(api.get(id('a'))).toEqual(makeNode('a'));
-        expect(api.get(id('missing'))).toBeUndefined();
-    });
-    test('update applies patch via store.updateNode', () => {
-        const store = makeFakeStore({ a: makeNode('a', { visible: true }) });
-        const api = createSceneApi(store);
-        api.update(id('a'), { visible: false });
-        expect(nodes(store)['a']).toMatchObject({ visible: false });
-    });
-    test('upsert calls createNode and returns the id', () => {
-        const store = makeFakeStore();
-        const api = createSceneApi(store);
-        const returnedId = api.upsert(makeNode('a'));
-        expect(returnedId).toBe(id('a'));
-        expect(nodes(store)['a']).toBeDefined();
-    });
-    test('delete removes node from store', () => {
-        const store = makeFakeStore({ a: makeNode('a') });
-        const api = createSceneApi(store);
-        api.delete(id('a'));
-        expect(nodes(store)['a']).toBeUndefined();
-    });
-    test('markDirty forwards to store', () => {
-        const store = makeFakeStore({ a: makeNode('a') });
-        const api = createSceneApi(store);
-        api.markDirty(id('a'));
-        expect(store._state.dirtyNodes.has(id('a'))).toBe(true);
-    });
-    test('pauseHistory and resumeHistory bracket store.temporal pause/resume', () => {
-        const store = makeFakeStore();
-        const api = createSceneApi(store);
-        expect(store._pausedCount()).toBe(0);
-        api.pauseHistory();
-        expect(store._pausedCount()).toBe(1);
-        api.resumeHistory();
-        expect(store._pausedCount()).toBe(0);
-    });
-    test('nested pause/resume use a depth counter (single pause call to temporal)', () => {
-        const store = makeFakeStore();
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.pauseHistory();
-        expect(store._pausedCount()).toBe(1); // only one actual pause
-        api.resumeHistory();
-        expect(store._pausedCount()).toBe(1); // still paused — inner resume
-        api.resumeHistory();
-        expect(store._pausedCount()).toBe(0);
-    });
-});
-describe('SceneApi snapshot / restore', () => {
-    beforeEach(() => {
-        resetSceneHistoryPauseDepth();
-    });
-    test('restore returns a touched node to its pre-pause state', () => {
-        const store = makeFakeStore({ a: makeNode('a', { visible: true }) });
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.update(id('a'), { visible: false });
-        expect(nodes(store)['a']).toMatchObject({ visible: false });
-        api.restore(id('a'));
-        expect(nodes(store)['a']).toMatchObject({ visible: true });
-        api.resumeHistory();
-    });
-    test('restore on a node never touched is a no-op', () => {
-        const store = makeFakeStore({ a: makeNode('a', { visible: true }) });
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.restore(id('a'));
-        expect(nodes(store)['a']).toMatchObject({ visible: true });
-        api.resumeHistory();
-    });
-    test('restoreAll reverts every touched node', () => {
-        const store = makeFakeStore({
-            a: makeNode('a', { visible: true }),
-            b: makeNode('b', { visible: true }),
-        });
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.update(id('a'), { visible: false });
-        api.update(id('b'), { visible: false });
-        api.restoreAll();
-        expect(nodes(store)['a']).toMatchObject({ visible: true });
-        expect(nodes(store)['b']).toMatchObject({ visible: true });
-        api.resumeHistory();
-    });
-    test('restore re-creates a node that was deleted mid-pause', () => {
-        const original = makeNode('a', { visible: true });
-        const store = makeFakeStore({ a: original });
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.delete(id('a'));
-        expect(nodes(store)['a']).toBeUndefined();
-        api.restore(id('a'));
-        expect(nodes(store)['a']).toEqual(original);
-        api.resumeHistory();
-    });
-    test('restore deletes a node that was upserted mid-pause', () => {
-        const store = makeFakeStore();
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.upsert(makeNode('a'));
-        expect(nodes(store)['a']).toBeDefined();
-        api.restore(id('a'));
-        expect(nodes(store)['a']).toBeUndefined();
-        api.resumeHistory();
-    });
-    test('snapshot is dropped on resumeHistory; restore after resume is a no-op', () => {
-        const store = makeFakeStore({ a: makeNode('a', { visible: true }) });
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.update(id('a'), { visible: false });
-        api.resumeHistory();
-        api.restore(id('a')); // snapshot gone — no effect
-        expect(nodes(store)['a']).toMatchObject({ visible: false });
-    });
-    test('only the first mutation in a pause window captures the original', () => {
-        const store = makeFakeStore({ a: makeNode('a', { visible: true }) });
-        const api = createSceneApi(store);
-        api.pauseHistory();
-        api.update(id('a'), { visible: false });
-        api.update(id('a'), { visible: true }); // second update — must not overwrite snapshot
-        api.update(id('a'), { visible: false });
-        api.restore(id('a'));
-        expect(nodes(store)['a']).toMatchObject({ visible: true }); // the *first* pre-pause value
-        api.resumeHistory();
-    });
-});

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

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

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

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

package/dist/registry/subtree.test.js

@@ -1,163 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { cloneNodesInto, collectSubtree } from './subtree';
-function makeNode(id, type, extra = {}) {
-    return {
-        object: 'node',
-        id,
-        type,
-        parentId: null,
-        visible: true,
-        metadata: {},
-        ...extra,
-    };
-}
-describe('collectSubtree', () => {
-    test('returns null for missing root', () => {
-        expect(collectSubtree({}, 'missing')).toBeNull();
-    });
-    test('returns just the root for a leaf node', () => {
-        const root = makeNode('shelf_1', 'shelf', { width: 1 });
-        const sub = collectSubtree({ ['shelf_1']: root }, 'shelf_1');
-        expect(sub?.root).toBe(root);
-        expect(sub?.descendants).toEqual([]);
-    });
-    test('walks descendants in BFS / declaration order', () => {
-        const nodes = {
-            ['shelf_1']: makeNode('shelf_1', 'shelf', {
-                position: [0, 0, 0],
-                children: ['item_a', 'item_b'],
-                width: 1,
-            }),
-            ['item_a']: makeNode('item_a', 'item', {
-                parentId: 'shelf_1',
-                position: [0, 0, 0],
-            }),
-            ['item_b']: makeNode('item_b', 'item', {
-                parentId: 'shelf_1',
-                position: [0.3, 0, 0],
-            }),
-        };
-        const sub = collectSubtree(nodes, 'shelf_1');
-        expect(sub?.descendants.map((n) => n.id)).toEqual(['item_a', 'item_b']);
-    });
-    test('returned nodes are live references — no cloning', () => {
-        const item = makeNode('item_a', 'item', { parentId: 'shelf_1', position: [0, 0, 0] });
-        const nodes = {
-            ['shelf_1']: makeNode('shelf_1', 'shelf', { children: ['item_a'] }),
-            ['item_a']: item,
-        };
-        const sub = collectSubtree(nodes, 'shelf_1');
-        expect(sub?.descendants[0]).toBe(item);
-    });
-});
-describe('cloneNodesInto', () => {
-    test('clones a single root with fresh id and supplied position', () => {
-        const original = makeNode('door_orig', 'door', {
-            position: [1, 2, 3],
-            wallId: 'wall_x',
-            width: 0.9,
-        });
-        const { rootId, nodes } = cloneNodesInto([original], {
-            rootId: 'door_orig',
-            position: [10, 0, -4],
-        });
-        expect(nodes).toHaveLength(1);
-        const cloned = nodes[0];
-        expect(cloned.id).toBe(rootId);
-        expect(cloned.id).not.toBe('door_orig');
-        expect(cloned.id.startsWith('door_')).toBe(true);
-        expect(cloned.position).toEqual([10, 0, -4]);
-        expect(cloned.width).toBe(0.9);
-        // cloneNodesInto is host-ref-agnostic — wallId is preserved
-        // verbatim. Stripping is the caller's job (see getHostRefFields).
-        expect(cloned.wallId).toBe('wall_x');
-    });
-    test('preserves root position when none is supplied', () => {
-        const original = makeNode('shelf_orig', 'shelf', { position: [5, 0, 5] });
-        const { nodes } = cloneNodesInto([original], { rootId: 'shelf_orig' });
-        expect(nodes[0].position).toEqual([5, 0, 5]);
-    });
-    test('preserves parent/child subtree with remapped ids and relative positions', () => {
-        const shelf = makeNode('shelf_1', 'shelf', {
-            position: [5, 0, 5],
-            children: ['item_a', 'item_b'],
-        });
-        const itemA = makeNode('item_a', 'item', { parentId: 'shelf_1', position: [0, 0, 0] });
-        const itemB = makeNode('item_b', 'item', { parentId: 'shelf_1', position: [0.3, 0, 0] });
-        const { rootId, nodes: out } = cloneNodesInto([shelf, itemA, itemB], {
-            rootId: 'shelf_1',
-            position: [99, 0, -99],
-        });
-        expect(out).toHaveLength(3);
-        const root = out[0];
-        expect(root.id).toBe(rootId);
-        expect(root.id).not.toBe('shelf_1');
-        expect(root.position).toEqual([99, 0, -99]);
-        // Root's children rewritten to fresh ids; descendants' parentIds
-        // point at the new root id.
-        const ids = new Set(out.map((n) => n.id));
-        expect(root.children).toHaveLength(2);
-        for (const cid of root.children)
-            expect(ids.has(cid)).toBe(true);
-        for (let i = 1; i < out.length; i += 1) {
-            const desc = out[i];
-            expect(desc.parentId).toBe(rootId);
-            expect(Array.isArray(desc.position)).toBe(true);
-        }
-    });
-    test('remaps associative measurement references inside the cloned subtree', () => {
-        const wall = makeNode('wall_1', 'wall', { parentId: 'level_1' });
-        const measurement = makeNode('measurement_1', 'measurement', {
-            parentId: 'level_1',
-            measurement: {
-                kind: 'distance',
-                points: [
-                    {
-                        kind: 'feature',
-                        reference: { nodeId: 'wall_1', featureId: 'wall:start' },
-                        fallback: [0, 0, 0],
-                    },
-                    [1, 0, 0],
-                ],
-            },
-        });
-        const result = cloneNodesInto([wall, measurement], {
-            rootId: 'wall_1',
-        });
-        const clonedMeasurement = result.nodes.find((node) => node.type === 'measurement');
-        expect(clonedMeasurement?.type).toBe('measurement');
-        if (clonedMeasurement?.type === 'measurement' &&
-            clonedMeasurement.measurement.kind === 'distance') {
-            const anchor = clonedMeasurement.measurement.points[0];
-            expect(Array.isArray(anchor)).toBe(false);
-            if (!Array.isArray(anchor)) {
-                expect(anchor.reference.nodeId).toBe(result.idMap.get('wall_1'));
-            }
-        }
-    });
-    test('parents the cloned root under opts.parentId when supplied', () => {
-        const orig = makeNode('shelf_1', 'shelf', { parentId: 'level_old' });
-        const { nodes } = cloneNodesInto([orig], {
-            rootId: 'shelf_1',
-            parentId: 'level_new',
-        });
-        expect(nodes[0].parentId).toBe('level_new');
-    });
-    test('two clones produce disjoint id sets', () => {
-        const orig = makeNode('shelf_1', 'shelf', {
-            position: [0, 0, 0],
-            children: ['item_a'],
-        });
-        const child = makeNode('item_a', 'item', { parentId: 'shelf_1', position: [0, 0, 0] });
-        const first = cloneNodesInto([orig, child], { rootId: 'shelf_1' });
-        const second = cloneNodesInto([orig, child], { rootId: 'shelf_1' });
-        const idsA = new Set(first.nodes.map((n) => n.id));
-        const idsB = new Set(second.nodes.map((n) => n.id));
-        for (const id of idsA)
-            expect(idsB.has(id)).toBe(false);
-    });
-    test('throws if rootId is missing from the input array', () => {
-        const orig = makeNode('shelf_1', 'shelf', {});
-        expect(() => cloneNodesInto([orig], { rootId: 'shelf_other' })).toThrow(/rootId/);
-    });
-});

package/dist/schema/asset-url.test.d.ts

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

package/dist/schema/asset-url.test.d.ts.map

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