@visulima/tui 0.0.1 → 1.0.0-alpha.1

package/README.md

@@ -1,45 +1,189 @@
-# @visulima/tui
+<!-- START_PACKAGE_OG_IMAGE_PLACEHOLDER -->
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+<a href="https://www.anolilab.com/open-source" align="center">
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+  <img src="__assets__/package-og.svg" alt="tui" />
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+</a>
 
-## Purpose
+<h3 align="center">React-based TUI library powered by a native Rust diff engine, drop-in Ink-compatible API</h3>
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@visulima/tui`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+<!-- END_PACKAGE_OG_IMAGE_PLACEHOLDER -->
 
-## What is OIDC Trusted Publishing?
+<br />
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+<div align="center">
 
-## Setup Instructions
+[![typescript-image][typescript-badge]][typescript-url]
+[![mit licence][license-badge]][license]
+[![npm downloads][npm-downloads-badge]][npm-downloads]
+[![Chat][chat-badge]][chat]
+[![PRs Welcome][prs-welcome-badge]][prs-welcome]
 
-To properly configure OIDC trusted publishing for this package:
+</div>
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+---
 
-## DO NOT USE THIS PACKAGE
+<div align="center">
+    <p>
+        <sup>
+            Daniel Bannert's open source work is supported by the community on <a href="https://github.com/sponsors/prisis">GitHub Sponsors</a>
+        </sup>
+    </p>
+</div>
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+---
 
-## More Information
+## Overview
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+`@visulima/tui` is a React-based terminal UI library with a native Rust diff engine and drop-in [Ink](https://github.com/vadimdemedes/ink)-compatible API. Build rich, interactive CLI applications with React components, hooks, and a familiar developer experience.
 
----
+Based on [ratatat](https://github.com/geoffmiller/ratatat) by Geoff Miller.
+
+## Features
+
+- **Faster than Ink** on mount (1.3-2.3x), competitive on rerender
+- **Drop-in Ink-compatible** React API
+- **Native Rust diff engine** via NAPI for high-throughput rendering
+- **React hooks** for input, focus, clipboard, mouse, scroll, animation, and window size
+- **Rich component library** - Box, Text, Spinner, Select, TextInput, Tabs, ScrollView, and more
+- **Cross-platform** native bindings (macOS, Linux glibc/musl, Windows x64/arm64)
+- **Server-side rendering** via `renderToString`
+- **Testing utilities** with mock streams and frame capture
+
+## Install
+
+```sh
+npm install @visulima/tui
+```
+
+```sh
+yarn add @visulima/tui
+```
+
+```sh
+pnpm add @visulima/tui
+```
+
+## Quick Start
+
+```tsx
+import { render, Box, Text } from "@visulima/tui";
+
+const App = () => (
+    <Box flexDirection="column" padding={1}>
+        <Text bold>Hello, world!</Text>
+        <Text color="green">Powered by a native Rust diff engine</Text>
+    </Box>
+);
+
+render(<App />);
+```
+
+## Hooks
+
+### `useAnimation(options?)`
+
+Drive frame-based or time-based animations with a shared timer. Multiple `useAnimation` calls consolidate into one render cycle.
+
+```tsx
+import { Text, useAnimation } from "@visulima/tui";
+
+const Spinner = () => {
+    const { frame } = useAnimation({ interval: 80 });
+    const characters = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+    return <Text>{characters[frame % characters.length]}</Text>;
+};
+```
+
+| Option     | Type      | Default | Description                                                                                                                |
+| ---------- | --------- | ------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `interval` | `number`  | `100`   | Time between ticks in milliseconds.                                                                                        |
+| `isActive` | `boolean` | `true`  | Whether the animation is running. When set to `false`, the animation stops. When toggled back to `true`, values reset to 0. |
+
+Returns `{ frame, time, delta, reset }`. See the [full hooks reference](https://visulima.com/packages/tui/hooks#useanimation) for detailed return values, more examples (sine waves, physics, pausable, reset), and `maxFps` interaction.
+
+## Documentation
+
+Full documentation, API reference, component gallery, and guides are available at:
+
+**[visulima.com/packages/tui](https://visulima.com/packages/tui)**
+
+- [Getting Started](https://visulima.com/packages/tui/getting-started)
+- [Package Map](https://visulima.com/packages/tui/package-map) - Entry points and what they export
+- [Components](https://visulima.com/packages/tui/components) - Box, Text, Spinner, Select, TextInput, and more
+- [Hooks](https://visulima.com/packages/tui/hooks) - useInput, useFocus, useApp, useStdout, and more
+- [Mouse Support](https://visulima.com/packages/tui/mouse) - Click, hover, drag, and scroll events
+- [Scroll](https://visulima.com/packages/tui/scroll) - ScrollView, ScrollList, and overflow handling
+- [Rendering Modes](https://visulima.com/packages/tui/rendering-modes) - Ink-compatible, React, and raw buffer
+- [Ink Compatibility](https://visulima.com/packages/tui/ink-compat) - Migration guide from Ink
+- [Testing](https://visulima.com/packages/tui/testing) - Testing utilities with mock streams
+- [Troubleshooting](https://visulima.com/packages/tui/troubleshooting)
+
+## Performance
+
+| Scenario                   | @visulima/tui |      Ink 6.8 |         Speedup |
+| -------------------------- | ------------: | -----------: | --------------: |
+| Mount + render (simple)    |   3,221 ops/s |  2,694 ops/s | **1.2x faster** |
+| Mount + render (dashboard) |   1,659 ops/s |    718 ops/s | **2.3x faster** |
+| Rerender (simple)          |  19,111 ops/s | 25,743 ops/s |           0.74x |
+
+> Benchmarks use production builds. Run: `pnpm --filter @visulima/tui run build:prod && pnpm vitest bench`
+
+### Kitchen Sink Demo
+
+| Layout                              | Focus                             | Graph                             | Live                            |
+| ----------------------------------- | --------------------------------- | --------------------------------- | ------------------------------- |
+| ![Layout](docs/media/ks-layout.png) | ![Focus](docs/media/ks-focus.png) | ![Graph](docs/media/ks-graph.png) | ![Live](docs/media/ks-live.png) |
+
+| Incremental                                   | UI                          | Static                              | Mouse                             |
+| --------------------------------------------- | --------------------------- | ----------------------------------- | --------------------------------- |
+| ![Incremental](docs/media/ks-incremental.png) | ![UI](docs/media/ks-ui.png) | ![Static](docs/media/ks-static.png) | ![Mouse](docs/media/ks-mouse.png) |
+
+## Related
+
+- [ink](https://github.com/vadimdemedes/ink) - React for interactive command-line apps
+- [ratatat](https://github.com/geoffmiller/ratatat) - The project this library is based on
+- [jacob314/ink](https://github.com/jacob314/ink) - Fork with StyledLine, Region model, and render caching (ported features)
+
+## Supported Node.js Versions
+
+Libraries in this ecosystem make the best effort to track [Node.js' release schedule](https://github.com/nodejs/release#release-schedule).
+Here's [a post on why we think this is important](https://medium.com/the-node-js-collection/maintainers-should-consider-following-node-js-release-schedule-ab08ed4de71a).
+
+## Contributing
+
+If you would like to help take a look at the [list of issues](https://github.com/visulima/visulima/issues) and check our [Contributing](.github/CONTRIBUTING.md) guidelines.
+
+> **Note:** please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.
+
+## Credits
+
+- [Daniel Bannert](https://github.com/prisis)
+- [Geoff Miller](https://github.com/geoffmiller) - Original [ratatat](https://github.com/geoffmiller/ratatat) library
+- [Vadym Demedes](https://github.com/vadimdemedes) - [Ink](https://github.com/vadimdemedes/ink) (MIT)
+- [Google LLC / jacob314](https://github.com/jacob314/ink) - StyledLine, Region model, render caching (Apache-2.0)
+- [Zeno Jiricek](https://github.com/nickhudkins/ink-mouse) - Mouse event system (Apache-2.0)
+- [All Contributors](https://github.com/visulima/visulima/graphs/contributors)
+
+## Made with ❤️ at Anolilab
+
+This is an open source project and will always remain free to use. If you think it's cool, please star it 🌟. [Anolilab](https://www.anolilab.com/open-source) is a Development and AI Studio. Contact us at [hello@anolilab.com](mailto:hello@anolilab.com) if you need any help with these technologies or just want to say hi!
+
+## License
+
+The visulima tui is open-sourced software licensed under the [MIT][license]
+
+<!-- badges -->
 
-**Maintained for OIDC setup purposes only**
+[license-badge]: https://img.shields.io/npm/l/@visulima/tui?style=for-the-badge
+[license]: https://github.com/visulima/visulima/blob/main/LICENSE
+[npm-downloads-badge]: https://img.shields.io/npm/dm/@visulima/tui?style=for-the-badge
+[npm-downloads]: https://www.npmjs.com/package/@visulima/tui
+[prs-welcome-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge
+[prs-welcome]: https://github.com/visulima/visulima/blob/main/.github/CONTRIBUTING.md
+[chat-badge]: https://img.shields.io/discord/932323359193186354.svg?style=for-the-badge
+[chat]: https://discord.gg/TtFJY8xkFK
+[typescript-badge]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
+[typescript-url]: https://www.typescriptlang.org/

package/dist/core/app.d.ts

@@ -0,0 +1,50 @@
+import EventEmitter from "eventemitter3";
+export declare class TuiApp extends EventEmitter {
+    private renderer;
+    private terminal;
+    private backBuffer;
+    private width;
+    private height;
+    private isRunning;
+    private stdoutBuffer;
+    private stderrBuffer;
+    constructor();
+    /** Enters raw mode + alternate screen. Does NOT start any render loop. */
+    start(): void;
+    /** Request a clean exit — restores terminal, stops input, exits the process. */
+    quit(): void;
+    /** Exits raw mode + alternate screen, then flushes any buffered stdout/stderr. */
+    stop(): void;
+    /**
+     * Buffer a write to stdout. While the alternate screen is active, writing
+     * directly would corrupt the TUI. Buffered output is flushed on stop().
+     */
+    writeStdout(text: string): void;
+    /**
+     * Buffer a write to stderr. While the alternate screen is active, writing
+     * directly would corrupt the TUI. Buffered output is flushed on stop().
+     */
+    writeStderr(text: string): void;
+    /** Returns the shared Uint32Array back-buffer (width * height * 2 u32 cells). */
+    getBuffer(): Uint32Array;
+    /** Returns current terminal dimensions. */
+    getSize(): {
+        height: number;
+        width: number;
+    };
+    /** Update terminal dimensions (called on SIGWINCH). */
+    resize(width: number, height: number): void;
+    /**
+     * Callbacks fired on every frame after React paints the buffer but before
+     * the Rust diff engine flushes to stdout. Use for direct buffer painting
+     * that needs to overlay React output (animated graphs, overlays, FPS counters).
+     * Multiple listeners are supported — they fire in registration order.
+     */
+    private beforeFlushListeners;
+    onBeforeFlush(function_: (buffer: Uint32Array, width: number, height: number) => void): () => void;
+    /**
+     * Layout + paint synchronously. Called from the render loop on every dirty frame,
+     * and directly on resize for immediate response.
+     */
+    paintNow(calculateLayout: (w: number, h: number) => void, renderToBuffer: (buf: Uint32Array, w: number, h: number) => void): void;
+}

package/dist/core/cell.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 2×u32 per-cell back-buffer layout:
+ *   buffer[idx * 2]     = charCode  (Unicode codepoint, u32)
+ *   buffer[idx * 2 + 1] = attrCode  = (styles &lt;< 16) | (bg &lt;< 8) | fg
+ */
+export declare const Cell: {
+    /** Read bg color from an attr slot value (buffer[idx*2+1]) — bits 15:8 */
+    getBg(attributeSlot: number): number;
+    /** Read the char character from a raw char slot value (buffer[idx*2]) */
+    getChar(charSlot: number): string;
+    /** Read fg color from an attr slot value (buffer[idx*2+1]) — bits 7:0 */
+    getFg(attributeSlot: number): number;
+    /** Read styles bitmask from an attr slot value (buffer[idx*2+1]) — bits 23:16 */
+    getStyles(attributeSlot: number): number;
+    /**
+     * Pack a cell into a [charCode, attrCode] tuple.
+     * charCode = char.codePointAt(0)
+     * attrCode = (styles & 0xFF) &lt;< 16 | (bg & 0xFF) &lt;< 8 | (fg & 0xFF)
+     *
+     * Write to buffer as: buffer[idx*2] = charCode; buffer[idx*2+1] = attrCode
+     */
+    pack(char: string, fg?: number, bg?: number, styles?: number): [number, number];
+};
+export declare const StyleMasks: {
+    BLINK: number;
+    BOLD: number;
+    DIM: number;
+    HIDDEN: number;
+    INVERT: number;
+    ITALIC: number;
+    STRIKETHROUGH: number;
+    UNDERLINE: number;
+};

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./app.d.ts";
+export * from "./cell.d.ts";
+export * from "./inline.d.ts";
+export * from "./input.d.ts";
+export { Renderer, TerminalGuard, type TerminalSize, terminalSize } from "./native-binding.d.ts";

package/dist/core/index.js

@@ -0,0 +1,5 @@
+export { TuiApp } from '../packem_shared/TuiApp-DfxOnXqi.js';
+export { Cell, StyleMasks } from '../packem_shared/Cell-DCg1kJY-.js';
+export { createInlineLoop } from '../packem_shared/createInlineLoop-BxMmcq9D.js';
+export { InputParser } from '../packem_shared/InputParser-BKHpWfvN.js';
+export { Renderer, TerminalGuard, terminalSize } from '../packem_shared/Renderer-zZ5O3vxc.js';

package/dist/core/inline.d.ts

@@ -0,0 +1,22 @@
+export interface InlineOptions {
+    /** Frames per second. Default: 60 */
+    fps?: number;
+    /**
+     * What to do with the rendered content when the loop stops.
+     * - 'preserve' (default) — content stays in terminal scrollback
+     * - 'destroy'            — content is cleared, terminal looks untouched
+     */
+    onExit?: "preserve" | "destroy";
+    /** Number of terminal rows to reserve. Default: 10 */
+    rows?: number;
+}
+export type InlinePaintFn = (buf: Uint32Array, cols: number, rows: number, frame: number) => void;
+export interface InlineLoop {
+    start: () => void;
+    stop: () => void;
+}
+/**
+ * Create an inline render loop. Renders `rows` lines immediately below the
+ * current cursor position (no alternate screen).
+ */
+export declare function createInlineLoop(paint: InlinePaintFn, options?: InlineOptions): InlineLoop;

package/dist/core/input.d.ts

@@ -0,0 +1,18 @@
+import EventEmitter from "eventemitter3";
+export interface MouseEvent {
+    button: "left" | "right" | "middle" | "scrollUp" | "scrollDown";
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    x: number;
+    y: number;
+}
+export declare class InputParser extends EventEmitter {
+    private stdin;
+    private _boundHandleData;
+    private _pasteBuffer;
+    constructor(stdin: NodeJS.ReadStream);
+    start(): void;
+    stop(): void;
+    private handleData;
+}

package/dist/core/native-binding.d.ts

@@ -0,0 +1,22 @@
+export interface TerminalSize {
+    cols: number;
+    rows: number;
+}
+export interface RendererInstance {
+    readonly height: number;
+    render: (backBuffer: Uint32Array) => void;
+    renderDiff: (backBuffer: Uint32Array) => string;
+    resize: (width: number, height: number) => void;
+    setRowOffset: (offset: number) => void;
+    readonly width: number;
+    writeRaw: (data: string) => void;
+}
+export type RendererConstructor = new (width: number, height: number) => RendererInstance;
+export interface TerminalGuardInstance {
+    getSize: () => TerminalSize;
+    leave: () => void;
+}
+export type TerminalGuardConstructor = new (mouse?: boolean | undefined | null) => TerminalGuardInstance;
+export declare const Renderer: RendererConstructor;
+export declare const TerminalGuard: TerminalGuardConstructor;
+export declare const terminalSize: () => TerminalSize;

package/dist/ink/ansi-to-cell.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sentinel value for the trailing cell of a wide (fullWidth) character.
+ * Must be outside Unicode scalar range so it never collides with real text.
+ */
+export declare const CONTINUATION_CELL_CODE = 1114112;

package/dist/ink/ansi-tokenizer.d.ts

@@ -0,0 +1,38 @@
+type ControlStringType = "osc" | "dcs" | "pm" | "apc" | "sos";
+type CsiToken = {
+    readonly finalCharacter: string;
+    readonly intermediateString: string;
+    readonly parameterString: string;
+    readonly type: "csi";
+    readonly value: string;
+};
+type EscToken = {
+    readonly finalCharacter: string;
+    readonly intermediateString: string;
+    readonly type: "esc";
+    readonly value: string;
+};
+type ControlStringToken = {
+    readonly type: ControlStringType;
+    readonly value: string;
+};
+type TextToken = {
+    readonly type: "text";
+    readonly value: string;
+};
+type StToken = {
+    readonly type: "st";
+    readonly value: string;
+};
+type C1Token = {
+    readonly type: "c1";
+    readonly value: string;
+};
+type InvalidToken = {
+    readonly type: "invalid";
+    readonly value: string;
+};
+export type AnsiToken = TextToken | CsiToken | EscToken | ControlStringToken | StToken | C1Token | InvalidToken;
+export declare const hasAnsiControlCharacters: (text: string) => boolean;
+export declare const tokenizeAnsi: (text: string) => AnsiToken[];
+export {};

package/dist/ink/clipboard.d.ts

@@ -0,0 +1,29 @@
+/**
+ * OSC 52 clipboard protocol utilities.
+ *
+ * OSC 52 allows terminal applications to read/write the system clipboard
+ * via escape sequences. Format: ESC ] 52 ; <target> ; <base64-data> BEL
+ * @see https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands
+ */
+import type { Writable } from "node:stream";
+/**
+ * Clipboard targets as defined by the OSC 52 spec.
+ * - `c` — system clipboard
+ * - `p` — primary selection (X11 only)
+ * - `s` — secondary selection (X11 only)
+ */
+export type ClipboardTarget = "c" | "p" | "s";
+/**
+ * Check whether the current terminal likely supports OSC 52.
+ *
+ * Detection is best-effort based on `TERM_PROGRAM` and other env vars.
+ * Returns `true` for known-supported terminals, `false` otherwise.
+ */
+export declare const isOsc52Supported: () => boolean;
+export declare const writeOsc52: (stream: Writable, text: string, target?: ClipboardTarget) => void;
+/**
+ * Clear the clipboard via OSC 52.
+ * @param stream The writable stream to write the escape sequence to.
+ * @param target The clipboard target. Defaults to `"c"`.
+ */
+export declare const clearOsc52: (stream: Writable, target?: ClipboardTarget) => void;

package/dist/ink/color-matrix.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Color matrix transforms for color blindness simulation and compensation.
+ *
+ * Matrices sourced from research by Brettel, Viénot, and Mollon (1997)
+ * and Machado, Oliveira, and Fernandes (2009).
+ * @see https://www.inf.ufrgs.br/~oliveira/pubs_files/CVD_Simulation/CVD_Simulation.html
+ */
+/**
+ * 3x3 color transformation matrix operating on linear RGB values (0-255).
+ */
+export type ColorMatrix = readonly [readonly [number, number, number], readonly [number, number, number], readonly [number, number, number]];
+export type ColorBlindnessType = "achromatopsia" | "deuteranopia" | "protanopia" | "tritanopia";
+/**
+ * Simulation matrices — show how colors appear to users with color vision deficiency.
+ */
+export declare const COLOR_BLINDNESS_SIMULATION: Record<ColorBlindnessType, ColorMatrix>;
+/**
+ * Compensation matrices — shift colors into a distinguishable range for affected users.
+ * These remap problematic colors to alternatives the user can perceive.
+ */
+/**
+ * Compensation matrices — enhance distinguishability for affected users
+ * by redistributing the lost channel's energy into perceivable channels.
+ * Based on Daltonization approach (Fidaner et al., 2005).
+ */
+export declare const COLOR_BLINDNESS_COMPENSATION: Record<Exclude<ColorBlindnessType, "achromatopsia">, ColorMatrix>;
+/**
+ * Identity matrix (no transformation).
+ */
+export declare const IDENTITY_MATRIX: ColorMatrix;
+/**
+ * Apply a 3x3 color matrix to an RGB triplet.
+ * @param r Red channel (0-255)
+ * @param g Green channel (0-255)
+ * @param b Blue channel (0-255)
+ * @param matrix The 3x3 transformation matrix
+ * @returns Transformed [r, g, b] triplet, clamped to 0-255
+ */
+export declare const applyColorMatrix: (r: number, g: number, b: number, matrix: ColorMatrix) => [number, number, number];
+export declare const hexToRgb: (hex: string) => [number, number, number] | null;
+/**
+ * Convert RGB components to a hex color string.
+ */
+export declare const rgbToHex: (r: number, g: number, b: number) => string;
+/**
+ * Transform a hex color through a color blindness simulation or compensation matrix.
+ * Returns the original color if parsing fails.
+ */
+export declare const transformHexColor: (hex: string, matrix: ColorMatrix) => string;

package/dist/ink/color-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared color lookup tables and parsing utilities.
+ *
+ * Used by styled-line-serializer.ts, styled-line-factory.ts, and output.ts
+ * to avoid triplicate color mapping code.
+ */
+/** Standard ANSI color names to 0-7 index */
+export declare const NAMED_COLORS: Readonly<Record<string, number>>;
+/** Bright ANSI color names to 8-15 index */
+export declare const BRIGHT_COLORS: Readonly<Record<string, number>>;
+/**
+ * Parse a color string into an ANSI 256-color index (0-255).
+ * Returns 255 (default) for unrecognized colors.
+ */
+export declare const colorToAnsi256: (color: string) => number;
+/**
+ * Convert a color string to SGR parameter array for escape sequences.
+ * @param color the color string to convert
+ * @param isFg true for foreground (30-based), false for background (40-based)
+ */
+export declare const colorToSgrParams: (color: string, isFg: boolean) => number[];
+/**
+ * Convert a color string to a raw ANSI escape code string.
+ */
+export declare const colorToAnsiCode: (color: string, isFg: boolean) => string | undefined;
+/**
+ * Convert an ANSI 256-color index to a named color string.
+ * Standard colors (0-7) use names; everything else uses ansi256(N).
+ */
+export declare const ansi256ToColorName: (index: number) => string;

package/dist/ink/colorize.d.ts

@@ -0,0 +1,4 @@
+type ColorType = "foreground" | "background";
+declare const colorize: (string_: string, color: string | undefined, type: ColorType) => string;
+export declare const getBackgroundColorEscape: (color: string) => string | undefined;
+export default colorize;

package/dist/ink/components/AccessibilityContext.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "react";
+export declare const accessibilityContext: Context<{
+    isScreenReaderEnabled: boolean;
+}>;

package/dist/ink/components/Alert.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Alert component for Ink.
+ *
+ * Inspired by ink-ui Alert by Vadim Demedes.
+ * @see https://github.com/vadimdemedes/ink-ui
+ *
+ * MIT License
+ * Copyright (c) Vadym Demedes (github.com/vadimdemedes)
+ */
+import type { ReactElement, ReactNode } from "react";
+import type { Variant } from "./variant-config.d.ts";
+export type AlertVariant = Variant;
+export type Props = {
+    /**
+     * Alert message content.
+     */
+    readonly children: ReactNode;
+    /**
+     * Optional heading displayed above the message.
+     */
+    readonly title?: string;
+    /**
+     * Determines the border color and icon.
+     */
+    readonly variant: AlertVariant;
+};
+/**
+ * Renders a bordered alert box with a variant-specific icon, optional title, and message.
+ */
+export default function Alert({ children, title, variant }: Props): ReactElement;

package/dist/ink/components/AnimationContext.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from "react";
+type AnimationContextValue = {
+    readonly renderThrottleMs: number;
+    readonly subscribe: (callback: (currentTime: number) => void, interval: number) => {
+        readonly startTime: number;
+        readonly unsubscribe: () => void;
+    };
+};
+declare const animationContext: Context<AnimationContextValue>;
+export default animationContext;

package/dist/ink/components/App.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from "react";
+import React from "react";
+import type { CursorPosition } from "../log-update.d.ts";
+type Props = {
+    readonly children: ReactNode;
+    readonly exitOnCtrlC: boolean;
+    readonly interactive: boolean;
+    readonly onExit: (errorOrResult?: unknown) => void;
+    readonly onWaitUntilRenderFlush: () => Promise<void>;
+    readonly renderThrottleMs: number;
+    readonly setCursorPosition: (position: CursorPosition | undefined) => void;
+    readonly stderr: NodeJS.WriteStream;
+    readonly stdin: NodeJS.ReadStream;
+    readonly stdout: NodeJS.WriteStream;
+    readonly writeToStderr: (data: string) => void;
+    readonly writeToStdout: (data: string) => void;
+};
+declare const _default: React.FC<Props>;
+export default _default;

package/dist/ink/components/AppContext.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from "react";
+export type Props = {
+    /**
+     * Exit (unmount) the whole Ink app.
+     *
+     * - `exit()` — resolves `waitUntilExit()` with `undefined`.
+     * - `exit(new Error('…'))` — rejects `waitUntilExit()` with the error.
+     * - `exit(value)` — resolves `waitUntilExit()` with `value`.
+     */
+    readonly exit: (errorOrResult?: Error | unknown) => void;
+    /**
+     * Returns a promise that settles after pending render output is flushed to stdout.
+     * @example
+     * ```jsx
+     * import {useEffect} from 'react';
+    * import {useApp} from 'ink';
+     
+    const Example = () => {
+        const {waitUntilRenderFlush} = useApp();
+     
+        useEffect(() => {
+            void (async () => {
+                await waitUntilRenderFlush();
+                runNextCommand();
+            })();
+        }, [waitUntilRenderFlush]);
+     
+        return …;
+    };
+    ```
+     */
+    readonly waitUntilRenderFlush: () => Promise<void>;
+};
+/**
+ * `AppContext` is a React context that exposes lifecycle methods for the app.
+ */
+declare const AppContext: Context<Props>;
+export default AppContext;

package/dist/ink/components/BackgroundContext.d.ts

@@ -0,0 +1,5 @@
+import type { AnsiColors } from "@visulima/colorize";
+import type { Context } from "react";
+import type { LiteralUnion } from "type-fest";
+export type BackgroundColor = LiteralUnion<AnsiColors, string>;
+export declare const backgroundContext: Context<BackgroundColor | undefined>;