tinky 1.5.0 → 1.7.0

package/lib/core/render-border.js

@@ -1,82 +1,91 @@
 import { boxStyles } from "./box-styles.js";
 import ansis from "ansis";
-import { colorize } from "../utils/colorize.js";
-/**
- * Renders the border for a DOM node.
- * Calculates border dimensions and draws border characters with specified
- * styles.
- *
- * @param x - The x-coordinate (column) where the border starts.
- * @param y - The y-coordinate (row) where the border starts.
- * @param node - The DOM node for which to render the border.
- * @param output - The output instance to write the border to.
- */
+import stringWidth from "string-width";
+import { getStyle } from "../utils/colorize.js";
+// Helper to resolve styles once
+const resolveBorderStyles = (color, dim) => {
+    const styles = [];
+    if (dim) {
+        styles.push({
+            type: "ansi",
+            code: ansis.dim.open,
+            endCode: ansis.dim.close,
+        });
+    }
+    const colorStyle = getStyle(color, "foreground");
+    if (colorStyle) {
+        styles.push(colorStyle);
+    }
+    return styles;
+};
 export const renderBorder = (x, y, node, output) => {
-    if (node.style.borderStyle) {
-        const layout = node.taffyNode?.tree.getLayout(node.taffyNode.id);
-        const width = layout?.width ?? 0;
-        const height = layout?.height ?? 0;
-        const box = typeof node.style.borderStyle === "string"
-            ? boxStyles[node.style.borderStyle]
-            : node.style.borderStyle;
-        const topBorderColor = node.style.borderTopColor ?? node.style.borderColor;
-        const bottomBorderColor = node.style.borderBottomColor ?? node.style.borderColor;
-        const leftBorderColor = node.style.borderLeftColor ?? node.style.borderColor;
-        const rightBorderColor = node.style.borderRightColor ?? node.style.borderColor;
-        const dimTopBorderColor = node.style.borderTopDimColor ?? node.style.borderDimColor;
-        const dimBottomBorderColor = node.style.borderBottomDimColor ?? node.style.borderDimColor;
-        const dimLeftBorderColor = node.style.borderLeftDimColor ?? node.style.borderDimColor;
-        const dimRightBorderColor = node.style.borderRightDimColor ?? node.style.borderDimColor;
-        const showTopBorder = node.style.borderTop !== false;
-        const showBottomBorder = node.style.borderBottom !== false;
-        const showLeftBorder = node.style.borderLeft !== false;
-        const showRightBorder = node.style.borderRight !== false;
-        const contentWidth = width - (showLeftBorder ? 1 : 0) - (showRightBorder ? 1 : 0);
-        let topBorder = showTopBorder
-            ? colorize((showLeftBorder ? box.topLeft : "") +
-                box.top.repeat(contentWidth) +
-                (showRightBorder ? box.topRight : ""), topBorderColor, "foreground")
-            : undefined;
-        if (showTopBorder && dimTopBorderColor) {
-            topBorder = ansis.dim(topBorder);
-        }
-        let verticalBorderHeight = height;
-        if (showTopBorder) {
-            verticalBorderHeight -= 1;
-        }
-        if (showBottomBorder) {
-            verticalBorderHeight -= 1;
-        }
-        let leftBorder = (colorize(box.left, leftBorderColor, "foreground") + "\n").repeat(verticalBorderHeight);
-        if (dimLeftBorderColor) {
-            leftBorder = ansis.dim(leftBorder);
+    const { borderStyle } = node.style;
+    if (!borderStyle) {
+        return;
+    }
+    const layout = node.taffyNode?.tree.getLayout(node.taffyNode.id);
+    const width = layout?.width ?? 0;
+    const height = layout?.height ?? 0;
+    const box = typeof borderStyle === "string" ? boxStyles[borderStyle] : borderStyle;
+    const { borderColor, borderTopColor, borderBottomColor, borderLeftColor, borderRightColor, borderDimColor, borderTopDimColor, borderBottomDimColor, borderLeftDimColor, borderRightDimColor, } = node.style;
+    const showTopBorder = node.style.borderTop !== false;
+    const showBottomBorder = node.style.borderBottom !== false;
+    const showLeftBorder = node.style.borderLeft !== false;
+    const showRightBorder = node.style.borderRight !== false;
+    const contentWidth = width - (showLeftBorder ? 1 : 0) - (showRightBorder ? 1 : 0);
+    // Top Border
+    if (showTopBorder) {
+        const styles = resolveBorderStyles(borderTopColor ?? borderColor, borderTopDimColor ?? borderDimColor);
+        if (showLeftBorder) {
+            output.fill(x, y, 1, box.topLeft, stringWidth(box.topLeft), styles);
         }
-        let rightBorder = (colorize(box.right, rightBorderColor, "foreground") + "\n").repeat(verticalBorderHeight);
-        if (dimRightBorderColor) {
-            rightBorder = ansis.dim(rightBorder);
+        if (contentWidth > 0) {
+            output.fill(x + (showLeftBorder ? 1 : 0), y, contentWidth, box.top, stringWidth(box.top), styles);
         }
-        let bottomBorder = showBottomBorder
-            ? colorize((showLeftBorder ? box.bottomLeft : "") +
-                box.bottom.repeat(contentWidth) +
-                (showRightBorder ? box.bottomRight : ""), bottomBorderColor, "foreground")
-            : undefined;
-        if (showBottomBorder && dimBottomBorderColor) {
-            bottomBorder = ansis.dim(bottomBorder);
+        if (showRightBorder) {
+            output.fill(x + width - 1, y, 1, box.topRight, stringWidth(box.topRight), styles);
         }
-        const offsetY = showTopBorder ? 1 : 0;
-        if (topBorder) {
-            output.write(x, y, topBorder, { transformers: [] });
+    }
+    // Vertical Borders
+    let verticalBorderHeight = height;
+    if (showTopBorder)
+        verticalBorderHeight -= 1;
+    if (showBottomBorder)
+        verticalBorderHeight -= 1;
+    if (verticalBorderHeight > 0) {
+        const offsetY = y + (showTopBorder ? 1 : 0);
+        // Optimization: Resolve styles once
+        const leftStyles = showLeftBorder
+            ? resolveBorderStyles(borderLeftColor ?? borderColor, borderLeftDimColor ?? borderDimColor)
+            : [];
+        const rightStyles = showRightBorder
+            ? resolveBorderStyles(borderRightColor ?? borderColor, borderRightDimColor ?? borderDimColor)
+            : [];
+        // Optimization: Calculate widths once
+        const leftWidth = showLeftBorder ? stringWidth(box.left) : 0;
+        const rightWidth = showRightBorder ? stringWidth(box.right) : 0;
+        for (let i = 0; i < verticalBorderHeight; i++) {
+            const row = offsetY + i;
+            if (showLeftBorder) {
+                output.fill(x, row, 1, box.left, leftWidth, leftStyles);
+            }
+            if (showRightBorder) {
+                output.fill(x + width - 1, row, 1, box.right, rightWidth, rightStyles);
+            }
         }
+    }
+    // Bottom Border
+    if (showBottomBorder) {
+        const styles = resolveBorderStyles(borderBottomColor ?? borderColor, borderBottomDimColor ?? borderDimColor);
+        const bottomY = y + height - 1;
         if (showLeftBorder) {
-            output.write(x, y + offsetY, leftBorder, { transformers: [] });
+            output.fill(x, bottomY, 1, box.bottomLeft, stringWidth(box.bottomLeft), styles);
         }
-        if (showRightBorder) {
-            output.write(x + width - 1, y + offsetY, rightBorder, {
-                transformers: [],
-            });
+        if (contentWidth > 0) {
+            output.fill(x + (showLeftBorder ? 1 : 0), bottomY, contentWidth, box.bottom, stringWidth(box.bottom), styles);
         }
-        if (bottomBorder) {
-            output.write(x, y + height - 1, bottomBorder, { transformers: [] });
+        if (showRightBorder) {
+            output.fill(x + width - 1, bottomY, 1, box.bottomRight, stringWidth(box.bottomRight), styles);
         }
     }
 };

package/lib/core/render-node-to-output.d.ts

@@ -1,5 +1,5 @@
 import { type DOMElement } from "./dom.js";
-import { type Output } from "./output.js";
+import { type OutputLike } from "./output.js";
 /**
  * Function type for transforming output text.
  */
@@ -35,7 +35,7 @@ export declare const renderNodeToScreenReaderOutput: (node: DOMElement, options?
  * @param options.transformers - Array of text transformers.
  * @param options.skipStaticElements - Whether to skip static elements.
  */
-export declare const renderNodeToOutput: (node: DOMElement, output: Output, options: {
+export declare const renderNodeToOutput: (node: DOMElement, output: OutputLike, options: {
     offsetX?: number;
     offsetY?: number;
     transformers?: OutputTransformer[];

package/lib/core/render.d.ts

@@ -1,6 +1,8 @@
 import { type ReactNode } from "react";
 import { type ReadStream, type WriteStream } from "../types/io.js";
 import { Tinky, type RenderMetrics } from "./tinky.js";
+import { type IncrementalRenderingConfig, type IncrementalRenderingOption } from "./incremental-rendering.js";
+export type { IncrementalRenderingConfig, IncrementalRenderingOption };
 /**
  * Options for the render function.
  */
@@ -64,13 +66,24 @@ export interface RenderOptions {
      */
     maxFps?: number;
     /**
-     * Enable incremental rendering mode which only updates changed lines instead
-     * of redrawing the entire output. Reduces flickering and improves
-     * performance.
+     * Configure incremental rendering mode.
+     *
+     * - `true`: Enables run-diff incremental rendering.
+     * - `false` or omitted: Disables incremental rendering.
+     * - Object mode:
+     *   - `{ enabled: false }` disables incremental rendering.
+     *   - `{ strategy: "line" }` enables line-diff incremental rendering.
+     *   - `{ strategy: "run" }` (or omitted strategy) enables run-diff rendering.
+     *
+     * Runtime notes:
+     * - In `run` strategy, terminal writes are skipped entirely when frames are unchanged.
+     * - In `debug` mode, Tinky always writes full frames.
+     * - In screen-reader mode, Tinky uses the screen-reader output path.
+     * - In CI mode, Tinky avoids cursor-diff updates.
      *
      * @defaultValue false
      */
-    incrementalRendering?: boolean;
+    incrementalRendering?: IncrementalRenderingOption;
     /**
      * Environment variables.
      *

package/lib/core/renderer.js

@@ -1,5 +1,6 @@
 import { renderNodeToOutput, renderNodeToScreenReaderOutput, } from "./render-node-to-output.js";
-import { Output } from "./output.js";
+import { CellBuffer } from "./cell-buffer.js";
+import { CellOutput } from "./cell-output.js";
 /**
  * Renders the DOM tree to a string output.
  *
@@ -27,31 +28,33 @@ export const renderer = (node, isScreenReaderEnabled) => {
             };
         }
         const layout = node.taffyNode.tree.getLayout(node.taffyNode.id);
-        const output = new Output({
+        const buffer = new CellBuffer({
             width: layout.width,
             height: layout.height,
         });
+        const output = new CellOutput(buffer);
         renderNodeToOutput(node, output, {
             skipStaticElements: true,
         });
         let staticOutput;
         if (node.staticNode?.taffyNode) {
             const staticLayout = node.staticNode.taffyNode.tree.getLayout(node.staticNode.taffyNode.id);
-            staticOutput = new Output({
+            const staticBuffer = new CellBuffer({
                 width: staticLayout.width,
                 height: staticLayout.height,
             });
+            staticOutput = new CellOutput(staticBuffer);
             renderNodeToOutput(node.staticNode, staticOutput, {
                 skipStaticElements: false,
             });
         }
-        const { output: generatedOutput, height: outputHeight } = output.get();
+        const generatedOutput = buffer.toString();
         return {
             output: generatedOutput,
-            outputHeight,
+            outputHeight: buffer.height,
             // Newline at the end is needed, because static output doesn't have one,
             // so interactive output will override last line of static output
-            staticOutput: staticOutput ? `${staticOutput.get().output}\n` : "",
+            staticOutput: staticOutput ? `${staticOutput.buffer.toString()}\n` : "",
         };
     }
     return {

package/lib/core/tinky.d.ts

@@ -1,5 +1,6 @@
 import { type ReactNode } from "react";
 import { type ReadStream, type WriteStream } from "../types/io.js";
+import { type IncrementalRenderingOption } from "./incremental-rendering.js";
 /**
  * Performance metrics for a render operation.
  */
@@ -59,10 +60,15 @@ export interface Options {
      */
     maxFps?: number;
     /**
-     * Enable incremental rendering mode which only updates changed lines instead
-     * of redrawing the entire output.
+     * Configure incremental rendering mode.
+     *
+     * - `true`: Enables run-diff incremental rendering.
+     * - `false` or omitted: Disables incremental rendering.
+     * - `{ enabled: false }`: Disables incremental rendering.
+     * - `{ strategy: "line" }`: Enables line-diff incremental rendering.
+     * - `{ strategy: "run" }` (or omitted strategy): Enables run-diff rendering.
      */
-    incrementalRendering?: boolean;
+    incrementalRendering?: IncrementalRenderingOption;
     /**
      * Environment variables.
      */
@@ -103,6 +109,16 @@ export declare class Tinky {
     private readonly unsubscribeResize?;
     /** Whether we are running in a CI environment. */
     private readonly isCI;
+    /** Whether run-diff incremental rendering is active for this instance. */
+    private readonly usesRunIncrementalRendering;
+    /** Run-diff log updater. */
+    private readonly cellLog?;
+    /** Shared style registry for run buffers. */
+    private readonly styleRegistry?;
+    /** Previous rendered frame for run-diff strategy. */
+    private frontBuffer?;
+    /** Current frame render target for run-diff strategy. */
+    private backBuffer?;
     /**
      * Creates an instance of Tinky.
      *
@@ -137,6 +153,14 @@ export declare class Tinky {
      * Handles string generation, static output, screen reader logic, and writing.
      */
     onRender: () => void;
+    /**
+     * Swaps front and back buffers. After swap, the caller's newly-rendered
+     * frame becomes the front buffer. The old front becomes the back buffer
+     * and will be cleared by cellRenderer (resize + clear) at the start of
+     * the next render cycle.
+     */
+    private swapRunBuffers;
+    private redrawRunBuffer;
     /**
      * Renders the given React node.
      *

package/lib/core/tinky.js

@@ -5,15 +5,20 @@ import { isCI } from "../utils/check-ci.js";
 import autoBind from "auto-bind";
 import { onExit } from "../utils/signal-exit.js";
 import { patchConsole } from "../utils/patch-console.js";
+import { advanceSquashTextEpoch } from "../utils/squash-text-nodes.js";
 import { LegacyRoot } from "react-reconciler/constants.js";
 import wrapAnsi from "wrap-ansi";
 import { reconciler } from "./reconciler.js";
 import { renderer } from "./renderer.js";
+import { cellRenderer } from "./cell-renderer.js";
 import * as dom from "./dom.js";
 import { logUpdate } from "./log-update.js";
+import { cellLogUpdateRun, } from "./cell-log-update-run.js";
 import { instances } from "./instances.js";
 import { App } from "../components/App.js";
 import { AccessibilityContext } from "../contexts/AccessibilityContext.js";
+import { CellBuffer, StyleRegistry } from "./cell-buffer.js";
+import { normalizeIncrementalRendering, } from "./incremental-rendering.js";
 const noop = () => {
     // no-op
 };
@@ -52,6 +57,16 @@ export class Tinky {
     unsubscribeResize;
     /** Whether we are running in a CI environment. */
     isCI;
+    /** Whether run-diff incremental rendering is active for this instance. */
+    usesRunIncrementalRendering;
+    /** Run-diff log updater. */
+    cellLog;
+    /** Shared style registry for run buffers. */
+    styleRegistry;
+    /** Previous rendered frame for run-diff strategy. */
+    frontBuffer;
+    /** Current frame render target for run-diff strategy. */
+    backBuffer;
     /**
      * Creates an instance of Tinky.
      *
@@ -65,6 +80,16 @@ export class Tinky {
         this.isScreenReaderEnabled =
             options.isScreenReaderEnabled ??
                 options.env?.["TINKY_SCREEN_READER"] === "true";
+        this.isCI = isCI(options.env);
+        const incrementalRenderStrategy = normalizeIncrementalRendering(options.incrementalRendering);
+        // Run-diff uses cursor addressing and interactive frame tracking, so we keep
+        // existing render paths in debug/screen-reader/CI modes.
+        this.usesRunIncrementalRendering =
+            incrementalRenderStrategy === "run" &&
+                !options.debug &&
+                !this.isScreenReaderEnabled &&
+                !this.isCI;
+        const useLineIncremental = incrementalRenderStrategy === "line";
         const unthrottled = options.debug || this.isScreenReaderEnabled;
         const maxFps = options.maxFps ?? 30;
         const renderThrottleMs = maxFps > 0 ? Math.max(1, Math.ceil(1000 / maxFps)) : 0;
@@ -76,7 +101,7 @@ export class Tinky {
             });
         this.rootNode.onImmediateRender = this.onRender;
         this.log = logUpdate.create(options.stdout, {
-            incremental: options.incrementalRendering,
+            incremental: useLineIncremental,
         });
         this.throttledLog = unthrottled
             ? this.log
@@ -84,6 +109,17 @@ export class Tinky {
                 leading: true,
                 trailing: true,
             });
+        if (this.usesRunIncrementalRendering) {
+            this.styleRegistry = new StyleRegistry();
+            this.frontBuffer = new CellBuffer({ width: 0, height: 0 }, this.styleRegistry);
+            this.backBuffer = new CellBuffer({ width: 0, height: 0 }, this.styleRegistry);
+            this.cellLog = cellLogUpdateRun.create(options.stdout, {
+                incremental: true,
+                mergeStrategy: "cost",
+                maxSegmentsBeforeFullRow: 12,
+                overwriteGapPenaltyBytes: 0,
+            });
+        }
         // Ignore last render after unmounting a tree to prevent empty output before
         // exit
         this.isUnmounted = false;
@@ -108,7 +144,6 @@ export class Tinky {
                 rendererPackageName: "tinky",
             });
         }
-        this.isCI = isCI(options.env);
         if (this.options.patchConsole) {
             this.patchConsole();
         }
@@ -138,8 +173,16 @@ export class Tinky {
         if (currentWidth < this.lastTerminalWidth) {
             // We clear the screen when decreasing terminal width to prevent duplicate
             // overlapping re-renders.
-            this.log.clear();
+            if (this.usesRunIncrementalRendering) {
+                this.cellLog?.clear();
+                this.frontBuffer?.resize(0, 0);
+                this.frontBuffer?.clear();
+            }
+            else {
+                this.log.clear();
+            }
             this.lastOutput = "";
+            this.lastOutputHeight = 0;
         }
         this.calculateLayout();
         this.onRender();
@@ -160,6 +203,8 @@ export class Tinky {
         if (this.rootNode.taffyNode === undefined) {
             return;
         }
+        // Keep text-squash cache scoped to one layout/render cycle.
+        advanceSquashTextEpoch();
         const terminalWidth = this.getTerminalWidth();
         const { tree } = this.rootNode.taffyNode;
         const rootStyle = tree.getStyle(this.rootNode.taffyNode.id);
@@ -186,6 +231,40 @@ export class Tinky {
         if (this.isUnmounted) {
             return;
         }
+        if (this.usesRunIncrementalRendering && this.backBuffer) {
+            const startTime = performance.now();
+            const { buffer, outputHeight, staticOutput } = cellRenderer(this.rootNode, this.backBuffer, false);
+            this.options.onRender?.({ renderTime: performance.now() - startTime });
+            const hasStaticOutput = staticOutput && staticOutput !== "\n";
+            if (hasStaticOutput) {
+                this.fullStaticOutput += staticOutput;
+            }
+            if (this.options.stdout.rows &&
+                this.lastOutputHeight >= this.options.stdout.rows) {
+                const output = buffer.toString();
+                this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + output);
+                this.lastOutput = output;
+                this.lastOutputHeight = outputHeight;
+                this.cellLog?.sync(buffer);
+                this.swapRunBuffers();
+                return;
+            }
+            if (hasStaticOutput) {
+                // Static output is appended once, then the interactive frame is redrawn.
+                this.cellLog?.clear();
+                this.options.stdout.write(staticOutput);
+                if (this.frontBuffer && this.cellLog) {
+                    this.cellLog(this.frontBuffer, buffer, { forceFull: true });
+                    this.swapRunBuffers();
+                }
+            }
+            else if (this.frontBuffer && this.cellLog) {
+                this.cellLog(this.frontBuffer, buffer);
+                this.swapRunBuffers();
+            }
+            this.lastOutputHeight = outputHeight;
+            return;
+        }
         const startTime = performance.now();
         const { output, outputHeight, staticOutput } = renderer(this.rootNode, this.isScreenReaderEnabled);
         this.options.onRender?.({ renderTime: performance.now() - startTime });
@@ -264,6 +343,25 @@ export class Tinky {
         this.lastOutput = output;
         this.lastOutputHeight = outputHeight;
     };
+    /**
+     * Swaps front and back buffers. After swap, the caller's newly-rendered
+     * frame becomes the front buffer. The old front becomes the back buffer
+     * and will be cleared by cellRenderer (resize + clear) at the start of
+     * the next render cycle.
+     */
+    swapRunBuffers() {
+        const previous = this.frontBuffer;
+        this.frontBuffer = this.backBuffer;
+        this.backBuffer = previous;
+    }
+    redrawRunBuffer() {
+        if (!this.frontBuffer || !this.cellLog) {
+            return;
+        }
+        this.cellLog(this.frontBuffer, this.frontBuffer, { forceFull: true });
+        this.lastOutput = this.frontBuffer.toString();
+        this.lastOutputHeight = this.frontBuffer.height;
+    }
     /**
      * Renders the given React node.
      *
@@ -291,6 +389,12 @@ export class Tinky {
             this.options.stdout.write(data);
             return;
         }
+        if (this.usesRunIncrementalRendering) {
+            this.cellLog?.clear();
+            this.options.stdout.write(data);
+            this.redrawRunBuffer();
+            return;
+        }
         this.log.clear();
         this.options.stdout.write(data);
         this.log(this.lastOutput);
@@ -313,6 +417,12 @@ export class Tinky {
             this.options.stderr.write(data);
             return;
         }
+        if (this.usesRunIncrementalRendering) {
+            this.cellLog?.clear();
+            this.options.stderr.write(data);
+            this.redrawRunBuffer();
+            return;
+        }
         this.log.clear();
         this.options.stderr.write(data);
         this.log(this.lastOutput);
@@ -345,7 +455,12 @@ export class Tinky {
             this.options.stdout.write(this.lastOutput + "\n");
         }
         else if (!this.options.debug) {
-            this.log.done();
+            if (this.usesRunIncrementalRendering) {
+                this.cellLog?.done();
+            }
+            else {
+                this.log.done();
+            }
         }
         this.isUnmounted = true;
         reconciler.updateContainerSync(null, this.container, null, noop);
@@ -387,7 +502,12 @@ export class Tinky {
     clear() {
         const isCiEnv = isCI(this.options.env);
         if (!isCiEnv) {
-            this.log.clear();
+            if (this.usesRunIncrementalRendering) {
+                this.cellLog?.clear();
+            }
+            else {
+                this.log.clear();
+            }
         }
     }
     /**

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 export { type ReadStream, type WriteStream } from "./types/io.js";
 export { render, type RenderOptions, type Instance } from "./core/render.js";
+export { type IncrementalRenderingConfig, type IncrementalRenderingOption, } from "./core/render.js";
 export { Box, type BoxProps } from "./components/Box.js";
 export { Text, type TextProps } from "./components/Text.js";
 export { AppContext, type AppProps } from "./contexts/AppContext.js";

package/lib/types/ansi.d.ts

@@ -0,0 +1,5 @@
+export interface AnsiCode {
+    type: "ansi";
+    code: string;
+    endCode: string;
+}

package/lib/types/ansi.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/ansi-escapes.d.ts

@@ -2,6 +2,7 @@ export declare const cursorTo: (x: number, y?: number) => string;
 export declare const cursorUp: (count?: number) => string;
 export declare const cursorNextLine = "\u001B[E";
 export declare const cursorLeft = "\u001B[G";
+export declare const cursorForward: (count?: number) => string;
 export declare const eraseEndLine = "\u001B[K";
 export declare const eraseLine = "\u001B[2K";
 export declare const eraseLines: (count: number) => string;
@@ -11,6 +12,7 @@ declare const ansiEscapes: {
     cursorUp: (count?: number) => string;
     cursorNextLine: string;
     cursorLeft: string;
+    cursorForward: (count?: number) => string;
     eraseEndLine: string;
     eraseLine: string;
     eraseLines: (count: number) => string;

package/lib/utils/ansi-escapes.js

@@ -11,6 +11,7 @@ export const cursorTo = (x, y) => {
 export const cursorUp = (count = 1) => `${ESC}${count}A`;
 export const cursorNextLine = `${ESC}E`;
 export const cursorLeft = `${ESC}G`;
+export const cursorForward = (count = 1) => `${ESC}${count}C`;
 export const eraseEndLine = `${ESC}K`;
 export const eraseLine = `${ESC}2K`;
 export const eraseLines = (count) => {
@@ -29,6 +30,7 @@ const ansiEscapes = {
     cursorUp,
     cursorNextLine,
     cursorLeft,
+    cursorForward,
     eraseEndLine,
     eraseLine,
     eraseLines,

package/lib/utils/colorize.d.ts

@@ -20,5 +20,10 @@ type ColorType = "foreground" | "background";
  * @param type - Whether to apply the color to the foreground or background.
  * @returns The colorized string.
  */
+import { type AnsiCode } from "../types/ansi.js";
+/**
+ * Gets the ANSI style for a color.
+ */
+export declare const getStyle: (color: string | undefined, type: ColorType) => AnsiCode | undefined;
 export declare const colorize: (str: string, color: string | undefined, type: ColorType) => string;
 export {};