reladraw 0.4.0 → 0.6.0

package/dist/parser.js

@@ -1,6 +1,7 @@
-import { COLOR_KEYS, DIAGRAM_KEYS, DIRECTIONS, describePlacement, SIDE_AXIS, SIDES, PASSAGE_AXES, TEXT_KEYS, CONTENTS_KEYS, PLACEMENT_KEYS, BOUNDARY_PARTS, INWARD, OPPOSITE, isDirection, isPart, isPosition, listTargets, nameTarget, } from './ast.js';
+import { COLOR_KEYS, DEFAULT_KEYS, DEFAULT_TARGETS, DIAGRAM_KEYS, DIRECTIONS, describePlacement, SIDE_AXIS, SIDES, PASSAGE_AXES, TEXT_KEYS, CONTENTS_KEYS, PLACEMENT_KEYS, BOUNDARY_PARTS, INWARD, OPPOSITE, isDirection, isPart, isPosition, listTargets, nameTarget, } from './ast.js';
 import { SourceError } from './errors.js';
 import { isAttrKey, tokenizeLine } from './lexer.js';
+import { THEME_NAMES, THEMES } from './themes.js';
 /** Parse a whole source file. One statement per line; blanks and comments drop out. */
 export function parse(source) {
     const statements = [];
@@ -27,6 +28,8 @@ function parseStatement(tokens, line) {
             return parseStyle(tokens, line);
         case 'diagram':
             return parseDiagram(tokens, line);
+        case 'default':
+            return parseDefault(tokens, line);
         default:
             throw new SourceError(substitution(keyword.text, tokens), line);
     }
@@ -458,9 +461,26 @@ function parseEdge(head, line) {
         between = { targets: read.targets, ...(axis !== undefined ? { axis } : {}) };
         return next;
     });
-    if (tail.placements.length > 0) {
-        throw new SourceError(`${subject}: "${describePlacement(tail.placements[0])}" places a node, and an edge is not ` +
-            'placed — it joins two things that are', line);
+    // An edge is not placed, so a direction on its line says which side of that
+    // node the line passes. The other placements say where a thing *is*, and
+    // have no reading for a line.
+    const passes = [];
+    for (const placement of tail.placements) {
+        const written = describePlacement(placement);
+        if (placement.kind !== 'offset' || placement.written !== undefined) {
+            throw new SourceError(`${subject}: "${written}" places a node, and an edge is not placed — it joins two things ` +
+                'that are. On an edge, above, below, left of and right of say which side of a node the ' +
+                'line passes', line);
+        }
+        if (placement.gap !== undefined) {
+            throw new SourceError(`${subject}: "${written}" gives a gap, and a gap is kept between nodes — the line passes ` +
+                'as close as it reads clearly. Drop the brackets', line);
+        }
+        passes.push(placement);
+    }
+    if (passes.length > 0 && between) {
+        throw new SourceError(`${subject}: "between" and "${describePlacement(passes[0])}" on one edge — an edge passing ` +
+            'between two things already has a side of each, so say one or the other', line);
     }
     refuseTextKey(tail.attrs, subject, 'after the arrow', line);
     return {
@@ -471,6 +491,7 @@ function parseEdge(head, line) {
         both: arrow.text === '<->',
         ...(textToken ? { text: textToken.text } : {}),
         ...(between ? { between } : {}),
+        ...(passes.length > 0 ? { passes } : {}),
         attrs: tail.attrs,
         line,
     };
@@ -502,12 +523,80 @@ function parseDiagram(head, line) {
         throw new SourceError('diagram sets nothing', line);
     }
     for (const key of Object.keys(attrs)) {
+        if (key.startsWith('text.')) {
+            // The theme has one text color, shared by everything, and that is all
+            // the diagram's text sets. A size or a wrap is about one kind of text.
+            if (key !== 'text.color') {
+                const inner = key.slice('text.'.length);
+                throw new SourceError(`diagram text: sets only a color — \`${inner}\` is about one kind of text, so write ` +
+                    `\`text: (${inner}: ${attrs[key]})\` on a \`default node\` or \`default edge\``, line);
+            }
+            continue;
+        }
         if (!DIAGRAM_KEYS.includes(key)) {
             throw new SourceError(`diagram has no "${key}" — it takes ${DIAGRAM_KEYS.join(', ')}`, line);
         }
     }
+    if (attrs['text'] !== undefined) {
+        throw new SourceError('diagram text: takes a bracket — `text: (color: #e0e0e0)`', line);
+    }
+    const theme = attrs['theme'];
+    if (theme !== undefined && THEMES[theme] === undefined) {
+        throw new SourceError(`there is no theme called "${theme}" — the themes are ${THEME_NAMES.join(', ')}`, line);
+    }
     return { kind: 'diagram', attrs, line };
 }
+/**
+ * `default <node | leaf | container | edge> <attributes>` — a style every thing
+ * of that kind wears without naming it. It is strict about kind where a style
+ * is permissive, because it names the kind it is for: a word that kind has no
+ * use for can only be a mistake.
+ */
+function parseDefault(head, line) {
+    const target = head[1];
+    if (!target || target.quoted || !DEFAULT_TARGETS.includes(target.text)) {
+        throw new SourceError(`default needs the kind it is for — ${DEFAULT_TARGETS.join(', ')}` +
+            (target && !isAttrKey(target) ? `, not "${target.text}"` : ''), line);
+    }
+    const kind = target.text;
+    const subject = `default ${kind}`;
+    // `default leaf node` reads naturally and says nothing `default leaf` does not.
+    const extra = head[2];
+    if (extra && !extra.quoted && !isAttrKey(extra) && extra.text === 'node' && kind !== 'node') {
+        throw new SourceError(`write \`default ${kind}\` — a ${kind} is already a node`, line);
+    }
+    const attrs = attrsOnly(head, 2, line, subject);
+    if (Object.keys(attrs).length === 0) {
+        throw new SourceError(`${subject} sets nothing`, line);
+    }
+    const allowed = DEFAULT_KEYS[kind];
+    for (const key of new Set(Object.keys(attrs).map((k) => k.split('.')[0]))) {
+        if (allowed.includes(key))
+            continue;
+        throw new SourceError(`${subject} has ${key}:, ${defaultRefusal(kind, key)}`, line);
+    }
+    return { kind: 'default', target: kind, attrs, line };
+}
+/** Why a default cannot carry a word, and what to write instead. */
+function defaultRefusal(kind, key) {
+    const takes = `it takes ${DEFAULT_KEYS[kind].map((k) => `${k}:`).join(', ')}`;
+    if (key === 'url')
+        return `and a destination belongs to one thing rather than to every one of a kind`;
+    if (key === 'badge') {
+        return 'and a badge is a child, so every leaf given one would become a container. ' +
+            'Put the badge in a style, or write `default container  badge:`';
+    }
+    if (key === 'icon') {
+        return 'and a picture cannot hold children, so an icon is a leaf\'s word — write `default leaf  icon:`';
+    }
+    if (kind === 'edge' && (key === 'fill' || key === 'border')) {
+        return `which an edge does not have — an edge is colored by line: and text: (color: …)`;
+    }
+    if (kind !== 'edge' && key === 'line') {
+        return `which is an edge's — a node is colored by fill:, border: and text: (color: …)`;
+    }
+    return `which a default does not set — ${takes}`;
+}
 function requireName(token, keyword, line) {
     if (!token || token.quoted) {
         throw new SourceError(`${keyword} needs a name`, line);

package/dist/render.d.ts

@@ -1,31 +1,10 @@
 import { type Measurer } from './measure.js';
 import type { Layout } from './model.js';
+import { type Theme } from './themes.js';
 export interface RenderOptions {
     measurer?: Measurer;
     fontSize?: number;
     theme?: Theme;
 }
-export interface Theme {
-    background: string;
-    boxFill: string;
-    boxStroke: string;
-    containerFill: string;
-    /** A container is a region rather than a thing, so its outline is quieter. */
-    containerStroke: string;
-    text: string;
-    mutedText: string;
-    edge: string;
-    /** An icon's drawn line. */
-    iconInk: string;
-    /** The body an icon's lines enclose. */
-    iconShade: string;
-}
-/**
- * Sampled out of `examples/reference/arch.png` rather than invented,
- * so the benchmark render and the drawing it is measured against differ by
- * geometry and typography alone. A container is a shade off the page and barely
- * outlined; a leaf is the navy that carries the diagram's weight.
- */
-export declare const DARK_THEME: Theme;
 /** Turn solved geometry into a standalone SVG document. */
 export declare function render(layout: Layout, options?: RenderOptions): string;