@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/pipe-segment/offset-operation.js

@@ -0,0 +1,104 @@
+import { nodeRegistry, PipeSegmentNode } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { queryNodes } from '@pascal-app/core/runtime';
+import { Vector3 } from 'three';
+import { planPipeElbowAtPort } from '../shared/auto-fitting.js';
+import { autoOffsetInvalidationUpdates } from '../shared/auto-offset-tag.js';
+import { transferRunEndCapOwnership } from '../shared/automatic-run-end-cap.js';
+import { pipeGrade, pipeGradesMatch } from './slope.js';
+export const offsetPipe = (nodes, input) => {
+    const pipe = nodes[input.nodeId];
+    if (pipe?.type !== 'pipe-segment')
+        return refuse('pipe_not_found', 'Select a pipe run.');
+    if (!nodeRegistry.get('pipe-segment')?.ports || !nodeRegistry.get('pipe-fitting')?.ports)
+        return refuse('node_capability_unavailable', 'Register pipe and fitting definitions before editing.');
+    if (pipe.path.length !== 2 || ![input.from, input.to, input.offset].every(Number.isFinite))
+        return refuse('pipe_offset_route', 'Choose a straight run and enter finite offset dimensions.');
+    if (queryNodes(nodes, { parentId: pipe.id }).length > 0 ||
+        Object.keys(pipe.hangerOverrides ?? {}).length)
+        return refuse('pipe_offset_attachments', 'Remove custom hanger adjustments or hosted children before splitting this run.');
+    const start = new Vector3(...pipe.path[0]), end = new Vector3(...pipe.path[1]);
+    const delta = end.clone().sub(start);
+    const length = Math.hypot(delta.x, delta.z);
+    if (length < 0.001 || Math.abs(input.offset) < 0.001)
+        return refuse('pipe_offset_route', 'Choose a non-vertical run and a non-zero vertical offset.');
+    const axis = delta.clone().divideScalar(length);
+    const at = (distance) => start.clone().addScaledVector(axis, distance);
+    const travel = Math.abs(input.offset);
+    const a = at(input.from), b = at(input.from + travel).add(new Vector3(0, input.offset, 0));
+    const d = at(input.to), c = at(input.to - travel).add(new Vector3(0, input.offset, 0));
+    const corners = [start, a, b, c, d, end];
+    if (input.from <= 0 || input.to >= length || input.to - input.from <= 2 * travel)
+        return refuse('pipe_offset_space', 'Place the bends inside the run and allow more than twice the offset height between the first and last bend.');
+    const directions = corners.slice(1).map((point, i) => point.clone().sub(corners[i]).normalize());
+    const elbows = [a, b, c, d].map((corner, i) => {
+        const plan = planPipeElbowAtPort({
+            id: 'end',
+            nodeId: pipe.id,
+            position: corner.toArray(),
+            direction: directions[i].toArray(),
+            diameter: pipe.diameter,
+            system: pipe.system,
+        }, directions[i + 1].toArray(), pipe.diameter, pipe.pipeMaterial);
+        if (!plan)
+            return refuse('pipe_offset_angle', 'The requested bends cannot be formed on this route.');
+        return plan;
+    });
+    const paths = [
+        [start.toArray(), elbows[0].trimmedPortPoint],
+        [elbows[0].collarPoint, elbows[1].trimmedPortPoint],
+        [elbows[1].collarPoint, elbows[2].trimmedPortPoint],
+        [elbows[2].collarPoint, elbows[3].trimmedPortPoint],
+        [elbows[3].collarPoint, end.toArray()],
+    ];
+    for (const [i, path] of paths.entries()) {
+        const segment = new Vector3(...path[1]).sub(new Vector3(...path[0]));
+        if (!segment.toArray().every(Number.isFinite) ||
+            segment.length() < 0.001 ||
+            segment.normalize().dot(directions[i]) < 0.999999)
+            return refuse('pipe_offset_space', 'Not enough straight pipe between the bends. Increase the offset height or spacing, or move the bends away from the endpoints.');
+    }
+    if ([0, 2, 4].some((i) => !pipeGradesMatch(pipe.path, paths[i])))
+        return refuse('pipe_offset_grade', 'This offset cannot preserve the existing grade.');
+    const { id: _id, ...defaults } = pipe;
+    const newRuns = paths.slice(1).map((path) => PipeSegmentNode.parse({
+        ...defaults,
+        metadata: {},
+        path,
+        wallAttachment: undefined,
+        hangerOverrides: undefined,
+    }));
+    const changes = {
+        update: [
+            {
+                id: pipe.id,
+                data: { path: paths[0], wallAttachment: undefined, hangerOverrides: undefined },
+            },
+        ],
+        create: [
+            ...newRuns,
+            ...elbows.map((elbow) => ({ ...elbow.fitting, parentId: pipe.parentId })),
+        ].map((node) => ({ node, parentId: pipe.parentId ?? undefined })),
+    };
+    changes.update.push(...transferRunEndCapOwnership(nodes, pipe.id, newRuns.at(-1).id, 'end'));
+    for (const entry of autoOffsetInvalidationUpdates(nodes, pipe.id)) {
+        const existing = changes.update.find((update) => update.id === entry.id);
+        if (existing)
+            existing.data = { ...existing.data, ...entry.data };
+        else
+            changes.update.push(entry);
+    }
+    const grade = pipeGrade(pipe.path[0], pipe.path[1]);
+    const uphill = grade === 0 || paths.some((path) => (path[1][1] - path[0][1]) * Math.sign(grade) > 1e-6);
+    return {
+        changes,
+        result: {
+            message: 'Four-bend offset; boundary connections and parallel-run grades preserved.',
+            paths,
+            uphill: pipe.system === 'waste' && uphill,
+            offset: input.offset,
+            fittings: 4,
+            runs: 5,
+        },
+    };
+};

package/dist/pipe-segment/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAqFxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA6ExE,CAAA"}

package/dist/pipe-segment/parametrics.js

@@ -13,7 +13,7 @@ export const pipeSegmentParametrics = {
         ...findAutomaticRunEndCapIds(pipe.id, nodes, 'pipe-fitting'),
         ...fittingDeletionPlansForRun(pipe, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
     ],
-    trailingSection: () => import('../shared/run-hanger-inspector.js'),
+    trailingSection: () => import('./grade-inspector.js'),
     groups: [
         {
             label: 'Hangers',
@@ -58,14 +58,6 @@ export const pipeSegmentParametrics = {
                     options: ['waste', 'vent'],
                     display: 'segmented',
                 },
-                {
-                    key: 'diameter',
-                    kind: 'number',
-                    unit: 'in',
-                    min: 1.25,
-                    max: 6,
-                    step: 0.25,
-                },
             ],
         },
         {

package/dist/pipe-segment/resize-inspector.d.ts

@@ -0,0 +1,5 @@
+import { type PipeSegmentNode } from '@pascal-app/core';
+export default function PipeResizeInspector({ node }: {
+    node: PipeSegmentNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=resize-inspector.d.ts.map

package/dist/pipe-segment/resize-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-inspector.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/resize-inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAIzB,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,+BA+H9E"}

package/dist/pipe-segment/resize-inspector.js

@@ -0,0 +1,75 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatNumber, usePascalI18n, useScene, } from '@pascal-app/core';
+import { useState } from 'react';
+import { resizePipe } from './resize-operation.js';
+export default function PipeResizeInspector({ node }) {
+    const i18n = usePascalI18n();
+    const [diameter, setDiameter] = useState(node.diameter);
+    const [scope, setScope] = useState('segment');
+    const [message, setMessage] = useState('');
+    const apply = (preview) => {
+        try {
+            const outcome = resizePipe(useScene.getState().nodes, { nodeId: node.id, diameter, scope }, { activeLevelId: node.parentId });
+            if (preview || !outcome.changes) {
+                setMessage(outcome.changes
+                    ? i18n._({
+                        id: 'node.pipeSegment.resizeInspector.resizeSummary',
+                        message: '{runs, plural, one {# run} other {# runs}}, {fittings, plural, one {# fitting} other {# fittings}}, {reducers, plural, one {# new reducer} other {# new reducers}}. Grades stay unchanged.',
+                        values: {
+                            runs: Number(outcome.result.runs),
+                            fittings: Number(outcome.result.fittings),
+                            reducers: Number(outcome.result.reducers),
+                        },
+                    })
+                    : String(outcome.result.message));
+                return;
+            }
+            useScene.getState().applyNodeChanges({
+                create: outcome.changes.create?.map((entry) => ({
+                    ...entry,
+                    parentId: entry.parentId,
+                })),
+                update: outcome.changes.update?.map((entry) => ({ ...entry, id: entry.id })),
+            });
+            setMessage(i18n._({
+                id: 'node.pipeSegment.resizeInspector.resized',
+                message: 'Resized in one undo step. Grades and boundary connections preserved.',
+            }));
+        }
+        catch (error) {
+            setMessage(error instanceof Error
+                ? error.message
+                : i18n._({
+                    id: 'node.pipeSegment.resizeInspector.unableToResize',
+                    message: 'Unable to resize pipe.',
+                }));
+        }
+    };
+    return (_jsxs("section", { className: "space-y-2 border-t pt-3 text-xs", children: [_jsx("h3", { className: "text-sm font-medium", children: i18n._({ id: 'node.pipeSegment.resizeInspector.pipeSize', message: 'Pipe size' }) }), _jsx("p", { children: i18n._({
+                    id: 'node.pipeSegment.resizeInspector.currentDiameter',
+                    message: 'Current diameter: {diameter} in',
+                    values: { diameter: formatNumber(node.diameter, { locale: i18n.getLocale() }) },
+                }) }), _jsxs("label", { className: "flex justify-between", children: [i18n._({ id: 'node.pipeSegment.resizeInspector.diameterIn', message: 'Diameter (in)' }), _jsx("input", { "aria-label": i18n._({
+                            id: 'node.pipeSegment.resizeInspector.pipeResizeDiameter',
+                            message: 'Pipe resize diameter',
+                        }), type: "number", min: 1.25, max: 8, step: 0.25, value: Number.isFinite(diameter) ? diameter : '', onChange: (event) => {
+                            setDiameter(event.target.valueAsNumber);
+                            setMessage('');
+                        }, className: "w-24 border bg-background p-1" })] }), _jsxs("select", { "aria-label": i18n._({
+                    id: 'node.pipeSegment.resizeInspector.pipeResizeScope',
+                    message: 'Pipe resize scope',
+                }), value: scope, onChange: (event) => {
+                    setScope(event.target.value);
+                    setMessage('');
+                }, className: "w-full border bg-background p-1", children: [_jsx("option", { value: "segment", children: i18n._({ id: 'node.pipeSegment.resizeInspector.thisSegment', message: 'This segment' }) }), _jsx("option", { value: "branch", children: i18n._({
+                            id: 'node.pipeSegment.resizeInspector.connectedBranch',
+                            message: 'Connected branch',
+                        }) })] }), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                    id: 'node.pipeSegment.resizeInspector.branchesStopAtJunctionsSizeOr',
+                    message: 'Branches stop at junctions, size or material changes, and fixture connections. Reducers keep boundary collars fixed.',
+                }) }), _jsxs("div", { className: "flex gap-2", children: [_jsx("button", { type: "button", className: "flex-1 rounded border p-1", onClick: () => apply(true), children: i18n._({ id: 'node.pipeSegment.resizeInspector.checkResize', message: 'Check resize' }) }), _jsx("button", { type: "button", className: "flex-1 rounded border p-1", onClick: () => apply(false), children: i18n._({
+                            id: 'node.pipeSegment.resizeInspector.applyPipeSize',
+                            message: 'Apply pipe size',
+                        }) })] }), message && _jsx("p", { role: "status", children: message })] }));
+}

package/dist/pipe-segment/resize-operation.d.ts

@@ -0,0 +1,8 @@
+import type { AgentOperation } from '@pascal-app/core/agent-operations';
+export type PipeResizeInput = {
+    nodeId: string;
+    diameter: number;
+    scope?: 'segment' | 'branch';
+};
+export declare const resizePipe: AgentOperation<PipeResizeInput>;
+//# sourceMappingURL=resize-operation.d.ts.map

package/dist/pipe-segment/resize-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-operation.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/resize-operation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,mCAAmC,CAAA;AASrF,MAAM,MAAM,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAE,CAAA;AAQhG,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAsJtD,CAAA"}

package/dist/pipe-segment/resize-operation.js

@@ -0,0 +1,143 @@
+import { nodeRegistry, PipeFittingNode, PipeSegmentNode } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { queryNodes } from '@pascal-app/core/runtime';
+import { Euler, Quaternion, Vector3 } from 'three';
+import { pipeFittingLegLength } from '../pipe-fitting/ports.js';
+import { pipeGradesMatch } from './slope.js';
+const portsOf = (node) => nodeRegistry
+    .get(node.type)
+    ?.ports?.(node)
+    .map((port) => ({ ...port, nodeId: node.id })) ?? [];
+const vector = (point) => new Vector3(...point);
+export const resizePipe = (nodes, input) => {
+    const root = nodes[input.nodeId];
+    if (root?.type !== 'pipe-segment')
+        return refuse('pipe_not_found', 'Select a pipe run.');
+    if (!nodeRegistry.get('pipe-segment')?.ports || !nodeRegistry.get('pipe-fitting')?.ports)
+        return refuse('node_capability_unavailable', 'Register pipe and fitting definitions before resizing.');
+    if (!PipeSegmentNode.safeParse({ ...root, diameter: input.diameter }).success)
+        return refuse('pipe_size_invalid', 'Enter a pipe diameter between 1.25 and 8 inches.');
+    const ports = queryNodes(nodes, { parentId: root.parentId }).flatMap(portsOf);
+    const mates = (port) => ports.filter((other) => other.nodeId !== port.nodeId &&
+        other.system === port.system &&
+        vector(other.position).distanceTo(vector(port.position)) < 0.005);
+    const mateOf = (port) => {
+        const found = mates(port);
+        if (found.length > 1)
+            return refuse('pipe_ambiguous_connection', 'Resolve overlapping connections before resizing.');
+        const mate = found[0];
+        if (mate && vector(mate.direction).dot(vector(port.direction)) > -0.999999)
+            return refuse('pipe_connection_angle', 'Align the connected collars before resizing.');
+        return mate;
+    };
+    const selected = new Set([root.id]);
+    const queue = [root];
+    for (const node of queue) {
+        for (const port of portsOf(node)) {
+            const mate = mateOf(port);
+            if (!mate || selected.has(mate.nodeId))
+                continue;
+            const owner = nodes[mate.nodeId];
+            const cap = owner.type === 'pipe-fitting' && owner.fittingType === 'end-cap';
+            const sameSize = 'diameter' in owner && owner.diameter === root.diameter;
+            const sameMaterial = 'pipeMaterial' in owner && owner.pipeMaterial === root.pipeMaterial;
+            const throughFitting = owner.type === 'pipe-fitting' &&
+                ['elbow', 'coupling', 'cleanout'].includes(owner.fittingType) &&
+                portsOf(owner).every((collar) => mates(collar).every((neighbor) => {
+                    const run = nodes[neighbor.nodeId];
+                    return (run?.type === 'pipe-segment' &&
+                        run.diameter === root.diameter &&
+                        run.pipeMaterial === root.pipeMaterial);
+                }));
+            if (sameSize &&
+                (cap ||
+                    (input.scope === 'branch' &&
+                        sameMaterial &&
+                        (owner.type === 'pipe-segment' || throughFitting)))) {
+                selected.add(owner.id);
+                queue.push(owner);
+            }
+        }
+    }
+    if (input.diameter === root.diameter)
+        return { result: { message: 'The branch already has this diameter.' } };
+    const changed = new Map();
+    for (const node of queue) {
+        if (node.type === 'pipe-segment')
+            changed.set(node.id, {
+                ...node,
+                diameter: input.diameter,
+                path: node.path.map((p) => [...p]),
+                wallAttachment: undefined,
+            });
+        else if (node.type === 'pipe-fitting') {
+            const next = PipeFittingNode.parse({
+                ...node,
+                diameter: input.diameter,
+                diameter2: input.diameter,
+            });
+            if (portsOf(node).length === 1) {
+                // Keep a cap's inlet fixed while its body grows away from the run.
+                const delta = vector(portsOf(node)[0].position).sub(vector(portsOf(next)[0].position));
+                next.position = vector(next.position).add(delta).toArray();
+            }
+            changed.set(node.id, next);
+        }
+    }
+    const create = [];
+    for (const node of queue) {
+        if (node.type !== 'pipe-segment')
+            continue;
+        const next = changed.get(node.id);
+        for (const port of portsOf(node)) {
+            const mate = mateOf(port);
+            if (!mate)
+                continue;
+            const index = port.id === 'start' ? 0 : next.path.length - 1;
+            if (selected.has(mate.nodeId)) {
+                const updatedMate = portsOf(changed.get(mate.nodeId)).find((p) => p.id === mate.id);
+                // Adjacent runs keep their shared point; only fitting collars move.
+                if (nodes[mate.nodeId]?.type === 'pipe-fitting' &&
+                    portsOf(changed.get(mate.nodeId)).length > 1)
+                    next.path[index] = [...updatedMate.position];
+                continue;
+            }
+            if (mate.diameter === input.diameter)
+                continue;
+            const axis = vector(mate.direction).normalize();
+            const leg = pipeFittingLegLength(Math.max(mate.diameter, input.diameter));
+            const rotation = new Euler().setFromQuaternion(new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), axis));
+            const fitting = PipeFittingNode.parse({
+                parentId: root.parentId,
+                fittingType: 'reducer',
+                system: root.system,
+                pipeMaterial: root.pipeMaterial,
+                diameter: mate.diameter,
+                diameter2: input.diameter,
+                position: vector(mate.position).addScaledVector(axis, leg).toArray(),
+                rotation: [rotation.x, rotation.y, rotation.z],
+            });
+            create.push({ node: fitting, parentId: root.parentId });
+            next.path[index] = [...portsOf(fitting).find((p) => p.id === 'outlet').position];
+        }
+        for (let i = 1; i < next.path.length; i++) {
+            const before = vector(node.path[i])
+                .sub(vector(node.path[i - 1]))
+                .normalize();
+            const after = vector(next.path[i]).sub(vector(next.path[i - 1]));
+            if (after.length() < 0.001 || before.dot(after.clone().normalize()) < 0.999999)
+                return refuse('pipe_resize_space', 'Not enough straight pipe for the new fittings. Extend the route first.');
+        }
+        if (!pipeGradesMatch(node.path, next.path))
+            return refuse('pipe_resize_grade', 'This resize would change the pipe grade. Adjust the fitting layout first.');
+    }
+    return {
+        result: {
+            message: 'Pipe sizes updated; grades and boundary connections preserved.',
+            runs: queue.filter((n) => n.type === 'pipe-segment').length,
+            fittings: queue.filter((n) => n.type === 'pipe-fitting').length,
+            reducers: create.length,
+        },
+        changes: { create, update: [...changed].map(([id, node]) => ({ id, data: node })) },
+    };
+};

package/dist/pipe-segment/run-move.d.ts

@@ -0,0 +1,65 @@
+import { type AnyNode, type AnyNodeId, PipeSegmentNode, type PortConnectivity } from '@pascal-app/core';
+import type { ScenePort } from '@pascal-app/editor/distribution';
+import type { PipeFittingNode } from '../pipe-fitting/schema.js';
+type Update = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+export type PipeRunMoveKind = {
+    axis: 'y';
+} | {
+    axis: 'horizontal';
+    dir: [number, number];
+};
+export type PipeRunMoveGhost = {
+    tint: 'valid' | 'invalid';
+    fittings: PipeFittingNode[];
+    risers: PipeSegmentNode[];
+};
+export type PipeRunMoveChange = {
+    create: AnyNode[];
+    delete: AnyNodeId[];
+    update: Update[];
+};
+/**
+ * One frame of a selected run's arrow move. A `valid` frame previews exactly the
+ * change it commits; `invalid` is a vertical offset that cannot be formed (red
+ * ghost, nothing to commit); `blocked` would regrade a connected run or pull a
+ * joint apart.
+ */
+export type PipeRunMoveFrame = {
+    status: 'valid';
+    preview: Update[];
+    hidden: AnyNodeId[];
+    ghost: PipeRunMoveGhost | null;
+    change: PipeRunMoveChange;
+} | {
+    status: 'invalid';
+    ghost: PipeRunMoveGhost;
+} | {
+    status: 'blocked';
+};
+type RunMoveArgs = {
+    pipe: PipeSegmentNode;
+    kind: PipeRunMoveKind;
+    /** Drag-start connectivity snapshot. */
+    connectivity: PortConnectivity | null;
+    /** Scene ports excluding the moved run. */
+    scenePorts: ScenePort[];
+    /** Drag-start node snapshots keyed by id. */
+    nodesById: Record<string, AnyNode>;
+};
+export declare function planPipeRunMoveFrame(args: RunMoveArgs & {
+    delta: number;
+}): PipeRunMoveFrame;
+/**
+ * Tracks one arrow move so release commits the frame on screen: a blocked frame
+ * keeps the last shown frame, as the endpoint handles do.
+ */
+export declare function startPipeRunMove(args: RunMoveArgs): {
+    update(delta: number): PipeRunMoveFrame;
+    /** The change to commit on release, or null when nothing valid is shown. */
+    release(): PipeRunMoveChange | null;
+};
+export {};
+//# sourceMappingURL=run-move.d.ts.map

package/dist/pipe-segment/run-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-move.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/run-move.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,gBAAgB,EAEtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAM7D,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAEvD,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AAE3F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,MAAM,EAAE,eAAe,EAAE,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAAC,MAAM,EAAE,SAAS,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAE5F;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IACE,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAC9B,MAAM,EAAE,iBAAiB,CAAA;CAC1B,GACD;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAEzB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,eAAe,CAAA;IACrB,wCAAwC;IACxC,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACrC,2CAA2C;IAC3C,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,CAAA;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,gBAAgB,CAwF5F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW;IAM9C,MAAM,QAAQ,MAAM,GAAG,gBAAgB;IAKvC,4EAA4E;IAC5E,OAAO,IAAI,iBAAiB,GAAG,IAAI;EAMtC"}

package/dist/pipe-segment/run-move.js

@@ -0,0 +1,110 @@
+import { PipeSegmentNode, resolveConnectivityUpdates, } from '@pascal-app/core';
+import { planPipeRunTranslationOffsets } from '../shared/pipe-run-translation-offset.js';
+import { planVerticalOffsets } from '../shared/pipe-vertical-offset.js';
+import { pipeUpdatesPreserveGrades } from './grade-operation.js';
+export function planPipeRunMoveFrame(args) {
+    const { pipe, kind, delta, connectivity, scenePorts, nodesById } = args;
+    const profile = { diameter: pipe.diameter, pipeMaterial: pipe.pipeMaterial };
+    const connections = connectivity?.connections ?? [];
+    const exists = (update) => !!nodesById[update.id];
+    const follow = (path) => connectivity
+        ? (resolveConnectivityUpdates(connectivity, { ...pipe, path })?.filter(exists) ??
+            null)
+        : [];
+    const path = pipe.path.map((p) => kind.axis === 'y'
+        ? [p[0], p[1] + delta, p[2]]
+        : [p[0] + delta * kind.dir[0], p[1], p[2] + delta * kind.dir[1]]);
+    const guarded = (frame) => pipeUpdatesPreserveGrades(nodesById, frame.change.update) ? frame : { status: 'blocked' };
+    if (kind.axis === 'y' && delta !== 0) {
+        const offsets = planVerticalOffsets({
+            pipe,
+            dy: delta,
+            profile,
+            connections,
+            scenePorts,
+            nodesById,
+        });
+        if (offsets?.status === 'invalid') {
+            const lifted = PipeSegmentNode.parse({ ...pipe, path });
+            return { status: 'invalid', ghost: { tint: 'invalid', fittings: [], risers: [lifted] } };
+        }
+        if (offsets?.status === 'valid') {
+            const { plan } = offsets;
+            const followers = follow(plan.followPath);
+            if (!followers)
+                return { status: 'blocked' };
+            const update = [
+                { id: pipe.id, data: { path: plan.pipePath } },
+                ...plan.updates.filter(exists),
+                ...followers,
+            ];
+            const hidden = (plan.delete ?? []).filter((id) => nodesById[id]);
+            return guarded({
+                status: 'valid',
+                preview: update,
+                hidden,
+                ghost: { tint: 'valid', fittings: plan.fittings, risers: plan.risers },
+                change: { create: [...plan.fittings, ...plan.risers], delete: hidden, update },
+            });
+        }
+    }
+    if (kind.axis === 'horizontal' && connectivity) {
+        const translation = planPipeRunTranslationOffsets({
+            pipe,
+            translatedPath: path,
+            profile,
+            connections,
+            scenePorts,
+            nodesById,
+        });
+        if (translation) {
+            const update = [
+                { id: pipe.id, data: { path: translation.pipePath } },
+                ...translation.updates,
+            ];
+            return guarded({
+                status: 'valid',
+                preview: update,
+                hidden: [],
+                ghost: { tint: 'valid', fittings: translation.fittings, risers: translation.connectors },
+                change: {
+                    create: [...translation.fittings, ...translation.connectors],
+                    delete: [],
+                    update,
+                },
+            });
+        }
+    }
+    const followers = follow(path);
+    if (!followers)
+        return { status: 'blocked' };
+    const update = [{ id: pipe.id, data: { path } }, ...followers];
+    return guarded({
+        status: 'valid',
+        preview: update,
+        hidden: [],
+        ghost: null,
+        change: { create: [], delete: [], update },
+    });
+}
+/**
+ * Tracks one arrow move so release commits the frame on screen: a blocked frame
+ * keeps the last shown frame, as the endpoint handles do.
+ */
+export function startPipeRunMove(args) {
+    let shown = null;
+    return {
+        update(delta) {
+            const frame = planPipeRunMoveFrame({ ...args, delta });
+            if (frame.status !== 'blocked')
+                shown = { delta, frame };
+            return frame;
+        },
+        /** The change to commit on release, or null when nothing valid is shown. */
+        release() {
+            return shown && shown.delta !== 0 && shown.frame.status === 'valid'
+                ? shown.frame.change
+                : null;
+        },
+    };
+}

package/dist/pipe-segment/selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/selection.tsx"],"names":[],"mappings":"AAiFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,QAAA,MAAM,8BAA8B,0CA+BnC,CAAA;eAs7Bc,8BAA8B"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/selection.tsx"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,QAAA,MAAM,8BAA8B,0CA+BnC,CAAA;eAu4Bc,8BAA8B"}