@pascal-app/nodes 0.1.1

package/dist/shared/pipe-run-translation-offset.js

@@ -0,0 +1,131 @@
+import { PipeSegmentNode, } from '@pascal-app/core';
+import { pipeFittingLegLength } from '../pipe-fitting/ports';
+import { planPipeElbowAtPort, planPipeElbowRealign } from './auto-fitting';
+const COINCIDENT_EPS_M = 0.05;
+const MIN_CONNECTOR_M = 0.05;
+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;
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function neg(v) {
+    return [-v[0], -v[1], -v[2]];
+}
+function unit(v) {
+    const len = Math.hypot(v[0], v[1], v[2]);
+    if (len < 1e-9)
+        return null;
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+function endpointOutwardDir(path, idx) {
+    const last = path.length - 1;
+    const [a, b] = idx === 0 ? [path[0], path[1]] : [path[last], path[last - 1]];
+    return unit([a[0] - b[0], a[1] - b[1], a[2] - b[2]]) ?? [1, 0, 0];
+}
+function portLike(position, direction, system) {
+    return {
+        id: 'x',
+        nodeId: 'x',
+        position,
+        direction,
+        diameter: 0,
+        system,
+    };
+}
+function connectorRun(from, to, pipe) {
+    return PipeSegmentNode.parse({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        name: pipe.name ?? 'Pipe run',
+        path: [from, to],
+        diameter: pipe.diameter,
+        pipeMaterial: pipe.pipeMaterial,
+        system: pipe.system,
+    });
+}
+function pipeElbowProfilePatch(profile) {
+    return {
+        diameter: profile.diameter,
+        diameter2: profile.diameter,
+        pipeMaterial: profile.pipeMaterial,
+    };
+}
+export function planPipeRunTranslationOffsets(args) {
+    const { pipe, translatedPath, profile, connections, scenePorts, nodesById } = args;
+    if (pipe.path.length < 2 || translatedPath.length !== pipe.path.length)
+        return null;
+    if (connections.length === 0)
+        return null;
+    const leg = pipeFittingLegLength(profile.diameter);
+    const minOffset = 2 * leg + MIN_CONNECTOR_M;
+    const eps2 = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    const pipePath = translatedPath.map((p) => [...p]);
+    const fittings = [];
+    const connectors = [];
+    const updates = [];
+    let routedAny = false;
+    for (const endIdx of pipe.path.length > 1 ? [0, pipe.path.length - 1] : [0]) {
+        const startEnd = pipe.path[endIdx];
+        const movedEnd = translatedPath[endIdx];
+        const delta = sub(movedEnd, startEnd);
+        const offsetDir = unit(delta);
+        if (!offsetDir || Math.hypot(delta[0], delta[1], delta[2]) < minOffset)
+            continue;
+        const partnerPort = scenePorts.find((sp) => distSq(sp.position, startEnd) <= eps2 &&
+            connections.some((conn) => conn.nodeId === sp.nodeId));
+        if (!partnerPort)
+            continue;
+        const conn = connections.find((c) => c.nodeId === partnerPort.nodeId);
+        if (!conn)
+            continue;
+        const pipePortDir = endpointOutwardDir(translatedPath, endIdx);
+        const top = planPipeElbowAtPort(portLike(movedEnd, pipePortDir, pipe.system), neg(offsetDir), profile.diameter, profile.pipeMaterial);
+        if (!top)
+            return null;
+        if (conn.kind === 'run') {
+            const bottom = planPipeElbowAtPort(portLike([startEnd[0], startEnd[1], startEnd[2]], [partnerPort.direction[0], partnerPort.direction[1], partnerPort.direction[2]], pipe.system), offsetDir, profile.diameter, profile.pipeMaterial);
+            if (!bottom)
+                return null;
+            fittings.push(bottom.fitting, top.fitting);
+            connectors.push(connectorRun(bottom.collarPoint, top.collarPoint, pipe));
+            pipePath[endIdx] = top.trimmedPortPoint;
+            const path = conn.startPath.map((p) => [...p]);
+            const tip = path.findIndex((p) => distSq(p, startEnd) <= eps2);
+            if (tip !== -1) {
+                path[tip] = bottom.trimmedPortPoint;
+                updates.push({ id: conn.nodeId, data: { path } });
+            }
+            routedAny = true;
+            continue;
+        }
+        const partner = nodesById[conn.nodeId];
+        if (partner?.type !== 'pipe-fitting')
+            return null;
+        const elbow = {
+            ...partner,
+            ...pipeElbowProfilePatch(profile),
+        };
+        if (elbow.fittingType !== 'elbow')
+            return null;
+        const realign = planPipeElbowRealign(elbow, partnerPort.id, offsetDir);
+        if (!realign)
+            return null;
+        fittings.push(top.fitting);
+        connectors.push(connectorRun(realign.collarPoint, top.collarPoint, pipe));
+        pipePath[endIdx] = top.trimmedPortPoint;
+        updates.push({
+            id: elbow.id,
+            data: { ...pipeElbowProfilePatch(profile), ...realign.update.data },
+        });
+        routedAny = true;
+    }
+    if (!routedAny)
+        return null;
+    return { pipePath, fittings, connectors, updates };
+}

package/dist/shared/pipe-vertical-offset.d.ts

@@ -0,0 +1,98 @@
+import { type AnyNode, type AnyNodeId, PipeSegmentNode, type PortConnection } from '@pascal-app/core';
+import type { PipeFittingNode } from '../pipe-fitting/schema';
+import type { ScenePort } from './ports';
+/**
+ * Center-cube vertical-move auto-routing for pipe runs.
+ *
+ * When a run is lifted / lowered with the run-center cube's ±Y arrows, a
+ * RUN-connected end should stay welded to its (stationary) partner by way of
+ * an offset: an elbow on the lifted run, a plumb riser down to the partner's
+ * height, and a second elbow that meets the partner — the classic pipe S/Z
+ * offset. Without it, plain connectivity-follow would translate the collinear
+ * partner run straight up too (it has no turn to absorb the lift), dragging
+ * the whole network along.
+ *
+ * RUN-connected end (partner stays at its old height):
+ *   - top elbow at the lifted endpoint, turning the run axis → vertical;
+ *   - a plumb riser straight down (same X/Z) to one leg above the partner;
+ *   - bottom elbow at the partner joint, turning vertical → the partner's
+ *     axis; the partner run is trimmed back one leg so the elbow replaces
+ *     that stretch.
+ * The lifted run is trimmed back one leg at the offset end so it meets the
+ * top elbow's collar instead of overlapping it.
+ *
+ * ELBOW-connected end (a clean L): the existing elbow STAYS PUT and re-aims so
+ * its mated collar swings vertical (flattening toward a straight coupling); a
+ * plumb riser rises from that collar to a single new TOP elbow that turns back
+ * along the run axis onto the lifted endpoint. One new elbow + one riser — no
+ * horizontal jog. Non-elbow fittings (and elbows whose re-aim is out of the
+ * buildable 15–90° range) ride up via plain connectivity-follow instead. Open
+ * ends likewise just ride up.
+ */
+type Point = [number, number, number];
+type PipeProfile = {
+    diameter: number;
+    pipeMaterial: PipeFittingNode['pipeMaterial'];
+};
+/**
+ * Three-state outcome of a connected vertical lift:
+ *  - `null` — the run has NO connected ends, so the caller plain-translates it
+ *    (nothing to keep welded; everyone is free to ride along or there's no one).
+ *  - `{ status: 'invalid' }` — at least one connected end CANNOT form a clean
+ *    offset at this height (no room for the elbows + riser, a non-elbow fitting,
+ *    or a re-aim out of the buildable 15–90° range). The caller lifts ONLY the
+ *    dragged run as a red preview, freezes every partner, and commits nothing on
+ *    release. We never silently drag the network up to "absorb" the lift.
+ *  - `{ status: 'valid', plan }` — every connected end welds back to its
+ *    stationary partner via the planned offset; the caller lifts + trims, ghosts
+ *    the new fittings green, and mints them on release.
+ */
+export type VerticalOffsetResult = {
+    status: 'valid';
+    plan: VerticalOffsetPlan;
+} | {
+    status: 'invalid';
+} | null;
+export type VerticalOffsetPlan = {
+    /** Actual vertical offset used by the route. This can differ from the raw
+     *  cursor delta when the route snaps through a topology transition. */
+    dy: number;
+    /** The lifted run's new path: every point raised by `dy`, each RUN-offset
+     *  end trimmed back one elbow-leg to meet its top elbow (fitting / open ends
+     *  keep their lifted endpoint). */
+    pipePath: Point[];
+    /** The path to seed the caller's connectivity-follow from: identical to the
+     *  lifted run except each RUN-offset end is reset to its ORIGINAL height, so
+     *  its trimmed partner shows zero delta (we trim it via `updates` instead)
+     *  while a FITTING / open end shows `+dy` — lifting its elbow rigidly and
+     *  lengthening that elbow's riser into a clean L. */
+    followPath: Point[];
+    /** Two elbows per RUN-offset end (top + bottom). */
+    fittings: PipeFittingNode[];
+    /** One plumb riser per RUN-offset end. */
+    risers: PipeSegmentNode[];
+    /** Partner-run trims (the run mated at each RUN-offset end pulled back one
+     *  leg). Fitting partners are rigid and never updated. */
+    updates: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+    /** Existing generated/absorbed parts to remove when an offset collapses into a direct L. */
+    delete?: AnyNodeId[];
+};
+export declare function planVerticalOffsets(args: {
+    pipe: PipeSegmentNode;
+    /** Signed vertical move (meters); +up / -down. */
+    dy: number;
+    profile: PipeProfile;
+    /** The drag-start connectivity snapshot's connections. */
+    connections: PortConnection[];
+    /** Scene ports (excluding the lifted run) for partner direction lookup. */
+    scenePorts: ScenePort[];
+    /** Drag-start node snapshots keyed by id, so a connected elbow's ORIGINAL
+     *  pose can be re-aimed each frame (the live store carries the last frame's
+     *  re-aim). */
+    nodesById: Record<string, AnyNode>;
+}): VerticalOffsetResult;
+export {};
+//# sourceMappingURL=pipe-vertical-offset.d.ts.map

package/dist/shared/pipe-vertical-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-vertical-offset.d.ts","sourceRoot":"","sources":["../../src/shared/pipe-vertical-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;CAC9C,CAAA;AASD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC7C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB,IAAI,CAAA;AAER,MAAM,MAAM,kBAAkB,GAAG;IAC/B;2EACuE;IACvE,EAAE,EAAE,MAAM,CAAA;IACV;;uCAEmC;IACnC,QAAQ,EAAE,KAAK,EAAE,CAAA;IACjB;;;;yDAIqD;IACrD,UAAU,EAAE,KAAK,EAAE,CAAA;IACnB,oDAAoD;IACpD,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,0CAA0C;IAC1C,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB;8DAC0D;IAC1D,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IACpD,4FAA4F;IAC5F,MAAM,CAAC,EAAE,SAAS,EAAE,CAAA;CACrB,CAAA;AAmnBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,IAAI,EAAE,eAAe,CAAA;IACrB,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,WAAW,CAAA;IACpB,0DAA0D;IAC1D,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,2EAA2E;IAC3E,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB;;mBAEe;IACf,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,GAAG,oBAAoB,CAMvB"}