reladraw 0.11.1 → 0.13.0

package/dist/search.d.ts

@@ -11,11 +11,11 @@
  * straight in, with a straight stretch at each end at least `stub` long, so an
  * arrowhead always lands on a straight piece. Between those two stretches it
  * takes the cheapest way through the grid, where cost is length plus a charge
- * for every turn. On a right-angled grid many ways tie on length — a staircase
- * is exactly as long as one bend — and the turn charge breaks those ties toward
- * the fewest bends, which is the line a person would draw. What still ties
- * after that goes over the top rather than under, and round the right rather
- * than the left.
+ * for every turn and for every line already placed that it crosses. On a
+ * right-angled grid many ways tie on length — a staircase is exactly as long as
+ * one bend — and the turn charge breaks those ties toward the fewest bends,
+ * which is the line a person would draw. What still ties after that goes over
+ * the top rather than under, and round the right rather than the left.
  *
  * A way through a box is not a losing option here. It is not a way at all.
  */
@@ -57,6 +57,35 @@ export interface SearchOptions {
      */
     taken: SearchPoint[][];
     lane: number;
+    /**
+     * For each line in `taken`, for each of its stretches, half the depth across
+     * it of a text riding there, and 0 where none does. A line running beside a
+     * stretch carrying a text keeps clear of the text, not just of the line.
+     */
+    takenHalves?: number[][];
+    /**
+     * A gap the line must pass through: somewhere it crosses the line at `at`
+     * on the `run` axis, travelling along `run`, at a level between `lo` and `hi`.
+     */
+    gate?: SearchGate;
+    /**
+     * Half the depth of this line's own text, which rides in the gate: inside it,
+     * the line keeps that much further from the lines beside it.
+     */
+    ownHalf?: number;
+    /**
+     * How far the line may go at all: the diagram with room round it. A wall
+     * reaching past this — a clause's fence, which runs to the edge of the page —
+     * cannot be gone round at its far end.
+     */
+    bounds?: SearchWall;
+}
+/** A gap a line must pass through. See `SearchOptions.gate`. */
+export interface SearchGate {
+    run: 'x' | 'y';
+    at: number;
+    lo: number;
+    hi: number;
 }
 export interface SearchResult {
     points: SearchPoint[];

package/dist/search.js

@@ -11,11 +11,11 @@
  * straight in, with a straight stretch at each end at least `stub` long, so an
  * arrowhead always lands on a straight piece. Between those two stretches it
  * takes the cheapest way through the grid, where cost is length plus a charge
- * for every turn. On a right-angled grid many ways tie on length — a staircase
- * is exactly as long as one bend — and the turn charge breaks those ties toward
- * the fewest bends, which is the line a person would draw. What still ties
- * after that goes over the top rather than under, and round the right rather
- * than the left.
+ * for every turn and for every line already placed that it crosses. On a
+ * right-angled grid many ways tie on length — a staircase is exactly as long as
+ * one bend — and the turn charge breaks those ties toward the fewest bends,
+ * which is the line a person would draw. What still ties after that goes over
+ * the top rather than under, and round the right rather than the left.
  *
  * A way through a box is not a losing option here. It is not a way at all.
  */
@@ -45,8 +45,25 @@ export function searchRoute(start, end, walls, options) {
         return undefined;
     if (inside(out, walls) || inside(back, walls))
         return undefined;
-    const xs = tracks(walls, 'x', clear, [out.x, back.x], options.taken, options.lane);
-    const ys = tracks(walls, 'y', clear, [out.y, back.y], options.taken, options.lane);
+    const bounds = options.bounds;
+    const gate = options.gate;
+    // How far a stretch keeps from a placed one beside it: a lane, or clear of
+    // the text either of them carries there.
+    const halves = options.takenHalves ?? [];
+    const ownHalf = options.ownHalf ?? 0;
+    const inGate = (a, b) => {
+        if (!gate)
+            return false;
+        const along = gate.run === 'x' ? Math.abs(a.y - b.y) < 0.5 : Math.abs(a.x - b.x) < 0.5;
+        const level = gate.run === 'x' ? a.y : a.x;
+        return along && level > gate.lo && level < gate.hi;
+    };
+    const spacing = (line, stretch, own) => Math.max(options.lane, (halves[line]?.[stretch] ?? 0) + own);
+    const gateTracks = (axis) => !gate ? [] : axis === gate.run ? [gate.at] : [(gate.lo + gate.hi) / 2];
+    const xs = tracks(walls, 'x', clear, [out.x, back.x, ...gateTracks('x')], options.taken, spacing, ownHalf)
+        .filter((x) => !bounds || (x >= bounds.minX && x <= bounds.maxX) || x === out.x || x === back.x);
+    const ys = tracks(walls, 'y', clear, [out.y, back.y, ...gateTracks('y')], options.taken, spacing, ownHalf)
+        .filter((y) => !bounds || (y >= bounds.minY && y <= bounds.maxY) || y === out.y || y === back.y);
     const ix = new Map(xs.map((x, index) => [x, index]));
     const iy = new Map(ys.map((y, index) => [y, index]));
     const width = xs.length;
@@ -69,14 +86,17 @@ export function searchRoute(start, end, walls, options) {
     const tj = iy.get(back.y);
     // Cost is compared first on length and turns, then on a tie-break that
     // prefers a stretch higher up the page, or further right, so that of two
-    // ways round that are exactly as long the line goes over the top.
-    const size = width * height * 4;
+    // ways round that are exactly as long the line goes over the top. A state
+    // also records whether the line has passed its gate yet; it may only finish
+    // once it has.
+    const size = width * height * 8;
     const cost = new Float64Array(size).fill(Infinity);
     const tie = new Float64Array(size).fill(Infinity);
     const from = new Int32Array(size).fill(-1);
-    const state = (i, j, h) => (j * width + i) * 4 + h;
+    const state = (i, j, h, p) => ((j * width + i) * 4 + h) * 2 + p;
+    const done = gate ? 1 : 0;
     const heap = new MinHeap();
-    const begin = state(si, sj, first);
+    const begin = state(si, sj, first, 0);
     cost[begin] = 0;
     tie[begin] = 0;
     heap.push(begin, 0, 0);
@@ -85,11 +105,13 @@ export function searchRoute(start, end, walls, options) {
         const [current, c, t] = heap.pop();
         if (c > cost[current] || (c === cost[current] && t > tie[current]))
             continue;
-        const h = current % 4;
-        const cell = (current - h) / 4;
+        const p = current % 2;
+        const rest = (current - p) / 2;
+        const h = rest % 4;
+        const cell = (rest - h) / 4;
         const i = cell % width;
         const j = (cell - i) / width;
-        if (i === ti && j === tj && h === last) {
+        if (i === ti && j === tj && h === last && p === done) {
             goal = current;
             break;
         }
@@ -99,7 +121,7 @@ export function searchRoute(start, end, walls, options) {
                 continue;
             if (next !== h) {
                 // Turning on the spot costs a turn and moves nowhere.
-                relax(current, state(i, j, next), c + turn, t);
+                relax(current, state(i, j, next, p), c + turn, t);
                 continue;
             }
             const ni = i + STEP[next][0];
@@ -108,16 +130,25 @@ export function searchRoute(start, end, walls, options) {
                 continue;
             const a = { x: xs[i], y: ys[j] };
             const b = { x: xs[ni], y: ys[nj] };
-            if (blocked(a, b, walls) || alongTaken(a, b, options.taken, options.lane))
+            const own = inGate(a, b) ? ownHalf : 0;
+            if (blocked(a, b, walls) || alongTaken(a, b, options.taken, spacing, own))
                 continue;
+            // Passing the gate: a stretch through it, reaching the line at `at`.
+            const through = inGate(a, b) &&
+                Math.min(gate.run === 'x' ? a.x : a.y, gate.run === 'x' ? b.x : b.y) <= gate.at + 0.01 &&
+                Math.max(gate.run === 'x' ? a.x : a.y, gate.run === 'x' ? b.x : b.y) >= gate.at - 0.01;
+            const np = p === 1 || through ? 1 : 0;
             // Running closer to a wall than `clear` counts double: the line may pass
-            // a narrow gap, but where there is room it keeps its distance.
-            const length = Math.abs(b.x - a.x) + Math.abs(b.y - a.y) + crowding(a, b, walls, clear);
+            // a narrow gap, but where there is room it keeps its distance. Crossing a
+            // line already placed costs what a turn does, so of two ways much the
+            // same length the one that crosses nothing wins.
+            const length = Math.abs(b.x - a.x) + Math.abs(b.y - a.y) + crowding(a, b, walls, clear) +
+                turn * crossings(a, b, options.taken);
             // Higher up for a stretch across, further right for one down: a smaller
             // tie-break is preferred, so the across level counts as it is and the
             // down level counts negated.
             const lean = next % 2 === 0 ? a.y * length : -a.x * length;
-            relax(current, state(ni, nj, next), c + length, t + lean);
+            relax(current, state(ni, nj, next, np), c + length, t + lean);
         }
     }
     if (goal < 0)
@@ -132,7 +163,8 @@ export function searchRoute(start, end, walls, options) {
     }
     const path = [];
     for (let at = goal; at >= 0; at = from[at]) {
-        const cell = (at - (at % 4)) / 4;
+        const rest = (at - (at % 2)) / 2;
+        const cell = (rest - (rest % 4)) / 4;
         const i = cell % width;
         const j = (cell - i) / width;
         const point = { x: xs[i], y: ys[j] };
@@ -146,9 +178,10 @@ export function searchRoute(start, end, walls, options) {
 /**
  * The tracks on one axis: beside each wall at `clear` where that is open,
  * down the middle of every gap between walls, through the ends, and a lane
- * either side of each line already placed.
+ * either side of each line already placed — a wider one where a text rides,
+ * and wider again by `own` for this line's own text.
  */
-function tracks(walls, axis, clear, ends, taken, lane) {
+function tracks(walls, axis, clear, ends, taken, spacing, own) {
     const lo = (wall) => (axis === 'x' ? wall.minX : wall.minY);
     const hi = (wall) => (axis === 'x' ? wall.maxX : wall.maxY);
     // The other axis, to tell a real gap — two walls facing each other across
@@ -166,7 +199,7 @@ function tracks(walls, axis, clear, ends, taken, lane) {
                 found.add((hi(a) + lo(b)) / 2);
         }
     }
-    for (const line of taken) {
+    taken.forEach((line, which) => {
         for (let index = 0; index + 1 < line.length; index += 1) {
             const [a, b] = [line[index], line[index + 1]];
             // A stretch across sits at a level on y; one down, at a level on x.
@@ -176,10 +209,12 @@ function tracks(walls, axis, clear, ends, taken, lane) {
             // A lane either side of a placed line. One that runs close beside a box
             // is paid for as crowding, like any other track.
             const level = axis === 'y' ? a.y : a.x;
-            found.add(level - lane);
-            found.add(level + lane);
+            for (const by of new Set([spacing(which, index, 0), spacing(which, index, own)])) {
+                found.add(level - by);
+                found.add(level + by);
+            }
         }
-    }
+    });
     return [...new Set([...found].map(snap))].sort((p, q) => p - q);
 }
 /** Coordinates to a hundredth, so a track and the end it runs through compare equal. */
@@ -250,20 +285,23 @@ function crowding(a, b, walls, clear) {
     }
     return worst;
 }
-/** Whether a stretch runs along a placed line, closer than a lane, for any distance. */
-function alongTaken(a, b, taken, lane) {
+/**
+ * Whether a stretch runs along a placed line, for any distance, closer than
+ * the spacing between the two there: a lane, or clear of a text either carries.
+ */
+function alongTaken(a, b, taken, spacing, own) {
     const across = Math.abs(a.y - b.y) < 0.5;
     const level = across ? a.y : a.x;
     const lo = across ? Math.min(a.x, b.x) : Math.min(a.y, b.y);
     const hi = across ? Math.max(a.x, b.x) : Math.max(a.y, b.y);
-    for (const line of taken) {
+    for (const [which, line] of taken.entries()) {
         for (let index = 0; index + 1 < line.length; index += 1) {
             const [p, q] = [line[index], line[index + 1]];
             const pAcross = Math.abs(p.y - q.y) < 0.5;
             if (pAcross !== across)
                 continue;
             const other = across ? p.y : p.x;
-            if (Math.abs(other - level) >= lane - 0.5)
+            if (Math.abs(other - level) >= spacing(which, index, own) - 0.5)
                 continue;
             const pLo = across ? Math.min(p.x, q.x) : Math.min(p.y, q.y);
             const pHi = across ? Math.max(p.x, q.x) : Math.max(p.y, q.y);
@@ -273,6 +311,28 @@ function alongTaken(a, b, taken, lane) {
     }
     return false;
 }
+/** How many stretches of placed lines a stretch crosses square on, touching neither end of either. */
+function crossings(a, b, taken) {
+    const across = Math.abs(a.y - b.y) < 0.5;
+    const level = across ? a.y : a.x;
+    const lo = across ? Math.min(a.x, b.x) : Math.min(a.y, b.y);
+    const hi = across ? Math.max(a.x, b.x) : Math.max(a.y, b.y);
+    let found = 0;
+    for (const line of taken) {
+        for (let index = 0; index + 1 < line.length; index += 1) {
+            const [p, q] = [line[index], line[index + 1]];
+            const pAcross = Math.abs(p.y - q.y) < 0.5;
+            if (pAcross === across)
+                continue;
+            const at = across ? p.x : p.y;
+            const pLo = across ? Math.min(p.y, q.y) : Math.min(p.x, q.x);
+            const pHi = across ? Math.max(p.y, q.y) : Math.max(p.x, q.x);
+            if (at > lo + 0.5 && at < hi - 0.5 && level > pLo + 0.5 && level < pHi - 0.5)
+                found += 1;
+        }
+    }
+    return found;
+}
 /** The points with every one dropped that sits on a straight run between its neighbors. */
 function straightRuns(points) {
     const kept = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reladraw",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "description": "A diagram language where you say where things go.",
   "type": "module",
   "bin": {
@@ -32,7 +32,7 @@
     "url": "https://github.com/reladraw/reladraw/issues"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.element.json",
     "prepublishOnly": "npm run build",
     "preversion": "./dev.sh check-version \"$npm_new_version\"",
     "dev": "tsc --watch",