reladraw 0.14.1 → 0.14.3

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.1. 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.3. 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.1
+# Syntax reference — 0.14.3
 
 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,19 @@ 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.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.
+
+- Many copies of one line draw far faster. Lines with the same two ends, the same sides, the same clauses and no text are now drawn as one line and its copies, each a lane further out, instead of each finding its own way round the copies before it. Fifteen copies of `edge a -> b  from: left  to: right` took about a third of a second and forty took two and a half; forty now take half a second. Where such copies used to split, some going over the top and some underneath, they now stay together. A copy that would run into a box or cross a line the first one does not is still found as before.
+- Curved lines in busy diagrams draw faster. No picture changes.
+
 **0.14.1**
 
 No syntax changes, and no file that worked is refused.

package/dist/render.js

@@ -1704,6 +1704,9 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
             ...(edge.passes ?? []).map((pass) => pass.written),
         ].join(' ');
     };
+    // Each line of such a group after the first, and the line it is drawn as a
+    // copy of: the one a lane inside it.
+    const copies = new Map();
     for (let index = 0; index < wanted.length; index += 1) {
         const key = sameWay(wanted[index]);
         const group = wanted.filter((edge) => sameWay(edge) === key);
@@ -1723,6 +1726,14 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
         rest.splice(index, 0, ...ordered);
         wanted.splice(0, wanted.length, ...rest);
         index += group.length - 1;
+        // A text widens the lane it rides in, which a copy cannot know; those are searched.
+        const named = (edge) => {
+            const { start, end } = ends.get(edge);
+            return start.side !== undefined && end.side !== undefined;
+        };
+        if (ordered.every((edge) => edge.lines === undefined && named(edge))) {
+            ordered.slice(1).forEach((edge, at) => copies.set(edge, ordered[at]));
+        }
     }
     // Where several lines leave one side, their ends may be squeezed closer than
     // a lane; the lines then run out of them that close together, and the lanes
@@ -1843,8 +1854,70 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
         found.set(edge, way);
         ends.set(edge, { start: way.start, end: way.end });
     };
+    // A line identical to one already placed is that line moved out by a lane,
+    // not a search of its own: the same way, every stretch shifted to the same
+    // side by the distance between their ends. Searching each afresh, keeping
+    // clear of every copy before it, made fifteen identical lines take as long as
+    // a tangled diagram. Where the copy would not do — its ends do not line up
+    // with the shift, a stretch folds up, it meets a box, crowds or crosses a line
+    // the first does not — the line is searched for as any other.
+    const copyOf = (edge, inside, placed) => {
+        const { start, end } = planned.get(edge);
+        const base = found.get(inside).points;
+        const count = base.length - 1;
+        if (count < 1)
+            return undefined;
+        const heading = base.slice(1).map((q, index) => {
+            const p = base[index];
+            const length = Math.hypot(q.x - p.x, q.y - p.y);
+            return { x: (q.x - p.x) / length, y: (q.y - p.y) / length, length };
+        });
+        if (heading.some((one) => one.length < 0.5 || (Math.abs(one.x) > 1e-6 && Math.abs(one.y) > 1e-6)))
+            return undefined;
+        const normal = heading.map((one) => ({ x: -one.y, y: one.x }));
+        const along = (from, to, axis) => (to.x - from.x) * axis.x + (to.y - from.y) * axis.y;
+        const shift = along(base[0], start, normal[0]);
+        if (Math.abs(shift) < 0.5 || Math.abs(along(base[0], start, heading[0])) > 0.5)
+            return undefined;
+        if (Math.abs(along(base[count], end, normal[count - 1]) - shift) > 0.5 || Math.abs(along(base[count], end, heading[count - 1])) > 0.5) {
+            return undefined;
+        }
+        const points = [{ x: start.x, y: start.y }];
+        for (let index = 1; index < count; index += 1) {
+            const [p, q] = [normal[index - 1], normal[index]];
+            const turns = Math.abs(p.x * q.x + p.y * q.y) < 0.5;
+            const v = base[index];
+            points.push(turns ? { x: v.x + shift * (p.x + q.x), y: v.y + shift * (p.y + q.y) } : { x: v.x + shift * q.x, y: v.y + shift * q.y });
+        }
+        points.push({ x: end.x, y: end.y });
+        for (let index = 0; index < count; index += 1) {
+            const [p, q] = [points[index], points[index + 1]];
+            if (along(p, q, heading[index]) < 0.5)
+                return undefined;
+        }
+        const inner = points.slice(1, -1);
+        const walls = nodes
+            .filter((node) => !contains(node, edge.from) && !contains(node, edge.to))
+            .map((node) => grow(extentOfBox(faceOf(node)), ATTACH_MARGIN - 0.5));
+        const own = [edge.from, edge.to].map((node) => grow(extentOfBox(faceOf(node)), ATTACH_MARGIN - 0.5));
+        const fences = (edge.passes ?? []).map((pass) => fenceOf(pass, 0));
+        if (!wayClear(points, [...obstaclesFor(edge, nodes), ...walls]) || !wayClear(inner, [...own, ...fences]) || !passesAll(edge, points)) {
+            return undefined;
+        }
+        const lane = laneFor(edge);
+        for (const other of placed) {
+            const theirs = found.get(other).points;
+            if (linesCross(points, theirs) > linesCross(base, theirs))
+                return undefined;
+            if (other !== inside && crowds(points, theirs, lane))
+                return undefined;
+        }
+        return { start, end, points, mid: textOnWay(points, edge, nodes, measurer, fontSize) };
+    };
     for (const edge of wanted) {
-        settle(edge, place(edge, [...order]));
+        const inside = copies.get(edge);
+        const copy = inside && found.has(inside) ? copyOf(edge, inside, [...order]) : undefined;
+        settle(edge, copy ?? place(edge, [...order]));
         order.push(edge);
     }
     // Which line takes the inside of a shared stretch depends on which was placed
@@ -1900,6 +1973,27 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
     }
     return routes;
 }
+/**
+ * Whether two lines run side by side, along the same stretch, nearer than a
+ * lane apart — which a line found by search never does.
+ */
+function crowds(a, b, lane) {
+    for (let i = 0; i + 1 < a.length; i += 1) {
+        const [p, q] = [a[i], a[i + 1]];
+        const level = Math.abs(p.y - q.y) < 0.5;
+        for (let j = 0; j + 1 < b.length; j += 1) {
+            const [r, s] = [b[j], b[j + 1]];
+            if (level !== Math.abs(r.y - s.y) < 0.5)
+                continue;
+            const [across, lo, hi, otherAcross, otherLo, otherHi] = level
+                ? [p.y, Math.min(p.x, q.x), Math.max(p.x, q.x), r.y, Math.min(r.x, s.x), Math.max(r.x, s.x)]
+                : [p.x, Math.min(p.y, q.y), Math.max(p.y, q.y), r.x, Math.min(r.y, s.y), Math.max(r.y, s.y)];
+            if (Math.min(hi, otherHi) - Math.max(lo, otherLo) > 0.5 && Math.abs(across - otherAcross) < lane - 0.5)
+                return true;
+        }
+    }
+    return false;
+}
 /** How many times two lines cross, each drawn as straight pieces through its points. */
 function linesCross(a, b) {
     let count = 0;
@@ -2562,9 +2656,21 @@ function sweptPath(points, boxes, neighbors, arrow, marks) {
                 return false;
             }
         }
+        // A piece of another line wholly beyond the curve's reach, and its air,
+        // can neither cross it nor come near it.
+        const reach = {
+            minX: Math.min(...trace.map((point) => point.x)) - SWEEP_AIR,
+            maxX: Math.max(...trace.map((point) => point.x)) + SWEEP_AIR,
+            minY: Math.min(...trace.map((point) => point.y)) - SWEEP_AIR,
+            maxY: Math.max(...trace.map((point) => point.y)) + SWEEP_AIR,
+        };
         for (const line of neighbors) {
             for (let index = 0; index + 1 < line.length; index += 1) {
                 const [p, q] = [line[index], line[index + 1]];
+                if (Math.max(p.x, q.x) < reach.minX || Math.min(p.x, q.x) > reach.maxX)
+                    continue;
+                if (Math.max(p.y, q.y) < reach.minY || Math.min(p.y, q.y) > reach.maxY)
+                    continue;
                 for (let step = 0; step < steps; step += 1) {
                     if (intersect(trace[step], trace[step + 1], p, q))
                         return false;
@@ -2632,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/package.json

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