@pascal-app/core 0.8.0 → 0.9.2

package/dist/services/port-connectivity.test.js

@@ -0,0 +1,297 @@
+import { describe, expect, test } from 'bun:test';
+import { registerNode } from '../registry';
+import { analyzePortConnectivity, resolveConnectivityUpdates } from './port-connectivity';
+// Stub registrations mirroring the real kinds' port + role conventions
+// without importing the nodes package (which pulls in CSG and can't load
+// under the test runner). A run exposes start/end at its path tips; the
+// fitting here is a simple two-collar elbow at ±X around its position.
+function stubDef(kind, distributionRole, ports) {
+    registerNode({
+        kind,
+        schemaVersion: 1,
+        schema: {},
+        category: 'utility',
+        distributionRole,
+        defaults: () => ({}),
+        capabilities: {},
+        ports,
+    });
+}
+stubDef('duct-segment', 'run', (node) => {
+    const path = node.path;
+    const system = node.system;
+    return [
+        { id: 'start', position: path[0], direction: [-1, 0, 0], diameter: 6, system },
+        { id: 'end', position: path[path.length - 1], direction: [1, 0, 0], diameter: 6, system },
+    ];
+});
+stubDef('duct-fitting', 'fitting', (node) => {
+    const position = node.position;
+    const system = node.system;
+    return [
+        {
+            id: 'inlet',
+            position: [position[0] - 0.2, position[1], position[2]],
+            direction: [-1, 0, 0],
+            diameter: 6,
+            system,
+        },
+        {
+            id: 'outlet',
+            position: [position[0] + 0.2, position[1], position[2]],
+            direction: [1, 0, 0],
+            diameter: 6,
+            system,
+        },
+    ];
+});
+stubDef('duct-tee', 'fitting', (node) => {
+    const position = node.position;
+    const system = node.system;
+    return [
+        {
+            id: 'inlet',
+            position: [position[0] - 0.2, position[1], position[2]],
+            direction: [-1, 0, 0],
+            diameter: 6,
+            system,
+        },
+        {
+            id: 'outlet',
+            position: [position[0] + 0.2, position[1], position[2]],
+            direction: [1, 0, 0],
+            diameter: 6,
+            system,
+        },
+        {
+            id: 'branch',
+            position: [position[0], position[1], position[2] + 0.2],
+            direction: [0, 0, 1],
+            diameter: 6,
+            system,
+        },
+    ];
+});
+let nextId = 0;
+function makeNode(type, fields) {
+    nextId += 1;
+    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
+}
+function sceneOf(...nodes) {
+    return Object.fromEntries(nodes.map((n) => [n.id, n]));
+}
+function expectPointClose(actual, expected) {
+    expect(actual[0]).toBeCloseTo(expected[0], 6);
+    expect(actual[1]).toBeCloseTo(expected[1], 6);
+    expect(actual[2]).toBeCloseTo(expected[2], 6);
+}
+describe('port connectivity — joint follow (stretch vs translate)', () => {
+    // Layout: duct A ends at the fitting's inlet (−0.2,0,0); duct B starts at the
+    // fitting's outlet (+0.2,0,0). Both runs lie on the X axis. Dragging A's
+    // mated endpoint carries the fitting and duct B; how B reacts depends on
+    // whether the drag is along its axis (stretch) or across it (translate).
+    function joint() {
+        const fitting = makeNode('duct-fitting', { position: [0, 0, 0], system: 'supply' });
+        const ductA = makeNode('duct-segment', {
+            path: [
+                [-3, 0, 0],
+                [-0.2, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const ductB = makeNode('duct-segment', {
+            path: [
+                [0.2, 0, 0],
+                [3, 0, 0],
+            ],
+            system: 'supply',
+        });
+        return { fitting, ductA, ductB };
+    }
+    function movedA(end) {
+        const { ductA } = joint();
+        return { ...ductA, path: [[-3, 0, 0], end] };
+    }
+    test('the fitting and sibling run are picked up as carried connections', () => {
+        const { fitting, ductA, ductB } = joint();
+        const connectivity = analyzePortConnectivity(ductA, sceneOf(fitting, ductA, ductB));
+        expect(connectivity.connections.find((c) => c.kind === 'rigid-node' && c.nodeId === fitting.id)).toBeDefined();
+        expect(connectivity.connections.find((c) => c.kind === 'run' && c.nodeId === ductB.id)).toBeDefined();
+    });
+    test('perpendicular drag translates the WHOLE sibling run (no skew)', () => {
+        const { fitting, ductA, ductB } = joint();
+        const nodes = sceneOf(fitting, ductA, ductB);
+        const connectivity = analyzePortConnectivity(ductA, nodes);
+        // Move A's mated end +1 in Z — perpendicular to B's X axis.
+        const updates = resolveConnectivityUpdates(connectivity, movedA([-0.2, 0, 1]));
+        expect(updates.find((u) => u.id === fitting.id).data.position).toEqual([0, 0, 1]);
+        const bPath = updates.find((u) => u.id === ductB.id).data.path;
+        // Both ends ride +1 in Z: the run keeps its length and direction.
+        expect(bPath[0]).toEqual([0.2, 0, 1]);
+        expect(bPath[1]).toEqual([3, 0, 1]);
+    });
+    test('parallel drag stretches the sibling run (only the near end slides)', () => {
+        const { fitting, ductA, ductB } = joint();
+        const nodes = sceneOf(fitting, ductA, ductB);
+        const connectivity = analyzePortConnectivity(ductA, nodes);
+        // Move A's mated end +0.5 in X — along B's axis (the fitting slides toward B).
+        const updates = resolveConnectivityUpdates(connectivity, movedA([0.3, 0, 0]));
+        const bPath = updates.find((u) => u.id === ductB.id).data.path;
+        // Near end slid +0.5 in X; far end stayed put → the run shortened.
+        expect(bPath[0]).toEqual([0.7, 0, 0]);
+        expect(bPath[1]).toEqual([3, 0, 0]);
+    });
+    test('perpendicular slide propagates through the sibling run to its far joint', () => {
+        // Extend the chain: duct B's far end (3,0,0) meets a second elbow, and duct
+        // C hangs off that elbow. A perpendicular drag should carry the whole chain.
+        const { fitting, ductA, ductB } = joint();
+        const elbow2 = makeNode('duct-fitting', { position: [3.2, 0, 0], system: 'supply' });
+        // elbow ports are ±0.2 on X around its position → inlet at (3,0,0) meets B.
+        const ductC = makeNode('duct-segment', {
+            path: [
+                [3.4, 0, 0],
+                [6, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const nodes = sceneOf(fitting, ductA, ductB, elbow2, ductC);
+        const connectivity = analyzePortConnectivity(ductA, nodes);
+        const updates = resolveConnectivityUpdates(connectivity, movedA([-0.2, 0, 1]));
+        // Whole chain rode +1 in Z.
+        const bPath = updates.find((u) => u.id === ductB.id).data.path;
+        expect(bPath[1]).toEqual([3, 0, 1]);
+        expect(updates.find((u) => u.id === elbow2.id).data.position).toEqual([3.2, 0, 1]);
+        const cPath = updates.find((u) => u.id === ductC.id).data.path;
+        expect(cPath[0]).toEqual([3.4, 0, 1]);
+        expect(cPath[1]).toEqual([6, 0, 1]);
+    });
+    test('a run reached from both ends applies both endpoint deltas', () => {
+        const moved = makeNode('duct-segment', {
+            path: [
+                [0, 0, 0],
+                [3, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const follower = makeNode('duct-segment', {
+            path: [
+                [0, 0, 0],
+                [3, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const nodes = sceneOf(moved, follower);
+        const connectivity = analyzePortConnectivity(moved, nodes);
+        const preview = {
+            ...moved,
+            path: [
+                [0, 0, 1],
+                [3, 0, 2],
+            ],
+        };
+        const updates = resolveConnectivityUpdates(connectivity, preview);
+        const path = updates.find((u) => u.id === follower.id).data.path;
+        expect(path[0]).toEqual([0, 0, 1]);
+        expect(path[1]).toEqual([3, 0, 2]);
+    });
+    test('a polyline run reached from both ends preserves interior bend shape', () => {
+        const moved = makeNode('duct-segment', {
+            path: [
+                [0, 0, 0],
+                [3, 0, 3],
+            ],
+            system: 'supply',
+        });
+        const follower = makeNode('duct-segment', {
+            path: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [1, 0, 3],
+                [3, 0, 3],
+            ],
+            system: 'supply',
+        });
+        const nodes = sceneOf(moved, follower);
+        const connectivity = analyzePortConnectivity(moved, nodes);
+        const preview = {
+            ...moved,
+            path: [
+                [-0.5, 0, 0],
+                [3.5, 0, 3],
+            ],
+        };
+        const updates = resolveConnectivityUpdates(connectivity, preview);
+        const path = updates.find((u) => u.id === follower.id).data.path;
+        expect(path).toEqual([
+            [-0.5, 0, 0],
+            [1, 0, 0],
+            [1, 0, 3],
+            [3.5, 0, 3],
+        ]);
+    });
+    test('a fitting reached from both collars rebroadcasts its final compatible rigid delta', () => {
+        const moved = makeNode('duct-segment', {
+            path: [
+                [-0.2, 0, 0],
+                [0.2, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const fitting = makeNode('duct-tee', { position: [0, 0, 0], system: 'supply' });
+        const downstream = makeNode('duct-segment', {
+            path: [
+                [0, 0, 0.2],
+                [3, 0, 0.2],
+            ],
+            system: 'supply',
+        });
+        const nodes = sceneOf(moved, fitting, downstream);
+        const connectivity = analyzePortConnectivity(moved, nodes);
+        const preview = {
+            ...moved,
+            path: [
+                [-0.2, 0, 1],
+                [0.2, 0, 1.00005],
+            ],
+        };
+        const updates = resolveConnectivityUpdates(connectivity, preview);
+        expectPointClose(updates.find((u) => u.id === fitting.id).data.position, [0, 0, 1.000025]);
+        const path = updates.find((u) => u.id === downstream.id).data.path;
+        expectPointClose(path[0], [0, 0, 1.200025]);
+        expectPointClose(path[1], [3, 0, 1.200025]);
+    });
+    test('a fitting reached from incompatible collars merges constraints deterministically', () => {
+        const moved = makeNode('duct-segment', {
+            path: [
+                [-0.2, 0, 0],
+                [0.2, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const fitting = makeNode('duct-fitting', { position: [0, 0, 0], system: 'supply' });
+        const nodes = sceneOf(moved, fitting);
+        const connectivity = analyzePortConnectivity(moved, nodes);
+        const preview = {
+            ...moved,
+            path: [
+                [-0.2, 0, 1],
+                [0.2, 0, -1],
+            ],
+        };
+        const updates = resolveConnectivityUpdates(connectivity, preview);
+        expectPointClose(updates.find((u) => u.id === fitting.id).data.position, [0, 0, 0]);
+    });
+    test('an unrelated run not on the fitting is left alone', () => {
+        const { fitting, ductA, ductB } = joint();
+        const distant = makeNode('duct-segment', {
+            path: [
+                [10, 0, 0],
+                [13, 0, 0],
+            ],
+            system: 'supply',
+        });
+        const nodes = sceneOf(fitting, ductA, ductB, distant);
+        const connectivity = analyzePortConnectivity(ductA, nodes);
+        expect(connectivity.connections.find((c) => c.nodeId === distant.id)).toBeUndefined();
+    });
+});

package/dist/services/riser-diagram.d.ts

@@ -0,0 +1,40 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+/** A 3D level-local point (meters) projected to 2D iso screen space.
+ *  Screen Y grows DOWNWARD (SVG convention), so higher elevation → lower
+ *  screen Y. */
+export declare function projectIso(x: number, y: number, z: number): [number, number];
+export type RiserLine = {
+    /** Projected endpoints in iso screen space. */
+    from: [number, number];
+    to: [number, number];
+    system: 'waste' | 'vent';
+    /** Nominal size in inches. */
+    diameter: number;
+    /** True for a (near-)vertical run — drawn solid/bold as a stack. */
+    vertical: boolean;
+    /** Source node, so the editor can link selection. */
+    nodeId: AnyNodeId;
+};
+export type RiserMarker = {
+    point: [number, number];
+    kind: 'trap' | 'vent-termination' | 'fitting';
+    label: string;
+    nodeId: AnyNodeId;
+};
+export type RiserDiagram = {
+    lines: RiserLine[];
+    markers: RiserMarker[];
+    /** Bounding box of all projected geometry, screen space. */
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+};
+/**
+ * Build the riser diagram for the whole scene. Returns null when there's
+ * no DWV geometry to draw.
+ */
+export declare function buildRiserDiagram(nodes: Readonly<Record<AnyNodeId, AnyNode>>): RiserDiagram | null;
+//# sourceMappingURL=riser-diagram.d.ts.map

package/dist/services/riser-diagram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riser-diagram.d.ts","sourceRoot":"","sources":["../../src/services/riser-diagram.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAiBnD;;gBAEgB;AAChB,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5E;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,+CAA+C;IAC/C,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtB,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpB,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;IACxB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAA;IACjB,qDAAqD;IACrD,MAAM,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAA;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB,4DAA4D;IAC5D,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CACnE,CAAA;AAcD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,YAAY,GAAG,IAAI,CAuErB"}

package/dist/services/riser-diagram.js

@@ -0,0 +1,110 @@
+/**
+ * Riser diagram (plumbing isometric) — the conventional way DWV systems
+ * are drawn for permit: the drain/vent tree projected to a 30° iso so
+ * vertical stacks read as vertical and horizontal runs lean off at 30°,
+ * annotated with size + slope and vent terminations.
+ *
+ * This is a pure projector: it turns the scene's DWV nodes into 2D
+ * drawables (level-independent, no rendering). The editor draws the
+ * result as SVG. Air/refrigerant nodes are ignored — riser diagrams are
+ * a plumbing convention.
+ */
+const COS30 = Math.cos(Math.PI / 6);
+const SIN30 = Math.sin(Math.PI / 6);
+/** A 3D level-local point (meters) projected to 2D iso screen space.
+ *  Screen Y grows DOWNWARD (SVG convention), so higher elevation → lower
+ *  screen Y. */
+export function projectIso(x, y, z) {
+    const sx = (x - z) * COS30;
+    const sy = (x + z) * SIN30 - y;
+    return [sx, sy];
+}
+/** Elevation gain per horizontal meter under which a leg is "vertical". */
+const VERTICAL_EPS = 4; // dy/dxz ratio: steeper than this reads as a stack
+function legIsVertical(a, b) {
+    const horizontal = Math.hypot(b[0] - a[0], b[2] - a[2]);
+    const vertical = Math.abs(b[1] - a[1]);
+    if (horizontal < 1e-4)
+        return true;
+    return vertical / horizontal > VERTICAL_EPS;
+}
+/**
+ * Build the riser diagram for the whole scene. Returns null when there's
+ * no DWV geometry to draw.
+ */
+export function buildRiserDiagram(nodes) {
+    const lines = [];
+    const markers = [];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const grow = (p) => {
+        if (p[0] < minX)
+            minX = p[0];
+        if (p[1] < minY)
+            minY = p[1];
+        if (p[0] > maxX)
+            maxX = p[0];
+        if (p[1] > maxY)
+            maxY = p[1];
+    };
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        if (node.type === 'pipe-segment') {
+            const path = node.path;
+            for (let i = 0; i < path.length - 1; i++) {
+                const a = path[i];
+                const b = path[i + 1];
+                const from = projectIso(a[0], a[1], a[2]);
+                const to = projectIso(b[0], b[1], b[2]);
+                grow(from);
+                grow(to);
+                lines.push({
+                    from,
+                    to,
+                    system: node.system,
+                    diameter: node.diameter,
+                    vertical: legIsVertical(a, b),
+                    nodeId: node.id,
+                });
+            }
+            // Vent runs that end above everything are vent terminations
+            // (through-roof). Tag the highest endpoint of a vent run.
+            if (node.system === 'vent') {
+                const top = path.reduce((hi, p) => (p[1] > hi[1] ? p : hi), path[0]);
+                const pt = projectIso(top[0], top[1], top[2]);
+                markers.push({
+                    point: pt,
+                    kind: 'vent-termination',
+                    label: `${node.diameter}" VTR`,
+                    nodeId: node.id,
+                });
+            }
+        }
+        else if (node.type === 'pipe-trap') {
+            const pt = projectIso(node.position[0], node.position[1], node.position[2]);
+            grow(pt);
+            markers.push({
+                point: pt,
+                kind: 'trap',
+                label: `${node.diameter}" P-trap`,
+                nodeId: node.id,
+            });
+        }
+        else if (node.type === 'pipe-fitting') {
+            const pt = projectIso(node.position[0], node.position[1], node.position[2]);
+            grow(pt);
+            markers.push({
+                point: pt,
+                kind: 'fitting',
+                label: node.fittingType,
+                nodeId: node.id,
+            });
+        }
+    }
+    if (lines.length === 0 && markers.length === 0)
+        return null;
+    return { lines, markers, bounds: { minX, minY, maxX, maxY } };
+}

package/dist/services/riser-diagram.test.d.ts

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

package/dist/services/riser-diagram.test.d.ts.map

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

package/dist/services/riser-diagram.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'bun:test';
+import { buildRiserDiagram, projectIso } from './riser-diagram';
+let nextId = 0;
+function makeNode(type, fields) {
+    nextId += 1;
+    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
+}
+function sceneOf(...nodes) {
+    return Object.fromEntries(nodes.map((n) => [n.id, n]));
+}
+describe('projectIso', () => {
+    test('higher elevation maps to smaller screen Y', () => {
+        const [, lowY] = projectIso(0, 0, 0);
+        const [, highY] = projectIso(0, 2, 0);
+        expect(highY).toBeLessThan(lowY);
+    });
+});
+describe('buildRiserDiagram', () => {
+    test('null when no DWV nodes', () => {
+        const wall = makeNode('wall', {});
+        expect(buildRiserDiagram(sceneOf(wall))).toBeNull();
+    });
+    test('classifies a vertical stack vs a sloped horizontal drain', () => {
+        const stack = makeNode('pipe-segment', {
+            path: [
+                [0, 0, 0],
+                [0, 3, 0],
+            ],
+            diameter: 3,
+            system: 'vent',
+        });
+        const drain = makeNode('pipe-segment', {
+            path: [
+                [0, 0, 0],
+                [3, -0.06, 0],
+            ],
+            diameter: 2,
+            system: 'waste',
+        });
+        const diagram = buildRiserDiagram(sceneOf(stack, drain));
+        const stackLine = diagram.lines.find((l) => l.nodeId === stack.id);
+        const drainLine = diagram.lines.find((l) => l.nodeId === drain.id);
+        expect(stackLine.vertical).toBe(true);
+        expect(drainLine.vertical).toBe(false);
+    });
+    test('emits a vent-termination marker for a vent run', () => {
+        const vent = makeNode('pipe-segment', {
+            path: [
+                [0, 0, 0],
+                [0, 3, 0],
+            ],
+            diameter: 2,
+            system: 'vent',
+        });
+        const diagram = buildRiserDiagram(sceneOf(vent));
+        expect(diagram.markers.some((m) => m.kind === 'vent-termination')).toBe(true);
+    });
+    test('labels traps', () => {
+        const trap = makeNode('pipe-trap', {
+            position: [1, 0, 0],
+            diameter: 1.5,
+        });
+        const diagram = buildRiserDiagram(sceneOf(trap));
+        expect(diagram.markers.some((m) => m.kind === 'trap')).toBe(true);
+    });
+});

package/dist/services/single-undo-dance.test.d.ts

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

package/dist/services/single-undo-dance.test.d.ts.map

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