reladraw 0.14.2 → 0.14.4

package/README.md

@@ -82,7 +82,7 @@ That gets you a copy of the skill at the time you run it, so you'll need to re-r
 
 ## Status
 
-Version 0.14.2. Early stage, but works. The parser, layout engine, and SVG renderer are written in TypeScript, with zero runtime dependencies. There is a command-line tool that turns a .reladraw text file into an SVG, and an element that does the same inside a web page.
+Version 0.14.4. Early stage, but works. The parser, layout engine, and SVG renderer are written in TypeScript, with zero runtime dependencies. There is a command-line tool that turns a .reladraw text file into an SVG, and an element that does the same inside a web page.
 
 The language isn't stable yet, so expect the syntax to change.
 

package/SYNTAX.md

@@ -1,4 +1,4 @@
-# Syntax reference — 0.14.2
+# Syntax reference — 0.14.4
 
 What the language accepts. The parser, resolver and SVG renderer implement all of it; the sections at the end record what is defective, unchecked or undecided.
 
@@ -1112,6 +1112,18 @@ That one was found by testing the lexer, not by rendering — and it could not h
 
 Pre-1.0, so the minor number is where a breaking change goes. Every removal below is refused by name with the replacement quoted, rather than dropped in silence — an older file stops with an error saying what to write instead.
 
+**0.14.4**
+
+No syntax changes, and no file that worked is refused. No example diagram draws differently.
+
+- Faster: lines steered with `between` in a busy diagram. When looking for its way, such a line didn't account for the gap it still had to pass through, so it searched much of the diagram before finding it. A test diagram with four of them among forty-four other lines drew in 6.8 seconds, and now draws in about 5.5.
+
+**0.14.3**
+
+No syntax changes, and no file that worked is refused. No example diagram draws differently.
+
+- A fix: many curved lines into one side could hang the page. With twenty-two copies of `edge a -> b  from: right  to: left`, some lines had no room left to curve before the arrowhead, and the tool kept trying ever smaller curves thousands of times. It now stops at the smallest, and the same file draws in a tenth of a second.
+
 **0.14.2**
 
 No syntax changes, and no file that worked is refused.

package/dist/render.js

@@ -2738,9 +2738,13 @@ function sweptPath(points, boxes, neighbors, arrow, marks) {
             const p3 = along(corner, dout, b);
             return [p0, along(p0, din, a * kappa), along(p3, dout, -b * kappa), p3];
         };
+        // Within half a pixel of the smallest is the smallest: where an end piece
+        // has no room left, the smallest is zero, which shrinking never reaches,
+        // and twenty-two lines into one side took the page down.
+        const shrink = (size) => (size * 0.85 < least + 0.5 ? least : size * 0.85);
         while ((a > least || b > least) && !clear(...quarter(a, b))) {
-            a = Math.max(least, a * 0.85);
-            b = Math.max(least, b * 0.85);
+            a = shrink(a);
+            b = shrink(b);
         }
         curve(...quarter(a, b));
     }

package/dist/search.js

@@ -106,10 +106,12 @@ export function searchRoute(start, end, walls, options) {
     // way just as long can arrive later with a better tie-break; it keeps on
     // until nothing waiting could come in as cheap as the end already has, and
     // what it finds is exactly what searching every direction alike would.
+    // Until the line has passed its gate, that is by way of the gate.
     const toGo = (current) => {
         const cell = (current - (current % 8)) / 8;
         const i = cell % width;
-        return Math.abs(xs[i] - back.x) + Math.abs(ys[(cell - i) / width] - back.y);
+        const point = { x: xs[i], y: ys[(cell - i) / width] };
+        return leastLength(point, back, current % 2 === 1 ? undefined : gate);
     };
     const heap = new MinHeap();
     const begin = state(si, sj, first, 0);
@@ -196,6 +198,18 @@ export function searchRoute(start, end, walls, options) {
     path.reverse();
     return { points: straightRuns([start, ...path, end]), cost: cost[goal] };
 }
+/**
+ * The shortest a right-angled line from `a` to `b` could be: straight across
+ * and straight down, or with a gate, across to its line at `at` and to a
+ * level within it on the way.
+ */
+function leastLength(a, b, gate) {
+    if (!gate)
+        return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+    const [u, v, bu, bv] = gate.run === 'x' ? [a.x, a.y, b.x, b.y] : [a.y, a.x, b.y, b.x];
+    const off = Math.max(0, gate.lo - Math.max(v, bv), Math.min(v, bv) - gate.hi);
+    return Math.abs(u - gate.at) + Math.abs(gate.at - bu) + Math.abs(v - bv) + 2 * off;
+}
 /**
  * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reladraw",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "description": "A diagram language where you say where things go.",
   "type": "module",
   "bin": {