reladraw 0.18.0 → 0.19.1

package/dist/parser.d.ts

@@ -1,5 +1,27 @@
 import type { Document } from './ast.js';
 import { SourceError } from './errors.js';
+import { type Token } from './lexer.js';
+/**
+ * One statement as `parse` gathered it, before reading: the line it starts on,
+ * and each of its lines with that line's tokens. A comment-only line inside it
+ * has no tokens and is not listed.
+ */
+export interface Gathered {
+    line: number;
+    lines: {
+        line: number;
+        tokens: Token[];
+    }[];
+}
+/**
+ * Parse a source for the formatter: each statement as gathered, and the first
+ * token of each clause read. Throws as `parse` does, so a file that does not
+ * parse is never rewritten.
+ */
+export declare function clausesOf(source: string): {
+    statements: Gathered[];
+    starts: Set<Token>;
+};
 /**
  * Parse a whole source file. A statement starts on an unindented line and runs
  * on through any line that starts with whitespace; a blank line or the next
@@ -15,7 +37,7 @@ import { SourceError } from './errors.js';
  * are its own, blank or not, and a line opening with one continues the
  * statement above without being indented.
  */
-export declare function parse(source: string): Document;
+export declare function parse(source: string, seen?: (statement: Gathered) => void): Document;
 /**
  * Find the line at fault for an error reported on the first line of a
  * continued statement. Everything after the parser reports a statement by the
@@ -30,3 +52,5 @@ export declare function parse(source: string): Document;
  * This costs a few extra runs, and only when there is an error to report.
  */
 export declare function blame(source: string, error: SourceError, run: (source: string) => unknown): SourceError;
+/** Whether a token is an arrow, or begins one: a bracketed mark, or a run of dashes with marks at its ends. */
+export declare function looksLikeArrow(token: Token): boolean;

package/dist/parser.js

@@ -9,6 +9,30 @@ import { checkOpacity } from './place.js';
 const SHAPE_FLAGS = [...new Set(Object.values(SHAPE_SETTINGS).flatMap((one) => Object.entries(one).filter(([, kind]) => kind === 'flag').map(([name]) => name)))];
 import { readSize, SIZE_KEYS, writeSize } from './size.js';
 import { THEME_COLORS, THEME_NAMES, THEMES } from './themes.js';
+/**
+ * Set while `clausesOf` runs: the first token of every clause the parser
+ * reads, so the formatter can tell where one clause ends and the next begins
+ * without a second grammar of its own. Clauses inside brackets are recorded
+ * too, and the formatter passes over them.
+ */
+let clauseStarts = null;
+/**
+ * Parse a source for the formatter: each statement as gathered, and the first
+ * token of each clause read. Throws as `parse` does, so a file that does not
+ * parse is never rewritten.
+ */
+export function clausesOf(source) {
+    const statements = [];
+    const starts = new Set();
+    clauseStarts = starts;
+    try {
+        parse(source, (statement) => statements.push(statement));
+    }
+    finally {
+        clauseStarts = null;
+    }
+    return { statements, starts };
+}
 /**
  * Parse a whole source file. A statement starts on an unindented line and runs
  * on through any line that starts with whitespace; a blank line or the next
@@ -24,16 +48,18 @@ import { THEME_COLORS, THEME_NAMES, THEMES } from './themes.js';
  * are its own, blank or not, and a line opening with one continues the
  * statement above without being indented.
  */
-export function parse(source) {
+export function parse(source, seen) {
     const statements = [];
-    /** The statement being gathered, and the line it starts on. */
+    /** The statement being gathered, the line it starts on, and its lines' tokens. */
     let open = null;
     // Brackets may close on a later line, and the lexer only reads `)` as a
     // bracket while one is open, so the depth is carried from line to line.
     let depth = 0;
     const close = () => {
-        if (open)
+        if (open) {
+            seen?.({ line: open.line, lines: open.lines });
             statements.push(parseStatement(open.tokens, open.line));
+        }
         open = null;
         depth = 0;
     };
@@ -74,7 +100,7 @@ export function parse(source) {
         if (tokens.length === 0)
             continue;
         if (!continues) {
-            open = { tokens, line: lineNumber };
+            open = { tokens: [...tokens], line: lineNumber, lines: [{ line: lineNumber, tokens }] };
         }
         else {
             const first = tokens[0];
@@ -90,6 +116,7 @@ export function parse(source) {
                     `the one before it, so remove the indentation to start a new statement`, lineNumber);
             }
             open.tokens.push(...tokens);
+            open.lines.push({ line: lineNumber, tokens });
         }
         for (const token of tokens) {
             if (token.quoted)
@@ -256,6 +283,7 @@ function parseTail(tokens, start, line, subject, other) {
     let i = start;
     while (i < tokens.length) {
         const token = tokens[i];
+        clauseStarts?.add(token);
         if (isAttrKey(token)) {
             i = readAttr(tokens, i, attrs, line, subject);
             continue;
@@ -324,6 +352,7 @@ function setOnce(attrs, key, value, subject, line, shown = { key, value: (v) =>
 /** Read one `key: value` pair, and refuse the words that used to be keys. */
 function readAttr(tokens, at, attrs, line, subject) {
     const keyToken = tokens[at];
+    clauseStarts?.add(keyToken);
     const key = keyToken.text.slice(0, -1);
     if (key === 'gap') {
         throw new SourceError(`${subject}: a node has no gap:, only a placement does — write it in the placement's bracket, ` +
@@ -1511,7 +1540,7 @@ function eachChildAt(head) {
     return found;
 }
 /** Whether a token is an arrow, or begins one: a bracketed mark, or a run of dashes with marks at its ends. */
-function looksLikeArrow(token) {
+export function looksLikeArrow(token) {
     if (token.quoted)
         return false;
     if (token.text === '(' || /^\[[^\]]*\]-*$/.test(token.text))
@@ -1758,6 +1787,7 @@ function parsePoint(head, line) {
     if (!head[start] || isAttrKey(head[start])) {
         throw new SourceError(`${subject} says where it is, such as \`point ${name}  between a and b\``, line);
     }
+    clauseStarts?.add(head[start]);
     const read = readOneTarget(head, start, subject, line, true);
     if (read.listed)
         throw new SourceError(`${subject} is one point, so it takes no list`, line);
@@ -1776,6 +1806,7 @@ function parseRegion(head, line) {
     if (!head[start] || isAttrKey(head[start])) {
         throw new SourceError(`${subject} says what it covers: two corners, \`region ${name}  a top-left to b bottom-right\`, or \`region ${name}  between a and b\``, line);
     }
+    clauseStarts?.add(head[start]);
     const first = readOneTarget(head, start, subject, line, true);
     if (first.listed)
         throw new SourceError(`${subject}: a region runs from one point to another, written with "to", not a list`, line);
@@ -1988,8 +2019,12 @@ function refuseNameMark(token, where, line) {
  * helps and never demanded. Shorthands added later extend this without
  * disturbing what it already reads.
  */
-function readPlacement(tokens, at, line, subject) {
+function readPlacement(tokens, at, line, subject, nested = false) {
     const word = tokens[at];
+    // A placement read after its own distance or part (`6 above x`) is still
+    // the clause that word began, so only the outermost read starts one.
+    if (!nested)
+        clauseStarts?.add(word);
     if (word.quoted) {
         throw new SourceError(`${subject}: unexpected text "${word.text}"`, line);
     }
@@ -1998,7 +2033,7 @@ function readPlacement(tokens, at, line, subject) {
     // the distance is required.
     if (!word.quoted && isPart(word.text) && !follows(tokens, at + 1, 'of') && !follows(tokens, at + 1, 'even')) {
         if (opensPartPlacement(tokens, at)) {
-            const read = readPlacement(tokens, at + 1, line, subject);
+            const read = readPlacement(tokens, at + 1, line, subject, true);
             if (read.placement.kind !== 'offset')
                 return read;
             return { placement: { ...read.placement, own: word.text }, next: read.next };
@@ -2031,7 +2066,7 @@ function readPlacement(tokens, at, line, subject) {
                 throw new SourceError(`${subject}: "${word.text} ${first} and ${other.text} ${second}" gives two distances, one for each axis, ` +
                     'so one direction is above or below and the other left or right', line);
             }
-            const read = readPlacement(tokens, at + 3, line, subject);
+            const read = readPlacement(tokens, at + 3, line, subject, true);
             if (read.placement.kind !== 'offset')
                 return read;
             const y = vertical(first) ? first : second;
@@ -2043,7 +2078,7 @@ function readPlacement(tokens, at, line, subject) {
                 next: read.next,
             };
         }
-        const read = readPlacement(tokens, at + 1, line, subject);
+        const read = readPlacement(tokens, at + 1, line, subject, true);
         if (read.placement.kind !== 'offset')
             return read;
         if (read.placement.gap !== undefined) {

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