@hncode/hncode 0.5.5 → 0.6.0

package/src/mermaid/registry.js

@@ -0,0 +1,54 @@
+/**
+ * The diagram registry: one entry per supported diagram type.
+ *
+ * `diagramKind` and `render` both resolve through this table, so the header
+ * test each parser gates on and the one `diagramKind` reports are the same
+ * function by construction. Adding a diagram type is one module in
+ * `diagrams/` plus one entry here.
+ */
+import { classDiagram } from './diagrams/class.js';
+import { er } from './diagrams/er.js';
+import { flowchart } from './diagrams/flowchart.js';
+import { gitgraph } from './diagrams/gitgraph.js';
+import { mindmap } from './diagrams/mindmap.js';
+import { pie } from './diagrams/pie.js';
+import { sequence } from './diagrams/sequence.js';
+import { state } from './diagrams/state.js';
+import { timeline } from './diagrams/timeline.js';
+import { stripControls } from './labels.js';
+import { headerKind, statementsOf } from './statements.js';
+export const DIAGRAMS = [
+    flowchart,
+    state,
+    classDiagram,
+    er,
+    sequence,
+    pie,
+    mindmap,
+    timeline,
+    gitgraph,
+];
+/** The registry entry `src`'s header declares, or `null`. */
+export function diagramFor(src) {
+    const header = headerKind(statementsOf(src));
+    if (header === null)
+        return null;
+    return DIAGRAMS.find((d) => d.headers.includes(header)) ?? null;
+}
+/**
+ * The kind of diagram `src` declares, or `null` if its header names no type
+ * this renderer draws.
+ *
+ * Reads the header only — it says nothing about whether the body parses. Pair
+ * it with `render` to tell a source this renderer will never draw from one that
+ * is merely malformed:
+ *
+ * ```ts
+ * render(src) === null && diagramKind(src) !== null   // syntax error
+ * ```
+ */
+export function diagramKind(src) {
+    // The same strip `render` applies, so the two entry points agree on any src.
+    return diagramFor(stripControls(src))?.kind ?? null;
+}
+//# sourceMappingURL=registry.js.map

package/src/mermaid/source-box.js

@@ -0,0 +1,102 @@
+/**
+ * The raw source in a framed box.
+ *
+ * What to show when `render` returns `null`, or returns art too wide for the
+ * space at hand. Both are the caller's call, so this is theirs to invoke — and
+ * theirs to caption, since only they know whether some other view of the
+ * diagram exists to point the reader at.
+ */
+import { srcLines, stripControls } from './labels.js';
+import { sat } from './layout.js';
+import { measured, stringWidth } from './width.js';
+/**
+ * Frame `src` in a titled box, hard-wrapping its lines to `maxWidth` columns.
+ *
+ * The result can still exceed `maxWidth`: the body wraps to
+ * `max(8, maxWidth - 4)` and the ` mermaid: <kind> ` title is never truncated,
+ * so a long first token sets a floor. Check `width` if it matters.
+ */
+export function sourceBox(src, maxWidth) {
+    src = stripControls(src);
+    const header = src.split(/\s+/).filter((w) => w !== '')[0] ?? 'diagram';
+    const title = ` mermaid: ${header} `;
+    const limit = maxWidth === undefined ? undefined : Math.max(8, sat(maxWidth, 4));
+    const body = srcLines(src)
+        .map((l) => expandTabs(l).replace(/\s+$/, ''))
+        .reduce((acc, l) => {
+        if (!acc.started && l === '')
+            return acc;
+        acc.started = true;
+        acc.lines.push(...chunkLine(l, limit));
+        return acc;
+    }, { started: false, lines: [] }).lines;
+    // reduce, not a spread: a spread of stringWidths overflows the arg limit
+    // on very large sources.
+    const contentW = body.reduce((w, l) => Math.max(w, stringWidth(l)), stringWidth(title));
+    const inner = contentW + 2;
+    const plain = [];
+    const styled = [];
+    const rule = '─'.repeat(sat(inner, stringWidth(title)));
+    plain.push(`╭${title}${rule}╮`);
+    styled.push([
+        { text: '╭', role: 'border' },
+        { text: title, role: 'title' },
+        { text: `${rule}╮`, role: 'border' },
+    ]);
+    for (const line of body) {
+        const pad = ' '.repeat(sat(contentW, stringWidth(line)));
+        plain.push(`│ ${line}${pad} │`);
+        styled.push([
+            { text: '│ ', role: 'border' },
+            { text: line, role: 'text' },
+            { text: `${pad} │`, role: 'border' },
+        ]);
+    }
+    const bottom = `╰${'─'.repeat(inner)}╯`;
+    plain.push(bottom);
+    styled.push([{ text: bottom, role: 'border' }]);
+    return { plain, styled, width: inner + 2, classDefs: {}, warnings: [] };
+}
+/**
+ * Expand tabs to 4-column stops. A literal tab measures one column here but
+ * whatever the terminal's tab stops say there, so the frame would misalign.
+ */
+function expandTabs(line) {
+    if (!line.includes('\t'))
+        return line;
+    let out = '';
+    let col = 0;
+    for (const [c, cw] of measured(line)) {
+        if (c === '\t') {
+            const pad = 4 - (col % 4);
+            out += ' '.repeat(pad);
+            col += pad;
+        }
+        else {
+            out += c;
+            col += cw;
+        }
+    }
+    return out;
+}
+/** Hard-break a line at `limit` columns, never splitting a wide glyph. */
+function chunkLine(line, limit) {
+    if (limit === undefined || stringWidth(line) <= limit)
+        return [line];
+    const out = [];
+    let cur = '';
+    let curW = 0;
+    for (const [c, cw] of measured(line)) {
+        if (curW + cw > limit && cur !== '') {
+            out.push(cur);
+            cur = '';
+            curW = 0;
+        }
+        cur += c;
+        curW += cw;
+    }
+    if (cur !== '')
+        out.push(cur);
+    return out;
+}
+//# sourceMappingURL=source-box.js.map

package/src/mermaid/statements.js

@@ -0,0 +1,235 @@
+/**
+ * The shared statement layer: source text to statements, plus the small
+ * string-reading helpers every grammar leans on.
+ */
+import { asciiLower, srcLines } from './labels.js';
+function flushStatement(cur, out) {
+    const trimmed = cur.trim();
+    if (trimmed !== '')
+        out.push(trimmed);
+    return '';
+}
+/**
+ * Split one source line into statements on `;`, stopping at a `%%` comment.
+ *
+ * Quoted spans are opaque, so a label may contain `;` and `%%`.
+ */
+export function splitStatements(line, out) {
+    const chars = [...line];
+    let cur = '';
+    let inQuotes = false;
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars[i];
+        if (inQuotes) {
+            if (c === '"')
+                inQuotes = false;
+            cur += c;
+        }
+        else if (c === '"') {
+            inQuotes = true;
+            cur += c;
+        }
+        else if (c === '%' && chars[i + 1] === '%') {
+            break;
+        }
+        else if (c === ';') {
+            cur = flushStatement(cur, out);
+        }
+        else {
+            cur += c;
+        }
+    }
+    flushStatement(cur, out);
+}
+/**
+ * Index just past a leading YAML frontmatter block (`---` … `---`), or 0 when
+ * there is none. While the block is still unterminated everything is
+ * frontmatter, so a streamed diagram stays blank until it closes.
+ */
+export function frontmatterEnd(lines) {
+    let i = 0;
+    while (i < lines.length && lines[i].trim() === '')
+        i++;
+    if (lines[i]?.trim() !== '---')
+        return 0;
+    i++;
+    while (i < lines.length && lines[i].trim() !== '---')
+        i++;
+    return i + 1;
+}
+/**
+ * All statements in a source block, in order. A leading YAML frontmatter
+ * block, part of the mermaid grammar since v10, is skipped.
+ */
+export function statementsOf(src) {
+    const lines = srcLines(src);
+    const out = [];
+    for (const line of lines.slice(frontmatterEnd(lines)))
+        splitStatements(line, out);
+    return out;
+}
+/**
+ * The `title:` of a leading frontmatter block, or null. The one frontmatter
+ * key with terminal meaning — `config` and friends style mermaid's own
+ * renderers and are deliberately ignored.
+ */
+export function frontmatterTitle(src) {
+    const lines = srcLines(src);
+    const end = frontmatterEnd(lines);
+    for (const line of lines.slice(0, end)) {
+        const kv = splitOnce(line, ':');
+        // Untrimmed on the left: an indented `title:` is nested under some other
+        // key, not the diagram's.
+        if (kv === null || kv[0].trimEnd() !== 'title')
+            continue;
+        const t = kv[1].trim();
+        const quoted = t.length > 1 &&
+            ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'")));
+        const title = (quoted ? t.slice(1, -1) : t).trim();
+        return title === '' ? null : title;
+    }
+    return null;
+}
+/** Per-char flags: 1 where the char lies inside a double-quoted span (quotes included). */
+export function quoteMask(chars) {
+    const mask = new Uint8Array(chars.length);
+    let inQuotes = false;
+    for (let i = 0; i < chars.length; i++) {
+        if (chars[i] === '"') {
+            mask[i] = 1;
+            inQuotes = !inQuotes;
+        }
+        else if (inQuotes) {
+            mask[i] = 1;
+        }
+    }
+    return mask;
+}
+/**
+ * Split on separator chars sitting outside double quotes and parentheses,
+ * dropping empty segments — the one splitter every grammar shares, so quote
+ * rules cannot drift between them.
+ */
+export function splitTop(s, isSep) {
+    const out = [];
+    let cur = '';
+    let inQuotes = false;
+    let depth = 0;
+    for (const c of s) {
+        if (c === '"')
+            inQuotes = !inQuotes;
+        else if (!inQuotes && c === '(')
+            depth++;
+        else if (!inQuotes && c === ')' && depth > 0)
+            depth--;
+        if (!inQuotes && depth === 0 && isSep(c)) {
+            if (cur !== '')
+                out.push(cur);
+            cur = '';
+        }
+        else {
+            cur += c;
+        }
+    }
+    if (cur !== '')
+        out.push(cur);
+    return out;
+}
+/**
+ * Split `head : rest` at the first label colon, skipping `:::` tag runs so
+ * `A:::hot : desc` keeps its tag with the id. `null` when there is no colon.
+ */
+export function splitColon(s) {
+    const chars = [...s];
+    for (let i = 0; i < chars.length; i++) {
+        if (chars[i] !== ':')
+            continue;
+        let run = i;
+        while (run < chars.length && chars[run] === ':')
+            run++;
+        if (run - i >= 3) {
+            i = run - 1;
+            continue;
+        }
+        return [chars.slice(0, i).join(''), chars.slice(i + 1).join('')];
+    }
+    return null;
+}
+/** Strip trailing `:::name` tags from an id token: `A:::hot` → id `A`, classes `[hot]`. */
+export function takeTags(token) {
+    const parts = token.split(':::');
+    if (parts.length === 1 || parts[0] === '')
+        return { id: token, classes: [] };
+    return { id: parts[0], classes: parts.slice(1).filter((c) => c !== '') };
+}
+/**
+ * The body of a `class A,B name` statement → `[ids, names]`. The last
+ * whitespace-separated token is the name list, everything before it the ids —
+ * so a space after a comma (`class A, B warn`) still reads as two ids.
+ */
+export function parseClassAssign(rest) {
+    const body = rest.trim();
+    const ws = body.search(/\s\S*$/);
+    if (ws === -1)
+        return null;
+    const split = (s) => s
+        .split(',')
+        .map((t) => t.trim())
+        .filter((t) => t !== '');
+    return [split(body.slice(0, ws)), split(body.slice(ws))];
+}
+/**
+ * `A "url" [tooltip]` / `A href "url" …` → `[id, url]`. The callback forms
+ * (`call`/`callback`) return null — their quoted string is a tooltip.
+ */
+export function parseHref(rest) {
+    const [id, second] = words(rest);
+    if (id === undefined || second === 'call' || second === 'callback')
+        return null;
+    const url = rest.match(/"([^"]+)"/);
+    return url === null ? null : [id, url[1]];
+}
+export const firstWord = (s) => s.split(/\s+/).filter((w) => w !== '')[0] ?? '';
+export const words = (s) => s.split(/\s+/).filter((w) => w !== '');
+/** Split on the first occurrence of `sep`, Rust's `split_once`. */
+export function splitOnce(s, sep) {
+    const i = s.indexOf(sep);
+    return i === -1 ? null : [s.slice(0, i), s.slice(i + sep.length)];
+}
+export const nonEmpty = (s) => (s === '' ? null : s);
+/** Diagram kind from the header statement, lowercased. */
+export function headerKind(statements) {
+    const header = statements[0];
+    if (header === undefined)
+        return null;
+    const kind = firstWord(header);
+    return kind === '' ? null : asciiLower(kind);
+}
+/**
+ * Parse the body of a `classDef` statement: `name[,name2] k1:v1,k2:v2`.
+ * Values are kept verbatim; malformed pairs are skipped.
+ */
+export function parseClassDef(rest) {
+    const body = rest.trim();
+    const ws = body.search(/\s/);
+    if (ws === -1)
+        return null;
+    const names = body
+        .slice(0, ws)
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s !== '');
+    const props = {};
+    // splitTop keeps `rgb(255,0,0)` whole; a bare comma still separates pairs.
+    for (const pair of splitTop(body.slice(ws).trim(), (c) => c === ',')) {
+        const kv = splitOnce(pair, ':');
+        if (kv === null)
+            continue;
+        const k = kv[0].trim();
+        const v = kv[1].trim();
+        if (k !== '' && v !== '')
+            props[k] = v;
+    }
+    return names.length === 0 ? null : { names, props };
+}
+//# sourceMappingURL=statements.js.map

package/src/mermaid/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/src/mermaid/width.js

@@ -0,0 +1,29 @@
+/**
+ * Display width for the diagram layout.
+ *
+ * The diagram engine measures a box in columns so its border lands on the right
+ * cell. `src/term.js` already answers that question for the rest of the UI, with
+ * the same grapheme clustering, so this module delegates rather than carrying a
+ * second Unicode table (the upstream one is 25 KB).
+ */
+import { visualWidth } from '../term.js';
+/** Columns occupied by one grapheme cluster. */
+export function clusterWidth(cluster) {
+  return visualWidth(cluster);
+}
+
+/**
+ * Iterate clusters paired with their display width.
+ *
+ * Callers paint from this rather than by code point: a CJK character claims two
+ * cells of layout but contributes one character of output.
+ */
+export function* measured(s) {
+  const seg = new Intl.Segmenter('en', { granularity: 'grapheme' });
+  for (const { segment } of seg.segment(s)) yield [segment, visualWidth(segment)];
+}
+
+/** Display columns of a string. */
+export function stringWidth(s) {
+  return visualWidth(s);
+}