@promptctl/rich-js 0.18.0 → 0.18.1

package/dist/renderables/panel.js

@@ -0,0 +1,307 @@
+/**
+ * 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 { embed, inlineLabel } from "./embed.js";
+import { normalizePadding } from "./padding.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
+    // 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;
+}
+/**
+ * The style of text set into a border: its own when one was given, the
+ * border's otherwise — the one rule for "what colour is the title text in".
+ */
+function borderTextStyle(options, own, border) {
+    return own === undefined ? border : getStyle(options, own);
+}
+export class Panel {
+    renderable;
+    box;
+    title;
+    subtitle;
+    bottomRightAccessory;
+    expand;
+    style;
+    borderStyle;
+    titleStyle;
+    subtitleStyle;
+    width;
+    padding;
+    constructor(content, options) {
+        this.renderable = embed(content);
+        this.box = options?.box ?? ROUNDED;
+        this.title = options?.title;
+        this.subtitle = options?.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);
+        const borderStyle = getStyle(options, this.borderStyle);
+        const style = getStyle(options, this.style);
+        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);
+        // Top border (with optional title)
+        yield* this._renderTopBorder(options, box, geometry, border);
+        // Top padding — a padding row is a content row whose content is nothing.
+        for (let i = 0; i < padTop; i++) {
+            yield* this._renderRow(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._renderRow(box, geometry, [], border, contentStyle);
+        }
+        // Bottom border (with optional subtitle)
+        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) {
+        // 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;
+    }
+    /**
+     * 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.
+     */
+    *_renderRow(box, geometry, line, border, contentStyle) {
+        const frame = box.getContentChars("row");
+        yield new Segment(frame.left.repeat(geometry.left), border);
+        const content = Segment.adjustLineLength(line, geometry.contentWidth, contentStyle, false);
+        const span = [new Segment(" ".repeat(geometry.padLeft), contentStyle), ...content];
+        yield* Segment.adjustLineLength(span, geometry.spanWidth, contentStyle);
+        yield new Segment(frame.right.repeat(geometry.right), border);
+        yield Segment.line();
+    }
+    measure(rawOptions) {
+        const options = withCellWidth(rawOptions);
+        const declared = this._declaredWidth;
+        if (declared !== undefined) {
+            // A declared width is not a ceiling on the content, it is the answer:
+            // `_getPanelWidth` returns it before measuring anything, so the panel
+            // draws at this width whatever the content wants. Reported with a
+            // content-derived floor instead, `{width: 20}` around "hi" offered 100
+            // cells answered 6..20 and then drew 20 every time, and a parent
+            // dividing space from the floor under-provisioned it.
+            const width = Math.min(options.maxWidth, declared);
+            return { minimum: width, maximum: width };
+        }
+        return this._fitRange(options);
+    }
+    /**
+     * 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.
+     */
+    _fitRange(options) {
+        const geometry = layoutPanel(options.maxWidth, this.padding);
+        const overhead = frameOverhead(geometry);
+        if (isMeasurable(this.renderable)) {
+            const innerOptions = {
+                ...options,
+                maxWidth: geometry.contentWidth,
+            };
+            const measurement = Measurement.get(innerOptions, this.renderable);
+            const maximum = Math.min(options.maxWidth, measurement.maximum + overhead);
+            return {
+                minimum: Math.min(measurement.minimum + overhead, maximum),
+                maximum,
+            };
+        }
+        // Content that cannot measure itself leaves the panel with nothing to want,
+        // so it wants the offer — unbounded included, which `withBoundedWidth`
+        // reports rather than turning into a number nobody can defend.
+        return { minimum: Math.min(overhead, options.maxWidth), maximum: options.maxWidth };
+    }
+    /**
+     * 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.
+     */
+    get _declaredWidth() {
+        return this.width === undefined ? undefined : cellCount(this.width);
+    }
+    _getPanelWidth(options) {
+        const declared = this._declaredWidth;
+        if (declared !== undefined)
+            return Math.min(declared, options.maxWidth);
+        if (this.expand)
+            return options.maxWidth;
+        return this._fitRange(options).maximum;
+    }
+    *_renderTopBorder(options, box, geometry, border) {
+        const innerBorderWidth = geometry.spanWidth;
+        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;
+        }
+        yield new Segment(box.top.left.repeat(geometry.left), border);
+        if (titleWidth >= innerBorderWidth) {
+            // 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
+            const leftRuleWidth = Math.floor((innerBorderWidth - titleWidth) / 2);
+            const rightRuleWidth = innerBorderWidth - titleWidth - leftRuleWidth;
+            if (leftRuleWidth > 0)
+                yield new Segment(box.top.horizontal.repeat(leftRuleWidth), border);
+            yield* title;
+            if (rightRuleWidth > 0)
+                yield new Segment(box.top.horizontal.repeat(rightRuleWidth), border);
+        }
+        yield new Segment(box.top.right.repeat(geometry.right), border);
+        yield Segment.line();
+    }
+    *_renderBottomBorder(options, box, geometry, border) {
+        const innerBorderWidth = geometry.spanWidth;
+        // 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} `;
+        const accessoryWidth = cellLen(accessoryDisplay);
+        const accessoryOwn = accessory instanceof RichText ? accessory.resolvedStyle(options) : NULL_STYLE;
+        const accessoryStyle = accessoryOwn.isNull ? border : accessoryOwn;
+        yield new Segment(box.bottom.left.repeat(geometry.left), border);
+        // Space available for the centered subtitle / rule fill — the accessory
+        // (if any) hugs the right edge and the subtitle treats the remainder
+        // as its centering canvas.
+        const centerWidth = Math.max(0, innerBorderWidth - accessoryWidth);
+        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 {
+            if (subtitleWidth >= centerWidth) {
+                // Cell-aware clip — see _renderTopBorder.
+                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* subtitle;
+                if (rightRuleWidth > 0)
+                    yield new Segment(box.bottom.horizontal.repeat(rightRuleWidth), border);
+            }
+        }
+        if (accessoryWidth > 0) {
+            // Cell-aware clip — see _renderTopBorder.
+            const fit = accessoryWidth > innerBorderWidth
+                ? setCellSize(accessoryDisplay, asCellCol(innerBorderWidth))
+                : accessoryDisplay;
+            yield new Segment(fit, accessoryStyle);
+        }
+        yield new Segment(box.bottom.right.repeat(geometry.right), 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 });
+    }
+}

package/dist/renderables/progress.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Progress — displays continuously updated progress bars.
+ */
+import { Segment } from "../core/segment.js";
+import { Console } from "../core/console.js";
+import type { Renderable, RenderOptions } from "../core/protocol.js";
+export interface TaskOptions {
+    total?: number;
+    start?: boolean;
+    visible?: boolean;
+}
+export interface TaskUpdateOptions {
+    completed?: number;
+    advance?: number;
+    description?: string;
+    visible?: boolean;
+    refresh?: boolean;
+}
+interface Task {
+    id: number;
+    description: string;
+    total: number | undefined;
+    completed: number;
+    started: boolean;
+    visible: boolean;
+    startTime: number;
+    elapsed: number;
+}
+export interface ProgressColumn extends Renderable {
+    render(options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export declare class TextColumn implements ProgressColumn {
+    readonly format: string;
+    constructor(format?: string);
+    render(options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export declare class BarColumn implements ProgressColumn {
+    readonly barWidth: number;
+    constructor(barWidth?: number);
+    render(_options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export declare class TaskProgressColumn implements ProgressColumn {
+    render(options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export declare class TimeRemainingColumn implements ProgressColumn {
+    render(options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export declare class TimeElapsedColumn implements ProgressColumn {
+    render(options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export declare class SpinnerColumn implements ProgressColumn {
+    private _spinner;
+    constructor(spinnerName?: string);
+    render(options: RenderOptions, _task?: Task): Iterable<Segment>;
+}
+export declare class MofNCompleteColumn implements ProgressColumn {
+    render(_options: RenderOptions, task?: Task): Iterable<Segment>;
+}
+export interface ProgressOptions {
+    refreshPerSecond?: number;
+    autoRefresh?: boolean;
+    transient?: boolean;
+    expand?: boolean;
+    console?: Console;
+}
+export declare class Progress implements Renderable {
+    private _columns;
+    private _tasks;
+    private _nextId;
+    private _live;
+    private _console;
+    readonly expand: boolean;
+    constructor(...columns: (ProgressColumn | ProgressOptions)[]);
+    get console(): Console;
+    get finished(): boolean;
+    static getDefaultColumns(): ProgressColumn[];
+    addTask(description: string, options?: TaskOptions): number;
+    updateTask(taskId: number, options: TaskUpdateOptions): void;
+    startTask(taskId: number): void;
+    start(): void;
+    stop(): void;
+    refresh(): void;
+    render(options: RenderOptions): Iterable<Segment>;
+}
+export declare function track<T>(iterable: Iterable<T>, options?: {
+    description?: string;
+    total?: number;
+    console?: Console;
+}): Iterable<T>;
+export {};

package/dist/renderables/progress.js

@@ -0,0 +1,238 @@
+/**
+ * Progress — displays continuously updated progress bars.
+ */
+import { Segment } from "../core/segment.js";
+import { RichText } from "../core/text.js";
+import { Console } from "../core/console.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";
+import { Table } from "./table.js";
+import { getStyle } from "../core/protocol.js";
+export class TextColumn {
+    format;
+    constructor(format) {
+        this.format = format ?? "{task.description}";
+    }
+    *render(options, task) {
+        // [LAW:single-enforcer] Format strings flow through the markup parser so
+        // tags like `[progress.description]` become Style spans, not literal text.
+        // Task descriptions are escaped first to prevent injection of stray tags.
+        const description = escapeMarkup(task?.description ?? "");
+        // 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:single-enforcer] A column is a row fragment, the same as any
+        // embedded text.
+        yield* embeddedText(formatted).render(options);
+    }
+}
+export class BarColumn {
+    barWidth;
+    constructor(barWidth) {
+        this.barWidth = barWidth ?? 40;
+    }
+    *render(_options, task) {
+        const bar = new ProgressBar({
+            total: task?.total ?? 100,
+            completed: task?.completed ?? 0,
+            width: this.barWidth,
+        });
+        yield* bar.render(_options);
+    }
+}
+export class TaskProgressColumn {
+    *render(options, task) {
+        const percent = task && task.total
+            ? Math.min(100, Math.round((task.completed / task.total) * 100))
+            : 0;
+        yield new Segment(`${percent}%`, getStyle(options, "progress.percentage"));
+    }
+}
+export class TimeRemainingColumn {
+    *render(options, task) {
+        const style = getStyle(options, "progress.remaining");
+        if (!task || !task.total || !task.started || task.completed <= 0) {
+            yield new Segment("-:--:--", style);
+            return;
+        }
+        const elapsed = (Date.now() - task.startTime) / 1000;
+        const rate = task.completed / elapsed;
+        const remaining = (task.total - task.completed) / rate;
+        yield new Segment(formatTime(remaining), style);
+    }
+}
+export class TimeElapsedColumn {
+    *render(options, task) {
+        const style = getStyle(options, "progress.elapsed");
+        if (!task || !task.started) {
+            yield new Segment("0:00:00", style);
+            return;
+        }
+        const elapsed = (Date.now() - task.startTime) / 1000;
+        yield new Segment(formatTime(elapsed), style);
+    }
+}
+export class SpinnerColumn {
+    _spinner;
+    constructor(spinnerName) {
+        this._spinner = new Spinner(spinnerName);
+    }
+    *render(options, _task) {
+        yield* this._spinner.render(options);
+    }
+}
+export class MofNCompleteColumn {
+    *render(_options, task) {
+        const completed = task?.completed ?? 0;
+        const total = task?.total ?? "?";
+        yield new Segment(`${completed}/${total}`);
+    }
+}
+function formatTime(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = Math.floor(seconds % 60);
+    return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+export class Progress {
+    _columns;
+    _tasks;
+    _nextId;
+    _live;
+    _console;
+    expand;
+    constructor(...columns) {
+        // Last arg might be options
+        let opts = {};
+        const cols = [];
+        for (const arg of columns) {
+            if ("render" in arg) {
+                cols.push(arg);
+            }
+            else {
+                opts = arg;
+            }
+        }
+        if (cols.length === 0) {
+            cols.push(new TextColumn("[progress.description]{task.description}"), new BarColumn(), new TaskProgressColumn(), new TimeRemainingColumn());
+        }
+        this._columns = cols;
+        this._tasks = new Map();
+        this._nextId = 1;
+        this._console = opts.console ?? new Console({ forceTerminal: true });
+        this.expand = opts.expand ?? false;
+        this._live = new Live(this, {
+            console: this._console,
+            refreshPerSecond: opts.refreshPerSecond ?? 10,
+            autoRefresh: opts.autoRefresh,
+            transient: opts.transient,
+        });
+    }
+    get console() {
+        return this._console;
+    }
+    get finished() {
+        for (const task of this._tasks.values()) {
+            if (!task.started || (task.total !== undefined && task.completed < task.total)) {
+                return false;
+            }
+        }
+        return this._tasks.size > 0;
+    }
+    static getDefaultColumns() {
+        return [
+            new TextColumn("[progress.description]{task.description}"),
+            new BarColumn(),
+            new TaskProgressColumn(),
+            new TimeRemainingColumn(),
+        ];
+    }
+    addTask(description, options) {
+        const id = this._nextId++;
+        const task = {
+            id,
+            description,
+            total: options?.total,
+            completed: 0,
+            started: options?.start !== false,
+            visible: options?.visible !== false,
+            startTime: Date.now(),
+            elapsed: 0,
+        };
+        this._tasks.set(id, task);
+        return id;
+    }
+    updateTask(taskId, options) {
+        const task = this._tasks.get(taskId);
+        if (!task)
+            return;
+        if (options.completed !== undefined)
+            task.completed = options.completed;
+        if (options.advance !== undefined)
+            task.completed += options.advance;
+        if (options.description !== undefined)
+            task.description = options.description;
+        if (options.visible !== undefined)
+            task.visible = options.visible;
+        if (options.refresh) {
+            this._live.update(this, { refresh: true });
+        }
+    }
+    startTask(taskId) {
+        const task = this._tasks.get(taskId);
+        if (task) {
+            task.started = true;
+            task.startTime = Date.now();
+        }
+    }
+    start() {
+        this._live.start();
+    }
+    stop() {
+        this._live.stop();
+    }
+    refresh() {
+        this._live.refresh();
+    }
+    *render(options) {
+        const table = Table.grid({ expand: this.expand });
+        for (const _col of this._columns) {
+            table.addColumn();
+        }
+        for (const task of this._tasks.values()) {
+            if (!task.visible)
+                continue;
+            const cells = this._columns.map((col) => {
+                const segs = [...col.render(options, task)];
+                // Build a RichText that preserves segment styles as spans
+                const text = new RichText("", { end: "" });
+                for (const seg of segs) {
+                    text.append(seg.text, seg.style);
+                }
+                return text;
+            });
+            table.addRow(...cells);
+        }
+        yield* table.render(options);
+    }
+}
+// --- track ---
+export function* track(iterable, options) {
+    const items = [...iterable];
+    const total = options?.total ?? items.length;
+    const progress = new Progress({ console: options?.console });
+    const taskId = progress.addTask(options?.description ?? "Working...", { total });
+    progress.start();
+    try {
+        for (let i = 0; i < items.length; i++) {
+            yield items[i];
+            progress.updateTask(taskId, { completed: i + 1 });
+        }
+    }
+    finally {
+        progress.stop();
+    }
+}

package/dist/renderables/progressBar.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ProgressBar — a visual progress bar rendered with block characters.
+ */
+import { Segment } from "../core/segment.js";
+import { Style } from "../core/style.js";
+import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+export interface ProgressBarOptions {
+    total?: number;
+    completed?: number;
+    width?: number;
+    pulse?: boolean;
+    style?: string | Style;
+    completeStyle?: string | Style;
+    finishedStyle?: string | Style;
+}
+export declare class ProgressBar implements Renderable, Measurable {
+    total: number;
+    completed: number;
+    readonly width: number | undefined;
+    readonly pulse: boolean;
+    readonly style: string | Style;
+    readonly completeStyle: string | Style;
+    readonly finishedStyle: string | Style;
+    constructor(options?: ProgressBarOptions);
+    get percentComplete(): number;
+    render(options: RenderOptions): Iterable<Segment>;
+    measure(_options: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+}