@xincli/opentui-core 0.4.6 → 0.4.7

package/renderables/Diff.d.ts

@@ -0,0 +1,147 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { type LineColorConfig } from "./LineNumberRenderable.js";
+import { RGBA } from "../lib/RGBA.js";
+import { SyntaxStyle } from "../syntax-style.js";
+import type { TreeSitterClient } from "../lib/tree-sitter/index.js";
+import type { MouseEvent } from "../renderer.js";
+export interface DiffRenderableOptions extends RenderableOptions<DiffRenderable> {
+    diff?: string;
+    syncScroll?: boolean;
+    view?: "unified" | "split";
+    fg?: string | RGBA;
+    filetype?: string;
+    syntaxStyle?: SyntaxStyle;
+    wrapMode?: "word" | "char" | "none";
+    conceal?: boolean;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    treeSitterClient?: TreeSitterClient;
+    showLineNumbers?: boolean;
+    lineNumberFg?: string | RGBA;
+    lineNumberBg?: string | RGBA;
+    addedBg?: string | RGBA;
+    removedBg?: string | RGBA;
+    contextBg?: string | RGBA;
+    addedContentBg?: string | RGBA;
+    removedContentBg?: string | RGBA;
+    contextContentBg?: string | RGBA;
+    addedSignColor?: string | RGBA;
+    removedSignColor?: string | RGBA;
+    addedLineNumberBg?: string | RGBA;
+    removedLineNumberBg?: string | RGBA;
+}
+export declare class DiffRenderable extends Renderable {
+    private _diff;
+    private _syncScroll;
+    private _view;
+    private _parsedDiff;
+    private _parseError;
+    private _hunkStartLines;
+    private _hunkRowOffsets;
+    private _fg?;
+    private _filetype?;
+    private _syntaxStyle?;
+    private _wrapMode?;
+    private _conceal;
+    private _selectionBg?;
+    private _selectionFg?;
+    private _treeSitterClient?;
+    private _showLineNumbers;
+    private _lineNumberFg;
+    private _lineNumberBg;
+    private _addedBg;
+    private _removedBg;
+    private _contextBg;
+    private _addedContentBg;
+    private _removedContentBg;
+    private _contextContentBg;
+    private _addedSignColor;
+    private _removedSignColor;
+    private _addedLineNumberBg;
+    private _removedLineNumberBg;
+    private leftSide;
+    private rightSide;
+    private leftSideAdded;
+    private rightSideAdded;
+    private leftCodeRenderable;
+    private rightCodeRenderable;
+    private pendingRebuild;
+    private _lastWidth;
+    private errorTextRenderable;
+    private errorCodeRenderable;
+    private _waitingForHighlight;
+    private _lineInfoChangeHandler;
+    constructor(ctx: RenderContext, options: DiffRenderableOptions);
+    private parseDiff;
+    private buildView;
+    protected onMouseEvent(event: MouseEvent): void;
+    private isInsideSide;
+    protected onResize(width: number, height: number): void;
+    private requestRebuild;
+    private invalidateHunkRowOffsets;
+    private rebuildView;
+    private handleLineInfoChange;
+    private attachLineInfoListeners;
+    private detachLineInfoListeners;
+    destroyRecursively(): void;
+    private buildErrorView;
+    private createOrUpdateCodeRenderable;
+    private createOrUpdateSide;
+    private buildUnifiedView;
+    private buildSplitView;
+    get diff(): string;
+    set diff(value: string);
+    get syncScroll(): boolean;
+    set syncScroll(value: boolean);
+    get view(): "unified" | "split";
+    set view(value: "unified" | "split");
+    get filetype(): string | undefined;
+    set filetype(value: string | undefined);
+    get syntaxStyle(): SyntaxStyle | undefined;
+    set syntaxStyle(value: SyntaxStyle | undefined);
+    get wrapMode(): "word" | "char" | "none" | undefined;
+    set wrapMode(value: "word" | "char" | "none" | undefined);
+    get showLineNumbers(): boolean;
+    set showLineNumbers(value: boolean);
+    get addedBg(): RGBA;
+    set addedBg(value: string | RGBA);
+    get removedBg(): RGBA;
+    set removedBg(value: string | RGBA);
+    get contextBg(): RGBA;
+    set contextBg(value: string | RGBA);
+    get addedSignColor(): RGBA;
+    set addedSignColor(value: string | RGBA);
+    get removedSignColor(): RGBA;
+    set removedSignColor(value: string | RGBA);
+    get addedLineNumberBg(): RGBA;
+    set addedLineNumberBg(value: string | RGBA);
+    get removedLineNumberBg(): RGBA;
+    set removedLineNumberBg(value: string | RGBA);
+    get lineNumberFg(): RGBA;
+    set lineNumberFg(value: string | RGBA);
+    get lineNumberBg(): RGBA;
+    set lineNumberBg(value: string | RGBA);
+    get addedContentBg(): RGBA | null;
+    set addedContentBg(value: string | RGBA | null);
+    get removedContentBg(): RGBA | null;
+    set removedContentBg(value: string | RGBA | null);
+    get contextContentBg(): RGBA | null;
+    set contextContentBg(value: string | RGBA | null);
+    get selectionBg(): RGBA | undefined;
+    set selectionBg(value: string | RGBA | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: string | RGBA | undefined);
+    get conceal(): boolean;
+    set conceal(value: boolean);
+    get fg(): RGBA | undefined;
+    set fg(value: string | RGBA | undefined);
+    setLineColor(line: number, color: string | RGBA | LineColorConfig): void;
+    clearLineColor(line: number): void;
+    setLineColors(lineColors: Map<number, string | RGBA | LineColorConfig>): void;
+    clearAllLineColors(): void;
+    highlightLines(startLine: number, endLine: number, color: string | RGBA | LineColorConfig): void;
+    clearHighlightLines(startLine: number, endLine: number): void;
+    getHunkRowOffsets(): number[];
+    private computeHunkRowOffsets;
+}

package/renderables/EditBufferRenderable.d.ts

@@ -0,0 +1,238 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { Selection, type LocalSelectionBounds } from "../lib/selection.js";
+import { EditBuffer, type LogicalCursor } from "../edit-buffer.js";
+import { EditorView, type VisualCursor } from "../editor-view.js";
+import { RGBA } from "../lib/RGBA.js";
+import type { RenderContext, Highlight, CursorStyleOptions, LineInfoProvider, LineInfo } from "../types.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import type { SyntaxStyle } from "../syntax-style.js";
+declare const BrandedEditBufferRenderable: unique symbol;
+export type EditorCapture = "escape" | "navigate" | "submit" | "tab";
+export interface EditorTraits {
+    capture?: readonly EditorCapture[];
+    suspend?: boolean;
+    status?: string;
+}
+export declare enum EditBufferRenderableEvents {
+    TRAITS_CHANGED = "traits-changed"
+}
+export declare function isEditBufferRenderable(obj: unknown): obj is EditBufferRenderable;
+export interface CursorChangeEvent {
+    line: number;
+    visualColumn: number;
+}
+export interface ContentChangeEvent {
+}
+export interface EditBufferOptions extends RenderableOptions<EditBufferRenderable> {
+    textColor?: string | RGBA;
+    backgroundColor?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+    wrapMode?: "none" | "char" | "word";
+    scrollMargin?: number;
+    scrollSpeed?: number;
+    showCursor?: boolean;
+    cursorColor?: string | RGBA;
+    cursorStyle?: CursorStyleOptions;
+    syntaxStyle?: SyntaxStyle;
+    tabIndicator?: string | number;
+    tabIndicatorColor?: string | RGBA;
+    onCursorChange?: (event: CursorChangeEvent) => void;
+    onContentChange?: (event: ContentChangeEvent) => void;
+}
+export declare abstract class EditBufferRenderable extends Renderable implements LineInfoProvider {
+    [BrandedEditBufferRenderable]: boolean;
+    protected _focusable: boolean;
+    selectable: boolean;
+    private _traits;
+    protected _textColor: RGBA;
+    protected _backgroundColor: RGBA;
+    protected _defaultAttributes: number;
+    protected _selectionBg: RGBA | undefined;
+    protected _selectionFg: RGBA | undefined;
+    protected _wrapMode: "none" | "char" | "word";
+    protected _scrollMargin: number;
+    protected _showCursor: boolean;
+    protected _cursorColor: RGBA;
+    protected _cursorStyle: CursorStyleOptions;
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    protected _tabIndicator?: string | number;
+    protected _tabIndicatorColor?: RGBA;
+    private _cursorChangeListener;
+    private _contentChangeListener;
+    private _autoScrollVelocity;
+    private _autoScrollAccumulator;
+    private _scrollSpeed;
+    private _keyboardSelectionActive;
+    readonly editBuffer: EditBuffer;
+    readonly editorView: EditorView;
+    private nativeRenderable;
+    protected _defaultOptions: {
+        textColor: RGBA;
+        backgroundColor: string;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrapMode: "none" | "char" | "word";
+        scrollMargin: number;
+        scrollSpeed: number;
+        showCursor: true;
+        cursorColor: RGBA;
+        cursorStyle: {
+            style: "block";
+            blinking: true;
+        };
+        tabIndicator: undefined;
+        tabIndicatorColor: undefined;
+    };
+    constructor(ctx: RenderContext, options: EditBufferOptions);
+    get lineInfo(): LineInfo;
+    private setupEventListeners;
+    get lineCount(): number;
+    get virtualLineCount(): number;
+    get scrollY(): number;
+    get plainText(): string;
+    get logicalCursor(): LogicalCursor;
+    get visualCursor(): VisualCursor;
+    get cursorOffset(): number;
+    set cursorOffset(offset: number);
+    get cursorCharacterOffset(): number | undefined;
+    get textColor(): RGBA;
+    set textColor(value: RGBA | string | undefined);
+    get selectionBg(): RGBA | undefined;
+    get traits(): EditorTraits;
+    set traits(value: EditorTraits);
+    set selectionBg(value: RGBA | string | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: RGBA | string | undefined);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get showCursor(): boolean;
+    set showCursor(value: boolean);
+    get cursorColor(): RGBA;
+    set cursorColor(value: RGBA | string);
+    get cursorStyle(): CursorStyleOptions;
+    set cursorStyle(style: CursorStyleOptions);
+    get tabIndicator(): string | number | undefined;
+    set tabIndicator(value: string | number | undefined);
+    get tabIndicatorColor(): RGBA | undefined;
+    set tabIndicatorColor(value: RGBA | string | undefined);
+    get scrollSpeed(): number;
+    set scrollSpeed(value: number);
+    protected onMouseEvent(event: any): void;
+    protected handleScroll(event: any): void;
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    protected onUpdate(deltaTime: number): void;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    private refreshSelectionStyle;
+    private deleteSelectedText;
+    setSelection(start: number, end: number): void;
+    setSelectionInclusive(start: number, end: number): void;
+    clearSelection(): boolean;
+    deleteSelection(): boolean;
+    setCursor(row: number, col: number): void;
+    insertChar(char: string): void;
+    insertText(text: string): void;
+    deleteChar(): boolean;
+    deleteCharBackward(): boolean;
+    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;
+    gotoLineStart(): void;
+    gotoLineTextEnd(): 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;
+    private setupNativeRenderable;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected renderCursor(buffer: OptimizedBuffer): void;
+    focus(): void;
+    blur(): void;
+    protected onRemove(): void;
+    destroy(): void;
+    set onCursorChange(handler: ((event: CursorChangeEvent) => void) | undefined);
+    get onCursorChange(): ((event: CursorChangeEvent) => void) | undefined;
+    set onContentChange(handler: ((event: ContentChangeEvent) => void) | undefined);
+    get onContentChange(): ((event: ContentChangeEvent) => void) | undefined;
+    get syntaxStyle(): SyntaxStyle | null;
+    set syntaxStyle(style: SyntaxStyle | null);
+    addHighlight(lineIdx: number, highlight: Highlight): void;
+    addHighlightByCharRange(highlight: Highlight): void;
+    removeHighlightsByRef(hlRef: number): void;
+    clearLineHighlights(lineIdx: number): void;
+    clearAllHighlights(): void;
+    getLineHighlights(lineIdx: number): Array<Highlight>;
+    /**
+     * Set text and completely reset the buffer state (clears history, resets add_buffer).
+     * Use this for initial text setting or when you want a clean slate.
+     */
+    setText(text: string): void;
+    /**
+     * Replace text while preserving undo history (creates an undo point).
+     * Use this when you want the setText operation to be undoable.
+     */
+    replaceText(text: string): void;
+    clear(): void;
+    deleteRange(startLine: number, startCol: number, endLine: number, endCol: number): void;
+    getTextRange(startOffset: number, endOffset: number): string;
+    getTextRangeByCoords(startRow: number, startCol: number, endRow: number, endCol: number): string;
+    protected updateSelectionForMovement(shiftPressed: boolean, isBeforeMovement: boolean): void;
+}
+export {};

package/renderables/FrameBuffer.d.ts

@@ -0,0 +1,16 @@
+import { type RenderableOptions, Renderable } from "../Renderable.js";
+import { OptimizedBuffer } from "../buffer.js";
+import type { RenderContext } from "../types.js";
+export interface FrameBufferOptions extends RenderableOptions<FrameBufferRenderable> {
+    width: number;
+    height: number;
+    respectAlpha?: boolean;
+}
+export declare class FrameBufferRenderable extends Renderable {
+    frameBuffer: OptimizedBuffer;
+    protected respectAlpha: boolean;
+    constructor(ctx: RenderContext, options: FrameBufferOptions);
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected destroySelf(): void;
+}

package/renderables/Input.d.ts

@@ -0,0 +1,72 @@
+import type { PasteEvent } from "../lib/KeyHandler.js";
+import type { RenderContext } from "../types.js";
+import { TextareaRenderable, type TextareaOptions, type TextareaAction, type KeyBinding as TextareaKeyBinding } from "./Textarea.js";
+export type InputAction = TextareaAction;
+export type InputKeyBinding = TextareaKeyBinding;
+export interface InputRenderableOptions extends Omit<TextareaOptions, "height" | "minHeight" | "maxHeight" | "initialValue"> {
+    /** Initial text value (newlines are stripped) */
+    value?: string;
+    /** Minimum number of characters allowed */
+    minLength?: number;
+    /** Maximum number of characters allowed */
+    maxLength?: number;
+    /** Placeholder text (Input only supports string, not StyledText) */
+    placeholder?: string;
+}
+export declare enum InputRenderableEvents {
+    INPUT = "input",
+    CHANGE = "change",
+    ENTER = "enter"
+}
+/**
+ * InputRenderable - A single-line text input component.
+ *
+ * Extends TextareaRenderable with single-line constraints:
+ * - Height is always 1
+ * - No text wrapping
+ * - Newlines are stripped from input
+ * - Enter key submits instead of inserting newline
+ *
+ * Inherits all keybindings from TextareaRenderable.
+ */
+export declare class InputRenderable extends TextareaRenderable {
+    private _maxLength;
+    private _minLength;
+    private _lastCommittedValue;
+    private static readonly defaultOptions;
+    constructor(ctx: RenderContext, options: InputRenderableOptions);
+    /**
+     * Prevent newlines in single-line input
+     */
+    newLine(): boolean;
+    /**
+     * Handle paste - strip newlines and enforce maxLength
+     */
+    handlePaste(event: PasteEvent): void;
+    /**
+     * Insert text - strip newlines and enforce maxLength
+     */
+    insertText(text: string): void;
+    get value(): string;
+    set value(value: string);
+    focus(): void;
+    blur(): void;
+    submit(): boolean;
+    deleteCharBackward(): boolean;
+    deleteChar(): boolean;
+    deleteLine(): boolean;
+    deleteWordBackward(): boolean;
+    deleteWordForward(): boolean;
+    deleteToLineStart(): boolean;
+    deleteToLineEnd(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    deleteCharacter(direction: "backward" | "forward"): void;
+    set maxLength(maxLength: number);
+    get maxLength(): number;
+    set minLength(minLength: number);
+    get minLength(): number;
+    set placeholder(placeholder: string);
+    get placeholder(): string;
+    set initialValue(value: string);
+}

package/renderables/LineNumberRenderable.d.ts

@@ -0,0 +1,78 @@
+import { Renderable, type BaseRenderable, type RenderableOptions } from "../Renderable.js";
+import { OptimizedBuffer } from "../buffer.js";
+import type { RenderContext, LineInfoProvider } from "../types.js";
+import { RGBA } from "../lib/RGBA.js";
+export interface LineSign {
+    before?: string;
+    beforeColor?: string | RGBA;
+    after?: string;
+    afterColor?: string | RGBA;
+}
+export interface LineColorConfig {
+    gutter?: string | RGBA;
+    content?: string | RGBA;
+}
+export interface LineNumberOptions extends RenderableOptions<LineNumberRenderable> {
+    target?: Renderable & LineInfoProvider;
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    minWidth?: number;
+    paddingRight?: number;
+    lineColors?: Map<number, string | RGBA | LineColorConfig>;
+    lineSigns?: Map<number, LineSign>;
+    lineNumberOffset?: number;
+    hideLineNumbers?: Set<number>;
+    lineNumbers?: Map<number, number>;
+    showLineNumbers?: boolean;
+}
+export declare class LineNumberRenderable extends Renderable {
+    private gutter;
+    private target;
+    private _lineColorsGutter;
+    private _lineColorsContent;
+    private _lineSigns;
+    private _fg;
+    private _bg;
+    private _minWidth;
+    private _paddingRight;
+    private _lineNumberOffset;
+    private _hideLineNumbers;
+    private _lineNumbers;
+    private _isDestroying;
+    private handleLineInfoChange;
+    private parseLineColor;
+    constructor(ctx: RenderContext, options: LineNumberOptions);
+    private setTarget;
+    add(child: Renderable): number;
+    remove(child: BaseRenderable): void;
+    destroyRecursively(): void;
+    clearTarget(): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    set showLineNumbers(value: boolean);
+    get showLineNumbers(): boolean;
+    get fg(): RGBA;
+    set fg(value: string | RGBA | undefined);
+    get bg(): RGBA;
+    set bg(value: string | RGBA | undefined);
+    setLineColor(line: number, color: string | RGBA | LineColorConfig): void;
+    clearLineColor(line: number): void;
+    clearAllLineColors(): void;
+    setLineColors(lineColors: Map<number, string | RGBA | LineColorConfig>): void;
+    getLineColors(): {
+        gutter: Map<number, RGBA>;
+        content: Map<number, RGBA>;
+    };
+    setLineSign(line: number, sign: LineSign): void;
+    clearLineSign(line: number): void;
+    clearAllLineSigns(): void;
+    setLineSigns(lineSigns: Map<number, LineSign>): void;
+    getLineSigns(): Map<number, LineSign>;
+    set lineNumberOffset(value: number);
+    get lineNumberOffset(): number;
+    setHideLineNumbers(hideLineNumbers: Set<number>): void;
+    getHideLineNumbers(): Set<number>;
+    setLineNumbers(lineNumbers: Map<number, number>): void;
+    getLineNumbers(): Map<number, number>;
+    highlightLines(startLine: number, endLine: number, color: string | RGBA | LineColorConfig): void;
+    clearHighlightLines(startLine: number, endLine: number): void;
+}