@promptctl/rich-js 0.18.0 → 0.19.0

package/dist/renderables/padding.js

@@ -0,0 +1,147 @@
+/**
+ * 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 { fitHeight, getStyle, insetHeight, withBoundedWidth, withCellWidth } from "../core/protocol.js";
+import { embed } from "./embed.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.
+ */
+export 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(content, padding, options) {
+        const [top, right, bottom, left] = normalizePadding(padding);
+        this.renderable = embed(content);
+        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);
+        // `expand` decides how wide the block is, never whether its rows reach
+        // that width: as Rich's does, a padding that does not expand narrows to
+        // what it measures, and every row is then padded out to it. Deciding the
+        // rows instead left the content rows ragged under a full-width blank row,
+        // and a `style` ground with holes down its right-hand side.
+        const width = this.expand ? options.maxWidth : Measurement.get(options, this).maximum;
+        const geometry = layoutPadding(width, this.left, this.right);
+        const innerOptions = {
+            ...options,
+            maxWidth: geometry.contentWidth,
+            height: insetHeight(options.height, this.top + this.bottom),
+        };
+        const resolved = getStyle(options, this.style);
+        const style = resolved.isNull ? undefined : resolved;
+        // The style is the ground the content is drawn on, not only the spaces
+        // around it — Rich's `render_lines(..., style=style)`. Applied to the
+        // padding alone, a background left a hole behind the content.
+        const segments = [...Segment.applyStyle(this.renderable.render(innerOptions), style)];
+        const lines = fitHeight(Segment.splitLines(segments), innerOptions.height);
+        // 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;
+            // Crops as well as pads: a child that ignored the canvas it was handed
+            // (a Table at its natural width) would otherwise burst the padding.
+            yield* Segment.adjustLineLength(line, geometry.contentWidth, style);
+            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;
+        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,
+        };
+    }
+}

package/dist/renderables/panel.d.ts

@@ -0,0 +1,114 @@
+/**
+ * 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 lays ONLY its wrapping `style` over
+ * the border's (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, laid over `borderStyle`:
+     * what it sets wins, and what it leaves unset the border's supplies.
+     */
+    titleStyle?: string | Style;
+    /**
+     * Style for the subtitle text in the bottom border, laid over
+     * `borderStyle` as `titleStyle` is.
+     */
+    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];
+    private readonly _titleLabel;
+    private readonly _subtitleLabel;
+    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, cut where Rich cuts it: frame column, left
+     * padding, the content line made exactly `contentWidth` wide, right padding,
+     * frame column — each its own segment, so each its own SGR run.
+     *
+     * [LAW:single-enforcer] `adjustLineLength` is the one place the content's
+     * width is decided: content that rendered wider than its canvas (a `Table`
+     * at its natural width, say) is cropped back to it, and a short line is
+     * filled out to it, so the right padding always starts at the same column.
+     */
+    private _renderRow;
+    /**
+     * A row of vertical padding: one blank run across the whole span, as Rich's
+     * `Padding` draws its blank lines, not a content row with nothing in it.
+     */
+    private _renderPaddingRow;
+    measure(rawOptions: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+    /** The content plus its own frame, both read off the division it will render against. */
+    private _contentRange;
+    /** The cells the title's label takes, its padding included; none without a title. */
+    private _labelWidth;
+    /**
+     * The width this panel was told to be, as a count of cells.
+     *
+     * [LAW:one-source-of-truth] `measure` and `_getPanelWidth` read the field
+     * from here, so neither can count it differently from the other.
+     */
+    private get _declaredWidth();
+    /**
+     * As Rich's `__rich_console__` sizes it: a declared width is a ceiling that
+     * `expand` fills and a fitted panel fits its content inside, and the title
+     * widens either.
+     */
+    private _getPanelWidth;
+    private _renderTopBorder;
+    private _renderBottomBorder;
+    private _resolveAccessory;
+    static fit(content: string | RichText | Renderable, options?: Omit<PanelOptions, "expand">): Panel;
+}

package/dist/renderables/panel.js

@@ -0,0 +1,303 @@
+/**
+ * Panel — a bordered box that wraps content, with optional title and subtitle.
+ */
+import { cellLen, setCellSize, asCellCol, cellCount } from "../core/cells.js";
+import { Segment } from "../core/segment.js";
+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 { cutLabel, drawLabel, embed, inlineLabel } from "./embed.js";
+import { normalizePadding } from "./padding.js";
+import { drawable, fitHeight, getStyle, insetHeight, 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
+    // this file produced: `_getPanelWidth` derives the fit-mode width from
+    // `Measurement.get` on an arbitrary `Measurable`, so a renderable reporting a
+    // negative maximum arrives here unparsed and reaches `repeat` as a negative
+    // count.
+    let budget = cellCount(outerWidth);
+    const take = (want) => {
+        const got = Math.min(want, budget);
+        budget -= got;
+        return got;
+    };
+    const left = take(1);
+    const right = take(1);
+    const firstContentCell = take(1);
+    const padLeft = take(padLeftWanted);
+    const padRight = take(padRightWanted);
+    const contentWidth = firstContentCell + budget;
+    return {
+        left,
+        right,
+        padLeft,
+        contentWidth,
+        padRight,
+        spanWidth: padLeft + contentWidth + padRight,
+    };
+}
+/**
+ * Every cell of a panel that is not content canvas. Read off the geometry
+ * rather than recomputed as `2 + padLeft + padRight`, because the two differ
+ * exactly where this panel is squeezed: a width that cannot afford its right
+ * frame column or its padding does not spend cells on them, and a measurement
+ * that assumed it did would report a minimum larger than its own maximum.
+ */
+function frameOverhead(geometry) {
+    return geometry.left + geometry.right + geometry.padLeft + geometry.padRight;
+}
+/**
+ * How a title or subtitle string is read: always as markup and never
+ * highlighted, whatever the console says, because Rich's `Panel` reads its
+ * title with `Text.from_markup` rather than through the console.
+ */
+function borderLabel(options) {
+    return { ...options, markup: true, highlight: false };
+}
+/** A title or subtitle as Rich's `Panel._title` sets it: read as a border reads it, a space either side. */
+function borderTitle(label, options) {
+    return label.text(borderLabel(options)).pad(1);
+}
+/**
+ * The style of text set into a border — title, subtitle and accessory alike:
+ * its own laid over the border's, the one rule for "what colour is the title
+ * text in". Laid over rather than in place of it, as Rich's `stylize_before`
+ * does, because the border's style carries the panel's own: a title that
+ * replaced it cut a hole in the panel's background on the top row.
+ */
+function borderTextStyle(border, own) {
+    return own.isNull ? border : (border ?? NULL_STYLE).add(own);
+}
+/**
+ * A border row: the opening corner, the rule across `span` cells with `label`
+ * centred in it, and `close` — the closing corner, or nothing when the caller
+ * sets something between the rule and its corner.
+ *
+ * Cut as Rich cuts it. An unlabelled rule is one run, corners included. A
+ * label is set into the `span - 2` cells between one rule cell either side,
+ * truncated to them as Rich's `align_text` truncates it — marked only when the
+ * label's own overflow is `"ellipsis"` — and centred with the rule filling the
+ * rest, so the row leaves as corner-and-rule, rule, label, rule,
+ * rule-and-corner. Rich draws no label in a span of two cells or fewer
+ * (`width <= 4`), where it would sit on the corners.
+ */
+function borderRow(options, edge, geometry, span, label, labelStyle, border, close) {
+    const corner = edge.left.repeat(geometry.left);
+    if (label === undefined || span <= 2) {
+        return [new Segment(corner + edge.horizontal.repeat(span) + close, border)];
+    }
+    const canvas = span - 2;
+    const text = borderTitle(label, options);
+    cutLabel(text, canvas, text.overflow === "ellipsis" ? drawable(options, "\u2026", ".") : "");
+    const fitted = drawLabel(text, borderLabel(options), labelStyle);
+    const excess = canvas - Segment.getLineLength(fitted);
+    const before = Math.floor(excess / 2);
+    return [
+        new Segment(corner + edge.horizontal, border),
+        new Segment(edge.horizontal.repeat(before), border),
+        ...fitted,
+        new Segment(edge.horizontal.repeat(excess - before), border),
+        new Segment(edge.horizontal + close, border),
+    ];
+}
+export class Panel {
+    renderable;
+    box;
+    title;
+    subtitle;
+    bottomRightAccessory;
+    expand;
+    style;
+    borderStyle;
+    titleStyle;
+    subtitleStyle;
+    width;
+    padding;
+    _titleLabel;
+    _subtitleLabel;
+    constructor(content, options) {
+        this.renderable = embed(content);
+        this.box = options?.box ?? ROUNDED;
+        this.title = options?.title;
+        this.subtitle = options?.subtitle;
+        this._titleLabel = inlineLabel(this.title);
+        this._subtitleLabel = inlineLabel(this.subtitle);
+        this.bottomRightAccessory = options?.bottomRightAccessory;
+        this.expand = options?.expand !== false;
+        this.style = options?.style ?? NULL_STYLE;
+        this.borderStyle = options?.borderStyle ?? NULL_STYLE;
+        this.titleStyle = options?.titleStyle;
+        this.subtitleStyle = options?.subtitleStyle;
+        this.width = options?.width;
+        this.padding = normalizePadding(options?.padding ?? [0, 1, 0, 1]);
+    }
+    *render(rawOptions) {
+        const options = withBoundedWidth(rawOptions, this);
+        const box = this.box.substitute(options);
+        // [LAW:one-source-of-truth] `style` is the ground the whole panel is drawn
+        // on, as Rich's is: the frame's style is the border style laid over it,
+        // and the content is rendered on top of it. Applied to the padding alone,
+        // "white on dark_blue" drew a blue ring with a hole where the text was.
+        const style = getStyle(options, this.style);
+        const borderStyle = style.add(getStyle(options, this.borderStyle));
+        const border = borderStyle.isNull ? undefined : borderStyle;
+        const contentStyle = style.isNull ? undefined : style;
+        const geometry = layoutPanel(this._getPanelWidth(options), this.padding);
+        const [padTop, , padBottom] = this.padding;
+        const contentLines = this._renderContent(options, geometry.contentWidth, contentStyle);
+        yield* this._renderTopBorder(options, box, geometry, border);
+        for (let i = 0; i < padTop; i++) {
+            yield* this._renderPaddingRow(box, geometry, border, contentStyle);
+        }
+        for (const line of contentLines) {
+            yield* this._renderRow(box, geometry, line, border, contentStyle);
+        }
+        for (let i = 0; i < padBottom; i++) {
+            yield* this._renderPaddingRow(box, geometry, border, contentStyle);
+        }
+        yield* this._renderBottomBorder(options, box, geometry, border);
+    }
+    /**
+     * 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.
+     */
+    _renderContent(options, contentWidth, style) {
+        // 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);
+        // No highlighter: what the panel holds is drawn plain, as Rich's `Panel`
+        // hands its body `highlight=False`.
+        const innerOptions = { ...options, highlight: false, maxWidth: contentWidth, height };
+        const lines = fitHeight(Segment.splitLines([...Segment.applyStyle(this.renderable.render(innerOptions), style)]), height);
+        return contentWidth === 0 ? [] : lines;
+    }
+    /**
+     * One row of the panel body, cut where Rich cuts it: frame column, left
+     * padding, the content line made exactly `contentWidth` wide, right padding,
+     * frame column — each its own segment, so each its own SGR run.
+     *
+     * [LAW:single-enforcer] `adjustLineLength` is the one place the content's
+     * width is decided: content that rendered wider than its canvas (a `Table`
+     * at its natural width, say) is cropped back to it, and a short line is
+     * filled out to it, so the right padding always starts at the same column.
+     */
+    *_renderRow(box, geometry, line, border, contentStyle) {
+        const frame = box.getContentChars("row");
+        yield new Segment(frame.left.repeat(geometry.left), border);
+        yield new Segment(" ".repeat(geometry.padLeft), contentStyle);
+        yield* Segment.adjustLineLength(line, geometry.contentWidth, contentStyle);
+        yield new Segment(" ".repeat(geometry.padRight), contentStyle);
+        yield new Segment(frame.right.repeat(geometry.right), border);
+        yield Segment.line();
+    }
+    /**
+     * A row of vertical padding: one blank run across the whole span, as Rich's
+     * `Padding` draws its blank lines, not a content row with nothing in it.
+     */
+    *_renderPaddingRow(box, geometry, border, contentStyle) {
+        const frame = box.getContentChars("row");
+        yield new Segment(frame.left.repeat(geometry.left), border);
+        yield new Segment(" ".repeat(geometry.spanWidth), contentStyle);
+        yield new Segment(frame.right.repeat(geometry.right), border);
+        yield Segment.line();
+    }
+    measure(rawOptions) {
+        const options = withCellWidth(rawOptions);
+        // Rich's `__rich_measure__`, which is not its render's arithmetic: a
+        // declared width is the measurement whatever the panel then draws inside
+        // it, and a title counts as content beside the body, with the padding and
+        // frame around it, where the render holds it between one rule cell either
+        // side. A parent sizing from it sizes as Rich's parent does.
+        const declared = this._declaredWidth;
+        if (declared !== undefined) {
+            const width = Math.min(options.maxWidth, declared);
+            return { minimum: width, maximum: width };
+        }
+        const content = this._contentRange(options);
+        const overhead = frameOverhead(layoutPanel(options.maxWidth, this.padding));
+        const maximum = Math.min(options.maxWidth, Math.max(content.maximum, this._labelWidth(options) + overhead));
+        return { minimum: Math.min(content.minimum, maximum), maximum };
+    }
+    /** The content plus its own frame, both read off the division it will render against. */
+    _contentRange(options) {
+        const geometry = layoutPanel(options.maxWidth, this.padding);
+        const overhead = frameOverhead(geometry);
+        const measurement = Measurement.get({ ...options, maxWidth: geometry.contentWidth }, this.renderable);
+        return {
+            minimum: measurement.minimum + overhead,
+            maximum: Math.min(options.maxWidth, measurement.maximum + overhead),
+        };
+    }
+    /** The cells the title's label takes, its padding included; none without a title. */
+    _labelWidth(options) {
+        return this._titleLabel === undefined ? 0 : borderTitle(this._titleLabel, options).cellLength;
+    }
+    /**
+     * The width this panel was told to be, as a count of cells.
+     *
+     * [LAW:one-source-of-truth] `measure` and `_getPanelWidth` read the field
+     * from here, so neither can count it differently from the other.
+     */
+    get _declaredWidth() {
+        return this.width === undefined ? undefined : cellCount(this.width);
+    }
+    /**
+     * As Rich's `__rich_console__` sizes it: a declared width is a ceiling that
+     * `expand` fills and a fitted panel fits its content inside, and the title
+     * widens either.
+     */
+    _getPanelWidth(options) {
+        const ceiling = Math.min(options.maxWidth, this._declaredWidth ?? options.maxWidth);
+        const body = this.expand ? ceiling : this._contentRange({ ...options, maxWidth: ceiling }).maximum;
+        // The title holds its label whole between one rule cell either side —
+        // past a declared width too, up to the width the panel was offered.
+        const floor = this._titleLabel === undefined ? 0 : this._labelWidth(options) + 4;
+        return Math.min(options.maxWidth, Math.max(body, floor));
+    }
+    *_renderTopBorder(options, box, geometry, border) {
+        const titleStyle = borderTextStyle(border, getStyle(options, this.titleStyle ?? NULL_STYLE));
+        yield* borderRow(options, box.top, geometry, geometry.spanWidth, this._titleLabel, titleStyle, border, box.top.right.repeat(geometry.right));
+        yield Segment.line();
+    }
+    *_renderBottomBorder(options, box, geometry, border) {
+        // Resolve the right accessory *now*. Function form evaluates after
+        // content has been rendered (Panel.render collects content segments
+        // before yielding any borders), so the thunk sees fresh widget state.
+        const accessory = this._resolveAccessory(this.bottomRightAccessory);
+        const accessoryDisplay = accessory === undefined
+            ? ""
+            : typeof accessory === "string"
+                ? ` ${accessory} `
+                : ` ${accessory.plain} `;
+        // Cell-aware clip: the accessory never claims more than the span.
+        const accessoryText = setCellSize(accessoryDisplay, asCellCol(Math.min(cellLen(accessoryDisplay), geometry.spanWidth)));
+        const accessoryOwn = accessory instanceof RichText ? accessory.resolvedStyle(options) : NULL_STYLE;
+        const subtitleStyle = borderTextStyle(border, getStyle(options, this.subtitleStyle ?? NULL_STYLE));
+        // The accessory hugs the bottom-right corner; the rule and subtitle are
+        // laid out, as Rich lays them, across the span it leaves. With no
+        // accessory the corner closes the rule's last run, as Rich's does.
+        const corner = box.bottom.right.repeat(geometry.right);
+        const [close, afterAccessory] = accessoryText === "" ? [corner, ""] : ["", corner];
+        yield* borderRow(options, box.bottom, geometry, geometry.spanWidth - cellLen(accessoryText), this._subtitleLabel, subtitleStyle, border, close);
+        yield new Segment(accessoryText, borderTextStyle(border, accessoryOwn));
+        yield new Segment(afterAccessory, border);
+        yield Segment.line();
+    }
+    _resolveAccessory(a) {
+        if (a === undefined)
+            return undefined;
+        if (typeof a === "function")
+            return a();
+        return a;
+    }
+    // --- Static factory ---
+    static fit(content, options) {
+        return new Panel(content, { ...options, expand: false });
+    }
+}