@fairyhunter13/opentui-core 0.1.91 → 0.1.94

package/renderables/TextTable.d.ts

@@ -0,0 +1,140 @@
+import { type RenderableOptions, Renderable } from "../Renderable";
+import type { OptimizedBuffer } from "../buffer";
+import { type BorderStyle } from "../lib/border";
+import { type Selection } from "../lib/selection";
+import { RGBA, type ColorInput } from "../lib/RGBA";
+import { type TextChunk } from "../text-buffer";
+import type { RenderContext } from "../types";
+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,114 @@
+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;
+    insertChar(char: string): void;
+    insertText(text: string): void;
+    deleteChar(): boolean;
+    deleteCharBackward(): boolean;
+    private deleteSelectedText;
+    newLine(): boolean;
+    deleteLine(): boolean;
+    moveCursorLeft(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorRight(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorUp(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorDown(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoLine(line: number): void;
+    gotoLineHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoLineEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoVisualLineHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoVisualLineEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoBufferHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoBufferEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    selectAll(): boolean;
+    deleteToLineEnd(): boolean;
+    deleteToLineStart(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    moveWordForward(options?: {
+        select?: boolean;
+    }): boolean;
+    moveWordBackward(options?: {
+        select?: boolean;
+    }): boolean;
+    deleteWordForward(): boolean;
+    deleteWordBackward(): boolean;
+    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";
+import { type ColorInput } from "../lib/RGBA";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+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 {};

package/renderables/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./ASCIIFont.js";
+export * from "./Box.js";
+export * from "./Code.js";
+export * from "./composition/constructs.js";
+export * from "./composition/VRenderable.js";
+export * from "./composition/vnode.js";
+export * from "./Diff.js";
+export * from "./FrameBuffer.js";
+export * from "./Input.js";
+export * from "./LineNumberRenderable.js";
+export * from "./Markdown.js";
+export * from "./ScrollBar.js";
+export * from "./ScrollBox.js";
+export * from "./Select.js";
+export * from "./Slider.js";
+export * from "./TextTable.js";
+export * from "./TabSelect.js";
+export * from "./Text.js";
+export * from "./TimeToFirstDraw.js";
+export * from "./TextBufferRenderable.js";
+export * from "./TextNode.js";
+export * from "./Textarea.js";

package/renderables/markdown-parser.d.ts

@@ -0,0 +1,10 @@
+import { type MarkedToken } from "marked";
+export interface ParseState {
+    content: string;
+    tokens: MarkedToken[];
+}
+/**
+ * Incrementally parse markdown, reusing unchanged tokens from previous parse.
+ * Compares token.raw at each offset - matching tokens keep same object reference.
+ */
+export declare function parseMarkdownIncremental(newContent: string, prevState: ParseState | null, trailingUnstable?: number): ParseState;