reladraw 0.19.0 → 0.19.1

package/README.md

@@ -2,7 +2,9 @@
 
 reladraw is a text language for diagrams where you say where things go.
 
-**[Try it in your browser →](https://reladraw.github.io/reladraw/)**
+> The language is changing frequently. The playground always runs the newest syntax, so a diagram that draws there today may need a small edit later. An installed copy from npm changes only when you upgrade it.
+
+**[Try it in your browser in the reladraw playground →](https://reladraw.github.io/reladraw/)**
 
 I wanted to be able to create custom, expressive diagrams where I decided how to arrange the diagram, but without the inefficiency of manually drawing in draw.io. For example, this is a diagram drawn in draw.io:
 
@@ -86,9 +88,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.19.0. 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.
+Version 0.19.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.
 
 ## License
 

package/SYNTAX.md

@@ -1,4 +1,4 @@
-# Syntax reference — 0.19.0
+# Syntax reference — 0.19.1
 
 What the language accepts. The changelog at the end lists what changed in each published version; 0.17.0's changes are large, and its entry has a table of every old spelling and what to write instead.
 
@@ -842,7 +842,7 @@ A line named `req` has parts. `req start` and `req end` are where it was written
 
 ### Copies fan out
 
-Copies are lines with the same two boxes on the same sides, in either direction, with nothing stated about their path. Texts and colors don't count, so a request and its response are copies. Copies are drawn as one shape, each shifted sideways from it by a fixed step like lanes on a road, so they never cross. Straight copies with no side named run parallel, a `tight` gap apart, each end landing where its lane meets the border. A line whose landing is stated, such as `to: top, right of z`, is no longer a copy, which is how to override the fan.
+Copies are lines with the same two boxes on the same sides, in either direction, with nothing stated about their path. Texts and colors don't count, so a request and its response are copies. Copies are drawn as one shape, each shifted sideways from it by a fixed step like lanes on a road, so they never cross. Straight copies with no side named run parallel, a `tight` gap apart, each end landing where its lane meets the border. A line that says anything about where it goes is no longer a copy, and is drawn as written: a stated landing (`to: top, right of z`), a place in a side's `right-edge-order:` list, or a `step-out:` or `turn:` in its own bracket. That is how to override the fan. A `step-out:` or `turn:` from `default edge` or a style says the same for every line, so copies sharing it still fan, each taking it from the first.
 
 ```
 node client
@@ -1281,6 +1281,11 @@ Designed and absent from the code.
 
 Pre-1.0, so the minor number is where a breaking change goes. Every removal 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.19.1**
+
+- **A copy that states its own `step-out:` or `turn:` keeps it.** Lines between the same two sides of the same two boxes fan into lanes, and each used to be drawn as the first one's shape shifted over, so a `step-out:` or `turn:` written on any later line was ignored. A line naming either is now drawn as written and leaves the fan, and so does a line named in its side's `right-edge-order:` list. Where that puts two lines on one run, it is reported as `edge-overlap`. Prompted by #19.
+- **Errors and findings name a named line by its name**, as written: `line e2 b.1 -- b.2 runs on line e1 b.1 -- b.2`. Two lines between the same boxes used to read identically.
+
 **0.19.0**
 
 - **`reladraw format`** lays a file out again: each statement on one line, neighboring statements with the same keyword lined up in columns, comments kept beside what they are about. No word is respelled, and the result is checked to draw what the original did. `--check` fails on a file that would change, and `.reladraw-format` holds a project's settings; `reladraw format --init` writes one with every setting explained. `reladraw format -` reads standard input and prints the result, for editors. A long statement can wrap past a width (`wrap-at`) or go one clause to a line (`clause-per-line-at`), and `clause-order` puts placements and keys in a chosen order. The playground has a Format button (Shift+Alt+F, undone with Ctrl+Z) and a panel for its settings, which can copy them as a `.reladraw-format`. Spacing inside a clause is evened out too: `gap:tight` becomes `gap: tight`, `( gap: tight )` becomes `(gap: tight)`. Prompted by #14, where a long statement was hard to read in a plain editor.

package/dist/lines.d.ts

@@ -101,4 +101,5 @@ export declare function crossingPoints(a: Point[], b: Point[], clear: number): {
     along: Point;
     other: Point;
 }[];
+/** An edge as written, its name first where it has one: `e2 b.1 -- b.2`, so two lines between the same boxes can be told apart. */
 export declare function describeEdge(edge: LayoutEdge): string;

package/dist/lines.js

@@ -145,16 +145,20 @@ export function planSides(layout) {
 /**
  * Copies are lines with the same two boxes on the same sides, in either
  * direction, with nothing stated about their path (6.5): no waypoints, no
- * landing point, no place among a side's ends. Found by filing each line under
- * its boxes and sides, in one pass.
+ * landing point, no place among a side's ends, and no `step-out:` or `turn:`
+ * written on the line itself. Found by filing each line under its boxes and
+ * sides, in one pass.
  */
 function copySets(edges, ends) {
     const filed = new Map();
-    const plain = (end) => end.spec.kind === 'side' && end.spec.after === undefined && !end.onLine && end.edge.onMark?.[end.which] !== 'point';
+    const listed = (end) => end.edge.name !== undefined && (end.node.attrs[`${end.spec.side}-edge-order`]?.split(', ').includes(end.edge.name) ?? false);
+    const plain = (end) => end.spec.kind === 'side' && end.spec.after === undefined && !listed(end) && !end.onLine && end.edge.onMark?.[end.which] !== 'point';
     const keyOf = (end) => `${end.node.name}\n${end.spec.side}`;
     for (const edge of edges) {
         if (edge.via !== undefined || edge.straight !== undefined)
             continue;
+        if (edge.look.stepOutWritten !== undefined || edge.look.turnWritten !== undefined)
+            continue;
         const [start, end] = ends.get(edge);
         if (!plain(start) || !plain(end))
             continue;
@@ -2007,8 +2011,10 @@ function intersect(a, b, c, d) {
         return undefined;
     return { x: a.x + r.x * t, y: a.y + r.y * t };
 }
+/** An edge as written, its name first where it has one: `e2 b.1 -- b.2`, so two lines between the same boxes can be told apart. */
 export function describeEdge(edge) {
     if (edge.bundle)
         return `bundle ${edge.name}`;
-    return `${edge.from.name} ${edge.arrow} ${edge.to.name}`;
+    const ends = `${edge.from.name} ${edge.arrow} ${edge.to.name}`;
+    return edge.name === undefined ? ends : `${edge.name} ${ends}`;
 }

package/dist/model.d.ts

@@ -287,6 +287,8 @@ export interface LineLook {
     turnWritten: string | undefined;
     /** The short first and last leg of a square or curved line, in pixels. */
     stepOut: number;
+    /** `step-out:` as written on the edge itself; from a style or a default it is undefined. */
+    stepOutWritten: string | undefined;
 }
 export interface Layout {
     /** Every node, containers and children alike, in declaration order. */

package/dist/resolve.js

@@ -1700,6 +1700,7 @@ function lineLook(written, appearance, what, line) {
         turn,
         turnWritten: written['line.turn'],
         stepOut,
+        stepOutWritten: written['line.step-out'],
     };
     // Said on the edge itself, a property its path doesn't have is refused; from
     // a style or a default it lands on the lines that have it.

package/package.json

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