reladraw 0.15.1 → 0.17.0

package/dist/lexer.d.ts

@@ -5,6 +5,12 @@ export interface Token {
     quoted: boolean;
     /** True when the string was written between `"""` marks. */
     triple?: boolean;
+    /**
+     * The whole word as written, on a key split from its value: `gap:tight` lexes
+     * as `gap:` and `tight`, and this is `gap:tight` on the first. Kept so an error
+     * about the word can quote what the author typed.
+     */
+    joined?: string;
 }
 /**
  * A `"""` string still open at the end of the text given. `parse` catches this
@@ -37,5 +43,11 @@ export declare class OpenString extends SourceError {
  * Returns an empty array for a blank or comment-only line.
  */
 export declare function tokenizeLine(line: string, lineNumber: number, depth?: number): Token[];
+/**
+ * The character in a word that a name may not hold, if any. A colon makes the
+ * word a key, written with or without its space, and `;` is kept free so it
+ * could one day separate clauses without changing what any file means.
+ */
+export declare function nameMark(token: Token): ':' | ';' | undefined;
 /** A bare token ending in `:` opens the attribute section of a statement. */
 export declare function isAttrKey(token: Token): boolean;

package/dist/lexer.js

@@ -1,4 +1,10 @@
 import { SourceError } from './errors.js';
+/**
+ * A key written against its value. The key part is spelled as the highlighter's
+ * attribute pattern spells one, and a value opening with a slash is left whole,
+ * so a file name such as `C:/icons/disk.svg` is not torn at the drive letter.
+ */
+const JOINED_KEY = /^([A-Za-z][A-Za-z0-9_-]*:)([^/\\].*)$/;
 /**
  * A `"""` string still open at the end of the text given. `parse` catches this
  * one, adds the next line and tries again, which is how a string runs over
@@ -93,6 +99,7 @@ export function tokenizeLine(line, lineNumber, depth = 0) {
             tokens.push({ text, quoted: true });
             continue;
         }
+        const start = i;
         let text = '';
         while (i < line.length) {
             const c = line[i];
@@ -105,10 +112,37 @@ export function tokenizeLine(line, lineNumber, depth = 0) {
             text += c;
             i += 1;
         }
+        // `gap:tight` is `gap: tight` with no space, since how much whitespace there
+        // is never matters. A word straight after a key is its value and is left
+        // whole, so `icon: a:b` still names an icon called `a:b`. The rest of the
+        // word is read again from just past the colon rather than kept as one
+        // token, so `line:(color:red)` opens its bracket as `line: (color: red)` does.
+        const previous = tokens[tokens.length - 1];
+        const joined = previous && isAttrKey(previous) ? null : JOINED_KEY.exec(text);
+        if (joined) {
+            tokens.push({ text: joined[1], quoted: false, joined: text });
+            i = start + joined[1].length;
+            continue;
+        }
         tokens.push({ text, quoted: false });
     }
     return tokens;
 }
+/**
+ * The character in a word that a name may not hold, if any. A colon makes the
+ * word a key, written with or without its space, and `;` is kept free so it
+ * could one day separate clauses without changing what any file means.
+ */
+export function nameMark(token) {
+    const written = token.joined ?? token.text;
+    if (token.quoted)
+        return undefined;
+    if (written.includes(':'))
+        return ':';
+    if (written.includes(';'))
+        return ';';
+    return undefined;
+}
 /** A bare token ending in `:` opens the attribute section of a statement. */
 export function isAttrKey(token) {
     return !token.quoted && token.text.length > 1 && token.text.endsWith(':');

package/dist/lines.d.ts

@@ -0,0 +1,96 @@
+import type { Layout, LayoutEdge, LayoutNode } from './model.js';
+export interface Point {
+    x: number;
+    y: number;
+}
+/** A rectangle as drawn: the node's face, which differs from its box only for a deck. */
+export interface Face {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** A circle is drawn in this square, so a line meets the circle. */
+    round: boolean;
+}
+export type Side = 'top' | 'bottom' | 'left' | 'right';
+/** One piece of a drawn line, from where the last one ended: straight, or a cubic. */
+export type Piece = {
+    to: Point;
+} | {
+    c1: Point;
+    c2: Point;
+    to: Point;
+};
+/** One line, worked out. */
+export interface Route {
+    edge: LayoutEdge;
+    /** Where the line starts; each piece runs on from the end of the one before. */
+    start: Point;
+    pieces: Piece[];
+    /**
+     * The line's corners, ends included: two points for a straight line, the
+     * square route's corners for a square one, and for a curved one the points
+     * the curve passes through.
+     */
+    points: Point[];
+    /** Each named leg, as drawn, in the direction the line travels. */
+    legs: Map<string, Point[]>;
+    /** Each stop the line passes, as written, and the points it put on the line: `req b top` finds its run here (4.6). */
+    stops: {
+        written: string;
+        points: Point[];
+    }[];
+    /**
+     * Pieces not drawn, as [first, past the last]: a member's way along a
+     * collapsed bundle, which the bus draws once (6.6). The line still travels
+     * there, so the trace and every finding include them.
+     */
+    hidden?: [number, number][];
+}
+/** Where every line in the layout goes. */
+export declare function planLines(layout: Layout): Map<LayoutEdge, Route>;
+/** The ends sharing one side of one box, in their order along it. */
+export interface SideEnds {
+    node: LayoutNode;
+    side: Side;
+    /** Where each end landed, in order along the side, the line it belongs to, and which of the line's ends it is. */
+    ends: {
+        at: Point;
+        edge: LayoutEdge;
+        which: 'from' | 'to';
+    }[];
+}
+/** Every line, and every side two or more ends share, for the findings to measure. */
+export declare function planSides(layout: Layout): {
+    routes: Map<LayoutEdge, Route>;
+    sides: SideEnds[];
+};
+/** The drawn rectangle of a node. */
+export declare function faceOfNode(node: LayoutNode): Face;
+/** The point a share of the way along a polyline, bends included, or its start or end. */
+export declare function alongLength(trace: Point[], at: number | 'start' | 'end'): Point;
+export declare function centerOf(face: Face): Point;
+/** The points with repeats and points in line with both neighbors dropped. */
+export declare function tidyCorners(points: Point[]): Point[];
+/** The line as drawn, as a polyline: curves flattened, everything else its own points. */
+export declare function traceRoute(route: Route): Point[];
+/** A line's pieces with those along a collapsed bundle left out, as the runs either side of each. */
+export declare function visibleRuns(route: Route): {
+    start: Point;
+    pieces: Route['pieces'];
+}[];
+/** The line as drawn, as polylines: its trace with any stretch along a collapsed bundle left out. */
+export declare function traceVisible(route: Route): Point[][];
+/**
+ * Where two drawn lines cross, with the way each runs there. Lines that only
+ * touch or run together don't cross, and nor do two lines nearer than `clear`
+ * to an end of either: that is two lines meeting at a box, not passing each
+ * other. The renderer jumps these and the `edge-crossings` finding counts
+ * them, so the two agree.
+ */
+export declare function crossingPoints(a: Point[], b: Point[], clear: number): {
+    at: Point;
+    along: Point;
+    other: Point;
+}[];
+export declare function describeEdge(edge: LayoutEdge): string;