@fairyhunter13/opentui-core 0.1.114 → 0.1.115

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 "./Text.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 {};

package/renderables/TextTable.d.ts

@@ -0,0 +1,140 @@
+import { type RenderableOptions, Renderable } from "../Renderable.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import { type BorderStyle } from "../lib/border.js";
+import { type Selection } from "../lib/selection.js";
+import { RGBA, type ColorInput } from "../lib/RGBA.js";
+import { type TextChunk } from "../text-buffer.js";
+import type { RenderContext } from "../types.js";
+export type TextTableCellContent = TextChunk[] | null | undefined;
+export type TextTableContent = TextTableCellContent[][];
+export type TextTableColumnWidthMode = "content" | "full";
+export type TextTableColumnFitter = "proportional" | "balanced";
+export interface TextTableOptions extends RenderableOptions<TextTableRenderable> {
+    content?: TextTableContent;
+    wrapMode?: "none" | "char" | "word";
+    columnWidthMode?: TextTableColumnWidthMode;
+    columnFitter?: TextTableColumnFitter;
+    cellPadding?: number;
+    showBorders?: boolean;
+    border?: boolean;
+    outerBorder?: boolean;
+    selectable?: boolean;
+    selectionBg?: ColorInput;
+    selectionFg?: ColorInput;
+    borderStyle?: BorderStyle;
+    borderColor?: ColorInput;
+    borderBackgroundColor?: ColorInput;
+    backgroundColor?: ColorInput;
+    fg?: ColorInput;
+    bg?: ColorInput;
+    attributes?: number;
+}
+export declare class TextTableRenderable extends Renderable {
+    private _content;
+    private _wrapMode;
+    private _columnWidthMode;
+    private _columnFitter;
+    private _cellPadding;
+    private _showBorders;
+    private _border;
+    private _outerBorder;
+    private _hasExplicitOuterBorder;
+    private _borderStyle;
+    private _borderColor;
+    private _borderBackgroundColor;
+    private _backgroundColor;
+    private _defaultFg;
+    private _defaultBg;
+    private _defaultAttributes;
+    private _selectionBg;
+    private _selectionFg;
+    private _lastLocalSelection;
+    private _lastSelectionMode;
+    private _cells;
+    private _prevCellContent;
+    private _rowCount;
+    private _columnCount;
+    private _layout;
+    private _layoutDirty;
+    private _rasterDirty;
+    private _cachedMeasureLayout;
+    private _cachedMeasureWidth;
+    private readonly _defaultOptions;
+    constructor(ctx: RenderContext, options?: TextTableOptions);
+    get content(): TextTableContent;
+    set content(value: TextTableContent);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get columnWidthMode(): TextTableColumnWidthMode;
+    set columnWidthMode(value: TextTableColumnWidthMode);
+    get columnFitter(): TextTableColumnFitter;
+    set columnFitter(value: TextTableColumnFitter);
+    get cellPadding(): number;
+    set cellPadding(value: number);
+    get showBorders(): boolean;
+    set showBorders(value: boolean);
+    get outerBorder(): boolean;
+    set outerBorder(value: boolean);
+    get border(): boolean;
+    set border(value: boolean);
+    get borderStyle(): BorderStyle;
+    set borderStyle(value: BorderStyle);
+    get borderColor(): RGBA;
+    set borderColor(value: ColorInput);
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    getSelectedText(): string;
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected destroySelf(): void;
+    private setupMeasureFunc;
+    private rebuildCells;
+    private updateCellsDiff;
+    private createCell;
+    private toStyledText;
+    private destroyCells;
+    private rebuildLayoutForCurrentWidth;
+    private computeLayout;
+    private isFullWidthMode;
+    private computeColumnWidths;
+    private expandColumnWidths;
+    private fitColumnWidths;
+    private fitColumnWidthsProportional;
+    private fitColumnWidthsBalanced;
+    private allocateShrinkByWeight;
+    private computeRowHeights;
+    private computeOffsets;
+    private applyLayoutToViews;
+    private resolveBorderLayout;
+    private getVerticalBorderCount;
+    private getHorizontalBorderCount;
+    private drawBorders;
+    private drawCells;
+    private drawCellRange;
+    private redrawSelectionRows;
+    private clearCellRange;
+    private ensureLayoutReady;
+    private getCellAtLocalPosition;
+    private applySelectionToCells;
+    private resolveSelectionResolution;
+    private getColumnAtLocalX;
+    private getFullCellSelectionCoords;
+    private findRowForLocalY;
+    private getSelectionRowRange;
+    private getDirtySelectionRowRange;
+    private resetRowSelection;
+    private resetCellSelections;
+    private createEmptyLayout;
+    private resolveLayoutWidthConstraint;
+    private getHorizontalCellPadding;
+    private getVerticalCellPadding;
+    private resolveColumnFitter;
+    private resolveCellPadding;
+    private invalidateLayoutAndRaster;
+    private invalidateRasterOnly;
+}

package/renderables/Textarea.d.ts

@@ -0,0 +1,63 @@
+import type { KeyEvent, PasteEvent } from "../lib/KeyHandler.js";
+import { RGBA, type ColorInput } from "../lib/RGBA.js";
+import { type RenderContext } from "../types.js";
+import { EditBufferRenderable, type EditBufferOptions } from "./EditBufferRenderable.js";
+import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping.js";
+import { type StyledText } from "../lib/styled-text.js";
+import type { ExtmarksController } from "../lib/extmarks.js";
+export type TextareaAction = "move-left" | "move-right" | "move-up" | "move-down" | "select-left" | "select-right" | "select-up" | "select-down" | "line-home" | "line-end" | "select-line-home" | "select-line-end" | "visual-line-home" | "visual-line-end" | "select-visual-line-home" | "select-visual-line-end" | "buffer-home" | "buffer-end" | "select-buffer-home" | "select-buffer-end" | "delete-line" | "delete-to-line-end" | "delete-to-line-start" | "backspace" | "delete" | "newline" | "undo" | "redo" | "word-forward" | "word-backward" | "select-word-forward" | "select-word-backward" | "delete-word-forward" | "delete-word-backward" | "select-all" | "submit";
+export type KeyBinding = BaseKeyBinding<TextareaAction>;
+export interface SubmitEvent {
+}
+export interface TextareaOptions extends EditBufferOptions {
+    initialValue?: string;
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    placeholder?: StyledText | string | null;
+    placeholderColor?: ColorInput;
+    keyBindings?: KeyBinding[];
+    keyAliasMap?: KeyAliasMap;
+    onSubmit?: (event: SubmitEvent) => void;
+}
+export declare class TextareaRenderable extends EditBufferRenderable {
+    private _placeholder;
+    private _placeholderColor;
+    private _unfocusedBackgroundColor;
+    private _unfocusedTextColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _keyBindingsMap;
+    private _keyAliasMap;
+    private _keyBindings;
+    private _actionHandlers;
+    private _initialValueSet;
+    private _submitListener;
+    private static readonly defaults;
+    constructor(ctx: RenderContext, options: TextareaOptions);
+    private applyPlaceholder;
+    private buildActionHandlers;
+    handlePaste(event: PasteEvent): void;
+    handleKeyPress(key: KeyEvent): boolean;
+    private updateColors;
+    focus(): void;
+    blur(): void;
+    get placeholder(): StyledText | string | null;
+    set placeholder(value: StyledText | string | null | undefined);
+    get placeholderColor(): RGBA;
+    set placeholderColor(value: ColorInput);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get textColor(): RGBA;
+    set textColor(value: RGBA | string | undefined);
+    set focusedBackgroundColor(value: ColorInput);
+    set focusedTextColor(value: ColorInput);
+    set initialValue(value: string);
+    submit(): boolean;
+    set onSubmit(handler: ((event: SubmitEvent) => void) | undefined);
+    get onSubmit(): ((event: SubmitEvent) => void) | undefined;
+    set keyBindings(bindings: KeyBinding[]);
+    set keyAliasMap(aliases: KeyAliasMap);
+    get extmarks(): ExtmarksController;
+}

package/renderables/TimeToFirstDraw.d.ts

@@ -0,0 +1,24 @@
+import type { OptimizedBuffer } from "../buffer.js";
+import { type ColorInput } from "../lib/RGBA.js";
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+export interface TimeToFirstDrawOptions extends RenderableOptions<TimeToFirstDrawRenderable> {
+    fg?: ColorInput;
+    label?: string;
+    precision?: number;
+}
+export declare class TimeToFirstDrawRenderable extends Renderable {
+    private _runtimeMs;
+    private textColor;
+    private label;
+    private precision;
+    constructor(ctx: RenderContext, options?: TimeToFirstDrawOptions);
+    get runtimeMs(): number | null;
+    set fg(value: ColorInput);
+    set color(value: ColorInput);
+    set textLabel(value: string);
+    set decimals(value: number);
+    reset(): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private normalizePrecision;
+}

package/renderables/__tests__/renderable-test-utils.d.ts

@@ -0,0 +1,12 @@
+import { TextareaRenderable } from "../Textarea.js";
+import { type TestRenderer } from "../../testing/test-renderer.js";
+import { type TextareaOptions } from "../Textarea.js";
+import type { DiffRenderable } from "../Diff.js";
+import type { MockTreeSitterClient } from "../../testing/mock-tree-sitter-client.js";
+import type { ManualClock } from "../../testing/manual-clock.js";
+export declare function createTextareaRenderable(renderer: TestRenderer, renderOnce: () => Promise<void>, options: TextareaOptions): Promise<{
+    textarea: TextareaRenderable;
+    root: any;
+}>;
+export declare function settleDiffHighlighting(diff: DiffRenderable, client: MockTreeSitterClient, render: () => Promise<void>): Promise<void>;
+export declare function simulateFrames(clock: ManualClock, renderOnce: () => Promise<void>, ms: number, frameInterval?: number): Promise<void>;

package/renderables/composition/VRenderable.d.ts

@@ -0,0 +1,16 @@
+import { Renderable, type RenderableOptions } from "../../Renderable.js";
+import type { OptimizedBuffer } from "../../buffer.js";
+import type { RenderContext } from "../../types.js";
+export interface VRenderableOptions extends RenderableOptions<VRenderable> {
+    render?: (this: VRenderable | VRenderableOptions, buffer: OptimizedBuffer, deltaTime: number, renderable: VRenderable) => void;
+}
+/**
+ * A generic renderable that accepts a custom render function as a prop.
+ * This allows functional constructs to specify custom rendering behavior
+ * without needing to subclass Renderable.
+ */
+export declare class VRenderable extends Renderable {
+    private options;
+    constructor(ctx: RenderContext, options: VRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+}

package/renderables/composition/constructs.d.ts

@@ -0,0 +1,35 @@
+import { ASCIIFontRenderable, BoxRenderable, CodeRenderable, InputRenderable, ScrollBoxRenderable, SelectRenderable, TabSelectRenderable, TextRenderable, VRenderable, FrameBufferRenderable, type ASCIIFontOptions, type BoxOptions, type CodeOptions, type TextOptions, type VRenderableOptions, type InputRenderableOptions, type ScrollBoxOptions, type SelectRenderableOptions, type TabSelectRenderableOptions, type FrameBufferOptions } from "..//index.js";
+import { TextNodeRenderable } from "../TextNode.js";
+import { type VChild } from "./vnode.js";
+import type { RGBA } from "../../lib/RGBA.js";
+export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof VRenderable>;
+export declare function Box(props?: BoxOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof BoxRenderable>;
+export declare function Text(props?: TextOptions & {
+    content?: any;
+}, ...children: VChild[] | TextNodeRenderable[]): import("./vnode.js").ProxiedVNode<typeof TextRenderable>;
+export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof ASCIIFontRenderable>;
+export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof InputRenderable>;
+export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof SelectRenderable>;
+export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof TabSelectRenderable>;
+export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof FrameBufferRenderable>;
+export declare function Code(props: CodeOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof CodeRenderable>;
+export declare function ScrollBox(props?: ScrollBoxOptions, ...children: VChild[]): import("./vnode.js").ProxiedVNode<typeof ScrollBoxRenderable>;
+export declare const vstyles: {
+    bold: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    italic: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    underline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    dim: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    blink: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    inverse: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    hidden: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    strikethrough: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldItalic: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    italicUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldItalicUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    color: (color: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    bgColor: (bgColor: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    fg: (color: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    bg: (bgColor: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    styled: (attributes?: number, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+};

package/renderables/composition/vnode.d.ts

@@ -0,0 +1,46 @@
+import { Renderable, type RenderableOptions } from "../../Renderable.js";
+import type { RenderContext } from "../../types.js";
+export type VChild = VNode | Renderable | VChild[] | null | undefined | false;
+export interface PendingCall {
+    method: string;
+    args: any[];
+    isProperty?: boolean;
+}
+declare const BrandedVNode: unique symbol;
+export interface VNode<P = any, C = VChild[]> {
+    [BrandedVNode]: true;
+    type: Construct<P>;
+    props?: P;
+    children?: C;
+    __delegateMap?: Record<string, string>;
+    __pendingCalls?: PendingCall[];
+}
+export type ProxiedVNode<TCtor extends RenderableConstructor<any>> = VNode<TCtor extends RenderableConstructor<infer P> ? P : any> & {
+    [K in keyof InstanceType<TCtor>]: InstanceType<TCtor>[K] extends (...args: infer Args) => any ? (...args: Args) => ProxiedVNode<TCtor> : InstanceType<TCtor>[K];
+};
+export interface RenderableConstructor<P extends RenderableOptions<any> = RenderableOptions<any>> {
+    new (ctx: RenderContext, options: P): Renderable;
+}
+export type FunctionalConstruct<P = any> = (props: P, children?: VChild[]) => VNode;
+export type Construct<P = any> = RenderableConstructor<P extends RenderableOptions<any> ? P : never> | FunctionalConstruct<P>;
+export declare function h<TCtor extends RenderableConstructor<any>>(type: TCtor, props?: TCtor extends RenderableConstructor<infer P> ? P : never, ...children: VChild[]): ProxiedVNode<TCtor>;
+export declare function h<P>(type: FunctionalConstruct<P>, props?: P, ...children: VChild[]): VNode<P>;
+export declare function h<P>(type: Construct<P>, props?: P, ...children: VChild[]): VNode<P> | ProxiedVNode<any>;
+export declare function isVNode(node: any): node is VNode;
+export declare function maybeMakeRenderable(ctx: RenderContext, node: Renderable | VNode<any, any[]> | unknown): Renderable | null;
+export declare function wrapWithDelegates<T extends InstanceType<RenderableConstructor>>(instance: T, delegateMap: Record<string, string> | undefined): T;
+export type InstantiateFn<NodeType extends VNode | Renderable> = Renderable & {
+    __node?: NodeType;
+};
+export declare function instantiate<NodeType extends VNode | Renderable>(ctx: RenderContext, node: NodeType): InstantiateFn<NodeType>;
+export type DelegateMap<T> = Partial<Record<keyof T, string>>;
+export type ValidateShape<Given, AllowedKeys> = {
+    [K in keyof Given]: K extends keyof AllowedKeys ? NonNullable<Given[K]> : never;
+};
+type InferNode<T> = T extends InstantiateFn<infer U> ? U : never;
+export declare function delegate<Factory extends InstantiateFn<any>, InnerNode extends InferNode<Factory>, TargetMap extends Record<keyof InnerNode, string>, const Mapping extends Partial<TargetMap>>(mapping: ValidateShape<Mapping, TargetMap>, vnode: Factory): Renderable;
+export declare function delegate<ConstructorType extends RenderableConstructor<any>, TargetMap extends Record<keyof InstanceType<ConstructorType>, string>, const Mapping extends Partial<TargetMap>>(mapping: ValidateShape<Mapping, TargetMap>, vnode: ProxiedVNode<ConstructorType>): ProxiedVNode<ConstructorType>;
+export declare function delegate<ConstructorType extends RenderableConstructor<any>, const Mapping extends DelegateMap<InstanceType<ConstructorType>>>(mapping: ValidateShape<Mapping, string>, vnode: VNode & {
+    type: ConstructorType;
+}): VNode;
+export {};