@hncode/hncode 0.5.6 → 0.6.1

package/src/mermaid/diagrams/state.js

@@ -0,0 +1,292 @@
+/**
+ * `stateDiagram` / `stateDiagram-v2`: states, transitions, descriptions and
+ * composite states. Lenient: an unreadable statement is dropped and recorded
+ * in `warnings`.
+ *
+ * A composite (`state X { ... }`) becomes a `Group`, drawn as a titled frame
+ * by the same machinery flowchart subgraphs use; `--` splits a composite into
+ * unlabelled sibling region groups. `[*]` is scoped per group, so an inner
+ * start dot is a different node from the outer one.
+ */
+import { Graph, MAX_GROUP_DEPTH, MAX_GROUPS, parseDir } from '../graph.js';
+import { asciiLower, decodeHtmlEntities } from '../labels.js';
+import { layoutFlowchart, layoutGrouped } from '../layout.js';
+import { firstWord, headerKind, nonEmpty, parseClassAssign, parseClassDef, splitColon, splitOnce, statementsOf, takeTags, words, } from '../statements.js';
+export const state = {
+    kind: 'state',
+    headers: ['statediagram', 'statediagram-v2'],
+    render(src) {
+        const graph = parseState(src);
+        if (graph === null)
+            return null;
+        const canvas = graph.groups.length === 0 ? layoutFlowchart(graph) : layoutGrouped(graph);
+        if (canvas === null)
+            return null;
+        return { canvas, warnings: graph.warnings, classDefs: graph.classDefs };
+    },
+};
+export function parseState(src) {
+    const statements = statementsOf(src);
+    const kind = headerKind(statements);
+    if (kind === null || !state.headers.includes(kind))
+        return null;
+    const graph = new Graph();
+    let inNote = false;
+    /** `class A,B name` assignments, applied after the walk. */
+    const classAssignments = [];
+    /** Open composites: the group itself and its current `--` region, if any. */
+    const stack = [];
+    /** New group under the current scope, or `null` once a cap is hit. */
+    const newGroup = (id, label) => {
+        if (graph.groups.length >= MAX_GROUPS || stack.length >= MAX_GROUP_DEPTH) {
+            graph.truncated ??= `subgraph cap (${MAX_GROUPS} groups, depth ${MAX_GROUP_DEPTH}) reached`;
+            return null;
+        }
+        graph.groups.push({ id, label, parent: graph.curGroup });
+        return graph.groups.length - 1;
+    };
+    const scopeOf = () => {
+        const top = stack.at(-1);
+        return top === undefined ? null : (top.region ?? top.base);
+    };
+    for (const st of statements.slice(1)) {
+        if (inNote) {
+            if (asciiLower(st) === 'end note')
+                inNote = false;
+            continue;
+        }
+        const first = asciiLower(firstWord(st));
+        if (first === 'direction') {
+            graph.dir = parseDir(words(st)[1] ?? '');
+        }
+        else if (first === 'note') {
+            // A single-line `note ... : text` needs no terminator.
+            if (!st.includes(':'))
+                inNote = true;
+        }
+        else if (first === 'state') {
+            const rest = st.slice(firstWord(st).length).trim();
+            const open = rest.endsWith('{');
+            const body = open ? rest.slice(0, -1).trim() : rest;
+            if (!open) {
+                if (parseStateDecl(body, graph) === null)
+                    graph.drop(st);
+            }
+            else {
+                // A composite. An unreadable declaration still opens an anonymous
+                // frame: the `{` was consumed, so the `}` balance must hold.
+                const named = compositeName(body);
+                if (named === null)
+                    graph.drop(st);
+                const gi = newGroup(named?.id ?? `anon ${graph.groups.length}`, named?.label ?? '');
+                if (gi !== null) {
+                    stack.push({ base: gi, region: null });
+                    graph.curGroup = gi;
+                }
+            }
+        }
+        else if (first === '}') {
+            stack.pop();
+            graph.curGroup = scopeOf();
+        }
+        else if (first === '--') {
+            // Region divider: members so far move into region 1 on the first `--`;
+            // each divider opens the next unlabelled sibling region.
+            const top = stack.at(-1);
+            if (top !== undefined) {
+                if (top.region === null) {
+                    const r1 = newGroup(`region ${graph.groups.length}`, '');
+                    if (r1 !== null) {
+                        graph.nodeGroup.forEach((g, i) => {
+                            if (g === top.base)
+                                graph.nodeGroup[i] = r1;
+                        });
+                        graph.groups.forEach((g, i) => {
+                            if (i !== r1 && g.parent === top.base)
+                                g.parent = r1;
+                        });
+                    }
+                }
+                graph.curGroup = top.base;
+                const next = newGroup(`region ${graph.groups.length}`, '');
+                top.region = next;
+                graph.curGroup = next ?? top.base;
+            }
+        }
+        else if (first === 'classdef') {
+            const def = parseClassDef(st.slice(firstWord(st).length));
+            if (def)
+                for (const name of def.names)
+                    graph.classDefs[name] = def.props;
+        }
+        else if (first === 'class') {
+            const assign = parseClassAssign(st.slice(firstWord(st).length));
+            if (assign)
+                classAssignments.push(assign);
+        }
+        else if (['hide', 'scale'].includes(first)) {
+            // Styling directives carry no layout meaning.
+        }
+        else if (st.includes('-->')) {
+            if (parseTransition(st, graph) === null)
+                graph.drop(st);
+        }
+        else if (parseStateDesc(st, graph) === null) {
+            graph.drop(st);
+        }
+        if (graph.truncated !== null) {
+            graph.warnings.push(`diagram truncated: ${graph.truncated}`);
+            break;
+        }
+    }
+    graph.applyClasses(classAssignments);
+    return graph.nodes.length === 0 ? null : graph;
+}
+/** The id and label of a composite declaration body, or `null`. */
+function compositeName(body) {
+    if (body.startsWith('"')) {
+        const close = body.indexOf('"', 1);
+        if (close === -1)
+            return null;
+        const label = decodeHtmlEntities(body.slice(1, close));
+        const after = body.slice(close + 1).trim();
+        // A `:::` tag on a composite is dropped: groups paint no classed cells.
+        const id = takeTags(after.startsWith('as') ? after.slice(2).trim() : label).id;
+        return id === '' ? null : { id, label };
+    }
+    // A stereotype on a composite carries no drawing of its own; keep the name.
+    const id = takeTags(body.split('<<')[0].trim()).id;
+    return id === '' || /\s/.test(id) ? null : { id, label: id };
+}
+/** `state "Label" as id` or `state id <<choice>>` — the non-composite forms. */
+function parseStateDecl(rest, graph) {
+    if (rest === '')
+        return true;
+    if (rest.startsWith('"')) {
+        const close = rest.indexOf('"', 1);
+        if (close === -1)
+            return null;
+        const label = rest.slice(1, close);
+        const after = rest.slice(close + 1).trim();
+        const { id, classes } = takeTags(after.startsWith('as') ? after.slice(2).trim() : label);
+        const idx = graph.nodeLabel(id, decodeHtmlEntities(label));
+        if (idx === null)
+            return null;
+        for (const cls of classes)
+            graph.addClass(idx, cls);
+        return true;
+    }
+    let shape = 'round';
+    let token = rest;
+    let stereotyped = false;
+    const pos = rest.indexOf('<<');
+    if (pos !== -1) {
+        const stereo = rest
+            .slice(pos + 2)
+            .replace(/>>$/, '')
+            .trim();
+        if (stereo === 'choice')
+            shape = 'diamond';
+        token = rest.slice(0, pos).trim();
+        stereotyped = true;
+    }
+    const { id, classes } = takeTags(token);
+    if (id === '' || /\s/.test(id))
+        return null;
+    const idx = graph.nodeIndex(id, stereotyped ? id : null, shape);
+    if (idx === null)
+        return null;
+    for (const cls of classes)
+        graph.addClass(idx, cls);
+    return true;
+}
+/** `A --> B: label`, including chains `A --> B --> C`. */
+function parseTransition(st, graph) {
+    let rest = st;
+    let prev = null;
+    for (;;) {
+        const split = splitOnce(rest, '-->');
+        if (!split)
+            break;
+        const [lhs, rhs] = split;
+        const fromTok = takeTags(lhs.trimEnd().replace(/-+$/, '').trim());
+        let from;
+        if (prev !== null) {
+            // Mid-chain: the source is the previous target, so nothing may precede.
+            if (fromTok.id !== '')
+                return null;
+            from = prev;
+        }
+        else {
+            if (fromTok.id === '')
+                return null;
+            const f = stateEndpoint(graph, fromTok.id, true);
+            if (f === null)
+                return null;
+            for (const cls of fromTok.classes)
+                graph.addClass(f, cls);
+            from = f;
+        }
+        // After the label colon it is all label — mermaid never chains past a
+        // label, so an arrow inside one (`: go "x --> y"`) is text, not a link.
+        const nextArrow = rhs.indexOf('-->');
+        const colon = splitColon(rhs);
+        const labelFirst = colon !== null && (nextArrow === -1 || colon[0].length < nextArrow);
+        const toPart = labelFirst ? colon[0] : nextArrow === -1 ? rhs : rhs.slice(0, nextArrow);
+        const label = labelFirst ? nonEmpty(decodeHtmlEntities(colon[1].trim())) : null;
+        const tail = labelFirst || nextArrow === -1 ? '' : rhs.slice(nextArrow);
+        const toTok = takeTags(toPart.trimStart().replace(/^>+/, '').trimEnd().replace(/-+$/, '').trim());
+        if (toTok.id === '')
+            return null;
+        const to = stateEndpoint(graph, toTok.id, false);
+        if (to === null)
+            return null;
+        for (const cls of toTok.classes)
+            graph.addClass(to, cls);
+        if (!graph.pushEdge({ from, to, label, headTo: 'arrow', headFrom: 'none', line: 'solid' })) {
+            return true;
+        }
+        prev = to;
+        rest = tail;
+    }
+    return true;
+}
+/**
+ * `[*]` is start or end depending on which side of the arrow it sits, and is
+ * scoped to the enclosing composite — each frame has its own start and end.
+ */
+function stateEndpoint(graph, id, isSource) {
+    if (id === '[*]') {
+        const scope = graph.curGroup === null ? '' : ` g${graph.curGroup}`;
+        return graph.nodeIndex(`[*]${isSource ? 'start' : 'end'}${scope}`, '●', 'round');
+    }
+    return graph.nodeIndex(id, null, 'round');
+}
+/** `id: description`, or a bare state name; either may carry `:::` tags. */
+function parseStateDesc(st, graph) {
+    const split = splitColon(st);
+    const { id, classes } = takeTags((split ? split[0] : st).trim());
+    let idx;
+    if (split) {
+        const desc = split[1].trim();
+        if (id === '' || /\s/.test(id) || desc === '')
+            return null;
+        // Repeated descriptions accumulate (mermaid stacks them as lines; here
+        // they join and wrap). A bare node's label is its id — that one replaces.
+        const prev = graph.index.get(id);
+        const before = prev === undefined ? null : graph.nodes[prev].label;
+        const text = decodeHtmlEntities(desc);
+        idx = graph.nodeLabel(id, before !== null && before !== id ? `${before} ${text}` : text);
+    }
+    else {
+        if (id === '' || /\s/.test(id))
+            return null;
+        idx = graph.nodeIndex(id, null, 'round');
+    }
+    if (idx === null)
+        return null;
+    for (const cls of classes)
+        graph.addClass(idx, cls);
+    return true;
+}
+//# sourceMappingURL=state.js.map

package/src/mermaid/diagrams/timeline.js

@@ -0,0 +1,99 @@
+/**
+ * `timeline`: periods and their events as a vertical list — one row per
+ * event, the period named on its first row. Lenient: an unreadable statement
+ * is dropped and recorded in `warnings`.
+ */
+import { Canvas, drawText } from '../canvas.js';
+import { MAX_EDGES } from '../graph.js';
+import { decodeHtmlEntities, fitLabel, MAX_LABEL } from '../labels.js';
+import { headerKind, nonEmpty, statementsOf, words } from '../statements.js';
+import { stringWidth } from '../width.js';
+export const timeline = {
+    kind: 'timeline',
+    headers: ['timeline'],
+    render(src) {
+        const parsed = parseTimeline(src);
+        if (parsed === null)
+            return null;
+        const { title, rows, warnings } = parsed;
+        const periodW = Math.max(...rows.map((r) => (r.section ? 0 : stringWidth(r.period))));
+        const top = title === null ? 0 : 1;
+        const width = Math.max(title === null ? 0 : stringWidth(title) + 6, ...rows.map((r) => (r.section ? stringWidth(r.event) : periodW + 3 + stringWidth(r.event))));
+        const canvas = new Canvas(width, top + rows.length);
+        if (title !== null) {
+            const t = ` ${title} `;
+            const x = Math.max(0, Math.floor((width - stringWidth(t) - 4) / 2));
+            drawText(canvas, '──', x, 0, 'edge');
+            drawText(canvas, t, x + 2, 0, 'title');
+            drawText(canvas, '──', x + 2 + stringWidth(t), 0, 'edge');
+        }
+        rows.forEach((row, i) => {
+            const y = top + i;
+            if (row.section) {
+                drawText(canvas, row.event, 0, y, 'title');
+                return;
+            }
+            drawText(canvas, row.period, 0, y, 'text');
+            if (row.event === '')
+                return;
+            drawText(canvas, '─', periodW + 1, y, 'edge');
+            drawText(canvas, row.event, periodW + 3, y, 'edgeLabel');
+        });
+        return { canvas, warnings, classDefs: {} };
+    },
+};
+function parseTimeline(src) {
+    const statements = statementsOf(src);
+    if (headerKind(statements) !== 'timeline')
+        return null;
+    let title = null;
+    const rows = [];
+    const warnings = [];
+    let truncated = false;
+    let lastPeriod = false;
+    for (const st of statements.slice(1)) {
+        if (rows.length >= MAX_EDGES) {
+            truncated = true;
+            break;
+        }
+        const first = words(st)[0]?.toLowerCase();
+        if (first === 'title') {
+            title = nonEmpty(st.slice(st.toLowerCase().indexOf('title') + 5).trim());
+            continue;
+        }
+        if (first === 'section') {
+            const name = st.slice(st.toLowerCase().indexOf('section') + 7).trim();
+            rows.push({ period: '', event: clean(name), section: true });
+            lastPeriod = false;
+            continue;
+        }
+        // `period : event : event`; a statement of only `: event`s continues the
+        // previous period (the `;`-split form of mermaid's multi-line events).
+        const parts = st.split(':').map((p) => clean(p));
+        const period = parts.shift() ?? '';
+        if (period === '' && parts.length > 0 && lastPeriod) {
+            for (const event of parts)
+                rows.push({ period: '', event });
+            continue;
+        }
+        // A bare period renders event-less, as mermaid draws it.
+        if (period !== '' && parts.length === 0) {
+            rows.push({ period, event: '' });
+            lastPeriod = true;
+            continue;
+        }
+        if (period === '' || parts.some((p) => p === '')) {
+            warnings.push(`dropped, unreadable statement: "${st}"`);
+            continue;
+        }
+        parts.forEach((event, i) => {
+            rows.push({ period: i === 0 ? period : '', event });
+        });
+        lastPeriod = true;
+    }
+    if (truncated)
+        warnings.push(`diagram truncated: event cap (${MAX_EDGES}) reached`);
+    return rows.length === 0 ? null : { title, rows, warnings };
+}
+const clean = (s) => fitLabel(decodeHtmlEntities(s.trim()), MAX_LABEL);
+//# sourceMappingURL=timeline.js.map

package/src/mermaid/graph.js

@@ -0,0 +1,138 @@
+/**
+ * The shared diagram model. Flowchart, state, class and ER sources all parse
+ * into a `Graph`; only sequence diagrams have their own model.
+ */
+import { asciiUpper } from './labels.js';
+/** Caps that keep layout bounded; exceeding one drops the diagram to fallback. */
+export const MAX_NODES = 128;
+export const MAX_EDGES = 512;
+export const MAX_GROUPS = 24;
+export const MAX_GROUP_DEPTH = 6;
+/** Class members / ER attributes listed per box before eliding with `…`. */
+export const MAX_MEMBERS = 8;
+/** `LR`/`RL`/`BT` as written in a header or `direction` statement; else `down`. */
+export function parseDir(token) {
+    switch (asciiUpper(token)) {
+        case 'LR':
+            return 'right';
+        case 'RL':
+            return 'left';
+        case 'BT':
+            return 'up';
+        default:
+            return 'down';
+    }
+}
+export class Graph {
+    nodes = [];
+    edges = [];
+    index = new Map();
+    groups = [];
+    /** Innermost subgraph each node was declared in, parallel to `nodes`. */
+    nodeGroup = [];
+    curGroup = null;
+    /**
+     * Set when a size cap was hit, naming the cap. The parser stops consuming
+     * statements and renders the prefix, warning about the truncation — a
+     * streamed diagram that outgrows a cap can never shrink back under it, so
+     * a stable truncated render beats flipping to the source box for good.
+     */
+    truncated = null;
+    /**
+     * Source the grammar could not read and dropped. Parsing is lenient in
+     * every grammar: a statement either contributes what parsed or is dropped
+     * and recorded here, so the reader can tell a clean diagram from one that
+     * is missing something they wrote.
+     */
+    warnings = [];
+    /** Parsed `classDef` declarations: name -> property map. */
+    classDefs = {};
+    dir = 'down';
+    constructor(dir = 'down') {
+        this.dir = dir;
+    }
+    /**
+     * Index of `id`, creating the node if new. A later declaration carrying a
+     * label overwrites the placeholder one an edge created. Returns `null` once
+     * `MAX_NODES` is reached, which truncates the parse.
+     */
+    nodeIndex(id, label, shape) {
+        const existing = this.index.get(id);
+        if (existing !== undefined) {
+            if (label !== null) {
+                this.nodes[existing].label = label;
+                this.nodes[existing].shape = shape;
+            }
+            return existing;
+        }
+        if (this.nodes.length >= MAX_NODES) {
+            this.truncated ??= `node cap (${MAX_NODES}) reached`;
+            return null;
+        }
+        this.index.set(id, this.nodes.length);
+        this.nodes.push({ label: label ?? id, shape });
+        this.nodeGroup.push(this.curGroup);
+        return this.nodes.length - 1;
+    }
+    /** Set a node's label without disturbing its shape, creating it if new. */
+    nodeLabel(id, label) {
+        const existing = this.index.get(id);
+        if (existing !== undefined) {
+            this.nodes[existing].label = label;
+            return existing;
+        }
+        return this.nodeIndex(id, label, 'round');
+    }
+    /** Attach an author class name to a node, ignoring a repeat. */
+    addClass(idx, name) {
+        const node = this.nodes[idx];
+        node.classes ??= [];
+        if (!node.classes.includes(name))
+            node.classes.push(name);
+    }
+    /**
+     * Apply collected `[ids, names]` class assignments. Run after the statement
+     * walk so a `class A,B name` (or `:::` tag) may precede the nodes it names;
+     * unknown ids are ignored.
+     */
+    applyClasses(assignments) {
+        for (const [ids, names] of assignments) {
+            for (const id of ids) {
+                const idx = this.index.get(id.trim());
+                if (idx === undefined)
+                    continue;
+                for (const name of names) {
+                    if (name.trim() !== '')
+                        this.addClass(idx, name.trim());
+                }
+            }
+        }
+    }
+    /** Apply `[id, url]` link targets; the last one per id wins, unknown ids
+     * are ignored. Deferred like `applyClasses`, for the same ordering reason. */
+    applyHrefs(hrefs) {
+        for (const [id, url] of hrefs) {
+            const idx = this.index.get(id.trim());
+            if (idx !== undefined)
+                this.nodes[idx].href = url;
+        }
+    }
+    /**
+     * Record an unreadable statement; the diagram renders without it. Skipped
+     * once truncated — a cap-caused parse failure is not the statement's fault.
+     */
+    drop(st) {
+        if (this.truncated === null)
+            this.warnings.push(`dropped, unreadable statement: "${st}"`);
+    }
+    /** Append an edge, or flag `truncated` when `MAX_EDGES` is reached. */
+    pushEdge(edge) {
+        if (this.edges.length >= MAX_EDGES) {
+            this.truncated ??= `edge cap (${MAX_EDGES}) reached`;
+            return false;
+        }
+        this.edges.push(edge);
+        return true;
+    }
+}
+//# sourceMappingURL=graph.js.map

package/src/mermaid/index.js

@@ -0,0 +1,59 @@
+import { stripControls } from './labels.js';
+import { diagramFor } from './registry.js';
+import { frontmatterTitle } from './statements.js';
+import { stringWidth } from './width.js';
+export { classSgr, DEFAULT_THEME, toAnsi } from './ansi.js';
+export { contrastOn, resolveClassStyle } from './class-style.js';
+export { diagramKind } from './registry.js';
+export { sourceBox } from './source-box.js';
+/**
+ * Render a Mermaid source block as Unicode box-drawing art.
+ *
+ * Supported: `graph`/`flowchart` (including `subgraph`), `stateDiagram`,
+ * `classDiagram`, `erDiagram`, `sequenceDiagram`, `pie`, `mindmap`,
+ * `timeline` and `gitGraph`.
+ *
+ * The diagram is laid out at whatever size it needs; `art.width` reports the
+ * columns that turned out to be. Deciding what to do when that exceeds the
+ * space at hand is the caller's — `sourceBox` is the usual answer:
+ *
+ * ```ts
+ * const art = render(src)
+ * show(art && art.width <= cols ? art : sourceBox(src, cols))
+ * ```
+ *
+ * `null` means there is no art to show: blank input, a diagram type this
+ * renderer does not draw, a source in which not one statement parsed, or a
+ * diagram large enough that laying it out is refused. `diagramKind` separates
+ * the middle two.
+ *
+ * Rendering is best-effort in every grammar: a statement either contributes
+ * what parsed or is dropped, and a diagram over a size cap renders its prefix.
+ * Everything given up on is listed in `art.warnings` — advisory only, never a
+ * reason to withhold the art.
+ */
+export function render(src) {
+    src = stripControls(src);
+    if (src.trim() === '')
+        return null;
+    const drawn = diagramFor(src)?.render(src) ?? null;
+    if (drawn === null)
+        return null;
+    const art = drawn.canvas.toLines();
+    // A frontmatter `title:` is centred above the art, in the `title` role.
+    const title = frontmatterTitle(src);
+    if (title !== null) {
+        const tw = stringWidth(title);
+        art.width = Math.max(art.width, tw);
+        const pad = ' '.repeat(Math.floor((art.width - tw) / 2));
+        art.plain.unshift(pad + title, '');
+        art.styled.unshift(pad === ''
+            ? [{ text: title, role: 'title' }]
+            : [
+                { text: pad, role: 'none' },
+                { text: title, role: 'title' },
+            ], []);
+    }
+    return { ...art, classDefs: drawn.classDefs, warnings: drawn.warnings };
+}
+//# sourceMappingURL=index.js.map