@sagmans/dsh-tui 0.1.2 → 0.3.0

package/lib/ui/editor.js

@@ -0,0 +1,159 @@
+import { Editor, isKittyProtocolActive, matchesKey, stripTerminalSequences, } from '@earendil-works/pi-tui';
+import { ENTER_KEY, defaultKeymap } from "../input/actions.js";
+import { promptKeys } from "../input/keymap.js";
+import { FRAME_COLUMNS, FRAME_GLYPHS, MIN_BOX_WIDTH, PADDING_X } from "./frame.js";
+/**
+ * Marks the rule that closes the input while one render is in flight.
+ *
+ * The base editor paints its completion menu after that rule, and this subclass
+ * has to know which rows those are to lift the menu above the box. The base
+ * offers no seam for that boundary, so one render pass tags its own closing rule
+ * and finds it again. The tag cannot collide with typed text, which the editor
+ * strips of control characters, and it never reaches the screen because the same
+ * pass removes it.
+ */
+const CLOSING_TAG = '\u0000';
+/**
+ * The line feed a plain Enter is handed to the base class as.
+ *
+ * The base owns what a newline does to paste markers, history, and undo, and it
+ * reads this byte as one in every terminal mode, including the modes where it
+ * no longer calls Enter itself a newline.
+ */
+const NEWLINE_BYTE = '\n';
+/** The one sequence a terminal that reports no modifiers sends for alt+enter. */
+const LEGACY_ALT_ENTER = '\u001b\r';
+/**
+ * The chords as the keyboard protocol spells them.
+ *
+ * The base class reads a legacy alt+enter and a bare line feed as line breaks
+ * before it looks at any binding, so each press is handed over as the chord the
+ * map actually holds for it. The submit path then runs whole, with the same
+ * guards a real chord meets, instead of a second sender beside it.
+ */
+const KITTY_ALT_ENTER = '\u001b[13;3u';
+const KITTY_CTRL_J = '\u001b[106;5u';
+/**
+ * The input bar drawn as a box, with its completion menu above it.
+ *
+ * The editor already draws the two rules and pads every row to the width it is
+ * given, so the frame comes from rendering two columns narrower and wrapping
+ * what comes back. The menu is lifted above the box because the reader scans it
+ * while writing: a list that grows upward never covers the line being typed.
+ */
+export class BoxedEditor extends Editor {
+    keymap;
+    /** Rows the menu took in the last render; a click there belongs to the list. */
+    menuRows = 0;
+    /** Rows between the rules in the last render; how the base editor counts its own. */
+    textRows = 0;
+    /** Whether the last render drew a frame, which is what a click is mapped through. */
+    boxed = false;
+    constructor(tui, theme, keymap = defaultKeymap) {
+        super(tui, theme, { paddingX: PADDING_X });
+        this.keymap = keymap;
+    }
+    /**
+     * Read the two presses the base class cannot place on its own.
+     *
+     * Enter breaks the line while the reader keeps that key for the line, so the
+     * press the base would submit with becomes a newline — except while it is
+     * picking a completion, the one press that chooses something instead of
+     * sending it, and except on a bar a question or a picker has borrowed, whose
+     * keys belong to whoever borrowed it.
+     */
+    handleInput(data) {
+        if (this.disableSubmit) {
+            super.handleInput(data);
+            return;
+        }
+        const keys = promptKeys(this.keymap());
+        // A bare line feed is a line break in the base class whatever the map says,
+        // so a reader who moved the line break off ctrl+j and sends with it would
+        // keep getting lines. It is read before the Return guard because a terminal
+        // without the protocol reports that byte as Return as well — and only
+        // without it, because a terminal that speaks the protocol sends the chord
+        // itself and reports a line feed for a key the reader meant as a line.
+        if (data === NEWLINE_BYTE && !isKittyProtocolActive() && keys.submit.includes('ctrl+j')) {
+            super.handleInput(KITTY_CTRL_J);
+            return;
+        }
+        if (keys.enterBreaksLine && matchesKey(data, ENTER_KEY) && !this.isShowingAutocomplete()) {
+            super.handleInput(NEWLINE_BYTE);
+            return;
+        }
+        // Only while the terminal cannot tell alt+enter apart from a mapping, and
+        // only for the reader who bound that key: with the protocol active the same
+        // sequence is the reader's shift+enter, and a bar that answered it as a send
+        // because some other chord contains the same bytes would be submitting a key
+        // the reader never bound. A reader who keeps the sequence for a line is
+        // answered by the library's own rule.
+        if (data === LEGACY_ALT_ENTER && !isKittyProtocolActive() && keys.submit.includes('alt+enter')) {
+            super.handleInput(KITTY_ALT_ENTER);
+            return;
+        }
+        super.handleInput(data);
+    }
+    /** Tag the closing rule so {@link render} can find where the box ends. */
+    renderBottomBorder(width, hiddenLineCount) {
+        return `${super.renderBottomBorder(width, hiddenLineCount)}${CLOSING_TAG}`;
+    }
+    /** A rule redrawn as a box edge, so the corners carry the border's own colour. */
+    edge(open, close, row) {
+        return this.borderColor(`${open}${stripTerminalSequences(row)}${close}`);
+    }
+    /**
+     * Rewrite one row of the text before it is framed, so a subclass can hide
+     * what it collects without hiding the box the reader types inside.
+     */
+    decorateText(row) {
+        return row;
+    }
+    render(width) {
+        const side = this.borderColor(FRAME_GLYPHS.side);
+        // A frame narrower than its own furniture would eat the text it exists to
+        // hold, and a hidden border token asks for no frame at all: both cases keep
+        // the plain rules rather than reserve columns for what nobody can see.
+        if (width < MIN_BOX_WIDTH || side === '') {
+            this.boxed = false;
+            return super.render(width).map(row => this.decorateText(row));
+        }
+        const rows = super.render(width - FRAME_COLUMNS);
+        const closing = rows.findIndex(row => row.includes(CLOSING_TAG));
+        // No tagged rule means the base did not paint the shape this class knows;
+        // an unframed render reports that better than a frame drawn on a guess.
+        if (closing < 0)
+            return rows.map(row => row.replace(CLOSING_TAG, ''));
+        const menu = rows.slice(closing + 1);
+        const text = rows.slice(1, closing);
+        this.menuRows = menu.length;
+        this.textRows = text.length;
+        this.boxed = true;
+        // The menu keeps the page's own width; only its rows moved above the box.
+        const lines = menu.map(row => row + ' '.repeat(FRAME_COLUMNS));
+        lines.push(this.edge(FRAME_GLYPHS.topLeft, FRAME_GLYPHS.topRight, rows[0] ?? ''));
+        for (const row of text)
+            lines.push(`${side}${this.decorateText(row)}${side}`);
+        lines.push(this.edge(FRAME_GLYPHS.bottomLeft, FRAME_GLYPHS.bottomRight, rows[closing].replace(CLOSING_TAG, '')));
+        return lines;
+    }
+    /**
+     * Map a click back through the frame and the lifted menu.
+     *
+     * The base editor hit-tests the rows it painted in its own order — the input
+     * under the top rule, the menu after the bottom one — and measures columns
+     * from the edge of the width it was asked for. This subclass draws the menu
+     * first and indents every line by the frame, so a click has to be translated
+     * back before that hit test can say what it hit.
+     */
+    handleMouse(event) {
+        if (!this.boxed)
+            return super.handleMouse(event);
+        const width = event.width - FRAME_COLUMNS;
+        if (event.y < this.menuRows) {
+            return super.handleMouse({ ...event, width, y: event.y + this.textRows + 2 });
+        }
+        return super.handleMouse({ ...event, width, x: event.x - 1, y: event.y - this.menuRows });
+    }
+}
+//# sourceMappingURL=editor.js.map

package/lib/ui/editor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.js","sourceRoot":"","sources":["../../src/ui/editor.ts"],"names":[],"mappings":"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"}

package/lib/ui/frame.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The frame every prompt is closed into.
+ *
+ * The editor, the prompts queued above it, and the prompts already submitted
+ * draw the same glyphs at the same width, so one prompt reads as the same object
+ * through its whole life; keeping the shape here is what stops the three from
+ * drifting.
+ */
+export declare const FRAME_GLYPHS: {
+    readonly topLeft: "╭";
+    readonly topRight: "╮";
+    readonly bottomLeft: "╰";
+    readonly bottomRight: "╯";
+    readonly side: "│";
+};
+/** The frame costs one column each side, so the text wraps that much narrower. */
+export declare const FRAME_COLUMNS = 2;
+/** One column of air inside the frame, so a full line never touches the border. */
+export declare const PADDING_X = 1;
+/** A box needs both edges, both paddings, and one column left to type in. */
+export declare const MIN_BOX_WIDTH: number;
+/** The columns the text of a bar owns, given the width of everything inside its frame. */
+export declare function textWidth(innerWidth: number): number;
+/** One text row of a bar: the air, the text, and the rest of the inside width. */
+export declare function textRow(text: string, innerWidth: number): string;
+/**
+ * The rule that closes a bar, naming what the bar could not fit.
+ *
+ * A hidden count is a fact about the text, not extra text, so it rides the rule
+ * the way the editor's own scroll indicator does: the same label in the same
+ * place, at the same width, so both bars report a fold identically.
+ */
+export declare function frameRule(innerWidth: number, hiddenRows: number): string;
+/** How one block of text paints itself inside the bar that carries it. */
+export interface FrameFaces {
+    /** Paints one row of the block's own text. */
+    readonly text: (line: string) => string;
+    /** Paints the frame's rules and its two sides. */
+    readonly border: (rule: string) => string;
+    /** Whether the frame may be drawn at all. */
+    readonly framed: boolean;
+}
+/** Whether a bar has the width, and the visible border, to close a frame. */
+export declare function canFrame(width: number, borderVisible: boolean): boolean;
+/**
+ * One block of text as a bar draws it: wrapped to the frame's own width, and
+ * closed into it when the frame can be drawn.
+ *
+ * A block with a limit is a preview, and the rows it drops are counted on the
+ * closing rule: a reader who cannot see the whole text still has to see that it
+ * continues. A block without a limit is the prompt itself, which is never cut.
+ */
+export declare function frameText(text: string, width: number, faces: FrameFaces, limit?: number): string[];
+//# sourceMappingURL=frame.d.ts.map

package/lib/ui/frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../src/ui/frame.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;CAAyF,CAAA;AAElH,kFAAkF;AAClF,eAAO,MAAM,aAAa,IAAI,CAAA;AAC9B,mFAAmF;AACnF,eAAO,MAAM,SAAS,IAAI,CAAA;AAC1B,6EAA6E;AAC7E,eAAO,MAAM,aAAa,QAAoC,CAAA;AAE9D,0FAA0F;AAC1F,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,kFAAkF;AAClF,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAgBxE;AAED,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IACvC,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IACzC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,GAAG,OAAO,CAEvE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,SAA2B,GAAG,MAAM,EAAE,CAYpH"}

package/lib/ui/frame.js

@@ -0,0 +1,79 @@
+import { visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { displayText } from "../text.js";
+/**
+ * The frame every prompt is closed into.
+ *
+ * The editor, the prompts queued above it, and the prompts already submitted
+ * draw the same glyphs at the same width, so one prompt reads as the same object
+ * through its whole life; keeping the shape here is what stops the three from
+ * drifting.
+ */
+export const FRAME_GLYPHS = { topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯', side: '│' };
+/** The frame costs one column each side, so the text wraps that much narrower. */
+export const FRAME_COLUMNS = 2;
+/** One column of air inside the frame, so a full line never touches the border. */
+export const PADDING_X = 1;
+/** A box needs both edges, both paddings, and one column left to type in. */
+export const MIN_BOX_WIDTH = FRAME_COLUMNS + PADDING_X * 2 + 1;
+/** The columns the text of a bar owns, given the width of everything inside its frame. */
+export function textWidth(innerWidth) {
+    return Math.max(1, innerWidth - PADDING_X * 2);
+}
+/** One text row of a bar: the air, the text, and the rest of the inside width. */
+export function textRow(text, innerWidth) {
+    const room = Math.max(0, textWidth(innerWidth) - visibleWidth(text));
+    return `${' '.repeat(PADDING_X)}${text}${' '.repeat(room)}${' '.repeat(PADDING_X)}`;
+}
+/**
+ * The rule that closes a bar, naming what the bar could not fit.
+ *
+ * A hidden count is a fact about the text, not extra text, so it rides the rule
+ * the way the editor's own scroll indicator does: the same label in the same
+ * place, at the same width, so both bars report a fold identically.
+ */
+export function frameRule(innerWidth, hiddenRows) {
+    const width = Math.max(0, innerWidth);
+    if (hiddenRows <= 0)
+        return '─'.repeat(width);
+    const label = ` ↓ ${hiddenRows} more `;
+    const labelWidth = visibleWidth(label);
+    if (labelWidth + 2 <= width) {
+        const left = Math.floor((width - labelWidth) / 2);
+        return `${'─'.repeat(left)}${label}${'─'.repeat(width - left - labelWidth)}`;
+    }
+    // Too narrow for a centred label: name it as far as it fits instead of
+    // dropping the fact. Both the label and the fallback are ASCII, so slicing by
+    // character is slicing by column here.
+    const indicator = `─── ↓ ${hiddenRows} more `;
+    if (visibleWidth(indicator) <= width)
+        return indicator + '─'.repeat(width - visibleWidth(indicator));
+    const ellipsis = '...'.slice(0, width);
+    return indicator.slice(0, Math.max(0, width - ellipsis.length)) + ellipsis;
+}
+/** Whether a bar has the width, and the visible border, to close a frame. */
+export function canFrame(width, borderVisible) {
+    return borderVisible && width >= MIN_BOX_WIDTH;
+}
+/**
+ * One block of text as a bar draws it: wrapped to the frame's own width, and
+ * closed into it when the frame can be drawn.
+ *
+ * A block with a limit is a preview, and the rows it drops are counted on the
+ * closing rule: a reader who cannot see the whole text still has to see that it
+ * continues. A block without a limit is the prompt itself, which is never cut.
+ */
+export function frameText(text, width, faces, limit = Number.POSITIVE_INFINITY) {
+    const inside = faces.framed ? width - FRAME_COLUMNS : width;
+    const wrapped = wrapTextWithAnsi(displayText(text), textWidth(inside));
+    const body = wrapped.slice(0, Math.max(0, limit));
+    const rows = body.map(line => textRow(faces.text(line), inside));
+    if (!faces.framed)
+        return rows;
+    const side = faces.border(FRAME_GLYPHS.side);
+    return [
+        faces.border(`${FRAME_GLYPHS.topLeft}${frameRule(inside, 0)}${FRAME_GLYPHS.topRight}`),
+        ...rows.map(row => `${side}${row}${side}`),
+        faces.border(`${FRAME_GLYPHS.bottomLeft}${frameRule(inside, wrapped.length - body.length)}${FRAME_GLYPHS.bottomRight}`),
+    ];
+}
+//# sourceMappingURL=frame.js.map

package/lib/ui/frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","sourceRoot":"","sources":["../../src/ui/frame.ts"],"names":[],"mappings":"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"}

package/lib/ui/gate-input.d.ts

@@ -0,0 +1,20 @@
+import { BoxedEditor } from './editor.ts';
+/** How a question's answer is shown while it is written. */
+export type GateInputMode = 'answer' | 'secret';
+/**
+ * The input bar a gate collects an answer with.
+ *
+ * It is the prompt bar's own component, so an answer is written with the
+ * movement, deletion, undo, and paste that bar already has. Its mode decides
+ * only how the answer is shown: a question that declares a credential is
+ * answered in the same bar with the middle of the value hidden, never in a
+ * second widget that would have to grow its own editing.
+ */
+export declare class GateInputBar extends BoxedEditor {
+    private mode;
+    /** Switch what the bar shows without changing a character of what it holds. */
+    setMode(mode: GateInputMode): void;
+    /** Hide a credential's middle while its owner still recognizes both ends. */
+    protected decorateText(row: string): string;
+}
+//# sourceMappingURL=gate-input.d.ts.map

package/lib/ui/gate-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-input.d.ts","sourceRoot":"","sources":["../../src/ui/gate-input.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEzC,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAA;AA2E/C;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,OAAO,CAAC,IAAI,CAA0B;IAEtC,+EAA+E;IAC/E,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAMlC,6EAA6E;cAC1D,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;CAGrD"}

package/lib/ui/gate-input.js

@@ -0,0 +1,96 @@
+import { visibleWidth } from '@earendil-works/pi-tui';
+import { BoxedEditor } from "./editor.js";
+/** One character of the mask, repeated to the width of what it hides. */
+const MASKED = '*';
+/** How much of a credential stays readable at each end, so its owner can recognize it. */
+const MASK_HEAD = 4;
+const MASK_TAIL = 4;
+/**
+ * A terminal sequence, so masking can tell a row's styling from its text: the
+ * cursor is drawn as an escape around a character, and hiding the character
+ * must not hide the mark that says where the cursor is.
+ *
+ * The string forms carry payloads a terminal reads rather than shows, and a
+ * cursor marker is one of them: masking a marker's own text would replace the
+ * position the terminal was told to place the cursor at with asterisks.
+ */
+const SEQUENCE = /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|[\][P_^X][^\u0007\u001b]*(?:\u0007|\u001b\\)|[@-Z\\-_])/gu;
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/**
+ * One visible grapheme, and where it sits among the row's visible characters.
+ *
+ * Whitespace is not among them: the editor lays the answer out with spaces that
+ * belong to its own drawing, and hiding them would move the text under the
+ * cursor rather than hide it.
+ */
+function visibleAt(text) {
+    const found = [];
+    let position = 0;
+    for (const { segment } of GRAPHEMES.segment(text)) {
+        if (segment.trim() === '') {
+            found.push({ segment, position: -1 });
+            continue;
+        }
+        found.push({ segment, position });
+        position += 1;
+    }
+    return found;
+}
+/**
+ * Hide the middle of a credential and keep its ends readable.
+ *
+ * The reader is checking which key they pasted, and a row of asterisks answers
+ * nothing; a bystander is not meant to read it either, so only the first and
+ * last few characters survive. Rows are masked one at a time because that is
+ * how the editor hands them over, and a credential is written on one line.
+ */
+function maskCredentialRow(row) {
+    const segments = [];
+    let last = 0;
+    for (const match of row.matchAll(SEQUENCE)) {
+        segments.push({ escape: false, text: row.slice(last, match.index) });
+        segments.push({ escape: true, text: match[0] });
+        last = match.index + match[0].length;
+    }
+    segments.push({ escape: false, text: row.slice(last) });
+    const visible = segments.filter(segment => !segment.escape).flatMap(segment => visibleAt(segment.text));
+    const total = visible.reduce((count, entry) => count + (entry.position >= 0 ? 1 : 0), 0);
+    if (total <= MASK_HEAD + MASK_TAIL)
+        return row;
+    let seen = 0;
+    return segments.map((segment) => {
+        if (segment.escape)
+            return segment.text;
+        return visibleAt(segment.text).map((entry) => {
+            if (entry.position < 0)
+                return entry.segment;
+            const readable = seen < MASK_HEAD || seen >= total - MASK_TAIL;
+            seen += 1;
+            return readable ? entry.segment : MASKED.repeat(Math.max(1, visibleWidth(entry.segment)));
+        }).join('');
+    }).join('');
+}
+/**
+ * The input bar a gate collects an answer with.
+ *
+ * It is the prompt bar's own component, so an answer is written with the
+ * movement, deletion, undo, and paste that bar already has. Its mode decides
+ * only how the answer is shown: a question that declares a credential is
+ * answered in the same bar with the middle of the value hidden, never in a
+ * second widget that would have to grow its own editing.
+ */
+export class GateInputBar extends BoxedEditor {
+    mode = 'answer';
+    /** Switch what the bar shows without changing a character of what it holds. */
+    setMode(mode) {
+        if (this.mode === mode)
+            return;
+        this.mode = mode;
+        this.invalidate();
+    }
+    /** Hide a credential's middle while its owner still recognizes both ends. */
+    decorateText(row) {
+        return this.mode === 'secret' ? maskCredentialRow(row) : row;
+    }
+}
+//# sourceMappingURL=gate-input.js.map

package/lib/ui/gate-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-input.js","sourceRoot":"","sources":["../../src/ui/gate-input.ts"],"names":[],"mappings":"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"}

package/lib/ui/markdown.d.ts

@@ -1,4 +1,5 @@
 import { type MarkdownTheme } from '@earendil-works/pi-tui';
+import type { MermaidTransform } from './mermaid.ts';
 /** Parsed messages kept for redraws; everything above this is cold transcript. */
 export declare const MARKDOWN_CACHE_LIMIT = 64;
 /**
@@ -10,8 +11,24 @@ export declare const MARKDOWN_CACHE_LIMIT = 64;
  */
 export declare class MarkdownRenderer {
     private readonly theme;
+    private readonly mermaid?;
     private readonly parsed;
-    constructor(theme: MarkdownTheme);
-    render(text: string, width: number): string[];
+    constructor(theme: MarkdownTheme, mermaid?: MermaidTransform | undefined);
+    render(text: string, width: number, live?: boolean): string[];
+    /**
+     * The parse options this renderer installs, absent when nothing transforms.
+     *
+     * The flag is captured rather than read per call: the component caches the
+     * rows it drew, so the value that built it is the only one it could honour.
+     */
+    private options;
+    /**
+     * Drop parsed messages after a theme change.
+     *
+     * A `Markdown` caches the lines it rendered for a width, so keeping the
+     * instance would keep the old escapes; the reader's new shade would land
+     * everywhere except the answer.
+     */
+    invalidate(): void;
 }
 //# sourceMappingURL=markdown.d.ts.map

package/lib/ui/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/ui/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAErE,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAGf,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;gBAExB,KAAK,EAAE,aAAa;IAEjD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;CAe9C"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/ui/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEpD,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAGf,OAAO,CAAC,QAAQ,CAAC,KAAK;IAAiB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAF5E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;gBAExB,KAAK,EAAE,aAAa,EAAmB,OAAO,CAAC,EAAE,gBAAgB,YAAA;IAE9F,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,MAAM,EAAE;IAqB3D;;;;;OAKG;IACH,OAAO,CAAC,OAAO;IAMf;;;;;;OAMG;IACH,UAAU,IAAI,IAAI;CAInB"}

package/lib/ui/markdown.js

@@ -10,26 +10,57 @@ export const MARKDOWN_CACHE_LIMIT = 64;
  */
 export class MarkdownRenderer {
     theme;
+    mermaid;
     parsed = new Map();
-    constructor(theme) {
+    constructor(theme, mermaid) {
         this.theme = theme;
+        this.mermaid = mermaid;
     }
-    render(text, width) {
-        let message = this.parsed.get(text);
+    render(text, width, live = false) {
+        // A streaming reply can settle on the very text it last streamed, and the
+        // two renderings are not the same: only a settled one may report what a
+        // drawing lost, and a mode may draw one and withhold the other. The flag is
+        // part of a message's identity for the same reason the text is.
+        const key = live ? `live\u0000${text}` : `settled\u0000${text}`;
+        let message = this.parsed.get(key);
         if (message === undefined) {
             if (this.parsed.size >= MARKDOWN_CACHE_LIMIT) {
                 const oldest = this.parsed.keys().next();
                 if (oldest.done !== true)
                     this.parsed.delete(oldest.value);
             }
-            message = new Markdown(text, 0, 0, this.theme);
+            message = new Markdown(text, 0, 0, this.theme, undefined, this.options(live));
         }
         else {
             // Reinserting keeps a message that is still on screen from ageing out.
-            this.parsed.delete(text);
+            this.parsed.delete(key);
         }
-        this.parsed.set(text, message);
+        this.parsed.set(key, message);
         return message.render(Math.max(1, Math.floor(width)));
     }
+    /**
+     * The parse options this renderer installs, absent when nothing transforms.
+     *
+     * The flag is captured rather than read per call: the component caches the
+     * rows it drew, so the value that built it is the only one it could honour.
+     */
+    options(live) {
+        const mermaid = this.mermaid;
+        if (mermaid === undefined)
+            return undefined;
+        return { transform: (markdown, availableWidth) => mermaid(markdown, availableWidth, live) };
+    }
+    /**
+     * Drop parsed messages after a theme change.
+     *
+     * A `Markdown` caches the lines it rendered for a width, so keeping the
+     * instance would keep the old escapes; the reader's new shade would land
+     * everywhere except the answer.
+     */
+    invalidate() {
+        for (const message of this.parsed.values())
+            message.invalidate();
+        this.parsed.clear();
+    }
 }
 //# sourceMappingURL=markdown.js.map

package/lib/ui/markdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../src/ui/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAsB,MAAM,wBAAwB,CAAA;AAErE,kFAAkF;AAClF,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAA;AAEtC;;;;;;GAMG;AACH,MAAM,OAAO,gBAAgB;IAGE;IAFZ,MAAM,GAAG,IAAI,GAAG,EAAoB,CAAA;IAErD,YAA6B,KAAoB;QAApB,UAAK,GAAL,KAAK,CAAe;IAAG,CAAC;IAErD,MAAM,CAAC,IAAY,EAAE,KAAa;QAChC,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACnC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,oBAAoB,EAAE,CAAC;gBAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAA;gBACxC,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI;oBAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAC5D,CAAC;YACD,OAAO,GAAG,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;QAChD,CAAC;aAAM,CAAC;YACN,uEAAuE;YACvE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAC1B,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QAC9B,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACvD,CAAC;CACF"}
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../src/ui/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA4C,MAAM,wBAAwB,CAAA;AAG3F,kFAAkF;AAClF,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAA;AAEtC;;;;;;GAMG;AACH,MAAM,OAAO,gBAAgB;IAGE;IAAuC;IAFnD,MAAM,GAAG,IAAI,GAAG,EAAoB,CAAA;IAErD,YAA6B,KAAoB,EAAmB,OAA0B;QAAjE,UAAK,GAAL,KAAK,CAAe;QAAmB,YAAO,GAAP,OAAO,CAAmB;IAAG,CAAC;IAElG,MAAM,CAAC,IAAY,EAAE,KAAa,EAAE,IAAI,GAAG,KAAK;QAC9C,0EAA0E;QAC1E,wEAAwE;QACxE,4EAA4E;QAC5E,gEAAgE;QAChE,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,CAAC,gBAAgB,IAAI,EAAE,CAAA;QAC/D,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAClC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,oBAAoB,EAAE,CAAC;gBAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAA;gBACxC,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI;oBAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAC5D,CAAC;YACD,OAAO,GAAG,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;QAC/E,CAAC;aAAM,CAAC;YACN,uEAAuE;YACvE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACzB,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;QAC7B,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACvD,CAAC;IAED;;;;;OAKG;IACK,OAAO,CAAC,IAAa;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAA;QAC5B,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,SAAS,CAAA;QAC3C,OAAO,EAAE,SAAS,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,CAAA;IAC7F,CAAC;IAED;;;;;;OAMG;IACH,UAAU;QACR,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAAE,OAAO,CAAC,UAAU,EAAE,CAAA;QAChE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;CACF"}

package/lib/ui/mermaid.d.ts

@@ -0,0 +1,44 @@
+import type { MermaidMode } from '../theme-settings.ts';
+import type { TuiTheme } from '../theme.ts';
+/** Drawings kept before the oldest is laid out again; a streaming reply redraws per delta. */
+export declare const MERMAID_CACHE_LIMIT = 32;
+/**
+ * The largest source this surface lays out.
+ *
+ * Layout is synchronous and happens inside a frame, and a streaming reply asks
+ * for it again on every delta, so past this the frame costs more than the
+ * drawing is worth and the source stays. Well above what the renderer's own
+ * node cap can fill, so no drawing a reader actually sees is kept out.
+ */
+export declare const MERMAID_MAX_SOURCE: number;
+export interface MermaidOptions {
+    readonly theme: TuiTheme;
+    /** Read per render, so a settings edit reaches a session that is already on screen. */
+    readonly mode: () => MermaidMode;
+}
+/**
+ * Rewrite one message's markdown, with `live` telling a streaming reply from a settled one.
+ *
+ * The width is the columns the message actually has, and a drawing that needs
+ * more than that is left as source rather than truncated: a mutilated diagram
+ * is worse than the text a reader can still read.
+ */
+export type MermaidTransform = (markdown: string, availableWidth: number, live: boolean) => string;
+/**
+ * Draw a reply's mermaid fences as terminal art.
+ *
+ * Replacements are spliced into the message at the offsets the lexer reported,
+ * never rebuilt from the tokens: lexing can decide something is not worth a
+ * token — a duplicate reference definition, for one — and a message that merely
+ * mentions mermaid would then change under a reader who asked for nothing. Text
+ * the transform does not draw is copied through byte for byte.
+ *
+ * A fence is replaced before the markdown is parsed, because that is the only
+ * moment the source is still whole: once tokens are flowing the drawing's rows
+ * would be re-wrapped as prose and lose the spacing they are made of. Each row
+ * is therefore emitted as an inline code span, which the markdown renderer
+ * keeps verbatim, and rows are separated by hard breaks so a diagram survives
+ * as one block instead of one paragraph.
+ */
+export declare function createMermaidTransform(options: MermaidOptions): MermaidTransform;
+//# sourceMappingURL=mermaid.d.ts.map

package/lib/ui/mermaid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid.d.ts","sourceRoot":"","sources":["../../src/ui/mermaid.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAQ3C,8FAA8F;AAC9F,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,QAAY,CAAA;AA8B3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;IACxB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,WAAW,CAAA;CACjC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;AAgElG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,cAAc,GAAG,gBAAgB,CAkEhF"}