@hncode/hncode 0.5.6 → 0.6.1

package/src/mermaid/diagrams/mindmap.js

@@ -0,0 +1,101 @@
+/**
+ * `mindmap`: an indentation tree, drawn the way every TUI draws trees
+ * (`├──`/`└──` guides). Parses raw lines rather than statements — the
+ * indentation IS the grammar, and `statementsOf` trims it away.
+ */
+import { Canvas, drawText } from '../canvas.js';
+import { MAX_NODES } from '../graph.js';
+import { cleanLabel, fitLabel, srcLines, WRAP_WIDTH } from '../labels.js';
+import { frontmatterEnd } from '../statements.js';
+import { stringWidth } from '../width.js';
+export const mindmap = {
+    kind: 'mindmap',
+    headers: ['mindmap'],
+    render(src) {
+        const parsed = parseMindmap(src);
+        if (parsed === null)
+            return null;
+        const { roots, warnings } = parsed;
+        /** [prefix, text] per row; prefixes carry the `│ ├ └` guides. */
+        const rows = [];
+        const walk = (node, prefix, childPrefix) => {
+            rows.push([prefix, node.text]);
+            node.children.forEach((child, i) => {
+                const last = i === node.children.length - 1;
+                walk(child, childPrefix + (last ? '└── ' : '├── '), childPrefix + (last ? '    ' : '│   '));
+            });
+        };
+        for (const root of roots)
+            walk(root, '', '');
+        const width = Math.max(...rows.map(([p, t]) => stringWidth(p) + stringWidth(t)));
+        const canvas = new Canvas(width, rows.length);
+        rows.forEach(([prefix, text], y) => {
+            drawText(canvas, prefix, 0, y, 'edge');
+            drawText(canvas, text, stringWidth(prefix), y, 'text');
+        });
+        return { canvas, warnings, classDefs: {} };
+    },
+};
+function parseMindmap(src) {
+    const lines = srcLines(src).slice(frontmatterEnd(srcLines(src)));
+    const headerAt = lines.findIndex((l) => l.trim() !== '');
+    if (headerAt === -1 || lines[headerAt].trim().toLowerCase() !== 'mindmap')
+        return null;
+    const roots = [];
+    const warnings = [];
+    /** Ancestors of the next node: the node at each indent level seen so far. */
+    const stack = [];
+    let count = 0;
+    let truncated = false;
+    for (const raw of lines.slice(headerAt + 1)) {
+        const noComment = raw.split('%%')[0];
+        if (noComment.trim() === '')
+            continue;
+        const indent = noComment.length - noComment.trimStart().length;
+        const body = noComment.trim();
+        // Decoration lines attach to the previous node and draw nothing.
+        if (body.startsWith('::icon') || body.startsWith(':::'))
+            continue;
+        const text = nodeText(body);
+        if (text === '') {
+            warnings.push(`dropped, unreadable statement: "${body}"`);
+            continue;
+        }
+        if (count >= MAX_NODES) {
+            truncated = true;
+            break;
+        }
+        count++;
+        const node = { text: fitLabel(text, WRAP_WIDTH), children: [] };
+        while (stack.length > 0 && stack[stack.length - 1].indent >= indent)
+            stack.pop();
+        if (stack.length === 0)
+            roots.push(node);
+        else
+            stack[stack.length - 1].node.children.push(node);
+        stack.push({ indent, node });
+    }
+    if (truncated)
+        warnings.push(`diagram truncated: node cap (${MAX_NODES}) reached`);
+    return roots.length === 0 ? null : { roots, warnings };
+}
+/** Shape brackets around a mindmap node all mean "text" in a terminal. */
+const SHAPES = [
+    ['((', '))'],
+    ['))', '(('],
+    ['(-', '-)'],
+    ['{{', '}}'],
+    ['[', ']'],
+    ['(', ')'],
+];
+function nodeText(body) {
+    // `id((text))` — an optional id may precede the bracket.
+    for (const [open, close] of SHAPES) {
+        const at = body.indexOf(open);
+        if (at !== -1 && body.endsWith(close) && body.length > at + open.length + close.length - 1) {
+            return cleanLabel(body.slice(at + open.length, body.length - close.length));
+        }
+    }
+    return cleanLabel(body);
+}
+//# sourceMappingURL=mindmap.js.map

package/src/mermaid/diagrams/pie.js

@@ -0,0 +1,104 @@
+/**
+ * `pie`: proportions as a labelled bar list. A terminal has no circle worth
+ * drawing; bars carry the same information in less space and align with how
+ * every TUI shows usage. Lenient: an unreadable statement is dropped and
+ * recorded in `warnings`.
+ */
+import { Canvas, drawText } from '../canvas.js';
+import { MAX_NODES } from '../graph.js';
+import { cleanLabel, fitLabel } from '../labels.js';
+import { headerKind, nonEmpty, quoteMask, statementsOf, words } from '../statements.js';
+import { stringWidth } from '../width.js';
+/** Columns of the full-scale bar; eighth blocks refine below one cell. */
+const BAR_W = 20;
+const EIGHTHS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
+export const pie = {
+    kind: 'pie',
+    headers: ['pie'],
+    render(src) {
+        const parsed = parsePie(src);
+        if (parsed === null)
+            return null;
+        const { title, slices, showData, warnings } = parsed;
+        const labelW = Math.max(...slices.map((s) => stringWidth(s.label)));
+        const total = slices.reduce((sum, s) => sum + s.value, 0);
+        const rows = slices.map((s) => {
+            const share = total === 0 ? 0 : s.value / total;
+            const pct = `${Math.round(share * 100)}%`.padStart(4);
+            const data = showData ? `  (${s.value})` : '';
+            return { ...s, share, suffix: pct + data };
+        });
+        const barX = labelW + 2;
+        const suffixX = barX + BAR_W + 1;
+        const width = suffixX + Math.max(...rows.map((r) => stringWidth(r.suffix)));
+        const top = title === null ? 0 : 1;
+        const canvas = new Canvas(width, top + rows.length);
+        if (title !== null) {
+            drawText(canvas, title, Math.max(0, Math.floor((width - stringWidth(title)) / 2)), 0, 'title');
+        }
+        rows.forEach((r, i) => {
+            const y = top + i;
+            drawText(canvas, r.label, 0, y, 'text');
+            const eighths = Math.round(r.share * BAR_W * 8);
+            let bar = '█'.repeat(Math.floor(eighths / 8)) + EIGHTHS[eighths % 8];
+            // A nonzero slice always shows at least a sliver.
+            if (bar === '' && r.value > 0)
+                bar = '▏';
+            drawText(canvas, bar, barX, y, 'edge');
+            // The unfilled remainder is a track, so every bar shows its full scale.
+            drawText(canvas, '░'.repeat(BAR_W - stringWidth(bar)), barX + stringWidth(bar), y, 'border');
+            drawText(canvas, r.suffix, suffixX, y, 'edgeLabel');
+        });
+        return { canvas, warnings, classDefs: {} };
+    },
+};
+function parsePie(src) {
+    const statements = statementsOf(src);
+    if (headerKind(statements) !== 'pie')
+        return null;
+    // The header line may carry `showData` and an inline `title ...`.
+    const head = words(statements[0]);
+    const showData = head.some((w) => w.toLowerCase() === 'showdata');
+    const inlineTitle = head.findIndex((w) => w.toLowerCase() === 'title');
+    let title = inlineTitle === -1 ? null : nonEmpty(head.slice(inlineTitle + 1).join(' '));
+    const slices = [];
+    const warnings = [];
+    let truncated = false;
+    for (const st of statements.slice(1)) {
+        const first = words(st)[0]?.toLowerCase();
+        if (first === 'title') {
+            title = nonEmpty(st.slice(st.toLowerCase().indexOf('title') + 5).trim());
+            continue;
+        }
+        const slice = parseSlice(st);
+        if (slice === null) {
+            warnings.push(`dropped, unreadable statement: "${st}"`);
+            continue;
+        }
+        if (slices.length >= MAX_NODES) {
+            truncated = true;
+            break;
+        }
+        slices.push(slice);
+    }
+    if (truncated)
+        warnings.push(`diagram truncated: slice cap (${MAX_NODES}) reached`);
+    return slices.length === 0 ? null : { title, slices, showData, warnings };
+}
+/** `"Label" : 42.5` — the label may be unquoted as long as it has no colon. */
+function parseSlice(st) {
+    const chars = [...st];
+    const quoted = quoteMask(chars);
+    const colon = chars.findIndex((c, i) => c === ':' && !quoted[i]);
+    if (colon === -1)
+        return null;
+    const label = fitLabel(cleanLabel(chars.slice(0, colon).join('')), 24);
+    const value = Number(chars
+        .slice(colon + 1)
+        .join('')
+        .trim());
+    if (label === '' || !Number.isFinite(value) || value < 0)
+        return null;
+    return { label, value };
+}
+//# sourceMappingURL=pie.js.map

package/src/mermaid/diagrams/sequence.js

@@ -0,0 +1,282 @@
+/**
+ * `sequenceDiagram`: participants, messages, notes and block dividers.
+ * Lenient: an unreadable statement is dropped and recorded in `warnings`.
+ *
+ * Sequence diagrams have their own model — participants in declaration order
+ * plus a flat list of items — and their own geometry in `layout-seq.ts`.
+ */
+import { MAX_EDGES, MAX_NODES } from '../graph.js';
+import { asciiLower, cleanLabel, decodeHtmlEntities } from '../labels.js';
+import { layoutSequence } from '../layout-seq.js';
+import { firstWord, headerKind, nonEmpty, splitOnce, statementsOf } from '../statements.js';
+export const sequence = {
+    kind: 'sequence',
+    headers: ['sequencediagram'],
+    render(src) {
+        const seq = parseSequence(src);
+        if (seq === null)
+            return null;
+        const canvas = layoutSequence(seq);
+        if (canvas === null)
+            return null;
+        return { canvas, warnings: seq.warnings, classDefs: {} };
+    },
+};
+/** Message operators, longest-first so `-->>` wins over `-->`. */
+const SEQ_OPS = [
+    ['-->>', true, 'arrow'],
+    ['->>', false, 'arrow'],
+    ['--x', true, 'cross'],
+    ['-x', false, 'cross'],
+    ['--)', true, 'arrow'],
+    ['-)', false, 'arrow'],
+    ['-->', true, 'arrow'],
+    ['->', false, 'arrow'],
+];
+const MAX_SEQ_OP = 4;
+export class Sequence {
+    labels = [];
+    index = new Map();
+    items = [];
+    activations = [];
+    /** Set when a size cap was hit; the parser stops and renders the prefix. */
+    truncated = null;
+    /** Statements the grammar could not read and dropped. */
+    warnings = [];
+    participant(id, label) {
+        const existing = this.index.get(id);
+        if (existing !== undefined) {
+            if (label !== null)
+                this.labels[existing] = label;
+            return existing;
+        }
+        if (this.labels.length >= MAX_NODES) {
+            this.truncated ??= `participant cap (${MAX_NODES}) reached`;
+            return null;
+        }
+        this.index.set(id, this.labels.length);
+        this.labels.push(label ?? id);
+        return this.labels.length - 1;
+    }
+    /** Append an item, or flag `truncated` when the item cap is reached. */
+    pushItem(item) {
+        if (this.items.length >= MAX_EDGES)
+            this.truncated ??= `item cap (${MAX_EDGES}) reached`;
+        else
+            this.items.push(item);
+    }
+    /** Record an unreadable statement; skipped once truncated. */
+    drop(st) {
+        if (this.truncated === null)
+            this.warnings.push(`dropped, unreadable statement: "${st}"`);
+    }
+    /** Open an activation at item `from`. */
+    activate(at, from) {
+        this.activations.push({ at, from, to: null });
+    }
+    /** Close the innermost open activation of `at` at item `to`. */
+    deactivate(at, to) {
+        for (let i = this.activations.length - 1; i >= 0; i--) {
+            const a = this.activations[i];
+            if (a.at === at && a.to === null) {
+                a.to = to;
+                return;
+            }
+        }
+    }
+}
+export function parseSequence(src) {
+    const statements = statementsOf(src);
+    const kind = headerKind(statements);
+    if (kind === null || !sequence.headers.includes(kind))
+        return null;
+    const seq = new Sequence();
+    let autonumber = false;
+    let msgCount = 0;
+    /** One entry per open block; `true` when it draws a divider on `end`. */
+    const blocks = [];
+    for (const st of statements.slice(1)) {
+        const first = firstWord(st);
+        const lower = asciiLower(first);
+        if (lower === 'participant' || lower === 'actor') {
+            const rest = st.slice(first.length).trim();
+            if (rest === '') {
+                seq.drop(st);
+            }
+            else {
+                const as = splitOnce(rest, ' as ');
+                seq.participant(as ? as[0].trim() : rest, as ? cleanLabel(as[1]) : null);
+            }
+        }
+        else if (lower === 'autonumber') {
+            autonumber = true;
+        }
+        else if (lower === 'activate' || lower === 'deactivate') {
+            // Applies to the preceding message's row.
+            const who = seq.index.get(st.slice(first.length).trim());
+            if (who !== undefined && seq.items.length > 0) {
+                if (lower === 'activate')
+                    seq.activate(who, seq.items.length - 1);
+                else
+                    seq.deactivate(who, seq.items.length - 1);
+            }
+        }
+        else if ([
+            'create',
+            'destroy',
+            'title',
+            'acctitle',
+            'accdescr',
+            'links',
+            'link',
+            'properties',
+        ].includes(lower)) {
+            // No layout meaning.
+        }
+        else if (lower === 'note') {
+            const note = parseNoteAnchor(st.slice(first.length).trim(), seq);
+            if (!note)
+                seq.drop(st);
+            else
+                seq.pushItem({ kind: 'note', anchor: note.anchor, text: note.text });
+        }
+        else if (['loop', 'alt', 'opt', 'par', 'critical', 'break', 'else', 'and', 'option'].includes(lower)) {
+            // A continuation only divides a block that opened one.
+            const continues = ['else', 'and', 'option'].includes(lower);
+            if (!continues)
+                blocks.push(true);
+            if (!continues || blocks.at(-1) === true) {
+                seq.pushItem({ kind: 'divider', text: decodeHtmlEntities(st) });
+            }
+        }
+        else if (lower === 'rect' || lower === 'box') {
+            blocks.push(false);
+        }
+        else if (lower === 'end') {
+            if (blocks.pop() === true)
+                seq.pushItem({ kind: 'divider', text: 'end' });
+        }
+        else {
+            const msg = parseSeqMessage(st, seq);
+            if (!msg) {
+                seq.drop(st);
+            }
+            else {
+                let text = msg.text;
+                if (autonumber) {
+                    msgCount++;
+                    text = text === null ? `${msgCount}.` : `${msgCount}. ${text}`;
+                }
+                const item = seq.items.length;
+                seq.pushItem({
+                    kind: 'message',
+                    from: msg.from,
+                    to: msg.to,
+                    text,
+                    dashed: msg.dashed,
+                    head: msg.head,
+                });
+                // `+` activates the receiver on this row; `-` deactivates the sender.
+                // Only once the item was accepted — an activation pointing past the
+                // item cap would dereference a message that does not exist.
+                if (seq.items.length === item + 1) {
+                    if (msg.marks.includes('+'))
+                        seq.activate(msg.to, item);
+                    if (msg.marks.includes('-'))
+                        seq.deactivate(msg.from, item);
+                }
+            }
+        }
+        if (seq.truncated !== null) {
+            seq.warnings.push(`diagram truncated: ${seq.truncated}`);
+            break;
+        }
+    }
+    return seq.labels.length === 0 ? null : seq;
+}
+function parseNoteAnchor(rest, seq) {
+    const lower = asciiLower(rest);
+    let kind;
+    let idsAndText;
+    if (lower.startsWith('over ')) {
+        kind = 'over';
+        idsAndText = rest.slice('over '.length);
+    }
+    else if (lower.startsWith('left of ')) {
+        kind = 'left';
+        idsAndText = rest.slice('left of '.length);
+    }
+    else if (lower.startsWith('right of ')) {
+        kind = 'right';
+        idsAndText = rest.slice('right of '.length);
+    }
+    else {
+        return null;
+    }
+    const split = splitOnce(idsAndText, ':');
+    if (!split)
+        return null;
+    const text = decodeHtmlEntities(split[1].trim());
+    const parts = split[0]
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s !== '');
+    if (parts.length === 0)
+        return null;
+    const a = seq.participant(parts[0], null);
+    if (a === null)
+        return null;
+    if (kind !== 'over')
+        return { text, anchor: { kind, at: a } };
+    let b = a;
+    if (parts[1] !== undefined) {
+        const second = seq.participant(parts[1], null);
+        if (second === null)
+            return null;
+        b = second;
+    }
+    return { text, anchor: { kind: 'over', from: Math.min(a, b), to: Math.max(a, b) } };
+}
+function parseSeqMessage(st, seq) {
+    const chars = [...st];
+    let found = null;
+    outer: for (let pos = 0; pos < chars.length; pos++) {
+        const tail = chars.slice(pos, pos + MAX_SEQ_OP).join('');
+        for (const [op, dashed, head] of SEQ_OPS) {
+            if (tail.startsWith(op)) {
+                // `-x` / `-)` embedded in a hyphenated token (`pre-x->>B`) is not an
+                // operator — the real one follows. Require a non-link char after.
+                const after = chars[pos + op.length];
+                if ((op.endsWith('x') || op.endsWith(')')) && (after === '-' || after === '>'))
+                    continue;
+                found = { pos, op, dashed, head };
+                break outer;
+            }
+        }
+    }
+    if (!found)
+        return null;
+    const fromId = chars.slice(0, found.pos).join('').trim();
+    if (fromId === '')
+        return null;
+    // `+` activates the receiver, `-` deactivates the sender.
+    const afterOp = chars
+        .slice(found.pos + [...found.op].length)
+        .join('')
+        .trimStart();
+    const marks = afterOp.match(/^[+-]+/)?.[0] ?? '';
+    const rest = afterOp.slice(marks.length);
+    const split = splitOnce(rest, ':');
+    const toId = (split ? split[0] : rest).trim();
+    const text = split ? nonEmpty(decodeHtmlEntities(split[1].trim())) : null;
+    if (toId === '')
+        return null;
+    const from = seq.participant(fromId, null);
+    if (from === null)
+        return null;
+    const to = seq.participant(toId, null);
+    if (to === null)
+        return null;
+    return { from, to, text, dashed: found.dashed, head: found.head, marks };
+}
+//# sourceMappingURL=sequence.js.map