@promptctl/rich-js 0.18.1 → 0.20.0

package/dist/renderables/ratio.js

@@ -0,0 +1,213 @@
+/**
+ * Rich's `_ratio.py`: integer totals split into parts by ratio, in exact
+ * arithmetic, each by the reference's own rounding.
+ *
+ * The rounding is the reference's and is kept for that reason alone. A
+ * largest-remainder split is fairer, and it is a different answer: 17 cells
+ * over ratios 2 and 1 are 12 + 5 by `ratioDistribute` and 11 + 6 by largest
+ * remainder, and 5 cells at 1:1 are 2 + 3 by `ratioResolve` and 3 + 2 by
+ * largest remainder with ties to the left. A renderable that splits by any
+ * other rule cannot print the bytes Rich prints for the same call.
+ *
+ * The arithmetic is the reference's too: Python's integers and `Fraction`s are
+ * exact at any size, and a double's `ratio * remaining` rounds once it passes
+ * 2^53, so the parts stopped summing to the total near
+ * `Number.MAX_SAFE_INTEGER`.
+ */
+/**
+ * Rich's `ratio_distribute`: each part the ceiling of its share of what the
+ * parts before it left, and never below its minimum, so the rounding lands on
+ * the leftmost parts. Given `minimums`, a part whose minimum is 0 takes no
+ * share, as the reference zeroes its ratio first. The parts sum to the total
+ * whenever the minimums leave room; a minimum that does not fit is paid anyway,
+ * as the reference pays it, and the parts then overrun the total. The ratios
+ * are weights in one exact proportion (`exactWeights`), so a fractional one
+ * divides as it reads, where the reference takes only whole ones.
+ */
+export function ratioDistribute(total, ratios, minimums) {
+    const weights = exactWeights(minimums === undefined ? ratios : ratios.map((ratio, index) => (minimums[index] > 0 ? ratio : 0)));
+    let totalRatio = weights.reduce((sum, ratio) => sum + ratio, 0n);
+    let remaining = BigInt(total);
+    return weights.map((ratio, index) => {
+        // A zero ratio sum is the reference's `else` arm: whatever is left goes to
+        // the part at hand, so the total is still handed out in full.
+        const share = totalRatio > 0n ? ceilDiv(ratio * remaining, totalRatio) : remaining;
+        const minimum = BigInt(minimums?.[index] ?? 0);
+        const part = share > minimum ? share : minimum;
+        totalRatio -= ratio;
+        remaining -= part;
+        return Number(part);
+    });
+}
+/**
+ * Rich's `ratio_reduce`: `total` taken back from `values` by ratio, each part
+ * giving up at most its `maximum`, and a part whose maximum is 0 giving up
+ * nothing, as the reference zeroes its ratio first. Each part gives up its
+ * share of what the parts before it left, rounded half to even as Python's
+ * `round` is, so 9 at 1:1 is 4 + 5. A part held to its maximum leaves the rest
+ * to the parts after it; when they cannot take it all, less than `total` is
+ * taken back, as in the reference.
+ */
+export function ratioReduce(total, ratios, maximums, values) {
+    const weights = exactWeights(ratios.map((ratio, index) => (maximums[index] > 0 ? ratio : 0)));
+    let totalRatio = weights.reduce((sum, ratio) => sum + ratio, 0n);
+    let remaining = BigInt(total);
+    return weights.map((ratio, index) => {
+        if (ratio === 0n)
+            return values[index];
+        const share = roundDiv(ratio * remaining, totalRatio);
+        const maximum = BigInt(maximums[index]);
+        const given = share < maximum ? share : maximum;
+        remaining -= given;
+        totalRatio -= ratio;
+        return values[index] - Number(given);
+    });
+}
+/** Python's `round(a / b)` for a positive `b`: the nearest integer, a tie to the even one. */
+function roundDiv(a, b) {
+    const floor = a / b - (a % b < 0n ? 1n : 0n);
+    const twice = 2n * (a - floor * b);
+    return twice > b || (twice === b && floor % 2n !== 0n) ? floor + 1n : floor;
+}
+/** Python's `ceil(a / b)` for a positive `b`: `BigInt` division truncates toward zero, which is the ceiling for a negative `a`. */
+function ceilDiv(a, b) {
+    const quotient = a / b;
+    return a % b > 0n ? quotient + 1n : quotient;
+}
+/**
+ * A share weight, not a cell count: fractions divide space meaningfully, so
+ * this parses where `cellCount` would floor. A weight that cannot name a share
+ * — negative, NaN, infinite — reads as zero, which already means "this part
+ * does not grow" and is set aside before any division.
+ */
+export function shareWeight(ratio) {
+    return (Number.isFinite(ratio) && ratio > 0 ? ratio : 0);
+}
+/** Whether an edge takes a share by ratio; one that does not is paid `size ?? minimumSize`. */
+const grows = (edge) => edge.size === undefined && edge.ratio !== 0;
+/**
+ * Rich's `ratio_resolve`: `total` cells split across `edges`, the declared
+ * sizes paid first and what is left shared by ratio.
+ *
+ * A growing edge whose share would not reach its `minimumSize` is paid that
+ * minimum and the rest are shared again without it, one edge at a time, first
+ * in order first. The shares then round by carrying each fraction into the edge
+ * after it, so they sum to what was left and the spare cells land on the
+ * rightmost edges: 5 cells at 1:1 are 2 + 3.
+ *
+ * Three departures, all the port's, not the reference's. Nothing is paid past
+ * what `total` still holds: Rich hands every edge its minimum even when that
+ * overruns the total and leaves the overflow for the screen to clip; here an
+ * edge is paid out of what is left, so the parts never sum past `total` and two
+ * panes of a layout asked to fit one cell cannot merge into a two-cell row. And
+ * a declared `size` of 0 is a pane of no cells, where Rich's `edge.size or
+ * None` reads it as undeclared and lets the pane grow. And a `ratio` of 0 is
+ * paid its minimum before any share is cut, where Rich keeps it among the
+ * growing parts and counts it as 1 in the sum (`edge.ratio or 1`), which thins
+ * every other share and can leave cells unassigned.
+ */
+export function ratioResolve(total, edges) {
+    const sizes = edges.map(() => 0);
+    let remaining = total;
+    const pay = (index, cells) => {
+        sizes[index] = Math.min(cells, remaining);
+        remaining -= sizes[index];
+    };
+    const growing = [];
+    edges.forEach((edge, index) => {
+        if (grows(edge))
+            growing.push(index);
+        else
+            pay(index, edge.size ?? edge.minimumSize);
+    });
+    const weights = exactWeights(growing.map((index) => edges[index].ratio));
+    let open = growing.map((index, slot) => ({
+        index,
+        weight: weights[slot],
+        minimum: BigInt(edges[index].minimumSize),
+    }));
+    // `remaining * weight / sum` is the edge's share; compared across the
+    // division so the test is exact. A budget already spent fails every edge's
+    // test, which pays each its minimum out of nothing — zero, the clip above.
+    let sum = open.reduce((acc, { weight }) => acc + weight, 0n);
+    const firstShort = () => open.find(({ weight, minimum }) => BigInt(remaining) * weight <= minimum * sum);
+    for (let short = firstShort(); short !== undefined; short = firstShort()) {
+        pay(short.index, Number(short.minimum));
+        sum -= short.weight;
+        open = open.filter((edge) => edge !== short);
+    }
+    // Carrying each edge's fraction into the next is the same as flooring the
+    // running total of the shares: an edge gets the whole cells its share moves
+    // that running total across.
+    const budget = BigInt(remaining);
+    let weightSoFar = 0n;
+    let cellsSoFar = 0n;
+    for (const { index, weight } of open) {
+        const before = cellsSoFar;
+        weightSoFar += weight;
+        cellsSoFar = (budget * weightSoFar) / sum;
+        sizes[index] = Number(cellsSoFar - before);
+    }
+    return sizes;
+}
+/**
+ * A `total` at which `ratioResolve` gives every growing edge at least
+ * `wants[i]` cells, and every other edge its declared size or minimum.
+ *
+ * [LAW:one-source-of-truth] It inverts the split above and sits beside it for
+ * that reason. A growing edge is never handed less than the floor of its share,
+ * `total * ratio / totalRatio`, because the running total it is carved from
+ * floors once on each side. So a budget at which every share's floor reaches
+ * its want is enough, and one budget serves them all: the row needs the largest
+ * such demand, never their total.
+ *
+ * Enough, and not always the least. Carried rounding hands spare cells to the
+ * right, so "left" and "right" at 1:1 fit in 9, as 4 + 5, where this answers
+ * 10. The least total is no closed formula's answer — an edge's cells are not
+ * monotone in the total — and searching for it costs a split per cell climbed,
+ * a climb that grows with how far apart the ratios are. The spare cells are
+ * cheaper.
+ *
+ * At that budget every share already covers its edge's minimum — the want
+ * includes it — so the re-share pass pays at most an edge whose share is
+ * exactly that minimum, which leaves every other share where it was. A want is
+ * whole cells, a fraction rounded up; an unbounded one, a pane with no width of
+ * its own offered all of it, is an unbounded budget, given before the exact
+ * arithmetic, which has no infinity.
+ */
+export function ratioBudget(edges, wants) {
+    const growing = edges.flatMap((edge, index) => (grows(edge) ? [index] : []));
+    const owed = growing.map((index) => Math.ceil(Math.max(edges[index].minimumSize, wants[index])));
+    if (!owed.every(Number.isFinite))
+        return Infinity;
+    const weights = exactWeights(growing.map((index) => edges[index].ratio));
+    const sum = weights.reduce((acc, weight) => acc + weight, 0n);
+    const pinned = edges.reduce((acc, edge) => acc + (grows(edge) ? 0 : (edge.size ?? edge.minimumSize)), 0);
+    const budget = owed.reduce((most, cells, slot) => {
+        const need = ceilDiv(BigInt(cells) * sum, weights[slot]);
+        return need > most ? need : most;
+    }, 0n);
+    return pinned + Number(budget);
+}
+/**
+ * Weights as integers in one exact proportion. Each is read as the decimal it
+ * prints as — the number its caller wrote, `0.1` rather than the binary double
+ * nearest it — and all are scaled by the one power of ten that makes them
+ * whole, so `0.1 : 0.3 : 1` is exactly `1 : 3 : 10`. A weight that does not
+ * print as a decimal, `Infinity`, is refused by `BigInt` with a SyntaxError:
+ * each caller parses its weights finite first, and this is the loud end of
+ * that.
+ *
+ * The common exponent is accumulated rather than spread into `Math.max`: a
+ * layout holds as many panes as its caller made, and one argument per pane
+ * overruns the engine's argument limit.
+ */
+export function exactWeights(weights) {
+    const decimals = weights.map((weight) => {
+        const [digits = "", power = "0"] = String(weight).split("e");
+        const [whole = "", fraction = ""] = digits.split(".");
+        return { mantissa: BigInt(whole + fraction), exponent: fraction.length - Number(power) };
+    });
+    const common = decimals.reduce((most, { exponent }) => Math.max(most, exponent), 0);
+    return decimals.map(({ mantissa, exponent }) => mantissa * 10n ** BigInt(common - exponent));
+}

package/dist/renderables/rule.d.ts

@@ -2,8 +2,8 @@
  * Rule — a horizontal divider line, optionally with a centered title.
  */
 import { Segment } from "../core/segment.js";
-import type { RichText } from "../core/text.js";
-import { Style } from "../core/style.js";
+import { type RichText } from "../core/text.js";
+import type { Style } from "../core/style.js";
 import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
 export type RuleAlign = "left" | "center" | "right";
 export interface RuleOptions {
@@ -16,6 +16,7 @@ export declare class Rule implements Renderable, Measurable {
     readonly characters: string;
     readonly align: RuleAlign;
     readonly style: string | Style;
+    private readonly _label;
     constructor(title?: string | RichText, options?: RuleOptions);
     render(options: RenderOptions): Iterable<Segment>;
     measure(_options: RenderOptions): {

package/dist/renderables/rule.js

@@ -1,11 +1,11 @@
 /**
  * Rule — a horizontal divider line, optionally with a centered title.
  */
-import { cellLen } from "../core/cells.js";
+import { asCellCol, cellLen, setCellSize } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
-import { NULL_STYLE } from "../core/style.js";
-import { drawable, getStyle } from "../core/protocol.js";
-import { inlineLabel } from "./embed.js";
+import { resolveStyle } from "../core/text.js";
+import { drawable } from "../core/protocol.js";
+import { cutLabel, drawLabel, inlineLabel } from "./embed.js";
 const ASCII_RULE_CHAR = "-";
 const DEFAULT_RULE_CHAR = "\u2500"; // ─
 export class Rule {
@@ -13,53 +13,67 @@ export class Rule {
     characters;
     align;
     style;
+    _label;
     constructor(title, options) {
         const chars = options?.characters ?? DEFAULT_RULE_CHAR;
-        if (chars.length === 0) {
-            throw new Error("Rule characters must not be empty");
+        // [LAW:parse-dont-validate] Rich's rule: a rule drawn from zero-width
+        // characters would advance no cells, so `repeatToWidth` never meets one.
+        if (cellLen(chars) < 1) {
+            throw new Error("Rule characters must have a cell width of at least 1");
         }
         const align = options?.align;
         if (align !== undefined && align !== "left" && align !== "center" && align !== "right") {
             throw new Error(`Invalid align value: "${align}"`);
         }
         this.title = title;
+        this._label = inlineLabel(title);
         this.characters = chars;
         this.align = align ?? "center";
-        this.style = options?.style ?? NULL_STYLE;
+        this.style = options?.style ?? "rule.line";
     }
     *render(options) {
         const maxWidth = options.maxWidth;
         const ruleChar = drawable(options, this.characters, ASCII_RULE_CHAR);
-        const style = getStyle(options, this.style);
+        // [LAW:single-enforcer] Resolved as Rich resolves the span it appends the
+        // line in: a name the theme lacks draws unstyled rather than throwing.
+        const style = resolveStyle(options, this.style);
         const ruleStyle = style.isNull ? undefined : style;
-        const title = inlineLabel(this.title, options, ruleStyle);
-        const titleWidth = Segment.getLineLength(title);
-        if (titleWidth === 0) {
-            // No title — just a line of repeated characters
-            yield new Segment(repeatToWidth(ruleChar, maxWidth), ruleStyle);
-            yield Segment.line();
-            return;
-        }
-        if (titleWidth >= maxWidth) {
-            // Title fills the whole width; adjustLineLength cuts by cells, not code units.
-            yield* Segment.adjustLineLength(title, maxWidth, ruleStyle);
+        const line = (width) => new Segment(repeatToWidth(ruleChar, width), ruleStyle);
+        // Rich's `required_space`: a centred title keeps a rule cell and a space
+        // either side of it, an aligned one a space and a rule cell on its open
+        // side. A rule with no room past that draws no title, as one without a title.
+        const room = Math.max(0, maxWidth - (this.align === "center" ? 4 : 2));
+        if (this._label === undefined || room === 0) {
+            yield line(maxWidth);
             yield Segment.line();
             return;
         }
-        const remaining = maxWidth - titleWidth;
-        // [LAW:dataflow-not-control-flow] Always compute both sides; alignment determines distribution
-        const leftWidth = this.align === "right"
-            ? remaining
-            : this.align === "center"
-                ? Math.floor(remaining / 2)
-                : 0;
-        const rightWidth = remaining - leftWidth;
-        if (leftWidth > 0) {
-            yield new Segment(repeatToWidth(ruleChar, leftWidth), ruleStyle);
-        }
-        yield* title;
-        if (rightWidth > 0) {
-            yield new Segment(repeatToWidth(ruleChar, rightWidth), ruleStyle);
+        // Rich's `render_str(title, style="rule.text")`: the title is read in its
+        // own style and set beside the line, never in the line's style.
+        const text = this._label.text(options, "rule.text");
+        cutLabel(text, room, drawable(options, "\u2026", "."));
+        const title = drawLabel(text, options, undefined);
+        const titleWidth = Segment.getLineLength(title);
+        // As Rich lays the line out: the gaps of a centred title are the rule's,
+        // styled with it; an aligned title's one gap is unstyled.
+        switch (this.align) {
+            case "center": {
+                const left = Math.floor((maxWidth - titleWidth) / 2) - 1;
+                yield new Segment(`${repeatToWidth(ruleChar, left)} `, ruleStyle);
+                yield* title;
+                yield new Segment(` ${repeatToWidth(ruleChar, maxWidth - left - titleWidth - 2)}`, ruleStyle);
+                break;
+            }
+            case "left":
+                yield* title;
+                yield new Segment(" ");
+                yield line(maxWidth - titleWidth - 1);
+                break;
+            case "right":
+                yield line(maxWidth - titleWidth - 1);
+                yield new Segment(" ");
+                yield* title;
+                break;
         }
         yield Segment.line();
     }
@@ -67,24 +81,8 @@ export class Rule {
         return { minimum: 1, maximum: _options.maxWidth };
     }
 }
+// [LAW:one-source-of-truth] `setCellSize` crops between the grapheme clusters
+// `cellLen` measures, so `❤️` or `👨‍👩‍👧` is never cut in half or over-counted.
 function repeatToWidth(char, width) {
-    const charWidth = cellLen(char);
-    if (charWidth === 0)
-        return " ".repeat(width);
-    const repeats = Math.ceil(width / charWidth);
-    const full = char.repeat(repeats);
-    // Trim to exact width
-    let w = 0;
-    let i = 0;
-    for (const c of full) {
-        const cw = cellLen(c);
-        if (w + cw > width)
-            break;
-        w += cw;
-        i += c.length;
-    }
-    const result = full.slice(0, i);
-    // Pad if needed (wide char couldn't fill exact width)
-    const gap = width - w;
-    return gap > 0 ? result + " ".repeat(gap) : result;
+    return setCellSize(char.repeat(Math.ceil(width / cellLen(char))), asCellCol(width));
 }

package/dist/renderables/spinner.d.ts

@@ -3,6 +3,7 @@
  */
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
+import { RichText } from "../core/text.js";
 import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
 export interface SpinnerOptions {
     speed?: number;
@@ -10,20 +11,45 @@ export interface SpinnerOptions {
 }
 export declare class Spinner implements Renderable, Measurable {
     readonly name: string;
-    readonly text: string | undefined;
     readonly speed: number;
     readonly style: string | Style;
+    /**
+     * The label drawn after the frame. It is read through `embed`'s one crossing
+     * each time it is drawn, so a string is markup under the console that draws
+     * it, as a string handed to `print` is — where Rich's `Spinner` parses it
+     * whatever the console says — and a `RichText` changed in place draws as
+     * changed, as the `Text` Rich keeps does. [LAW:single-enforcer]
+     */
+    text: string | RichText;
     private readonly _data;
     private _frameIndex;
     private _lastUpdate;
-    constructor(name?: string, text?: string, options?: SpinnerOptions);
+    constructor(name?: string, text?: string | RichText, options?: SpinnerOptions);
     get frames(): readonly string[];
     get interval(): number;
     /** Advance the frame count by the time elapsed, and return it. */
     private _advance;
     /** The frames this output can draw: the `line` spinner stands in for any other on an ASCII-only one. */
     private _drawnFrames;
+    /**
+     * The current frame and its label as one line wrapped to the width and
+     * ended, as the reference's `Text` is — printed, stacked in a `Group`, or
+     * laid out in a `Progress` cell alike.
+     */
     render(options: RenderOptions): Iterable<Segment>;
+    private _currentLine;
+    /**
+     * `frame` and the label as one text, as Rich's `Text.assemble(frame, " ",
+     * text)`: a long label wraps as one line with its frame. A label that draws
+     * nothing — the default `""`, or markup that styles nothing — is no label,
+     * not a trailing space, as an empty `Text` is falsy there.
+     */
+    private _line;
+    /**
+     * Measured at its widest frame, so a column holding it never narrows as it
+     * turns, and never offered less than that frame: a frame is one picture,
+     * which the reference's `Text` measure would let wrap apart at its spaces.
+     */
     measure(options: RenderOptions): {
         minimum: number;
         maximum: number;

package/dist/renderables/spinner.js

@@ -4,18 +4,27 @@
 import { cellLen } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
+import { RichText } from "../core/text.js";
 import { SPINNERS, DEFAULT_SPINNER, LINE_SPINNER } from "../core/spinnerData.js";
-import { drawable, getStyle } from "../core/protocol.js";
+import { drawable } from "../core/protocol.js";
+import { EmbeddedText } from "./embed.js";
 const spinnerGlyphs = ({ frames }) => frames.join("");
 export class Spinner {
     name;
-    text;
     speed;
     style;
+    /**
+     * The label drawn after the frame. It is read through `embed`'s one crossing
+     * each time it is drawn, so a string is markup under the console that draws
+     * it, as a string handed to `print` is — where Rich's `Spinner` parses it
+     * whatever the console says — and a `RichText` changed in place draws as
+     * changed, as the `Text` Rich keeps does. [LAW:single-enforcer]
+     */
+    text;
     _data;
     _frameIndex;
     _lastUpdate;
-    constructor(name, text, options) {
+    constructor(name, text = "", options) {
         const spinnerName = name ?? DEFAULT_SPINNER;
         const data = SPINNERS[spinnerName];
         if (!data) {
@@ -38,11 +47,12 @@ export class Spinner {
     /** Advance the frame count by the time elapsed, and return it. */
     _advance() {
         const now = Date.now();
-        const elapsed = now - this._lastUpdate;
-        const effectiveInterval = this.interval / this.speed;
-        if (elapsed >= effectiveInterval) {
-            const steps = Math.floor(elapsed / effectiveInterval);
-            this._frameIndex = (this._frameIndex + steps) % this._data.frames.length;
+        // Whole frames passed at this speed; a negative speed steps backwards, as
+        // Rich's does, so the index wraps with a modulo that is never negative.
+        const steps = Math.trunc(((now - this._lastUpdate) * this.speed) / this.interval);
+        if (steps !== 0) {
+            const count = this._data.frames.length;
+            this._frameIndex = (((this._frameIndex + steps) % count) + count) % count;
             this._lastUpdate = now;
         }
         return this._frameIndex;
@@ -51,20 +61,43 @@ export class Spinner {
     _drawnFrames(options) {
         return drawable(options, this._data, LINE_SPINNER, spinnerGlyphs).frames;
     }
+    /**
+     * The current frame and its label as one line wrapped to the width and
+     * ended, as the reference's `Text` is — printed, stacked in a `Group`, or
+     * laid out in a `Progress` cell alike.
+     */
     *render(options) {
+        yield* this._currentLine(options).render(options);
+        yield Segment.line();
+    }
+    _currentLine(options) {
         const frames = this._drawnFrames(options);
-        const frame = frames[this._advance() % frames.length];
-        const style = getStyle(options, this.style);
-        const spinStyle = style.isNull ? undefined : style;
-        yield new Segment(frame, spinStyle);
-        if (this.text) {
-            yield new Segment(` ${this.text}`);
-        }
+        return this._line(frames[this._advance() % frames.length], options);
+    }
+    /**
+     * `frame` and the label as one text, as Rich's `Text.assemble(frame, " ",
+     * text)`: a long label wraps as one line with its frame. A label that draws
+     * nothing — the default `""`, or markup that styles nothing — is no label,
+     * not a trailing space, as an empty `Text` is falsy there.
+     */
+    _line(frame, options) {
+        const line = new RichText("", { end: "" }).append(frame, this.style);
+        // Unhighlighted: Rich's label is a `Text` from the moment it is handed over, and a `Text` is never highlighted.
+        const label = new EmbeddedText(this.text).text({ ...options, highlight: false });
+        if (label.plain !== "")
+            line.append(" ").append(label);
+        return line;
     }
+    /**
+     * Measured at its widest frame, so a column holding it never narrows as it
+     * turns, and never offered less than that frame: a frame is one picture,
+     * which the reference's `Text` measure would let wrap apart at its spaces.
+     */
     measure(options) {
-        const frameWidth = Math.max(...this._drawnFrames(options).map((f) => cellLen(f)));
-        const textWidth = this.text ? cellLen(this.text) + 1 : 0;
-        const total = frameWidth + textWidth;
-        return { minimum: frameWidth, maximum: total };
+        const frames = this._drawnFrames(options);
+        const widths = frames.map((frame) => cellLen(frame));
+        const frameWidth = Math.max(...widths);
+        const { minimum, maximum } = this._line(frames[widths.indexOf(frameWidth)], options).measure(options);
+        return { minimum: Math.max(minimum, Math.min(frameWidth, maximum)), maximum };
     }
 }

package/dist/renderables/status.d.ts

@@ -1,23 +1,29 @@
 /**
  * Status — displays a spinner animation with a status message.
+ *
+ * Its renderable is a `Spinner` whose label is the message, as Rich's is, so
+ * the message is drawn the way the spinner draws its label: a string is markup
+ * under the console that draws it.
  */
-import { Style } from "../core/style.js";
+import type { Style } from "../core/style.js";
+import type { RichText } from "../core/text.js";
 import { Console } from "../core/console.js";
 export interface StatusOptions {
     spinner?: string;
     speed?: number;
-    style?: string | Style;
+    /** The spinner's frame style; the message styles itself with its markup. */
+    spinnerStyle?: string | Style;
     console?: Console;
 }
 export declare class Status {
     private _live;
-    private _renderable;
+    private _spinner;
     private _console;
-    constructor(message: string, options?: StatusOptions);
+    constructor(message: string | RichText, options?: StatusOptions);
     get console(): Console;
-    get message(): string;
-    set message(value: string);
+    get message(): string | RichText;
+    set message(value: string | RichText);
     start(): void;
     stop(): void;
-    update(message: string): void;
+    update(message: string | RichText): void;
 }

package/dist/renderables/status.js

@@ -1,38 +1,24 @@
 /**
  * Status — displays a spinner animation with a status message.
+ *
+ * Its renderable is a `Spinner` whose label is the message, as Rich's is, so
+ * the message is drawn the way the spinner draws its label: a string is markup
+ * under the console that draws it.
  */
-import { Segment } from "../core/segment.js";
-import { NULL_STYLE } from "../core/style.js";
 import { Console } from "../core/console.js";
 import { Spinner } from "./spinner.js";
 import { Live } from "./live.js";
-import { getStyle } from "../core/protocol.js";
-/** A renderable that shows spinner + message */
-class StatusRenderable {
-    message;
-    _spinner;
-    _style;
-    constructor(message, spinner, style) {
-        this.message = message;
-        this._spinner = spinner;
-        this._style = style;
-    }
-    *render(options) {
-        yield* this._spinner.render(options);
-        const style = getStyle(options, this._style);
-        const msgStyle = style.isNull ? undefined : style;
-        yield new Segment(` ${this.message}`, msgStyle);
-    }
-}
 export class Status {
     _live;
-    _renderable;
+    _spinner;
     _console;
     constructor(message, options) {
-        this._console = options?.console ?? new Console({ forceTerminal: true });
-        const spinner = new Spinner(options?.spinner ?? "dots", undefined, { speed: options?.speed });
-        this._renderable = new StatusRenderable(message, spinner, options?.style ?? NULL_STYLE);
-        this._live = new Live(this._renderable, {
+        this._console = options?.console ?? new Console();
+        this._spinner = new Spinner(options?.spinner ?? "dots", message, {
+            speed: options?.speed,
+            style: options?.spinnerStyle ?? "status.spinner",
+        });
+        this._live = new Live(this._spinner, {
             console: this._console,
             transient: true,
             refreshPerSecond: 12.5,
@@ -42,10 +28,10 @@ export class Status {
         return this._console;
     }
     get message() {
-        return this._renderable.message;
+        return this._spinner.text;
     }
     set message(value) {
-        this._renderable.message = value;
+        this._spinner.text = value;
     }
     start() {
         this._live.start();
@@ -54,7 +40,7 @@ export class Status {
         this._live.stop();
     }
     update(message) {
-        this._renderable.message = message;
-        this._live.update(this._renderable, { refresh: true });
+        this._spinner.text = message;
+        this._live.update(this._spinner, { refresh: true });
     }
 }