@promptctl/rich-js 0.16.0 → 0.18.0

package/dist/renderables/markdown.js

@@ -1,182 +0,0 @@
-/**
- * Markdown — renders Markdown content to the terminal.
- * Uses built-in parsing (no external dependency).
- */
-import { Segment } from "../core/segment.js";
-import { Style } from "../core/style.js";
-import { RichText } from "../core/text.js";
-import { Rule } from "./rule.js";
-import { getStyle } from "../core/protocol.js";
-function tokenize(markdown) {
-    const lines = markdown.split("\n");
-    const tokens = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Blank line
-        if (line.trim() === "") {
-            tokens.push({ type: "blank" });
-            i++;
-            continue;
-        }
-        // Heading
-        const headingMatch = /^(#{1,6})\s+(.+)$/.exec(line);
-        if (headingMatch) {
-            tokens.push({ type: "heading", level: headingMatch[1].length, text: headingMatch[2] });
-            i++;
-            continue;
-        }
-        // Horizontal rule
-        if (/^(?:---+|===+|\*\*\*+)$/.test(line.trim())) {
-            tokens.push({ type: "hr" });
-            i++;
-            continue;
-        }
-        // Fenced code block
-        const codeMatch = /^```(\w*)/.exec(line);
-        if (codeMatch) {
-            const lang = codeMatch[1] ?? "";
-            const codeLines = [];
-            i++;
-            while (i < lines.length && !lines[i].startsWith("```")) {
-                codeLines.push(lines[i]);
-                i++;
-            }
-            i++; // skip closing ```
-            tokens.push({ type: "code_block", language: lang, code: codeLines.join("\n") });
-            continue;
-        }
-        // Blockquote
-        if (line.startsWith("> ")) {
-            const quoteLines = [];
-            while (i < lines.length && lines[i].startsWith("> ")) {
-                quoteLines.push(lines[i].slice(2));
-                i++;
-            }
-            tokens.push({ type: "blockquote", text: quoteLines.join("\n") });
-            continue;
-        }
-        // Unordered list
-        const ulMatch = /^([*\-+])\s+(.+)$/.exec(line);
-        if (ulMatch) {
-            tokens.push({ type: "list_item", ordered: false, index: 0, text: ulMatch[2] });
-            i++;
-            continue;
-        }
-        // Ordered list
-        const olMatch = /^(\d+)\.\s+(.+)$/.exec(line);
-        if (olMatch) {
-            tokens.push({ type: "list_item", ordered: true, index: parseInt(olMatch[1], 10), text: olMatch[2] });
-            i++;
-            continue;
-        }
-        // Paragraph (collect consecutive non-blank lines)
-        const paraLines = [];
-        while (i < lines.length && lines[i].trim() !== "" && !/^#{1,6}\s/.test(lines[i]) && !/^```/.test(lines[i])) {
-            paraLines.push(lines[i]);
-            i++;
-        }
-        tokens.push({ type: "paragraph", text: paraLines.join(" ") });
-    }
-    return tokens;
-}
-function applyInlineStyles(text) {
-    const result = new RichText("", { end: "" });
-    // Process inline patterns
-    const inlineRe = /(\*\*(.+?)\*\*|\*(.+?)\*|`(.+?)`|\[(.+?)\]\((.+?)\))/g;
-    let lastIdx = 0;
-    let match;
-    while ((match = inlineRe.exec(text)) !== null) {
-        // Add text before match
-        if (match.index > lastIdx) {
-            result.append(text.slice(lastIdx, match.index));
-        }
-        if (match[2]) {
-            // Bold: **text**
-            result.append(match[2], "bold");
-        }
-        else if (match[3]) {
-            // Italic: *text*
-            result.append(match[3], "italic");
-        }
-        else if (match[4]) {
-            // Inline code: `text`
-            result.append(match[4], "markdown.code");
-        }
-        else if (match[5] && match[6]) {
-            // Link: [text](url)
-            result.append(match[5], new Style({ link: match[6] }));
-        }
-        lastIdx = match.index + match[0].length;
-    }
-    // Remaining text
-    if (lastIdx < text.length) {
-        result.append(text.slice(lastIdx));
-    }
-    return result;
-}
-export class Markdown {
-    markdown;
-    inlineCodeStyle;
-    hyperlinks;
-    constructor(markdown, options) {
-        this.markdown = markdown;
-        this.inlineCodeStyle = options?.inlineCodeStyle ?? "markdown.code";
-        this.hyperlinks = options?.hyperlinks !== false;
-    }
-    *render(options) {
-        const tokens = tokenize(this.markdown);
-        for (const token of tokens) {
-            switch (token.type) {
-                case "heading": {
-                    const style = getStyle(options, `markdown.h${Math.min(token.level, 4)}`);
-                    const text = applyInlineStyles(token.text);
-                    yield* Segment.applyStyle([...text.render(options)], style);
-                    yield Segment.line();
-                    break;
-                }
-                case "paragraph": {
-                    const text = applyInlineStyles(token.text);
-                    yield* text.render(options);
-                    yield Segment.line();
-                    break;
-                }
-                case "code_block": {
-                    const codeStyle = getStyle(options, "markdown.code");
-                    const lines = token.code.split("\n");
-                    for (const line of lines) {
-                        yield new Segment(line, codeStyle);
-                        yield Segment.line();
-                    }
-                    break;
-                }
-                case "hr": {
-                    const rule = new Rule(undefined, { style: "markdown.hr" });
-                    yield* rule.render(options);
-                    break;
-                }
-                case "list_item": {
-                    const bullet = token.ordered ? `${token.index}. ` : "  • ";
-                    yield new Segment(bullet);
-                    const text = applyInlineStyles(token.text);
-                    yield* text.render({ ...options, maxWidth: options.maxWidth - bullet.length });
-                    break;
-                }
-                case "blockquote": {
-                    const quoteStyle = Style.parse("dim italic");
-                    yield new Segment("▎ ", getStyle(options, "markdown.hr"));
-                    const text = applyInlineStyles(token.text);
-                    yield* Segment.applyStyle([...text.render(options)], quoteStyle);
-                    yield Segment.line();
-                    break;
-                }
-                case "blank":
-                    yield Segment.line();
-                    break;
-            }
-        }
-    }
-    measure(options) {
-        return { minimum: 1, maximum: options.maxWidth };
-    }
-}

package/dist/renderables/padding.d.ts

@@ -1,38 +0,0 @@
-/**
- * Padding — wraps a renderable with whitespace padding on all four sides.
- */
-import { Segment } from "../core/segment.js";
-import { Style } from "../core/style.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
-export type PaddingDimensions = number | [number, number] | [number, number, number, number];
-/**
- * Parses the shapes a caller may write padding in — one number, a vertical/
- * horizontal pair, or all four sides — into the four-sided form every
- * renderable indexes by, flooring each side at zero.
- *
- * [LAW:parse-dont-validate] This is the one crossing between the public
- * padding vocabulary and the internal tuple, which is why the floor lives
- * here and nowhere downstream: past this point `" ".repeat(left)` is safe in
- * any renderable without asking what the caller passed. A negative side used
- * to reach the renderers, where `Panel` drew content rows wider than its own
- * border and `Table` threw outright.
- */
-export declare function normalizePadding(padding: PaddingDimensions): [number, number, number, number];
-export declare class Padding implements Renderable, Measurable {
-    readonly renderable: Renderable;
-    readonly top: number;
-    readonly right: number;
-    readonly bottom: number;
-    readonly left: number;
-    readonly style: string | Style;
-    readonly expand: boolean;
-    constructor(renderable: Renderable, padding: PaddingDimensions, options?: {
-        style?: string | Style;
-        expand?: boolean;
-    });
-    render(rawOptions: RenderOptions): Iterable<Segment>;
-    measure(rawOptions: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
-}

package/dist/renderables/padding.js

@@ -1,140 +0,0 @@
-/**
- * Padding — wraps a renderable with whitespace padding on all four sides.
- */
-import { Segment } from "../core/segment.js";
-import { cellCount } from "../core/cells.js";
-import { NULL_STYLE } from "../core/style.js";
-import { Measurement } from "../core/measure.js";
-import { getStyle, isMeasurable, withBoundedWidth, withCellWidth } from "../core/protocol.js";
-/**
- * Parses the shapes a caller may write padding in — one number, a vertical/
- * horizontal pair, or all four sides — into the four-sided form every
- * renderable indexes by, flooring each side at zero.
- *
- * [LAW:parse-dont-validate] This is the one crossing between the public
- * padding vocabulary and the internal tuple, which is why the floor lives
- * here and nowhere downstream: past this point `" ".repeat(left)` is safe in
- * any renderable without asking what the caller passed. A negative side used
- * to reach the renderers, where `Panel` drew content rows wider than its own
- * border and `Table` threw outright.
- */
-export function normalizePadding(padding) {
-    // A padding side is a count of cells like any other, so it is parsed by the
-    // same rule rather than by a second copy of it: a fractional side reaches
-    // `" ".repeat`, which truncates, while the rows around it are measured
-    // arithmetically — so the padding and the border disagree and the frame
-    // breaks. `cellCount`'s header carries why the comparison, not `Math.max`.
-    //
-    // `Infinity` is where a side stops being an offer and the rule needs the one
-    // addition. An unbounded *offer* is a question a renderable can answer, so
-    // `cellCount` passes it through; an unbounded *side* is a quantity and there
-    // is nothing to draw. Unparsed it reached `budget -= got` as
-    // `Infinity - Infinity`, and `new Padding(text, Infinity).measure(...)`
-    // handed back `{NaN, NaN}` from a public API.
-    const side = (n) => (Number.isFinite(n) ? cellCount(n) : 0);
-    const sides = typeof padding === "number"
-        ? [padding, padding, padding, padding]
-        : padding.length === 2
-            ? [padding[0], padding[1], padding[0], padding[1]]
-            : padding;
-    return [side(sides[0]), side(sides[1]), side(sides[2]), side(sides[3])];
-}
-/**
- * Divides the requested width once into the three spans a padded row is made
- * of, in the order they are worth spending cells on.
- *
- * The three used to be derived separately and disagree where it matters:
- * `render` took the canvas as `Math.max(1, maxWidth - left - right)`, which
- * clamps *up*, so a padding of 1 inside a 2-cell request drew 3-cell content
- * rows beside 2-cell blank rows — an open frame the terminal then soft-wraps.
- * Content takes its first cell before padding takes any, for the reason
- * `layoutPanel` gives: a squeeze should cost you the decoration, not the thing
- * being decorated.
- */
-function layoutPadding(outerWidth, leftWanted, rightWanted) {
-    let budget = cellCount(outerWidth);
-    const take = (want) => {
-        const got = Math.min(want, budget);
-        budget -= got;
-        return got;
-    };
-    const firstContentCell = take(1);
-    const left = take(leftWanted);
-    const right = take(rightWanted);
-    return { left, contentWidth: firstContentCell + budget, right };
-}
-/** The full width of a padded row — the division, added back up. */
-function rowWidth(geometry) {
-    return geometry.left + geometry.contentWidth + geometry.right;
-}
-export class Padding {
-    renderable;
-    top;
-    right;
-    bottom;
-    left;
-    style;
-    expand;
-    constructor(renderable, padding, options) {
-        const [top, right, bottom, left] = normalizePadding(padding);
-        this.renderable = renderable;
-        this.top = top;
-        this.right = right;
-        this.bottom = bottom;
-        this.left = left;
-        this.style = options?.style ?? NULL_STYLE;
-        this.expand = options?.expand !== false;
-    }
-    *render(rawOptions) {
-        const options = withBoundedWidth(rawOptions, this);
-        const geometry = layoutPadding(options.maxWidth, this.left, this.right);
-        const innerOptions = {
-            ...options,
-            maxWidth: geometry.contentWidth,
-        };
-        const segments = [...this.renderable.render(innerOptions)];
-        const lines = Segment.splitLines(segments);
-        const resolved = getStyle(options, this.style);
-        const style = resolved.isNull ? undefined : resolved;
-        // Zero-length spans need no branch to suppress: the wire boundary drops
-        // empty segments, so a padding the width could not afford emits nothing.
-        const leftPad = new Segment(" ".repeat(geometry.left), style);
-        const rightPad = new Segment(" ".repeat(geometry.right), style);
-        const blankLine = new Segment(" ".repeat(rowWidth(geometry)), style);
-        for (let i = 0; i < this.top; i++) {
-            yield blankLine;
-            yield Segment.line();
-        }
-        for (const line of lines) {
-            yield leftPad;
-            // `expand` is the pad half of this call; the crop half is unconditional,
-            // because a child that ignored the canvas it was handed (a Table at its
-            // natural width) would otherwise burst the padding around it.
-            yield* Segment.adjustLineLength(line, geometry.contentWidth, style, this.expand);
-            yield rightPad;
-            yield Segment.line();
-        }
-        for (let i = 0; i < this.bottom; i++) {
-            yield blankLine;
-            yield Segment.line();
-        }
-    }
-    measure(rawOptions) {
-        const options = withCellWidth(rawOptions);
-        const geometry = layoutPadding(options.maxWidth, this.left, this.right);
-        const overhead = geometry.left + geometry.right;
-        if (isMeasurable(this.renderable)) {
-            const measurement = Measurement.get({ ...options, maxWidth: geometry.contentWidth }, this.renderable);
-            // The ceiling is what was offered, and it wins over what the child asks
-            // for: a range whose floor sits above its own ceiling — this returned
-            // {8, 8} for three cells of padding inside a two-cell offer — is one no
-            // parent layout can divide.
-            const maximum = Math.min(options.maxWidth, measurement.maximum + overhead);
-            return {
-                minimum: Math.min(measurement.minimum + overhead, maximum),
-                maximum,
-            };
-        }
-        return { minimum: overhead, maximum: options.maxWidth };
-    }
-}

package/dist/renderables/panel.d.ts

@@ -1,116 +0,0 @@
-/**
- * Panel — a bordered box that wraps content, with optional title and subtitle.
- */
-import { Segment } from "../core/segment.js";
-import { Style } from "../core/style.js";
-import { Box } from "../core/box.js";
-import { RichText } from "../core/text.js";
-import type { PaddingDimensions } from "./padding.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
-/**
- * A lazily-resolved border accessory. Strings render inline in the
- * border style; a `RichText` accessory contributes ONLY its wrapping
- * `style` (per-range spans within the RichText are not preserved — the
- * accessory is a small status indicator, not an arbitrary span carrier).
- * A function form is evaluated at render time, *after* content has been
- * rendered for the current frame — use this when the accessory mirrors
- * state that the wrapped renderable populates during its own `render()`
- * (e.g. a widget's post-render scroll position).
- */
-export type BorderAccessory = string | RichText | (() => string | RichText | undefined);
-export interface PanelOptions {
-    box?: Box;
-    title?: string | RichText;
-    subtitle?: string | RichText;
-    /**
-     * Right-aligned accessory in the bottom border, just left of the
-     * `bottomRight` corner. Coexists with `subtitle` — the subtitle
-     * remains centered in the remaining space. Padded with a leading/
-     * trailing space like `title`/`subtitle`, so passing `"[14/102]"`
-     * renders as `─ [14/102] ┘`.
-     */
-    bottomRightAccessory?: BorderAccessory;
-    expand?: boolean;
-    style?: string | Style;
-    borderStyle?: string | Style;
-    /**
-     * Style for the title text in the top border. Defaults to `borderStyle`
-     * (i.e. title inherits the border color). Set independently when the
-     * title should pop relative to the border.
-     */
-    titleStyle?: string | Style;
-    /**
-     * Style for the subtitle text in the bottom border. Defaults to
-     * `borderStyle`.
-     */
-    subtitleStyle?: string | Style;
-    width?: number;
-    padding?: PaddingDimensions;
-}
-export declare class Panel implements Renderable, Measurable {
-    readonly renderable: Renderable;
-    readonly box: Box;
-    readonly title: string | RichText | undefined;
-    readonly subtitle: string | RichText | undefined;
-    readonly bottomRightAccessory: BorderAccessory | undefined;
-    readonly expand: boolean;
-    readonly style: string | Style;
-    readonly borderStyle: string | Style;
-    readonly titleStyle: string | Style | undefined;
-    readonly subtitleStyle: string | Style | undefined;
-    readonly width: number | undefined;
-    readonly padding: [number, number, number, number];
-    constructor(content: string | RichText | Renderable, options?: PanelOptions);
-    render(rawOptions: RenderOptions): Iterable<Segment>;
-    /**
-     * The wrapped renderable's lines, laid out on a canvas `contentWidth` cells
-     * wide. Below width 3 a panel is all frame and the canvas holds no lines —
-     * but the render still happens, because a `bottomRightAccessory` thunk
-     * fires at every width and reads state this render populates.
-     */
-    private _renderContent;
-    /**
-     * One row of the panel body: frame column, span, frame column.
-     *
-     * [LAW:single-enforcer] `adjustLineLength` is the one place a width is
-     * decided here, and it runs twice against two different widths. The first
-     * pass crops content that rendered wider than the canvas it was handed (a
-     * `Table` at its natural width, say) back to the canvas, so an oversized
-     * child is trimmed rather than allowed to eat the right-hand padding. The
-     * second fills the rest of the span, which is the trailing padding and any
-     * shortfall in one stroke.
-     */
-    private _renderRow;
-    measure(rawOptions: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
-    /**
-     * The width this panel wants when nothing declared one for it: its content
-     * plus its own frame, both read off the division it will render against.
-     *
-     * [LAW:one-source-of-truth] `measure` and `_getPanelWidth` ask this same
-     * question, and each used to work it out itself — the same `layoutPanel`, the
-     * same `frameOverhead`, the same `Math.min(maxWidth, maximum + overhead)`,
-     * written twice. That is the pattern `_declaredWidth` below was extracted to
-     * stop, left standing for the fit case; changing how overhead is derived in
-     * one copy is all it would take to put `measure` and `render` back into the
-     * disagreement this epic spent itself closing.
-     */
-    private _fitRange;
-    /**
-     * The width this panel was told to be, as a count of cells.
-     *
-     * [LAW:one-source-of-truth] `measure` and `_getPanelWidth` answer the same
-     * question about the same field, so they read it from here. Answered
-     * separately, `measure` reported nine cells of content while `render` drew the
-     * declared twelve, and the parent that divided space from the range got a
-     * panel three cells wider than the share it granted.
-     */
-    private get _declaredWidth();
-    private _getPanelWidth;
-    private _renderTopBorder;
-    private _renderBottomBorder;
-    private _resolveAccessory;
-    static fit(content: string | RichText | Renderable, options?: Omit<PanelOptions, "expand">): Panel;
-}