@opentui/core 0.0.0-20250908-4906ddad

package/lib/RGBA.d.ts

@@ -0,0 +1,24 @@
+export declare class RGBA {
+    buffer: Float32Array;
+    constructor(buffer: Float32Array);
+    static fromArray(array: Float32Array): RGBA;
+    static fromValues(r: number, g: number, b: number, a?: number): RGBA;
+    static fromInts(r: number, g: number, b: number, a?: number): RGBA;
+    static fromHex(hex: string): RGBA;
+    toInts(): [number, number, number, number];
+    get r(): number;
+    set r(value: number);
+    get g(): number;
+    set g(value: number);
+    get b(): number;
+    set b(value: number);
+    get a(): number;
+    set a(value: number);
+    map<R>(fn: (value: number) => R): R[];
+    toString(): string;
+}
+export type ColorInput = string | RGBA;
+export declare function hexToRgb(hex: string): RGBA;
+export declare function rgbToHex(rgb: RGBA): string;
+export declare function hsvToRgb(h: number, s: number, v: number): RGBA;
+export declare function parseColor(color: ColorInput): RGBA;

package/lib/TrackedNode.d.ts

@@ -0,0 +1,36 @@
+import { type Config, type Node as YogaNode } from "yoga-layout";
+import { EventEmitter } from "events";
+interface NodeMetadata {
+    [key: string]: any;
+}
+declare class TrackedNode<T extends NodeMetadata = NodeMetadata> extends EventEmitter {
+    private static idCounter;
+    id: number;
+    yogaNode: YogaNode;
+    metadata: T;
+    parent: TrackedNode<any> | null;
+    children: TrackedNode<any>[];
+    protected _destroyed: boolean;
+    protected _width: number | "auto" | `${number}%`;
+    protected _height: number | "auto" | `${number}%`;
+    constructor(yogaNode: YogaNode, metadata?: T);
+    parseWidth(width: number | "auto" | `${number}%`): number | "auto";
+    parseHeight(height: number | "auto" | `${number}%`): number | "auto";
+    setWidth(width: number | "auto" | `${number}%`): void;
+    setHeight(height: number | "auto" | `${number}%`): void;
+    addChild<U extends NodeMetadata>(childNode: TrackedNode<U>): number;
+    getChildIndex<U extends NodeMetadata>(childNode: TrackedNode<U>): number;
+    removeChild<U extends NodeMetadata>(childNode: TrackedNode<U>): boolean;
+    removeChildAtIndex(index: number): TrackedNode<any> | null;
+    moveChild<U extends NodeMetadata>(childNode: TrackedNode<U>, newIndex: number): number;
+    insertChild<U extends NodeMetadata>(childNode: TrackedNode<U>, index: number): number;
+    getChildCount(): number;
+    getChildAtIndex(index: number): TrackedNode<any> | null;
+    setMetadata(key: keyof T, value: T[keyof T]): void;
+    getMetadata<K extends keyof T>(key: K): T[K];
+    removeMetadata<K extends keyof T>(key: K): void;
+    hasChild<U extends NodeMetadata>(childNode: TrackedNode<U>): boolean;
+    destroy(): void;
+}
+declare function createTrackedNode<T extends NodeMetadata>(metadata?: T, yogaConfig?: Config): TrackedNode<T>;
+export { TrackedNode, createTrackedNode };

package/lib/ascii.font.d.ts

@@ -0,0 +1,301 @@
+import { OptimizedBuffer } from "../buffer";
+import { RGBA } from "./RGBA";
+export type ASCIIFontName = "tiny" | "block" | "shade" | "slick";
+export declare const fonts: {
+    tiny: {
+        name: string;
+        version: string;
+        homepage: string;
+        colors: number;
+        lines: number;
+        buffer: string[];
+        letterspace: string[];
+        letterspace_size: number;
+        chars: {
+            A: string[];
+            B: string[];
+            C: string[];
+            D: string[];
+            E: string[];
+            F: string[];
+            G: string[];
+            H: string[];
+            I: string[];
+            J: string[];
+            K: string[];
+            L: string[];
+            M: string[];
+            N: string[];
+            O: string[];
+            P: string[];
+            Q: string[];
+            R: string[];
+            S: string[];
+            T: string[];
+            U: string[];
+            V: string[];
+            W: string[];
+            X: string[];
+            Y: string[];
+            Z: string[];
+            "0": string[];
+            "1": string[];
+            "2": string[];
+            "3": string[];
+            "4": string[];
+            "5": string[];
+            "6": string[];
+            "7": string[];
+            "8": string[];
+            "9": string[];
+            "!": string[];
+            "?": string[];
+            ".": string[];
+            "+": string[];
+            "-": string[];
+            _: string[];
+            "=": string[];
+            "@": string[];
+            "#": string[];
+            $: string[];
+            "%": string[];
+            "&": string[];
+            "(": string[];
+            ")": string[];
+            "/": string[];
+            ":": string[];
+            ";": string[];
+            ",": string[];
+            "'": string[];
+            "\"": string[];
+            " ": string[];
+        };
+    };
+    block: {
+        name: string;
+        version: string;
+        homepage: string;
+        colors: number;
+        lines: number;
+        buffer: string[];
+        letterspace: string[];
+        letterspace_size: number;
+        chars: {
+            A: string[];
+            B: string[];
+            C: string[];
+            D: string[];
+            E: string[];
+            F: string[];
+            G: string[];
+            H: string[];
+            I: string[];
+            J: string[];
+            K: string[];
+            L: string[];
+            M: string[];
+            N: string[];
+            O: string[];
+            P: string[];
+            Q: string[];
+            R: string[];
+            S: string[];
+            T: string[];
+            U: string[];
+            V: string[];
+            W: string[];
+            X: string[];
+            Y: string[];
+            Z: string[];
+            "0": string[];
+            "1": string[];
+            "2": string[];
+            "3": string[];
+            "4": string[];
+            "5": string[];
+            "6": string[];
+            "7": string[];
+            "8": string[];
+            "9": string[];
+            "!": string[];
+            "?": string[];
+            ".": string[];
+            "+": string[];
+            "-": string[];
+            _: string[];
+            "=": string[];
+            "@": string[];
+            "#": string[];
+            $: string[];
+            "%": string[];
+            "&": string[];
+            "(": string[];
+            ")": string[];
+            "/": string[];
+            ":": string[];
+            ";": string[];
+            ",": string[];
+            "'": string[];
+            "\"": string[];
+            " ": string[];
+        };
+    };
+    shade: {
+        name: string;
+        version: string;
+        homepage: string;
+        colors: number;
+        lines: number;
+        buffer: string[];
+        letterspace: string[];
+        letterspace_size: number;
+        chars: {
+            A: string[];
+            B: string[];
+            C: string[];
+            D: string[];
+            E: string[];
+            F: string[];
+            G: string[];
+            H: string[];
+            I: string[];
+            J: string[];
+            K: string[];
+            L: string[];
+            M: string[];
+            N: string[];
+            O: string[];
+            P: string[];
+            Q: string[];
+            R: string[];
+            S: string[];
+            T: string[];
+            U: string[];
+            V: string[];
+            W: string[];
+            X: string[];
+            Y: string[];
+            Z: string[];
+            "0": string[];
+            "1": string[];
+            "2": string[];
+            "3": string[];
+            "4": string[];
+            "5": string[];
+            "6": string[];
+            "7": string[];
+            "8": string[];
+            "9": string[];
+            "!": string[];
+            "?": string[];
+            ".": string[];
+            "+": string[];
+            "-": string[];
+            _: string[];
+            "=": string[];
+            "@": string[];
+            "#": string[];
+            $: string[];
+            "%": string[];
+            "&": string[];
+            "(": string[];
+            ")": string[];
+            "/": string[];
+            ":": string[];
+            ";": string[];
+            ",": string[];
+            "'": string[];
+            "\"": string[];
+            " ": string[];
+        };
+    };
+    slick: {
+        name: string;
+        version: string;
+        homepage: string;
+        colors: number;
+        lines: number;
+        buffer: string[];
+        letterspace: string[];
+        letterspace_size: number;
+        chars: {
+            A: string[];
+            B: string[];
+            C: string[];
+            D: string[];
+            E: string[];
+            F: string[];
+            G: string[];
+            H: string[];
+            I: string[];
+            J: string[];
+            K: string[];
+            L: string[];
+            M: string[];
+            N: string[];
+            O: string[];
+            P: string[];
+            Q: string[];
+            R: string[];
+            S: string[];
+            T: string[];
+            U: string[];
+            V: string[];
+            W: string[];
+            X: string[];
+            Y: string[];
+            Z: string[];
+            "0": string[];
+            "1": string[];
+            "2": string[];
+            "3": string[];
+            "4": string[];
+            "5": string[];
+            "6": string[];
+            "7": string[];
+            "8": string[];
+            "9": string[];
+            "!": string[];
+            "?": string[];
+            ".": string[];
+            "+": string[];
+            "-": string[];
+            _: string[];
+            "=": string[];
+            "@": string[];
+            "#": string[];
+            $: string[];
+            "%": string[];
+            "&": string[];
+            "(": string[];
+            ")": string[];
+            "/": string[];
+            ":": string[];
+            ";": string[];
+            ",": string[];
+            "'": string[];
+            "\"": string[];
+            " ": string[];
+        };
+    };
+};
+export declare function measureText({ text, font }: {
+    text: string;
+    font?: keyof typeof fonts;
+}): {
+    width: number;
+    height: number;
+};
+export declare function getCharacterPositions(text: string, font?: keyof typeof fonts): number[];
+export declare function coordinateToCharacterIndex(x: number, text: string, font?: keyof typeof fonts): number;
+export declare function renderFontToFrameBuffer(buffer: OptimizedBuffer, { text, x, y, fg, bg, font, }: {
+    text: string;
+    x?: number;
+    y?: number;
+    fg?: RGBA | RGBA[];
+    bg?: RGBA;
+    font?: keyof typeof fonts;
+}): {
+    width: number;
+    height: number;
+};

package/lib/border.d.ts

@@ -0,0 +1,47 @@
+import type { ColorInput } from "./RGBA";
+export interface BorderCharacters {
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+    horizontal: string;
+    vertical: string;
+    topT: string;
+    bottomT: string;
+    leftT: string;
+    rightT: string;
+    cross: string;
+}
+export type BorderStyle = "single" | "double" | "rounded" | "heavy";
+export type BorderSides = "top" | "right" | "bottom" | "left";
+export declare const BorderChars: Record<BorderStyle, BorderCharacters>;
+export interface BorderConfig {
+    borderStyle: BorderStyle;
+    border: boolean | BorderSides[];
+    borderColor?: ColorInput;
+    customBorderChars?: BorderCharacters;
+}
+export interface BoxDrawOptions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    borderStyle: BorderStyle;
+    border: boolean | BorderSides[];
+    borderColor: ColorInput;
+    customBorderChars?: BorderCharacters;
+    backgroundColor: ColorInput;
+    shouldFill?: boolean;
+    title?: string;
+    titleAlignment?: "left" | "center" | "right";
+}
+export interface BorderSidesConfig {
+    top: boolean;
+    right: boolean;
+    bottom: boolean;
+    left: boolean;
+}
+export declare function getBorderFromSides(sides: BorderSidesConfig): boolean | BorderSides[];
+export declare function getBorderSides(border: boolean | BorderSides[]): BorderSidesConfig;
+export declare function borderCharsToArray(chars: BorderCharacters): Uint32Array;
+export declare const BorderCharArrays: Record<BorderStyle, Uint32Array>;

package/lib/hast-styled-text.d.ts

@@ -0,0 +1,38 @@
+import { RGBA } from "./RGBA";
+import { StyledText } from "./styled-text";
+export interface HASTText {
+    type: "text";
+    value: string;
+}
+export interface HASTElement {
+    type: "element";
+    tagName: string;
+    properties?: {
+        className?: string;
+    };
+    children: HASTNode[];
+}
+export type HASTNode = HASTText | HASTElement;
+export interface StyleDefinition {
+    fg?: RGBA;
+    bg?: RGBA;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+}
+interface MergedStyle {
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes: number;
+}
+export declare class SyntaxStyle {
+    private styles;
+    private mergedStyleCache;
+    constructor(styles: Record<string, StyleDefinition>);
+    mergeStyles(...styleNames: string[]): MergedStyle;
+    clearCache(): void;
+    getCacheSize(): number;
+}
+export declare function hastToStyledText(hast: HASTNode, syntaxStyle: SyntaxStyle): StyledText;
+export {};

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./border";
+export * from "./TrackedNode";
+export * from "./KeyHandler";
+export * from "./ascii.font";
+export * from "./hast-styled-text";
+export * from "./RGBA";
+export * from "./parse.keypress";
+export * from "./styled-text";
+export * from "./yoga.options";
+export * from "./parse.mouse";
+export * from "./selection";

package/lib/output.capture.d.ts

@@ -0,0 +1,24 @@
+import { Writable } from "stream";
+import { EventEmitter } from "events";
+export type CapturedOutput = {
+    stream: "stdout" | "stderr";
+    output: string;
+};
+export declare class Capture extends EventEmitter {
+    private output;
+    constructor();
+    get size(): number;
+    write(stream: "stdout" | "stderr", data: string): void;
+    claimOutput(): string;
+    private clear;
+}
+export declare class CapturedWritableStream extends Writable {
+    private stream;
+    private capture;
+    isTTY: boolean;
+    columns: number;
+    rows: number;
+    constructor(stream: "stdout" | "stderr", capture: Capture);
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    getColorDepth(): number;
+}

package/lib/parse.keypress.d.ts

@@ -0,0 +1,14 @@
+import { Buffer } from "node:buffer";
+export declare const nonAlphanumericKeys: string[];
+export type ParsedKey = {
+    name: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    option: boolean;
+    sequence: string;
+    number: boolean;
+    raw: string;
+    code?: string;
+};
+export declare const parseKeypress: (s?: Buffer | string) => ParsedKey;

package/lib/parse.mouse.d.ts

@@ -0,0 +1,23 @@
+export type MouseEventType = "down" | "up" | "move" | "drag" | "drag-end" | "drop" | "over" | "out" | "scroll";
+export interface ScrollInfo {
+    direction: "up" | "down" | "left" | "right";
+    delta: number;
+}
+export type RawMouseEvent = {
+    type: MouseEventType;
+    button: number;
+    x: number;
+    y: number;
+    modifiers: {
+        shift: boolean;
+        alt: boolean;
+        ctrl: boolean;
+    };
+    scroll?: ScrollInfo;
+};
+export declare class MouseParser {
+    private mouseButtonsPressed;
+    private static readonly SCROLL_DIRECTIONS;
+    reset(): void;
+    parseMouseEvent(data: Buffer): RawMouseEvent | null;
+}

package/lib/selection.d.ts

@@ -0,0 +1,63 @@
+import { Renderable, type ViewportBounds } from "..";
+import { fonts } from "./ascii.font";
+export declare class Selection {
+    private _anchor;
+    private _originalFocus;
+    private _normalizedAnchor;
+    private _normalizedFocus;
+    private _selectedRenderables;
+    private _touchedRenderables;
+    private _isActive;
+    private _isSelecting;
+    constructor(anchorRenderable: Renderable, anchor: {
+        x: number;
+        y: number;
+    }, focus: {
+        x: number;
+        y: number;
+    });
+    get anchor(): {
+        x: number;
+        y: number;
+    };
+    get focus(): {
+        x: number;
+        y: number;
+    };
+    set focus(value: {
+        x: number;
+        y: number;
+    });
+    private _updateNormalizedSelection;
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    get isSelecting(): boolean;
+    set isSelecting(value: boolean);
+    get bounds(): ViewportBounds;
+    updateSelectedRenderables(selectedRenderables: Renderable[]): void;
+    get selectedRenderables(): Renderable[];
+    updateTouchedRenderables(touchedRenderables: Renderable[]): void;
+    get touchedRenderables(): Renderable[];
+    getSelectedText(): string;
+}
+export interface LocalSelectionBounds {
+    anchorX: number;
+    anchorY: number;
+    focusX: number;
+    focusY: number;
+    isActive: boolean;
+}
+export declare function convertGlobalToLocalSelection(globalSelection: Selection | null, localX: number, localY: number): LocalSelectionBounds | null;
+export declare class ASCIIFontSelectionHelper {
+    private getText;
+    private getFont;
+    private localSelection;
+    constructor(getText: () => string, getFont: () => keyof typeof fonts);
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    shouldStartSelection(localX: number, localY: number, width: number, height: number): boolean;
+    onLocalSelectionChanged(localSelection: LocalSelectionBounds | null, width: number, height: number): boolean;
+}

package/lib/styled-text.d.ts

@@ -0,0 +1,73 @@
+import type { TextRenderable } from "../renderables/Text";
+import type { TextChunk } from "../text-buffer";
+import { type ColorInput } from "./RGBA";
+export type Color = ColorInput;
+export interface StyleAttrs {
+    fg?: Color;
+    bg?: Color;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    dim?: boolean;
+    reverse?: boolean;
+    blink?: boolean;
+}
+export declare class StyledText {
+    chunks: TextChunk[];
+    textRenderable?: TextRenderable;
+    constructor(chunks: TextChunk[]);
+    mount(textRenderable: TextRenderable): void;
+    /**
+     * @deprecated: Use textRenderable.insertChunk instead
+     */
+    insert(chunk: TextChunk, index?: number): StyledText;
+    /**
+     * @deprecated: Use textRenderable.removeChunk instead
+     */
+    remove(chunk: TextChunk): StyledText;
+    /**
+     * @deprecated: Use textRenderable.replaceChunk instead
+     */
+    replace(chunk: TextChunk, oldChunk: TextChunk): StyledText;
+}
+export declare function stringToStyledText(content: string): StyledText;
+export type StylableInput = string | number | boolean | TextChunk;
+export declare const black: (input: StylableInput) => TextChunk;
+export declare const red: (input: StylableInput) => TextChunk;
+export declare const green: (input: StylableInput) => TextChunk;
+export declare const yellow: (input: StylableInput) => TextChunk;
+export declare const blue: (input: StylableInput) => TextChunk;
+export declare const magenta: (input: StylableInput) => TextChunk;
+export declare const cyan: (input: StylableInput) => TextChunk;
+export declare const white: (input: StylableInput) => TextChunk;
+export declare const brightBlack: (input: StylableInput) => TextChunk;
+export declare const brightRed: (input: StylableInput) => TextChunk;
+export declare const brightGreen: (input: StylableInput) => TextChunk;
+export declare const brightYellow: (input: StylableInput) => TextChunk;
+export declare const brightBlue: (input: StylableInput) => TextChunk;
+export declare const brightMagenta: (input: StylableInput) => TextChunk;
+export declare const brightCyan: (input: StylableInput) => TextChunk;
+export declare const brightWhite: (input: StylableInput) => TextChunk;
+export declare const bgBlack: (input: StylableInput) => TextChunk;
+export declare const bgRed: (input: StylableInput) => TextChunk;
+export declare const bgGreen: (input: StylableInput) => TextChunk;
+export declare const bgYellow: (input: StylableInput) => TextChunk;
+export declare const bgBlue: (input: StylableInput) => TextChunk;
+export declare const bgMagenta: (input: StylableInput) => TextChunk;
+export declare const bgCyan: (input: StylableInput) => TextChunk;
+export declare const bgWhite: (input: StylableInput) => TextChunk;
+export declare const bold: (input: StylableInput) => TextChunk;
+export declare const italic: (input: StylableInput) => TextChunk;
+export declare const underline: (input: StylableInput) => TextChunk;
+export declare const strikethrough: (input: StylableInput) => TextChunk;
+export declare const dim: (input: StylableInput) => TextChunk;
+export declare const reverse: (input: StylableInput) => TextChunk;
+export declare const blink: (input: StylableInput) => TextChunk;
+export declare const fg: (color: Color) => (input: StylableInput) => TextChunk;
+export declare const bg: (color: Color) => (input: StylableInput) => TextChunk;
+/**
+ * Template literal handler for styled text (non-cached version).
+ * Returns a StyledText object containing chunks of text with optional styles.
+ */
+export declare function t(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;

package/lib/word-jumps.d.ts

@@ -0,0 +1,2 @@
+export declare function nextWordEndCrossLines(text: string, caret: number): number;
+export declare function previousWordStartCrossLines(text: string, caret: number): number;