reladraw 0.12.0 → 0.14.0

package/dist/resolve.js

@@ -1,4 +1,4 @@
-import { ALL_ATTR_KEYS, ATTR_KEYS, PART_SIDES, COLOR_KEYS, COLOR_PARTS, CONTENT_ALIGNMENTS, CONTENT_WIDTHS, LINE_VALUES, describePlacement, nameTarget, } from './ast.js';
+import { ALL_ATTR_KEYS, ATTR_KEYS, MARKS, PART_SIDES, COLOR_KEYS, COLOR_PARTS, CONTENT_ALIGNMENTS, CONTENT_WIDTHS, LINE_VALUES, describePlacement, nameTarget, } from './ast.js';
 import { BARE_EDGE_RUN, CHILD_GAP, DECK_STEP, DEFAULT_FONT_SIZE, DEFAULT_MARGIN, GAPS, HEADER_GAP, ICON_GAP, ICON_LINES, TEXT_CLEARANCE, PAD, SEPARATION_GAP, THICKNESS, arrowLength, fontSizeFor, leafTop, textExtent, textStyleFor, widestLine, } from './constants.js';
 import { fix, reachability, tightest } from './constrain.js';
 import { SourceError } from './errors.js';
@@ -430,6 +430,34 @@ function appearanceOf(attrs, styles, line) {
     }
     return { ...merged, ...attrs };
 }
+/**
+ * What is drawn at one end of an edge. A mark written in the arrow is final:
+ * the edge's own `from-mark:` or `to-mark:` may repeat it but not contradict
+ * it, since both halves are on one line and whichever lost would be dead text.
+ * An end the arrow leaves blank is unsaid, and the edge's attribute, then its
+ * style, then nothing, fills it. Layering is between places, never within one.
+ */
+function markAt(end, stmt, appearance, what) {
+    const key = `${end}-mark`;
+    const check = (value) => {
+        if (!MARKS.includes(value)) {
+            throw new SourceError(`edge ${what}: "${key}: ${value}" is not a mark — use ${MARKS.join(', ')}`, stmt.line);
+        }
+        return value;
+    };
+    const written = stmt.marks[end];
+    const own = stmt.attrs[key];
+    if (written !== undefined) {
+        if (own !== undefined && check(own) !== written) {
+            throw new SourceError(`edge ${what}: the arrow already puts ${written === 'none' ? 'nothing' : `a${/^[aeiou]/.test(written) ? 'n' : ''} ${written}`} ` +
+                `at ${stmt[end]}, and "${key}: ${own}" says otherwise. Say it once: leave that end of the ` +
+                `arrow blank and keep "${key}: ${own}", or drop "${key}:"`, stmt.line);
+        }
+        return written;
+    }
+    const given = appearance[key];
+    return given === undefined ? 'none' : check(given);
+}
 function buildEdges(statements, byName, styles, defaults) {
     const edges = [];
     for (const stmt of statements) {
@@ -477,7 +505,7 @@ function buildEdges(statements, byName, styles, defaults) {
             };
         });
         const appearance = { ...defaults.get('edge'), ...appearanceOf(stmt.attrs, styles, stmt.line) };
-        const what = `${stmt.from} -> ${stmt.to}`;
+        const what = `${stmt.from} ${stmt.arrow} ${stmt.to}`;
         checkAttrs('edge', what, stmt.attrs, stmt.line);
         checkStyleUse('edge', what, stmt.attrs, styles, stmt.line);
         if (stmt.attrs['url'] !== undefined && stmt.text === undefined) {
@@ -492,7 +520,10 @@ function buildEdges(statements, byName, styles, defaults) {
         edges.push({
             from,
             to,
-            both: stmt.both,
+            marks: {
+                from: markAt('from', stmt, appearance, what),
+                to: markAt('to', stmt, appearance, what),
+            },
             textAttrs,
             ...(stmt.text !== undefined
                 ? { text: stmt.text, lines: linesFor(stmt.text, textAttrs, `edge ${what}`, stmt.line) }
@@ -1468,10 +1499,11 @@ function corridorsIn(edges, locate, measurer, fontSize) {
         const to = locate(edge.to);
         if (!from || !to || from.index === to.index)
             continue;
-        // With no text, the gap still has to show a run of line behind each head,
+        // With no text, the gap still has to show a run of line behind each mark,
         // or two stacked children with an arrow between them draw as a head alone.
+        const marked = [edge.marks.from, edge.marks.to].filter((mark) => mark !== 'none').length;
         if (edge.text === undefined) {
-            const bare = BARE_EDGE_RUN + arrowLength(edge.look.thickness) * (edge.both ? 2 : 1);
+            const bare = BARE_EDGE_RUN + arrowLength(edge.look.thickness) * marked;
             corridors.push({
                 edge,
                 from,
@@ -1486,9 +1518,11 @@ function corridorsIn(edges, locate, measurer, fontSize) {
         // at either end. The arrowhead is charged on both sides for the same reason:
         // it covers the head's length of the line it arrives on, and reserving that
         // at one end only would move the midpoint rather than lengthen the run. A
-        // thick line's head is longer, and takes the room it needs.
+        // thick line's head is longer, and takes the room it needs. A line with no
+        // mark at either end is charged for none.
+        const head = marked > 0 ? arrowLength(edge.look.thickness) : 0;
         const extent = (axis) => textExtent(edge.lines, edge.textAttrs, axis, measurer, fontSize, edge.line) +
-            (TEXT_CLEARANCE + arrowLength(edge.look.thickness)) * 2;
+            (TEXT_CLEARANCE + head) * 2;
         corridors.push({
             edge,
             from,

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.12.0",
+  "version": "0.14.0",
   "description": "A diagram language where you say where things go.",
   "type": "module",
   "bin": {