@woosh/meep-engine 3.14.6 → 3.16.0

package/src/core/model/node-graph/visual/layout/route_nudge.js

@@ -0,0 +1,220 @@
+import { overlap1D } from "../../../../math/interval/overlap1D.js";
+
+/**
+ * Fraction of the clearance around a box that nudged wires are allowed to spread into.
+ *
+ * Nudging moves a wire off the line the router put it on, and the nearest thing to that line is
+ * usually a box. Spreading past this would push the outermost wire of a group into whatever the
+ * clearance was protecting it from.
+ *
+ * @type {number}
+ */
+const SPREAD_LIMIT = 0.7;
+
+/**
+ * Pull apart wires that ended up drawn on top of each other.
+ *
+ * The router does most of this itself — negotiating over the lines is exactly the business of not
+ * sharing them — but it cannot always finish. Two wires that genuinely have one route between them
+ * both take it, and what the drawing then shows is one wire where there are two. Congestion has no
+ * answer to that, because there is no second route to move to; the answer is to stop insisting they
+ * are on a line at all and spread them a few units either side of it.
+ *
+ * **Which one goes on which side** is not a free choice. Wires arriving at a shared run from above
+ * and leaving it above have to stay above, or the two of them cross twice for nothing — once to
+ * swap and once to swap back. So a group is ordered by where its members come from and where they
+ * go, and gets spread in that order.
+ *
+ * Only the middle of a wire moves. The two ends meet ports, and a port is where it is.
+ *
+ * @param {RouteSet} routes mutated in place
+ * @param {NodeGraphLayoutOptions} options
+ * @returns {number} how many runs were moved
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function route_nudge(routes, options) {
+    const segments = collect(routes);
+
+    const count = segments.count;
+
+    if (count === 0) {
+        return 0;
+    }
+
+    const separation = options.wire_gap / 2;
+    const limit = options.clearance * SPREAD_LIMIT;
+
+    const order = new Int32Array(count);
+
+    for (let i = 0; i < count; i++) {
+        order[i] = i;
+    }
+
+    // grouped by the line they sit on, then by where along it they start
+    order.sort((a, b) =>
+        (segments.axis[a] - segments.axis[b])
+        || (segments.fixed[a] - segments.fixed[b])
+        || (segments.low[a] - segments.low[b])
+    );
+
+    let moved = 0;
+
+    let start = 0;
+
+    while (start < count) {
+        let end = start + 1;
+
+        // one cluster: same line, and every member overlapping something already in it
+        let reach = segments.high[order[start]];
+
+        while (
+            end < count
+            && segments.axis[order[end]] === segments.axis[order[start]]
+            && segments.fixed[order[end]] === segments.fixed[order[start]]
+            && overlap1D(segments.low[order[start]], reach, segments.low[order[end]], segments.high[order[end]])
+        ) {
+            if (segments.high[order[end]] > reach) {
+                reach = segments.high[order[end]];
+            }
+
+            end++;
+        }
+
+        const size = end - start;
+
+        if (size > 1) {
+            spread(routes, segments, order, start, end, separation, limit);
+
+            moved += size;
+        }
+
+        start = end;
+    }
+
+    return moved;
+}
+
+/**
+ * Move one group of overlapping runs off their shared line, evenly either side of it.
+ *
+ * @param {RouteSet} routes
+ * @param {object} segments
+ * @param {Int32Array} order
+ * @param {number} start
+ * @param {number} end exclusive
+ * @param {number} separation
+ * @param {number} limit largest distance any of them may be moved
+ * @returns {void}
+ */
+function spread(routes, segments, order, start, end, separation, limit) {
+    const size = end - start;
+
+    const group = order.subarray(start, end);
+
+    // Where each wire comes into the run from and where it leaves it for, across the line rather
+    // than along it. A wire that was above stays above.
+    group.sort((a, b) =>
+        (segments.before[a] - segments.before[b])
+        || (segments.after[a] - segments.after[b])
+        || (segments.route[a] - segments.route[b])
+    );
+
+    const step = Math.min(separation, size > 1 ? limit * 2 / (size - 1) : separation);
+
+    for (let i = 0; i < size; i++) {
+        const segment = group[i];
+
+        const shift = (i - (size - 1) / 2) * step;
+
+        if (shift === 0) {
+            continue;
+        }
+
+        const at = segments.point[segment];
+
+        if (segments.axis[segment] === 0) {
+            routes.y[at] += shift;
+            routes.y[at + 1] += shift;
+        } else {
+            routes.x[at] += shift;
+            routes.x[at + 1] += shift;
+        }
+    }
+}
+
+/**
+ * Gather every straight run that is free to move.
+ *
+ * A run of a wire that is not along an axis cannot be nudged along one, and the first and last runs
+ * of a wire are pinned to its ports. Everything else is a candidate.
+ *
+ * @param {RouteSet} routes
+ * @returns {object}
+ */
+function collect(routes) {
+    let capacity = 0;
+
+    for (let i = 0; i < routes.count; i++) {
+        const length = routes.length_of(i);
+
+        if (length > 3) {
+            capacity += length - 3;
+        }
+    }
+
+    const segments = {
+        count: 0,
+        route: new Int32Array(capacity),
+        point: new Int32Array(capacity),
+        axis: new Uint8Array(capacity),
+        fixed: new Float64Array(capacity),
+        low: new Float64Array(capacity),
+        high: new Float64Array(capacity),
+        before: new Float64Array(capacity),
+        after: new Float64Array(capacity)
+    };
+
+    for (let i = 0; i < routes.count; i++) {
+        const start = routes.offset[i];
+        const end = routes.offset[i + 1];
+
+        for (let p = start + 1; p + 2 < end; p++) {
+            const ax = routes.x[p];
+            const ay = routes.y[p];
+            const bx = routes.x[p + 1];
+            const by = routes.y[p + 1];
+
+            const horizontal = ay === by;
+            const vertical = ax === bx;
+
+            if (horizontal === vertical) {
+                // a diagonal, or a run of no length: neither is something to line up with anything
+                continue;
+            }
+
+            const at = segments.count++;
+
+            segments.route[at] = i;
+            segments.point[at] = p;
+            segments.axis[at] = horizontal ? 0 : 1;
+
+            if (horizontal) {
+                segments.fixed[at] = ay;
+                segments.low[at] = Math.min(ax, bx);
+                segments.high[at] = Math.max(ax, bx);
+                segments.before[at] = routes.y[p - 1];
+                segments.after[at] = routes.y[p + 2];
+            } else {
+                segments.fixed[at] = ax;
+                segments.low[at] = Math.min(ay, by);
+                segments.high[at] = Math.max(ay, by);
+                segments.before[at] = routes.x[p - 1];
+                segments.after[at] = routes.x[p + 2];
+            }
+        }
+    }
+
+    return segments;
+}

package/src/core/model/node-graph/visual/layout/route_to_spline.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Turn a route into the curve that gets drawn.
+ *
+ * The router works in straight lines and right angles because that is what can be reasoned about —
+ * what is blocked, what is shared, what is shortest. None of that is what should be drawn. A node
+ * graph drawn in right angles reads as a circuit board, and the thing a reader is doing with it is
+ * following one wire with their eye, which a corner interrupts and a curve does not.
+ *
+ * So every corner becomes a curve, and the radius is **as large as the space allows**: the whole
+ * corner radius where there is room, and half the shorter of the two runs meeting there where there
+ * is not. A long run therefore stays a long straight line that turns at the end, and a short jog
+ * between two runs disappears into a single smooth S. What comes out is a wire that happens to be
+ * well organised, rather than a trace.
+ *
+ * Straight runs stay exactly straight. A knot's tangent points along the run leaving it, and a cubic
+ * whose end tangents are both parallel to the line between its ends *is* that line — the curve only
+ * travels along it at an uneven rate, which nothing can see.
+ *
+ * @param {RouteSet} routes
+ * @param {number} index which route
+ * @param {NodeGraphLayoutOptions} options
+ * @param {ConnectionVisualData} target written into
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function route_to_spline(routes: RouteSet, index: number, options: NodeGraphLayoutOptions, target: ConnectionVisualData): void;
+//# sourceMappingURL=route_to_spline.d.ts.map

package/src/core/model/node-graph/visual/layout/route_to_spline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route_to_spline.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/route_to_spline.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,yDARW,MAAM,kEAGJ,IAAI,CAsFhB"}

package/src/core/model/node-graph/visual/layout/route_to_spline.js

@@ -0,0 +1,120 @@
+/**
+ * Tangent length, as a multiple of the corner radius, that makes a cubic follow a quarter circle.
+ *
+ * A Bézier approximating a quarter circle puts its control points at `0.5523 r` along the tangents,
+ * and a Hermite tangent is three times the control point offset. The corner is then round rather
+ * than merely not-sharp, which is what stops a route reading as a staircase.
+ *
+ * @type {number}
+ */
+const ARC_TANGENT = 3 * 0.5523;
+
+/**
+ * Turn a route into the curve that gets drawn.
+ *
+ * The router works in straight lines and right angles because that is what can be reasoned about —
+ * what is blocked, what is shared, what is shortest. None of that is what should be drawn. A node
+ * graph drawn in right angles reads as a circuit board, and the thing a reader is doing with it is
+ * following one wire with their eye, which a corner interrupts and a curve does not.
+ *
+ * So every corner becomes a curve, and the radius is **as large as the space allows**: the whole
+ * corner radius where there is room, and half the shorter of the two runs meeting there where there
+ * is not. A long run therefore stays a long straight line that turns at the end, and a short jog
+ * between two runs disappears into a single smooth S. What comes out is a wire that happens to be
+ * well organised, rather than a trace.
+ *
+ * Straight runs stay exactly straight. A knot's tangent points along the run leaving it, and a cubic
+ * whose end tangents are both parallel to the line between its ends *is* that line — the curve only
+ * travels along it at an uneven rate, which nothing can see.
+ *
+ * @param {RouteSet} routes
+ * @param {number} index which route
+ * @param {NodeGraphLayoutOptions} options
+ * @param {ConnectionVisualData} target written into
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function route_to_spline(routes, index, options, target) {
+    const start = routes.offset[index];
+    const count = routes.offset[index + 1] - start;
+
+    if (count < 2) {
+        target.allocate(0);
+
+        return;
+    }
+
+    const x = routes.x;
+    const y = routes.y;
+
+    // two knots per corner it rounds, plus the two ends
+    target.allocate(2 + (count - 2) * 2);
+
+    let knot = 0;
+
+    // Where the previous knot was left, so the first and last knots can be given a tangent reaching
+    // exactly to their neighbour and the runs at either end come out straight.
+    let previous_x = x[start];
+    let previous_y = y[start];
+
+    // filled in once the knot after it is known
+    knot++;
+
+    for (let k = 1; k + 1 < count; k++) {
+        const px = x[start + k];
+        const py = y[start + k];
+
+        const in_x = px - x[start + k - 1];
+        const in_y = py - y[start + k - 1];
+
+        const out_x = x[start + k + 1] - px;
+        const out_y = y[start + k + 1] - py;
+
+        const in_length = Math.sqrt(in_x * in_x + in_y * in_y);
+        const out_length = Math.sqrt(out_x * out_x + out_y * out_y);
+
+        if (in_length === 0 || out_length === 0) {
+            continue;
+        }
+
+        const radius = Math.min(options.corner_radius, in_length / 2, out_length / 2);
+
+        const in_nx = in_x / in_length;
+        const in_ny = in_y / in_length;
+
+        const out_nx = out_x / out_length;
+        const out_ny = out_y / out_length;
+
+        const entry_x = px - in_nx * radius;
+        const entry_y = py - in_ny * radius;
+
+        const exit_x = px + out_nx * radius;
+        const exit_y = py + out_ny * radius;
+
+        if (knot === 1) {
+            // the first knot reaches the entry of the first corner, and the run between is straight
+            target.set_knot(0, previous_x, previous_y, entry_x - previous_x, entry_y - previous_y);
+        }
+
+        target.set_knot(knot++, entry_x, entry_y, in_nx * ARC_TANGENT * radius, in_ny * ARC_TANGENT * radius);
+        target.set_knot(knot++, exit_x, exit_y, out_nx * ARC_TANGENT * radius, out_ny * ARC_TANGENT * radius);
+
+        previous_x = exit_x;
+        previous_y = exit_y;
+    }
+
+    const end_x = x[start + count - 1];
+    const end_y = y[start + count - 1];
+
+    if (knot === 1) {
+        // no corner survived: a wire that goes straight from one port to the other
+        target.set_knot(0, previous_x, previous_y, end_x - previous_x, end_y - previous_y);
+    }
+
+    target.set_knot(knot++, end_x, end_y, end_x - previous_x, end_y - previous_y);
+
+    // corners that collapsed leave knots unwritten at the end
+    target.knot_count = knot;
+}

package/src/engine/EngineHarness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EngineHarness.d.ts","sourceRoot":"","sources":["../../../src/engine/EngineHarness.js"],"names":[],"mappings":"AA0EA;IAmBI;;;;OAIG;IACH,8CAHmB,mBAAmB,UAAQ,MAAM,WACxC,QAAQ,MAAM,CAAC,CAM1B;IAED;;;;;;;;;OASG;IACH,0BAHW,MAAM,GACJ,KAAK,CAYjB;IAED;;;;;;;;;OASG;IACH,6BAHW,MAAM,GACJ,aAAa,CAQzB;IAkED;;;;;;;;;;;;;OAaG;IACH;QAZyB,MAAM,EAApB,MAAM;QACyB,GAAG;QAClB,MAAM,GAAtB,OAAO;QACQ,QAAQ,GAAvB,MAAM;QACS,KAAK,GAApB,MAAM;QACS,GAAG,GAAlB,MAAM;QACU,QAAQ,GAAxB,OAAO;QACQ,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACJ,MAAM,CA+DlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QApB0B,MAAM,EAArB,MAAM;QACgC,KAAK,GAA3C;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACrB,SAAS;QACT,WAAW;QACF,KAAK,GAArB,MAAM;QACU,GAAG,GAAnB,MAAM;QACU,QAAQ,GAAxB,MAAM;QACwB,WAAW,GAAzC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAC,CAAC,EAAC,MAAM,CAAA;SAAC;QACJ,iBAAiB,GAAjC,MAAM;QACW,WAAW,GAA5B,OAAO;QACU,aAAa,GAA9B,OAAO;QACU,YAAY,GAA7B,OAAO;QACU,aAAa,GAA9B,OAAO;QACS,iBAAiB,GAAjC,MAAM;QACU,iBAAiB,GAAjC,MAAM;QACW,gBAAgB,GAAjC,OAAO;QACU,cAAc,GAA/B,OAAO;QACS,mBAAmB,GAAnC,MAAM;QACW,OAAO,GAAxB,OAAO;sBA0EjB;IAGD;;;;;;;;;;;;OAYG;IACH;QAXyB,MAAM,EAApB,MAAM;QACyB,GAAG;QACnB,mBAAmB,GAAlC,MAAM;QACU,UAAU,GAA1B,OAAO;QACO,GAAG,GAAjB,KAAK;QACU,YAAY,GAA3B,MAAM;QACU,YAAY,GAA5B,OAAO;QACO,OAAO,GAArB,KAAK;QACU,gBAAgB,GAA/B,MAAM;QACS,iBAAiB,GAAhC,MAAM;sBAqDhB;IAED;;;;;;;OAOG;IACH;QAN0B,YAAY,GAA3B,MAAM;QACQ,MAAM,EAApB,MAAM;QACS,WAAW,GAA1B,MAAM;QACyB,GAAG;QAChC,QAAQ,MAAM,CAAC,CA6C3B;IAGD;;;;;;;;;;OAUG;IACH,sFATW,MAAM,GAOJ,OAAO,CA0DnB;IA9eD;;;OAGG;IACH,YAFU,eAAQ,IAAI,CAEb;IAGL;;;OAGG;IACH,QAFU,MAAM,CAEiC;IA0DrD;;;;;OAKG;IACH;iCAJmB,mBAAmB,UAAQ,MAAM;8BACzC,OAAO;QACL,QAAQ,MAAM,CAAC,CA0D3B;CA4WJ;;IAID;;;OAGG;IACH,uCAMC;;mBA1jBkB,aAAa;oCACI,0BAA0B;sBAOxC,kCAAkC;8BAhB1B,mCAAmC;oBAD7C,yBAAyB;mBAK1B,iBAAiB;sBATd,wBAAwB;oBAW1B,8BAA8B"}
+{"version":3,"file":"EngineHarness.d.ts","sourceRoot":"","sources":["../../../src/engine/EngineHarness.js"],"names":[],"mappings":"AA2EA;IAmBI;;;;OAIG;IACH,8CAHmB,mBAAmB,UAAQ,MAAM,WACxC,QAAQ,MAAM,CAAC,CAM1B;IAED;;;;;;;;;OASG;IACH,0BAHW,MAAM,GACJ,KAAK,CAYjB;IAED;;;;;;;;;OASG;IACH,6BAHW,MAAM,GACJ,aAAa,CAQzB;IAkED;;;;;;;;;;;;;OAaG;IACH;QAZyB,MAAM,EAApB,MAAM;QACyB,GAAG;QAClB,MAAM,GAAtB,OAAO;QACQ,QAAQ,GAAvB,MAAM;QACS,KAAK,GAApB,MAAM;QACS,GAAG,GAAlB,MAAM;QACU,QAAQ,GAAxB,OAAO;QACQ,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACJ,MAAM,CA+DlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QApB0B,MAAM,EAArB,MAAM;QACgC,KAAK,GAA3C;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACrB,SAAS;QACT,WAAW;QACF,KAAK,GAArB,MAAM;QACU,GAAG,GAAnB,MAAM;QACU,QAAQ,GAAxB,MAAM;QACwB,WAAW,GAAzC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAC,CAAC,EAAC,MAAM,CAAA;SAAC;QACJ,iBAAiB,GAAjC,MAAM;QACW,WAAW,GAA5B,OAAO;QACU,aAAa,GAA9B,OAAO;QACU,YAAY,GAA7B,OAAO;QACU,aAAa,GAA9B,OAAO;QACS,iBAAiB,GAAjC,MAAM;QACU,iBAAiB,GAAjC,MAAM;QACW,gBAAgB,GAAjC,OAAO;QACU,cAAc,GAA/B,OAAO;QACS,mBAAmB,GAAnC,MAAM;QACW,OAAO,GAAxB,OAAO;sBA0EjB;IAGD;;;;;;;;;;;;OAYG;IACH;QAXyB,MAAM,EAApB,MAAM;QACyB,GAAG;QACnB,mBAAmB,GAAlC,MAAM;QACU,UAAU,GAA1B,OAAO;QACO,GAAG,GAAjB,KAAK;QACU,YAAY,GAA3B,MAAM;QACU,YAAY,GAA5B,OAAO;QACO,OAAO,GAArB,KAAK;QACU,gBAAgB,GAA/B,MAAM;QACS,iBAAiB,GAAhC,MAAM;sBA2DhB;IAED;;;;;;;OAOG;IACH;QAN0B,YAAY,GAA3B,MAAM;QACQ,MAAM,EAApB,MAAM;QACS,WAAW,GAA1B,MAAM;QACyB,GAAG;QAChC,QAAQ,MAAM,CAAC,CA6C3B;IAGD;;;;;;;;;;OAUG;IACH,sFATW,MAAM,GAOJ,OAAO,CA0DnB;IApfD;;;OAGG;IACH,YAFU,eAAQ,IAAI,CAEb;IAGL;;;OAGG;IACH,QAFU,MAAM,CAEiC;IA0DrD;;;;;OAKG;IACH;iCAJmB,mBAAmB,UAAQ,MAAM;8BACzC,OAAO;QACL,QAAQ,MAAM,CAAC,CA0D3B;CAkXJ;;IAID;;;OAGG;IACH,uCAMC;;mBAhkBkB,aAAa;oCACI,0BAA0B;sBAOxC,kCAAkC;8BAjB1B,mCAAmC;oBAD7C,yBAAyB;mBAK1B,iBAAiB;sBATd,wBAAwB;oBAW1B,8BAA8B"}