@fairyhunter13/opentui-core 0.1.91 → 0.1.94

package/renderables/ScrollBar.d.ts

@@ -0,0 +1,77 @@
+import type { OptimizedBuffer } from "../buffer.js";
+import { RGBA, type ColorInput } from "../lib/index.js";
+import type { KeyEvent } from "../lib/KeyHandler.js";
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { SliderRenderable, type SliderOptions } from "./Slider.js";
+export interface ScrollBarOptions extends RenderableOptions<ScrollBarRenderable> {
+    orientation: "vertical" | "horizontal";
+    showArrows?: boolean;
+    arrowOptions?: Omit<ArrowOptions, "direction">;
+    trackOptions?: Partial<SliderOptions>;
+    onChange?: (position: number) => void;
+}
+export type ScrollUnit = "absolute" | "viewport" | "content" | "step";
+export declare class ScrollBarRenderable extends Renderable {
+    readonly slider: SliderRenderable;
+    readonly startArrow: ArrowRenderable;
+    readonly endArrow: ArrowRenderable;
+    readonly orientation: "vertical" | "horizontal";
+    protected _focusable: boolean;
+    private _scrollSize;
+    private _scrollPosition;
+    private _viewportSize;
+    private _showArrows;
+    private _manualVisibility;
+    private _onChange;
+    scrollStep: number | undefined | null;
+    get visible(): boolean;
+    set visible(value: boolean);
+    resetVisibilityControl(): void;
+    get scrollSize(): number;
+    get scrollPosition(): number;
+    get viewportSize(): number;
+    set scrollSize(value: number);
+    set scrollPosition(value: number);
+    set viewportSize(value: number);
+    get showArrows(): boolean;
+    set showArrows(value: boolean);
+    constructor(ctx: RenderContext, { trackOptions, arrowOptions, orientation, showArrows, ...options }: ScrollBarOptions);
+    set arrowOptions(options: ScrollBarOptions["arrowOptions"]);
+    set trackOptions(options: ScrollBarOptions["trackOptions"]);
+    private updateSliderFromScrollState;
+    scrollBy(delta: number, unit?: ScrollUnit): void;
+    private recalculateVisibility;
+    handleKeyPress(key: KeyEvent): boolean;
+}
+export interface ArrowOptions extends RenderableOptions<ArrowRenderable> {
+    direction: "up" | "down" | "left" | "right";
+    foregroundColor?: ColorInput;
+    backgroundColor?: ColorInput;
+    attributes?: number;
+    arrowChars?: {
+        up?: string;
+        down?: string;
+        left?: string;
+        right?: string;
+    };
+}
+export declare class ArrowRenderable extends Renderable {
+    private _direction;
+    private _foregroundColor;
+    private _backgroundColor;
+    private _attributes;
+    private _arrowChars;
+    constructor(ctx: RenderContext, options: ArrowOptions);
+    get direction(): "up" | "down" | "left" | "right";
+    set direction(value: "up" | "down" | "left" | "right");
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get attributes(): number;
+    set attributes(value: number);
+    set arrowChars(value: ArrowOptions["arrowChars"]);
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private getArrowChar;
+}

package/renderables/ScrollBox.d.ts

@@ -0,0 +1,124 @@
+import { type KeyEvent } from "../lib/index.js";
+import { type ScrollAcceleration } from "../lib/scroll-acceleration.js";
+import type { Renderable, RenderableOptions } from "../Renderable.js";
+import type { MouseEvent } from "../renderer.js";
+import type { RenderContext } from "../types.js";
+import { BoxRenderable, type BoxOptions } from "./Box.js";
+import type { VNode } from "./composition/vnode.js";
+import { ScrollBarRenderable, type ScrollBarOptions, type ScrollUnit } from "./ScrollBar.js";
+declare class ContentRenderable extends BoxRenderable {
+    private viewport;
+    private _viewportCulling;
+    constructor(ctx: RenderContext, viewport: BoxRenderable, viewportCulling: boolean, options: RenderableOptions<BoxRenderable>);
+    get viewportCulling(): boolean;
+    set viewportCulling(value: boolean);
+    protected _getVisibleChildren(): number[];
+}
+export interface ScrollBoxOptions extends BoxOptions<ScrollBoxRenderable> {
+    rootOptions?: BoxOptions;
+    wrapperOptions?: BoxOptions;
+    viewportOptions?: BoxOptions;
+    contentOptions?: BoxOptions;
+    scrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    verticalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    horizontalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    stickyScroll?: boolean;
+    stickyStart?: "bottom" | "top" | "left" | "right";
+    scrollX?: boolean;
+    scrollY?: boolean;
+    scrollAcceleration?: ScrollAcceleration;
+    viewportCulling?: boolean;
+}
+export declare class ScrollBoxRenderable extends BoxRenderable {
+    static idCounter: number;
+    private internalId;
+    readonly wrapper: BoxRenderable;
+    readonly viewport: BoxRenderable;
+    readonly content: ContentRenderable;
+    readonly horizontalScrollBar: ScrollBarRenderable;
+    readonly verticalScrollBar: ScrollBarRenderable;
+    protected _focusable: boolean;
+    private selectionListener?;
+    private autoScrollMouseX;
+    private autoScrollMouseY;
+    private readonly autoScrollThresholdVertical;
+    private readonly autoScrollThresholdHorizontal;
+    private readonly autoScrollSpeedSlow;
+    private readonly autoScrollSpeedMedium;
+    private readonly autoScrollSpeedFast;
+    private isAutoScrolling;
+    private cachedAutoScrollSpeed;
+    private autoScrollAccumulatorX;
+    private autoScrollAccumulatorY;
+    private scrollAccumulatorX;
+    private scrollAccumulatorY;
+    private _stickyScroll;
+    private _stickyScrollTop;
+    private _stickyScrollBottom;
+    private _stickyScrollLeft;
+    private _stickyScrollRight;
+    private _stickyStart?;
+    private _hasManualScroll;
+    private _isApplyingStickyScroll;
+    private scrollAccel;
+    get stickyScroll(): boolean;
+    set stickyScroll(value: boolean);
+    get stickyStart(): "bottom" | "top" | "left" | "right" | undefined;
+    set stickyStart(value: "bottom" | "top" | "left" | "right" | undefined);
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    private updateStickyState;
+    private applyStickyStart;
+    constructor(ctx: RenderContext, options: ScrollBoxOptions);
+    protected onUpdate(deltaTime: number): void;
+    scrollBy(delta: number | {
+        x: number;
+        y: number;
+    }, unit?: ScrollUnit): void;
+    scrollChildIntoView(childId: string): void;
+    scrollTo(position: number | {
+        x: number;
+        y: number;
+    }): void;
+    private isAtStickyPosition;
+    add(obj: Renderable | VNode<any, any[]>, index?: number): number;
+    insertBefore(obj: Renderable | VNode<any, any[]> | unknown, anchor?: Renderable | unknown): number;
+    remove(id: string): void;
+    getChildren(): Renderable[];
+    protected onMouseEvent(event: MouseEvent): void;
+    handleKeyPress(key: KeyEvent): boolean;
+    private resetScrollAccumulators;
+    startAutoScroll(mouseX: number, mouseY: number): void;
+    updateAutoScroll(mouseX: number, mouseY: number): void;
+    stopAutoScroll(): void;
+    private hasOtherLiveReasons;
+    private handleAutoScroll;
+    private getAutoScrollDirectionX;
+    private getAutoScrollDirectionY;
+    private getAutoScrollSpeed;
+    private recalculateBarProps;
+    set padding(value: number | `${number}%` | null | undefined);
+    set paddingX(value: number | `${number}%` | null | undefined);
+    set paddingY(value: number | `${number}%` | null | undefined);
+    set paddingTop(value: number | `${number}%` | null | undefined);
+    set paddingRight(value: number | `${number}%` | null | undefined);
+    set paddingBottom(value: number | `${number}%` | null | undefined);
+    set paddingLeft(value: number | `${number}%` | null | undefined);
+    set rootOptions(options: ScrollBoxOptions["rootOptions"]);
+    set wrapperOptions(options: ScrollBoxOptions["wrapperOptions"]);
+    set viewportOptions(options: ScrollBoxOptions["viewportOptions"]);
+    set contentOptions(options: ScrollBoxOptions["contentOptions"]);
+    set scrollbarOptions(options: ScrollBoxOptions["scrollbarOptions"]);
+    set verticalScrollbarOptions(options: ScrollBoxOptions["verticalScrollbarOptions"]);
+    set horizontalScrollbarOptions(options: ScrollBoxOptions["horizontalScrollbarOptions"]);
+    get scrollAcceleration(): ScrollAcceleration;
+    set scrollAcceleration(value: ScrollAcceleration);
+    get viewportCulling(): boolean;
+    set viewportCulling(value: boolean);
+    protected destroySelf(): void;
+}
+export {};

package/renderables/Select.d.ts

@@ -0,0 +1,115 @@
+import { OptimizedBuffer } from "../buffer.js";
+import { fonts } from "../lib/ascii.font.js";
+import type { KeyEvent } from "../lib/KeyHandler.js";
+import { type ColorInput } from "../lib/RGBA.js";
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping.js";
+export interface SelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export type SelectAction = "move-up" | "move-down" | "move-up-fast" | "move-down-fast" | "select-current";
+export type SelectKeyBinding = BaseKeyBinding<SelectAction>;
+export interface SelectRenderableOptions extends RenderableOptions<SelectRenderable> {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    options?: SelectOption[];
+    selectedIndex?: number;
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    descriptionColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollIndicator?: boolean;
+    wrapSelection?: boolean;
+    showDescription?: boolean;
+    font?: keyof typeof fonts;
+    itemSpacing?: number;
+    fastScrollStep?: number;
+    keyBindings?: SelectKeyBinding[];
+    keyAliasMap?: KeyAliasMap;
+}
+export declare enum SelectRenderableEvents {
+    SELECTION_CHANGED = "selectionChanged",
+    ITEM_SELECTED = "itemSelected"
+}
+export declare class SelectRenderable extends Renderable {
+    protected _focusable: boolean;
+    private _options;
+    private _selectedIndex;
+    private scrollOffset;
+    private maxVisibleItems;
+    private _backgroundColor;
+    private _textColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _selectedBackgroundColor;
+    private _selectedTextColor;
+    private _descriptionColor;
+    private _selectedDescriptionColor;
+    private _showScrollIndicator;
+    private _wrapSelection;
+    private _showDescription;
+    private _font?;
+    private _itemSpacing;
+    private linesPerItem;
+    private fontHeight;
+    private _fastScrollStep;
+    private _keyBindingsMap;
+    private _keyAliasMap;
+    private _keyBindings;
+    protected _defaultOptions: {
+        backgroundColor: string;
+        textColor: string;
+        focusedBackgroundColor: string;
+        focusedTextColor: string;
+        selectedBackgroundColor: string;
+        selectedTextColor: string;
+        selectedIndex: number;
+        descriptionColor: string;
+        selectedDescriptionColor: string;
+        showScrollIndicator: false;
+        wrapSelection: false;
+        showDescription: true;
+        itemSpacing: number;
+        fastScrollStep: number;
+    };
+    constructor(ctx: RenderContext, options: SelectRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private renderScrollIndicatorToFrameBuffer;
+    get options(): SelectOption[];
+    set options(options: SelectOption[]);
+    getSelectedOption(): SelectOption | null;
+    getSelectedIndex(): number;
+    moveUp(steps?: number): void;
+    moveDown(steps?: number): void;
+    selectCurrent(): void;
+    setSelectedIndex(index: number): void;
+    private updateScrollOffset;
+    protected onResize(width: number, height: number): void;
+    handleKeyPress(key: KeyEvent): boolean;
+    get showScrollIndicator(): boolean;
+    set showScrollIndicator(show: boolean);
+    get showDescription(): boolean;
+    set showDescription(show: boolean);
+    get wrapSelection(): boolean;
+    set wrapSelection(wrap: boolean);
+    set backgroundColor(value: ColorInput);
+    set textColor(value: ColorInput);
+    set focusedBackgroundColor(value: ColorInput);
+    set focusedTextColor(value: ColorInput);
+    set selectedBackgroundColor(value: ColorInput);
+    set selectedTextColor(value: ColorInput);
+    set descriptionColor(value: ColorInput);
+    set selectedDescriptionColor(value: ColorInput);
+    set font(font: keyof typeof fonts);
+    set itemSpacing(spacing: number);
+    set fastScrollStep(step: number);
+    set keyBindings(bindings: SelectKeyBinding[]);
+    set keyAliasMap(aliases: KeyAliasMap);
+    set selectedIndex(value: number);
+}

package/renderables/Slider.d.ts

@@ -0,0 +1,44 @@
+import { type ColorInput, OptimizedBuffer, Renderable, type RenderableOptions, type RenderContext, RGBA } from "../index.js";
+export interface SliderOptions extends RenderableOptions<SliderRenderable> {
+    orientation: "vertical" | "horizontal";
+    value?: number;
+    min?: number;
+    max?: number;
+    viewPortSize?: number;
+    backgroundColor?: ColorInput;
+    foregroundColor?: ColorInput;
+    onChange?: (value: number) => void;
+}
+export declare class SliderRenderable extends Renderable {
+    readonly orientation: "vertical" | "horizontal";
+    private _value;
+    private _min;
+    private _max;
+    private _viewPortSize;
+    private _backgroundColor;
+    private _foregroundColor;
+    private _onChange?;
+    constructor(ctx: RenderContext, options: SliderOptions);
+    get value(): number;
+    set value(newValue: number);
+    get min(): number;
+    set min(newMin: number);
+    get max(): number;
+    set max(newMax: number);
+    set viewPortSize(size: number);
+    get viewPortSize(): number;
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    private calculateDragOffsetVirtual;
+    private setupMouseHandling;
+    private updateValueFromMouseDirect;
+    private updateValueFromMouseWithOffset;
+    private getThumbRect;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private renderHorizontal;
+    private renderVertical;
+    private getVirtualThumbSize;
+    private getVirtualThumbStart;
+}

package/renderables/TabSelect.d.ts

@@ -0,0 +1,96 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { OptimizedBuffer } from "../buffer.js";
+import { type ColorInput } from "../lib/RGBA.js";
+import type { KeyEvent } from "../lib/KeyHandler.js";
+import type { RenderContext } from "../types.js";
+import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping.js";
+export interface TabSelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export type TabSelectAction = "move-left" | "move-right" | "select-current";
+export type TabSelectKeyBinding = BaseKeyBinding<TabSelectAction>;
+export interface TabSelectRenderableOptions extends Omit<RenderableOptions<TabSelectRenderable>, "height"> {
+    height?: number;
+    options?: TabSelectOption[];
+    tabWidth?: number;
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollArrows?: boolean;
+    showDescription?: boolean;
+    showUnderline?: boolean;
+    wrapSelection?: boolean;
+    keyBindings?: TabSelectKeyBinding[];
+    keyAliasMap?: KeyAliasMap;
+}
+export declare enum TabSelectRenderableEvents {
+    SELECTION_CHANGED = "selectionChanged",
+    ITEM_SELECTED = "itemSelected"
+}
+export declare class TabSelectRenderable extends Renderable {
+    protected _focusable: boolean;
+    private _options;
+    private selectedIndex;
+    private scrollOffset;
+    private _tabWidth;
+    private maxVisibleTabs;
+    private _backgroundColor;
+    private _textColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _selectedBackgroundColor;
+    private _selectedTextColor;
+    private _selectedDescriptionColor;
+    private _showScrollArrows;
+    private _showDescription;
+    private _showUnderline;
+    private _wrapSelection;
+    private _keyBindingsMap;
+    private _keyAliasMap;
+    private _keyBindings;
+    constructor(ctx: RenderContext, options: TabSelectRenderableOptions);
+    private calculateDynamicHeight;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private truncateText;
+    private renderScrollArrowsToFrameBuffer;
+    setOptions(options: TabSelectOption[]): void;
+    getSelectedOption(): TabSelectOption | null;
+    getSelectedIndex(): number;
+    moveLeft(): void;
+    moveRight(): void;
+    selectCurrent(): void;
+    setSelectedIndex(index: number): void;
+    private updateScrollOffset;
+    protected onResize(width: number, height: number): void;
+    setTabWidth(tabWidth: number): void;
+    getTabWidth(): number;
+    handleKeyPress(key: KeyEvent): boolean;
+    get options(): TabSelectOption[];
+    set options(options: TabSelectOption[]);
+    set backgroundColor(color: ColorInput);
+    set textColor(color: ColorInput);
+    set focusedBackgroundColor(color: ColorInput);
+    set focusedTextColor(color: ColorInput);
+    set selectedBackgroundColor(color: ColorInput);
+    set selectedTextColor(color: ColorInput);
+    set selectedDescriptionColor(color: ColorInput);
+    get showDescription(): boolean;
+    set showDescription(show: boolean);
+    get showUnderline(): boolean;
+    set showUnderline(show: boolean);
+    get showScrollArrows(): boolean;
+    set showScrollArrows(show: boolean);
+    get wrapSelection(): boolean;
+    set wrapSelection(wrap: boolean);
+    get tabWidth(): number;
+    set tabWidth(tabWidth: number);
+    set keyBindings(bindings: TabSelectKeyBinding[]);
+    set keyAliasMap(aliases: KeyAliasMap);
+}

package/renderables/Text.d.ts

@@ -0,0 +1,36 @@
+import { BaseRenderable } from "../Renderable.js";
+import { StyledText } from "../lib/styled-text.js";
+import { type TextChunk } from "../text-buffer.js";
+import { RGBA } from "../lib/RGBA.js";
+import { type RenderContext } from "../types.js";
+import { RootTextNodeRenderable, TextNodeRenderable } from "./TextNode.js";
+import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable.js";
+export interface TextOptions extends TextBufferOptions {
+    content?: StyledText | string;
+}
+export declare class TextRenderable extends TextBufferRenderable {
+    private _text;
+    private _hasManualStyledText;
+    protected rootTextNode: RootTextNodeRenderable;
+    protected _contentDefaultOptions: {
+        content: string;
+    };
+    constructor(ctx: RenderContext, options: TextOptions);
+    private updateTextBuffer;
+    private clearChunks;
+    get content(): StyledText;
+    get chunks(): TextChunk[];
+    get textNode(): RootTextNodeRenderable;
+    set content(value: StyledText | string);
+    private updateTextFromNodes;
+    add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
+    remove(id: string): void;
+    insertBefore(obj: BaseRenderable | any, anchor?: TextNodeRenderable): number;
+    getTextChildren(): BaseRenderable[];
+    clear(): void;
+    onLifecyclePass: () => void;
+    protected onFgChanged(newColor: RGBA): void;
+    protected onBgChanged(newColor: RGBA): void;
+    protected onAttributesChanged(newAttributes: number): void;
+    destroy(): void;
+}

package/renderables/TextBufferRenderable.d.ts

@@ -0,0 +1,105 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { Selection, type LocalSelectionBounds } from "../lib/selection.js";
+import { TextBuffer } from "../text-buffer.js";
+import { TextBufferView } from "../text-buffer-view.js";
+import { RGBA } from "../lib/RGBA.js";
+import { type RenderContext, type LineInfoProvider } from "../types.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import type { LineInfo } from "../zig.js";
+import { SyntaxStyle } from "../syntax-style.js";
+export interface TextBufferOptions extends RenderableOptions<TextBufferRenderable> {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+    wrapMode?: "none" | "char" | "word";
+    tabIndicator?: string | number;
+    tabIndicatorColor?: string | RGBA;
+    truncate?: boolean;
+}
+export declare abstract class TextBufferRenderable extends Renderable implements LineInfoProvider {
+    selectable: boolean;
+    protected _defaultFg: RGBA;
+    protected _defaultBg: RGBA;
+    protected _defaultAttributes: number;
+    protected _selectionBg: RGBA | undefined;
+    protected _selectionFg: RGBA | undefined;
+    protected _wrapMode: "none" | "char" | "word";
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    protected _tabIndicator?: string | number;
+    protected _tabIndicatorColor?: RGBA;
+    protected _scrollX: number;
+    protected _scrollY: number;
+    protected _truncate: boolean;
+    protected textBuffer: TextBuffer;
+    protected textBufferView: TextBufferView;
+    protected _textBufferSyntaxStyle: SyntaxStyle;
+    protected _defaultOptions: {
+        fg: RGBA;
+        bg: RGBA;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrapMode: "none" | "char" | "word";
+        tabIndicator: undefined;
+        tabIndicatorColor: undefined;
+        truncate: false;
+    };
+    constructor(ctx: RenderContext, options: TextBufferOptions);
+    protected onMouseEvent(event: any): void;
+    protected handleScroll(event: any): void;
+    get lineInfo(): LineInfo;
+    get lineCount(): number;
+    get virtualLineCount(): number;
+    get scrollY(): number;
+    set scrollY(value: number);
+    get scrollX(): number;
+    set scrollX(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    get maxScrollY(): number;
+    get maxScrollX(): number;
+    protected updateViewportOffset(): void;
+    get plainText(): string;
+    get textLength(): number;
+    get fg(): RGBA;
+    set fg(value: RGBA | string | undefined);
+    get selectionBg(): RGBA | undefined;
+    set selectionBg(value: RGBA | string | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: RGBA | string | undefined);
+    get bg(): RGBA;
+    set bg(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get tabIndicator(): string | number | undefined;
+    set tabIndicator(value: string | number | undefined);
+    get tabIndicatorColor(): RGBA | undefined;
+    set tabIndicatorColor(value: RGBA | string | undefined);
+    get truncate(): boolean;
+    set truncate(value: boolean);
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    protected updateTextInfo(): void;
+    private setupMeasureFunc;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    destroy(): void;
+    protected onFgChanged(newColor: RGBA): void;
+    protected onBgChanged(newColor: RGBA): void;
+    protected onAttributesChanged(newAttributes: number): void;
+}

package/renderables/TextNode.d.ts

@@ -0,0 +1,91 @@
+import type { TextRenderable } from "./index.js";
+import { BaseRenderable, type BaseRenderableOptions } from "../Renderable.js";
+import { RGBA } from "../lib/RGBA.js";
+import { StyledText } from "../lib/styled-text.js";
+import { type TextChunk } from "../text-buffer.js";
+import type { RenderContext } from "../types.js";
+export interface TextNodeOptions extends BaseRenderableOptions {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    attributes?: number;
+    link?: {
+        url: string;
+    };
+}
+declare const BrandedTextNodeRenderable: unique symbol;
+export declare function isTextNodeRenderable(obj: any): obj is TextNodeRenderable;
+export declare class TextNodeRenderable extends BaseRenderable {
+    [BrandedTextNodeRenderable]: boolean;
+    private _fg?;
+    private _bg?;
+    private _attributes;
+    private _link?;
+    private _children;
+    parent: TextNodeRenderable | null;
+    constructor(options: TextNodeOptions);
+    get children(): (string | TextNodeRenderable)[];
+    set children(children: (string | TextNodeRenderable)[]);
+    requestRender(): void;
+    add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
+    replace(obj: TextNodeRenderable | string, index: number): void;
+    insertBefore(child: string | TextNodeRenderable | StyledText, anchorNode: TextNodeRenderable | string | unknown): this;
+    remove(id: string): this;
+    clear(): void;
+    mergeStyles(parentStyle: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    }): {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    };
+    gatherWithInheritedStyle(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    }): TextChunk[];
+    static fromString(text: string, options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    static fromNodes(nodes: TextNodeRenderable[], options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    toChunks(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    }): TextChunk[];
+    getChildren(): BaseRenderable[];
+    getChildrenCount(): number;
+    getRenderable(id: string): BaseRenderable | undefined;
+    getRenderableIndex(id: string): number;
+    get fg(): RGBA | undefined;
+    set fg(fg: RGBA | string | undefined);
+    set bg(bg: RGBA | string | undefined);
+    get bg(): RGBA | undefined;
+    set attributes(attributes: number);
+    get attributes(): number;
+    set link(link: {
+        url: string;
+    } | undefined);
+    get link(): {
+        url: string;
+    } | undefined;
+    findDescendantById(id: string): BaseRenderable | undefined;
+}
+export declare class RootTextNodeRenderable extends TextNodeRenderable {
+    private readonly ctx;
+    textParent: TextRenderable;
+    constructor(ctx: RenderContext, options: TextNodeOptions, textParent: TextRenderable);
+    requestRender(): void;
+}
+export {};