@pascal-app/core 0.9.1 → 0.9.2

package/dist/services/port-connectivity.js

@@ -0,0 +1,300 @@
+import { nodeRegistry } from '../registry';
+/** Distance (meters) under which two ports count as the same joint. Joints
+ *  formed by placement snapping coincide to sub-millimeter; 5 cm leaves
+ *  generous slack for grid-snapped hand placement without false matches. */
+const COINCIDENT_EPS_M = 0.05;
+/** Below this (meters) a propagated delta is treated as zero — stops the
+ *  walk from chasing sub-millimeter perpendicular residue. */
+const DELTA_EPS_M = 1e-4;
+const PROPAGATION_EPS_M = 1e-9;
+function portsOf(node) {
+    return nodeRegistry.get(node.type)?.ports?.(node);
+}
+/** A node's distribution role from the registry (run / fitting / …). */
+function roleOf(node) {
+    return nodeRegistry.get(node.type)?.distributionRole;
+}
+function distSq(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+/** Two ports mate when they coincide AND don't cross incompatible systems
+ *  (a supply duct and a waste pipe that merely touch must not fuse). */
+function portsMate(a, b, epsSq) {
+    if (distSq(a.position, b.position) > epsSq)
+        return false;
+    if (a.system && b.system && a.system !== b.system)
+        return false;
+    return true;
+}
+/**
+ * Snapshot the joint graph reachable from `movedNode`'s ports, taken at the
+ * start of a move/resize. Call once before the drag; feed the result to
+ * `resolveConnectivityUpdates` on every frame.
+ *
+ * Only `run`-role partners (segments) and `fitting`-role partners are walked —
+ * terminals and equipment usually mount to a surface and shouldn't be yanked
+ * off it when an adjacent fitting nudges. Fittings that declare
+ * `portConnectivityFollow: false` are anchored fixtures (e.g. pipe-trap) and
+ * are skipped, so a connected run stretches against them instead.
+ */
+export function analyzePortConnectivity(movedNode, nodes) {
+    const epsSq = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    const movedPorts = portsOf(movedNode) ?? [];
+    const startMovedPorts = {};
+    for (const p of movedPorts)
+        startMovedPorts[p.id] = p.position;
+    // Candidate partners: every run + every following fitting in the scene.
+    const candidates = [];
+    for (const other of Object.values(nodes)) {
+        if (!other || other.id === movedNode.id)
+            continue;
+        const role = roleOf(other);
+        if (role !== 'run' && role !== 'fitting')
+            continue;
+        if (role === 'fitting' && nodeRegistry.get(other.type)?.portConnectivityFollow === false) {
+            continue;
+        }
+        const ports = portsOf(other);
+        if (!ports)
+            continue;
+        const startPath = role === 'run'
+            ? other.path?.map((p) => [...p])
+            : undefined;
+        if (role === 'run' && (!startPath || startPath.length < 2))
+            continue;
+        const startPosition = role === 'fitting'
+            ? (() => {
+                const pos = other.position;
+                return pos ? [pos[0], pos[1], pos[2]] : undefined;
+            })()
+            : undefined;
+        if (role === 'fitting' && !startPosition)
+            continue;
+        candidates.push({ id: other.id, role, ports, startPath, startPosition });
+    }
+    // Walk outward from the moved node, collecting every node reachable through
+    // coincident ports. The adjacency records each port's mates so the resolver
+    // can replay the same edges with live deltas.
+    const adjacency = {};
+    const addEdge = (nodeId, portId, mate) => {
+        const byPort = adjacency[nodeId] ?? {};
+        adjacency[nodeId] = byPort;
+        const mates = byPort[portId] ?? [];
+        byPort[portId] = mates;
+        mates.push(mate);
+    };
+    const graph = {};
+    const visited = new Set([movedNode.id]);
+    // Seed: the moved node's own ports.
+    const queue = [{ id: movedNode.id, ports: movedPorts }];
+    while (queue.length > 0) {
+        const { id, ports } = queue.shift();
+        for (const port of ports) {
+            for (const cand of candidates) {
+                if (cand.id === id)
+                    continue;
+                for (const cp of cand.ports) {
+                    if (!portsMate(port, cp, epsSq))
+                        continue;
+                    addEdge(id, port.id, { nodeId: cand.id, portId: cp.id });
+                    addEdge(cand.id, cp.id, { nodeId: id, portId: port.id });
+                    if (!visited.has(cand.id)) {
+                        visited.add(cand.id);
+                        graph[cand.id] = cand;
+                        queue.push({ id: cand.id, ports: cand.ports });
+                    }
+                }
+            }
+        }
+    }
+    const connections = Object.values(graph).map((g) => g.role === 'fitting'
+        ? { kind: 'rigid-node', nodeId: g.id, startPosition: g.startPosition }
+        : { kind: 'run', nodeId: g.id, startPath: g.startPath });
+    return {
+        movedNodeId: movedNode.id,
+        startMovedPorts,
+        graph,
+        adjacency,
+        connections,
+    };
+}
+function add(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function lenSq(v) {
+    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+}
+/** Split `delta` into the component along unit `axis` and the remainder. */
+function decompose(delta, axis) {
+    const dot = delta[0] * axis[0] + delta[1] * axis[1] + delta[2] * axis[2];
+    const parallel = [axis[0] * dot, axis[1] * dot, axis[2] * dot];
+    return { parallel, perp: sub(delta, parallel) };
+}
+function scale(v, scalar) {
+    return [v[0] * scalar, v[1] * scalar, v[2] * scalar];
+}
+function average(deltas) {
+    const sum = deltas.reduce((acc, delta) => add(acc, delta), [0, 0, 0]);
+    return scale(sum, 1 / deltas.length);
+}
+function nearlyEqual(a, b) {
+    return lenSq(sub(a, b)) <= DELTA_EPS_M * DELTA_EPS_M;
+}
+function propagationEqual(a, b) {
+    return lenSq(sub(a, b)) <= PROPAGATION_EPS_M * PROPAGATION_EPS_M;
+}
+function effectivePortDeltas(constraints) {
+    return Object.fromEntries(Object.entries(constraints).map(([portId, bySource]) => [
+        portId,
+        average(Object.values(bySource)),
+    ]));
+}
+/** Unit direction of the run's segment adjacent to its `start` / `end` tip. */
+function endpointAxis(path, portId) {
+    const n = path.length;
+    const [a, b] = portId === 'start' ? [path[1], path[0]] : [path[n - 2], path[n - 1]];
+    const dir = sub(b, a);
+    const l2 = lenSq(dir);
+    if (l2 < 1e-12)
+        return [0, 0, 0];
+    const l = Math.sqrt(l2);
+    return [dir[0] / l, dir[1] / l, dir[2] / l];
+}
+function runPathFromSinglePortDelta(startPath, portId, delta) {
+    const nearIdx = portId === 'start' ? 0 : startPath.length - 1;
+    const axis = endpointAxis(startPath, portId);
+    const { parallel, perp } = decompose(delta, axis);
+    const path = startPath.map((p) => add(p, perp));
+    path[nearIdx] = add(path[nearIdx], parallel);
+    return path;
+}
+function runEndpointDeltas(startPath, path) {
+    return {
+        start: sub(path[0], startPath[0]),
+        end: sub(path[path.length - 1], startPath[startPath.length - 1]),
+    };
+}
+function runPathFromPortDeltas(startPath, portDeltas) {
+    const startDelta = portDeltas.start;
+    const endDelta = portDeltas.end;
+    if (startDelta && endDelta) {
+        if (startPath.length === 2) {
+            return [add(startPath[0], startDelta), add(startPath[1], endDelta)];
+        }
+        if (nearlyEqual(startDelta, endDelta)) {
+            return startPath.map((p) => add(p, startDelta));
+        }
+        const startParts = decompose(startDelta, endpointAxis(startPath, 'start'));
+        const endParts = decompose(endDelta, endpointAxis(startPath, 'end'));
+        const commonPerp = average([startParts.perp, endParts.perp]);
+        const path = startPath.map((p) => add(p, commonPerp));
+        path[0] = add(path[0], startParts.parallel);
+        path[path.length - 1] = add(path[path.length - 1], endParts.parallel);
+        return path;
+    }
+    return runPathFromSinglePortDelta(startPath, startDelta ? 'start' : 'end', (startDelta ?? endDelta));
+}
+/**
+ * Given the moved node in its live (in-drag) transform, produce the patches
+ * that keep every connected node attached. `previewNode` is the moved node
+ * with its current drag position/rotation applied so its ports recompute.
+ *
+ * Walks the snapshotted graph, propagating each port delta outward: fittings
+ * translate rigidly, runs stretch along their axis and translate across it
+ * (never skew when driven from one end), and effective port movement carries on
+ * to neighbouring joints. Port-level output guards bound cycles while still
+ * allowing a looped/shared run to accept constraints at both endpoints.
+ */
+export function resolveConnectivityUpdates(connectivity, previewNode) {
+    const { graph, adjacency, startMovedPorts, movedNodeId } = connectivity;
+    if (Object.keys(graph).length === 0)
+        return [];
+    const newPorts = portsOf(previewNode) ?? [];
+    const newMovedPos = {};
+    for (const p of newPorts)
+        newMovedPos[p.id] = p.position;
+    // Each queue item drives a node's port by a delta ("this collar / endpoint
+    // must move by this much").
+    const queue = [];
+    const results = {};
+    const constrainedPorts = {};
+    const propagatedPorts = {};
+    const enqueueMates = (nodeId, portId, delta) => {
+        const byPort = propagatedPorts[nodeId] ?? {};
+        propagatedPorts[nodeId] = byPort;
+        const previous = byPort[portId];
+        if (previous && propagationEqual(previous, delta))
+            return;
+        byPort[portId] = delta;
+        for (const mate of adjacency[nodeId]?.[portId] ?? []) {
+            if (mate.nodeId === movedNodeId)
+                continue;
+            queue.push({
+                nodeId: mate.nodeId,
+                portId: mate.portId,
+                delta,
+                sourceKey: `${nodeId}:${portId}`,
+            });
+        }
+    };
+    const acceptPortDelta = (nodeId, portId, sourceKey, delta) => {
+        const byPort = constrainedPorts[nodeId] ?? {};
+        constrainedPorts[nodeId] = byPort;
+        const bySource = byPort[portId] ?? {};
+        byPort[portId] = bySource;
+        const existing = bySource[sourceKey];
+        if (existing && propagationEqual(existing, delta)) {
+            return false;
+        }
+        bySource[sourceKey] = delta;
+        return true;
+    };
+    // Seed from the moved node's live port deltas.
+    for (const [portId, start] of Object.entries(startMovedPorts)) {
+        const now = newMovedPos[portId];
+        if (!now)
+            continue;
+        const delta = sub(now, start);
+        if (lenSq(delta) <= DELTA_EPS_M * DELTA_EPS_M)
+            continue;
+        enqueueMates(movedNodeId, portId, delta);
+    }
+    while (queue.length > 0) {
+        const { nodeId, portId, delta, sourceKey } = queue.shift();
+        const node = graph[nodeId];
+        if (!node)
+            continue;
+        if (!acceptPortDelta(nodeId, portId, sourceKey, delta))
+            continue;
+        const portDeltas = effectivePortDeltas(constrainedPorts[nodeId]);
+        if (node.role === 'fitting') {
+            const start = node.startPosition;
+            const effectiveDelta = average(Object.values(portDeltas));
+            results[nodeId] = {
+                id: nodeId,
+                data: { position: add(start, effectiveDelta) },
+            };
+            // Rigid: every collar carries the effective body translation onward.
+            for (const p of node.ports) {
+                enqueueMates(nodeId, p.id, effectiveDelta);
+            }
+        }
+        else {
+            const startPath = node.startPath;
+            const path = runPathFromPortDeltas(startPath, portDeltas);
+            results[nodeId] = { id: nodeId, data: { path } };
+            for (const [nextPortId, nextDelta] of Object.entries(runEndpointDeltas(startPath, path))) {
+                if (lenSq(nextDelta) <= DELTA_EPS_M * DELTA_EPS_M)
+                    continue;
+                enqueueMates(nodeId, nextPortId, nextDelta);
+            }
+        }
+    }
+    return Object.values(results);
+}

package/dist/services/port-connectivity.test.d.ts

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

package/dist/services/port-connectivity.test.d.ts.map

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

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