@promptctl/rich-js 0.16.0 → 0.18.0

package/dist/renderables/panel.js

@@ -1,322 +0,0 @@
-/**
- * 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 { normalizePadding } from "./padding.js";
-import { getStyle, 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);
-}
-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;
-    title;
-    subtitle;
-    bottomRightAccessory;
-    expand;
-    style;
-    borderStyle;
-    titleStyle;
-    subtitleStyle;
-    width;
-    padding;
-    constructor(content, options) {
-        this.renderable = toRenderable(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 = options.asciiOnly ? this.box.substitute({ asciiOnly: true }) : this.box;
-        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) {
-        const innerOptions = {
-            ...options,
-            maxWidth: contentWidth,
-        };
-        const lines = Segment.splitLines([...this.renderable.render(innerOptions)]);
-        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;
-        if (!this.title) {
-            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);
-        }
-        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 new Segment(titleDisplay, titleSeg);
-            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);
-        if (!this.subtitle) {
-            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);
-            }
-            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);
-                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

@@ -1,90 +0,0 @@
-/**
- * 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

@@ -1,241 +0,0 @@
-/**
- * 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, renderMarkup } from "../core/markup.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: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);
-    }
-}
-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

@@ -1,31 +0,0 @@
-/**
- * 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;
-    };
-}