@promptctl/rich-js 0.17.0 → 0.18.1

package/dist/renderables/panel.js

@@ -7,8 +7,9 @@ import { NULL_STYLE } from "../core/style.js";
 import { ROUNDED } from "../core/box.js";
 import { Measurement } from "../core/measure.js";
 import { RichText } from "../core/text.js";
+import { embed, inlineLabel } from "./embed.js";
 import { normalizePadding } from "./padding.js";
-import { getStyle, isMeasurable, withBoundedWidth, withCellWidth } from "../core/protocol.js";
+import { fitHeight, getStyle, insetHeight, isMeasurable, withBoundedWidth, withCellWidth } from "../core/protocol.js";
 function layoutPanel(outerWidth, padding) {
     const [, padRightWanted, , padLeftWanted] = padding;
     // Panel's one division point, and the width reaching it is not always one
@@ -54,22 +55,6 @@ function frameOverhead(geometry) {
 function borderTextStyle(options, own, border) {
     return own === undefined ? border : getStyle(options, own);
 }
-function toRenderable(content) {
-    // [LAW:one-type-per-behavior] Content embedded in a panel is a line, not a
-    // printed unit — the same reason columns, table cells, tree labels, and
-    // every other embedding site build their RichText with `end: ""`. Now that
-    // `RichText.render` honors `end` uniformly (rich-text-5ai), leaving this at
-    // the default "\n" would draw a trailing blank row whenever content ends
-    // with a literal newline.
-    if (typeof content === "string")
-        return new RichText(content, { end: "" });
-    if (content instanceof RichText) {
-        const copy = content.copy();
-        copy.end = "";
-        return copy;
-    }
-    return content;
-}
 export class Panel {
     renderable;
     box;
@@ -84,7 +69,7 @@ export class Panel {
     width;
     padding;
     constructor(content, options) {
-        this.renderable = toRenderable(content);
+        this.renderable = embed(content);
         this.box = options?.box ?? ROUNDED;
         this.title = options?.title;
         this.subtitle = options?.subtitle;
@@ -99,7 +84,7 @@ export class Panel {
     }
     *render(rawOptions) {
         const options = withBoundedWidth(rawOptions, this);
-        const box = options.asciiOnly ? this.box.substitute({ asciiOnly: true }) : this.box;
+        const box = this.box.substitute(options);
         const borderStyle = getStyle(options, this.borderStyle);
         const style = getStyle(options, this.style);
         const border = borderStyle.isNull ? undefined : borderStyle;
@@ -129,11 +114,13 @@ export class Panel {
      * fires at every width and reads state this render populates.
      */
     _renderContent(options, contentWidth) {
-        const innerOptions = {
-            ...options,
-            maxWidth: contentWidth,
-        };
-        const lines = Segment.splitLines([...this.renderable.render(innerOptions)]);
+        // Two border rows and the vertical padding are the panel's own. Handed on
+        // as a region, the rest is the panel's to shape, which is what stretches
+        // its frame down a pane and keeps its bottom border inside one.
+        const [padTop, , padBottom] = this.padding;
+        const height = insetHeight(options.height, 2 + padTop + padBottom);
+        const innerOptions = { ...options, maxWidth: contentWidth, height };
+        const lines = fitHeight(Segment.splitLines([...this.renderable.render(innerOptions)]), height);
         return contentWidth === 0 ? [] : lines;
     }
     /**
@@ -225,23 +212,22 @@ export class Panel {
     }
     *_renderTopBorder(options, box, geometry, border) {
         const innerBorderWidth = geometry.spanWidth;
-        if (!this.title) {
+        const titleSeg = borderTextStyle(options, this.titleStyle, border);
+        const title = inlineLabel(this.title, options, titleSeg);
+        const titleWidth = Segment.getLineLength(title);
+        if (titleWidth === 0) {
             yield new Segment(box.top.left.repeat(geometry.left), border);
             yield new Segment(box.top.horizontal.repeat(innerBorderWidth), border);
             yield new Segment(box.top.right.repeat(geometry.right), border);
             yield Segment.line();
             return;
         }
-        const titleText = typeof this.title === "string" ? this.title : this.title.plain;
-        const titleDisplay = ` ${titleText} `;
-        const titleWidth = cellLen(titleDisplay);
-        const titleSeg = borderTextStyle(options, this.titleStyle, border);
         yield new Segment(box.top.left.repeat(geometry.left), border);
         if (titleWidth >= innerBorderWidth) {
-            // Title fills the border. [LAW:one-source-of-truth] cellLen / setCellSize
-            // are the cell-width authority — plain .slice would miscount wide chars
-            // and break border alignment.
-            yield new Segment(setCellSize(titleDisplay, asCellCol(innerBorderWidth)), titleSeg);
+            // Title fills the border. [LAW:one-source-of-truth] adjustLineLength is
+            // cell-aware — a plain .slice would miscount wide chars and break border
+            // alignment.
+            yield* Segment.adjustLineLength(title, innerBorderWidth, titleSeg);
         }
         else {
             // Center the title in the top border
@@ -249,7 +235,7 @@ export class Panel {
             const rightRuleWidth = innerBorderWidth - titleWidth - leftRuleWidth;
             if (leftRuleWidth > 0)
                 yield new Segment(box.top.horizontal.repeat(leftRuleWidth), border);
-            yield new Segment(titleDisplay, titleSeg);
+            yield* title;
             if (rightRuleWidth > 0)
                 yield new Segment(box.top.horizontal.repeat(rightRuleWidth), border);
         }
@@ -275,25 +261,24 @@ export class Panel {
         // (if any) hugs the right edge and the subtitle treats the remainder
         // as its centering canvas.
         const centerWidth = Math.max(0, innerBorderWidth - accessoryWidth);
-        if (!this.subtitle) {
+        const subtitleSeg = borderTextStyle(options, this.subtitleStyle, border);
+        const subtitle = inlineLabel(this.subtitle, options, subtitleSeg);
+        const subtitleWidth = Segment.getLineLength(subtitle);
+        if (subtitleWidth === 0) {
             if (centerWidth > 0)
                 yield new Segment(box.bottom.horizontal.repeat(centerWidth), border);
         }
         else {
-            const subtitleText = typeof this.subtitle === "string" ? this.subtitle : this.subtitle.plain;
-            const subtitleDisplay = ` ${subtitleText} `;
-            const subtitleWidth = cellLen(subtitleDisplay);
-            const subtitleSeg = borderTextStyle(options, this.subtitleStyle, border);
             if (subtitleWidth >= centerWidth) {
                 // Cell-aware clip — see _renderTopBorder.
-                yield new Segment(setCellSize(subtitleDisplay, asCellCol(centerWidth)), subtitleSeg);
+                yield* Segment.adjustLineLength(subtitle, centerWidth, subtitleSeg);
             }
             else {
                 const leftRuleWidth = Math.floor((centerWidth - subtitleWidth) / 2);
                 const rightRuleWidth = centerWidth - subtitleWidth - leftRuleWidth;
                 if (leftRuleWidth > 0)
                     yield new Segment(box.bottom.horizontal.repeat(leftRuleWidth), border);
-                yield new Segment(subtitleDisplay, subtitleSeg);
+                yield* subtitle;
                 if (rightRuleWidth > 0)
                     yield new Segment(box.bottom.horizontal.repeat(rightRuleWidth), border);
             }

package/dist/renderables/progress.js

@@ -4,7 +4,8 @@
 import { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";
 import { Console } from "../core/console.js";
-import { escape as escapeMarkup, renderMarkup } from "../core/markup.js";
+import { escape as escapeMarkup } from "../core/markup.js";
+import { embeddedText } from "./embed.js";
 import { ProgressBar } from "./progressBar.js";
 import { Spinner } from "./spinner.js";
 import { Live } from "./live.js";
@@ -23,13 +24,9 @@ export class TextColumn {
         // Use a callback so `$&`/`$1`/`$$` in the task description aren't
         // reinterpreted by String.replace as replacement patterns.
         const formatted = this.format.replace(/\{task\.description\}/g, () => description);
-        // [LAW:one-type-per-behavior] A column is a row fragment, not a printed
-        // line, so it clears `end` the same way `toCellText` does in table.ts —
-        // `renderMarkup` returns a fresh `RichText` each call, so it is safe to
-        // mutate directly rather than copy.
-        const text = renderMarkup(formatted);
-        text.end = "";
-        yield* text.render(options);
+        // [LAW:single-enforcer] A column is a row fragment, the same as any
+        // embedded text.
+        yield* embeddedText(formatted).render(options);
     }
 }
 export class BarColumn {

package/dist/renderables/progressBar.js

@@ -3,9 +3,9 @@
  */
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
-import { getStyle } from "../core/protocol.js";
-const FULL_BLOCK = "━";
-const EMPTY_BLOCK = "━";
+import { drawable, getStyle } from "../core/protocol.js";
+const BAR = "━";
+const ASCII_BAR = "-";
 export class ProgressBar {
     total;
     completed;
@@ -38,11 +38,12 @@ export class ProgressBar {
         const back = getStyle(options, this.style);
         const fillStyle = fill.isNull ? undefined : fill;
         const bgStyle = back.isNull ? undefined : back;
+        const bar = drawable(options, BAR, ASCII_BAR);
         if (filledWidth > 0) {
-            yield new Segment(FULL_BLOCK.repeat(filledWidth), fillStyle);
+            yield new Segment(bar.repeat(filledWidth), fillStyle);
         }
         if (emptyWidth > 0) {
-            yield new Segment(EMPTY_BLOCK.repeat(emptyWidth), bgStyle);
+            yield new Segment(bar.repeat(emptyWidth), bgStyle);
         }
     }
     measure(_options) {

package/dist/renderables/rule.d.ts

@@ -2,6 +2,7 @@
  * 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 { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
 export type RuleAlign = "left" | "center" | "right";
@@ -11,11 +12,11 @@ export interface RuleOptions {
     style?: string | Style;
 }
 export declare class Rule implements Renderable, Measurable {
-    readonly title: string | undefined;
+    readonly title: string | RichText | undefined;
     readonly characters: string;
     readonly align: RuleAlign;
     readonly style: string | Style;
-    constructor(title?: string, options?: RuleOptions);
+    constructor(title?: string | RichText, options?: RuleOptions);
     render(options: RenderOptions): Iterable<Segment>;
     measure(_options: RenderOptions): {
         minimum: number;

package/dist/renderables/rule.js

@@ -4,7 +4,8 @@
 import { cellLen } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
-import { getStyle } from "../core/protocol.js";
+import { drawable, getStyle } from "../core/protocol.js";
+import { inlineLabel } from "./embed.js";
 const ASCII_RULE_CHAR = "-";
 const DEFAULT_RULE_CHAR = "\u2500"; // ─
 export class Rule {
@@ -28,21 +29,20 @@ export class Rule {
     }
     *render(options) {
         const maxWidth = options.maxWidth;
-        const ruleChar = options.asciiOnly ? ASCII_RULE_CHAR : this.characters;
+        const ruleChar = drawable(options, this.characters, ASCII_RULE_CHAR);
         const style = getStyle(options, this.style);
         const ruleStyle = style.isNull ? undefined : style;
-        if (!this.title) {
+        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;
         }
-        // With title
-        const titleText = ` ${this.title} `;
-        const titleWidth = cellLen(titleText);
         if (titleWidth >= maxWidth) {
-            // Title fills the whole width
-            yield new Segment(titleText.slice(0, maxWidth), ruleStyle);
+            // Title fills the whole width; adjustLineLength cuts by cells, not code units.
+            yield* Segment.adjustLineLength(title, maxWidth, ruleStyle);
             yield Segment.line();
             return;
         }
@@ -57,7 +57,7 @@ export class Rule {
         if (leftWidth > 0) {
             yield new Segment(repeatToWidth(ruleChar, leftWidth), ruleStyle);
         }
-        yield new Segment(titleText, ruleStyle);
+        yield* title;
         if (rightWidth > 0) {
             yield new Segment(repeatToWidth(ruleChar, rightWidth), ruleStyle);
         }

package/dist/renderables/spinner.d.ts

@@ -19,10 +19,12 @@ export declare class Spinner implements Renderable, Measurable {
     constructor(name?: string, text?: string, options?: SpinnerOptions);
     get frames(): readonly string[];
     get interval(): number;
-    /** Advance frame based on elapsed time and return current frame. */
-    private _currentFrame;
+    /** 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;
     render(options: RenderOptions): Iterable<Segment>;
-    measure(_options: RenderOptions): {
+    measure(options: RenderOptions): {
         minimum: number;
         maximum: number;
     };

package/dist/renderables/spinner.js

@@ -4,8 +4,9 @@
 import { cellLen } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
-import { SPINNERS, DEFAULT_SPINNER } from "../core/spinnerData.js";
-import { getStyle } from "../core/protocol.js";
+import { SPINNERS, DEFAULT_SPINNER, LINE_SPINNER } from "../core/spinnerData.js";
+import { drawable, getStyle } from "../core/protocol.js";
+const spinnerGlyphs = ({ frames }) => frames.join("");
 export class Spinner {
     name;
     text;
@@ -34,8 +35,8 @@ export class Spinner {
     get interval() {
         return this._data.interval;
     }
-    /** Advance frame based on elapsed time and return current frame. */
-    _currentFrame() {
+    /** 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;
@@ -44,10 +45,15 @@ export class Spinner {
             this._frameIndex = (this._frameIndex + steps) % this._data.frames.length;
             this._lastUpdate = now;
         }
-        return this._data.frames[this._frameIndex];
+        return this._frameIndex;
+    }
+    /** The frames this output can draw: the `line` spinner stands in for any other on an ASCII-only one. */
+    _drawnFrames(options) {
+        return drawable(options, this._data, LINE_SPINNER, spinnerGlyphs).frames;
     }
     *render(options) {
-        const frame = this._currentFrame();
+        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);
@@ -55,8 +61,8 @@ export class Spinner {
             yield new Segment(` ${this.text}`);
         }
     }
-    measure(_options) {
-        const frameWidth = Math.max(...this._data.frames.map((f) => cellLen(f)));
+    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 };

package/dist/renderables/syntax.d.ts

@@ -4,7 +4,7 @@
  */
 import { Segment } from "../core/segment.js";
 import type { PaddingDimensions } from "./padding.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+import { type Measurable, type Renderable, type RenderOptions } from "../core/protocol.js";
 export interface SyntaxOptions {
     lineNumbers?: boolean;
     theme?: string;

package/dist/renderables/syntax.js

@@ -6,6 +6,7 @@ import { cellLen } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import { RichText } from "../core/text.js";
+import { drawable } from "../core/protocol.js";
 // Built-in token patterns for common languages
 const TOKEN_PATTERNS = {
     _default: [
@@ -72,7 +73,7 @@ export class Syntax {
                     ? Style.parse("bold on grey27")
                     : Style.parse("dim");
                 yield new Segment(numStr, numStyle);
-                yield new Segment("│ ", Style.parse("dim"));
+                yield new Segment(drawable(options, "│ ", "| "), Style.parse("dim"));
             }
             const line = textLines[i];
             const segs = [...line.render({ ...options, maxWidth: options.maxWidth - lineNumWidth - 2 })];

package/dist/renderables/table.d.ts

@@ -6,7 +6,7 @@ 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";
+import type { Renderable, Measurable, OverflowMethod, RenderOptions } from "../core/protocol.js";
 export interface ColumnOptions {
     header?: string | RichText;
     footer?: string | RichText;
@@ -19,7 +19,7 @@ export interface ColumnOptions {
     maxWidth?: number;
     ratio?: number;
     noWrap?: boolean;
-    overflow?: "fold" | "crop" | "ellipsis";
+    overflow?: OverflowMethod;
 }
 export declare class Column {
     private _header;
@@ -33,7 +33,7 @@ export declare class Column {
     maxWidth: number | undefined;
     ratio: number | undefined;
     noWrap: boolean;
-    overflow: "fold" | "crop" | "ellipsis";
+    overflow: OverflowMethod;
     private _cells;
     constructor(options?: ColumnOptions);
     /**
@@ -42,7 +42,7 @@ export declare class Column {
      * constructor-only stamp held only until the first `columns[0].footer = mine`
      * — which installed content that had parsed no markup, still carried its
      * `end`, and was still owned by the caller, into a slot every reader below
-     * assumes `toCellText` has been through. [LAW:parse-dont-validate] The setter
+     * assumes `embeddedText` has been through. [LAW:parse-dont-validate] The setter
      * is the border, so the guarantee holds for the object's whole lifetime and
      * the constructor is one caller of it rather than the one place it is true.
      *
@@ -51,7 +51,7 @@ export declare class Column {
      * a column always has one and `show_footer` alone decides whether it is
      * drawn. Modelling the absence as `undefined` instead made "no column has a
      * footer" a state the render path could ask about — and it did, skipping the
-     * row a caller had asked for. `toCellText` already maps nothing onto empty,
+     * row a caller had asked for. `embeddedText` already maps nothing onto empty,
      * which is why the setters take `undefined` rather than defaulting around it.
      */
     get header(): RichText;
@@ -121,11 +121,13 @@ export declare class Table implements Renderable, Measurable {
      * [LAW:one-source-of-truth] Both ends of the range are widths the geometry
      * actually produced — the maximum from the demands as they stand, the
      * minimum from the same layout with every column asking for a single cell.
-     * Neither end stretches: a stretch only spends cells an offer happens to
-     * leave over, and a renderable reports the width its content wants rather
-     * than the width it was offered. Letting it in made an expanding table
-     * measure `Infinity` against an unbounded offer, where `withBoundedWidth`
-     * needs a natural width to fall back on.
+     * Neither end stretches or fills into an offer: both only spend cells an
+     * offer happens to leave over, and a renderable reports the width its content
+     * wants rather than the width it was offered. A declared `width` is not an
+     * offer, and the maximum reports it. Letting either in made the table measure
+     * `Infinity` against an unbounded offer, where `withBoundedWidth` needs a
+     * natural width to fall back on — an expanding table, and an empty
+     * `Table.grid()`.
      * Neither can exceed the width offered and the tighter request cannot exceed
      * the looser one, so the range cannot invert. Deriving the minimum from raw
      * column and padding counts instead is what used to return
@@ -172,11 +174,21 @@ export declare class Table implements Renderable, Measurable {
      */
     private _columnCells;
     /**
-     * The widest cell in a column, bounded by its own `minWidth`/`maxWidth`.
-     * Zero for a column that draws nothing — a gutter asks for its padding and
-     * nothing else.
+     * The widest cell in a column, or `undefined` when the column has no cell to
+     * measure. Zero is a column whose cells draw nothing — a gutter asks for its
+     * padding and nothing else — and is not the same answer.
+     * [LAW:types-are-the-program]
      */
-    private _naturalWidth;
+    private _widestCell;
+    /**
+     * A natural width held to the column's own `minWidth`/`maxWidth`.
+     *
+     * A bound is a count of cells, read by the rule every width is read by: NaN
+     * and a negative are zero cells, so a NaN floor bounds nothing and a NaN
+     * ceiling is a ceiling of zero, as `width: NaN` is. A bare `Math.max` returns
+     * NaN instead, and the column vanishes. [LAW:one-source-of-truth]
+     */
+    private _bounded;
     private _renderRow;
     private _renderTitle;
 }