@opentui/core 0.1.13 → 0.1.15

package/lib/KeyHandler.d.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from "events";
-export declare class KeyHandler extends EventEmitter {
+import { type ParsedKey } from "./parse.keypress";
+type KeyHandlerEventMap = {
+    keypress: [ParsedKey];
+};
+export declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
     constructor();
     destroy(): void;
 }
 export declare function getKeyHandler(): KeyHandler;
+export {};

package/lib/selection.d.ts

@@ -1,11 +1,15 @@
-import { Renderable } from "..";
-import type { SelectionState } from "../types";
+import { Renderable, type ViewportBounds } from "..";
 import { fonts } from "./ascii.font";
 export declare class Selection {
     private _anchor;
-    private _focus;
+    private _originalFocus;
+    private _normalizedAnchor;
+    private _normalizedFocus;
     private _selectedRenderables;
-    constructor(anchor: {
+    private _touchedRenderables;
+    private _isActive;
+    private _isSelecting;
+    constructor(anchorRenderable: Renderable, anchor: {
         x: number;
         y: number;
     }, focus: {
@@ -20,51 +24,40 @@ export declare class Selection {
         x: number;
         y: number;
     };
-    get bounds(): {
-        startX: number;
-        startY: number;
-        endX: number;
-        endY: number;
-    };
+    set focus(value: {
+        x: number;
+        y: number;
+    });
+    private _updateNormalizedSelection;
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    get isSelecting(): boolean;
+    set isSelecting(value: boolean);
+    get bounds(): ViewportBounds;
     updateSelectedRenderables(selectedRenderables: Renderable[]): void;
+    get selectedRenderables(): Renderable[];
+    updateTouchedRenderables(touchedRenderables: Renderable[]): void;
+    get touchedRenderables(): Renderable[];
     getSelectedText(): string;
 }
-export declare class TextSelectionHelper {
-    private getX;
-    private getY;
-    private getTextLength;
-    private getLineInfo?;
-    private localSelection;
-    private cachedGlobalSelection;
-    constructor(getX: () => number, getY: () => number, getTextLength: () => number, getLineInfo?: (() => {
-        lineStarts: number[];
-        lineWidths: number[];
-    }) | undefined);
-    hasSelection(): boolean;
-    getSelection(): {
-        start: number;
-        end: number;
-    } | null;
-    reevaluateSelection(width: number, height?: number): boolean;
-    shouldStartSelection(x: number, y: number, width: number, height: number): boolean;
-    onSelectionChanged(selection: SelectionState | null, width: number, height?: number): boolean;
-    private calculateSingleLineSelection;
-    private calculateMultiLineSelection;
+export interface LocalSelectionBounds {
+    anchorX: number;
+    anchorY: number;
+    focusX: number;
+    focusY: number;
+    isActive: boolean;
 }
+export declare function convertGlobalToLocalSelection(globalSelection: Selection | null, localX: number, localY: number): LocalSelectionBounds | null;
 export declare class ASCIIFontSelectionHelper {
-    private getX;
-    private getY;
     private getText;
     private getFont;
     private localSelection;
-    private cachedGlobalSelection;
-    constructor(getX: () => number, getY: () => number, getText: () => string, getFont: () => keyof typeof fonts);
+    constructor(getText: () => string, getFont: () => keyof typeof fonts);
     hasSelection(): boolean;
     getSelection(): {
         start: number;
         end: number;
     } | null;
-    shouldStartSelection(x: number, y: number, width: number, height: number): boolean;
-    onSelectionChanged(selection: SelectionState | null, width: number, height: number): boolean;
-    reevaluateSelection(width: number, height: number): boolean;
+    shouldStartSelection(localX: number, localY: number, width: number, height: number): boolean;
+    onLocalSelectionChanged(localSelection: LocalSelectionBounds | null, width: number, height: number): boolean;
 }

package/lib/styled-text.d.ts

@@ -14,11 +14,8 @@ export interface StyleAttrs {
 }
 export declare class StyledText {
     readonly chunks: TextChunk[];
-    private _plainText;
     constructor(chunks: TextChunk[]);
-    toString(): string;
     private static _createInstance;
-    private static _chunksToPlainText;
     insert(chunk: TextChunk, index?: number): StyledText;
     remove(chunk: TextChunk): StyledText;
     replace(chunk: TextChunk, oldChunk: TextChunk): StyledText;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -38,11 +38,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.13",
-    "@opentui/core-darwin-arm64": "0.1.13",
-    "@opentui/core-linux-x64": "0.1.13",
-    "@opentui/core-linux-arm64": "0.1.13",
-    "@opentui/core-win32-x64": "0.1.13",
-    "@opentui/core-win32-arm64": "0.1.13"
+    "@opentui/core-darwin-x64": "0.1.15",
+    "@opentui/core-darwin-arm64": "0.1.15",
+    "@opentui/core-linux-x64": "0.1.15",
+    "@opentui/core-linux-arm64": "0.1.15",
+    "@opentui/core-win32-x64": "0.1.15",
+    "@opentui/core-win32-arm64": "0.1.15"
   }
 }

package/renderables/ASCIIFont.d.ts

@@ -1,8 +1,9 @@
 import type { RenderableOptions } from "../Renderable";
+import { Selection } from "../lib/selection";
 import { type fonts, type ASCIIFontName } from "../lib/ascii.font";
 import { RGBA } from "../lib/RGBA";
 import { FrameBufferRenderable } from "./FrameBuffer";
-import type { RenderContext, SelectionState } from "../types";
+import type { RenderContext } from "../types";
 export interface ASCIIFontOptions extends RenderableOptions<ASCIIFontRenderable> {
     text?: string;
     font?: ASCIIFontName;
@@ -20,6 +21,7 @@ export declare class ASCIIFontRenderable extends FrameBufferRenderable {
     private _bg;
     private _selectionBg;
     private _selectionFg;
+    private lastLocalSelection;
     private selectionHelper;
     constructor(ctx: RenderContext, options: ASCIIFontOptions);
     get text(): string;
@@ -32,7 +34,7 @@ export declare class ASCIIFontRenderable extends FrameBufferRenderable {
     set bg(value: RGBA | string);
     private updateDimensions;
     shouldStartSelection(x: number, y: number): boolean;
-    onSelectionChanged(selection: SelectionState | null): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
     hasSelection(): boolean;
     protected onResize(width: number, height: number): void;

package/renderables/Box.d.ts

@@ -3,7 +3,7 @@ import type { OptimizedBuffer } from "../buffer";
 import { type BorderCharacters, type BorderSides, type BorderSidesConfig, type BorderStyle } from "../lib";
 import { type ColorInput, RGBA } from "../lib/RGBA";
 import type { RenderContext } from "../types";
-export interface BoxOptions extends RenderableOptions<BoxRenderable> {
+export interface BoxOptions<TRenderable extends Renderable = BoxRenderable> extends RenderableOptions<TRenderable> {
     backgroundColor?: string | RGBA;
     borderStyle?: BorderStyle;
     border?: boolean | BorderSides[];
@@ -56,6 +56,12 @@ export declare class BoxRenderable extends Renderable {
     get titleAlignment(): "left" | "center" | "right";
     set titleAlignment(value: "left" | "center" | "right");
     protected renderSelf(buffer: OptimizedBuffer): void;
+    protected getScissorRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
     private applyYogaBorders;
     private applyYogaGap;
     set gap(gap: number | `${number}%` | undefined);

package/renderables/ScrollBar.d.ts

@@ -0,0 +1,77 @@
+import type { OptimizedBuffer } from "../buffer";
+import { RGBA, type ColorInput } from "../lib";
+import type { ParsedKey } from "../lib/parse.keypress";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+import { SliderRenderable, type SliderOptions } from "./Slider";
+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: ParsedKey | string): 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,82 @@
+import { type ParsedKey } from "../lib";
+import type { Renderable, RenderableOptions } from "../Renderable";
+import type { MouseEvent } from "../renderer";
+import type { RenderContext } from "../types";
+import { BoxRenderable, type BoxOptions } from "./Box";
+import type { VNode } from "./composition/vnode";
+import { ScrollBarRenderable, type ScrollBarOptions, type ScrollUnit } from "./ScrollBar";
+declare class ContentRenderable extends BoxRenderable {
+    private viewport;
+    constructor(ctx: RenderContext, viewport: BoxRenderable, options: RenderableOptions<BoxRenderable>);
+    protected _getChildren(): Renderable[];
+}
+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">;
+}
+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;
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    constructor(ctx: RenderContext, { wrapperOptions, viewportOptions, contentOptions, rootOptions, scrollbarOptions, verticalScrollbarOptions, horizontalScrollbarOptions, ...options }: ScrollBoxOptions);
+    protected onUpdate(deltaTime: number): void;
+    scrollBy(delta: number | {
+        x: number;
+        y: number;
+    }, unit?: ScrollUnit): void;
+    scrollTo(position: number | {
+        x: number;
+        y: number;
+    }): void;
+    add(obj: Renderable | VNode<any, any[]>, index?: number): number;
+    remove(id: string): void;
+    getChildren(): Renderable[];
+    protected onMouseEvent(event: MouseEvent): void;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    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 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"]);
+    protected destroySelf(): void;
+}
+export {};

package/renderables/Slider.d.ts

@@ -0,0 +1,31 @@
+import { type ColorInput, OptimizedBuffer, Renderable, type RenderableOptions, type RenderContext, RGBA } from "../index";
+export interface SliderOptions extends RenderableOptions<SliderRenderable> {
+    orientation: "vertical" | "horizontal";
+    thumbSize?: number;
+    thumbPosition?: number;
+    backgroundColor?: ColorInput;
+    foregroundColor?: ColorInput;
+    onChange?: (position: number) => void;
+}
+export declare class SliderRenderable extends Renderable {
+    readonly orientation: "vertical" | "horizontal";
+    private _thumbSize;
+    private _thumbPosition;
+    private _backgroundColor;
+    private _foregroundColor;
+    private _onChange?;
+    constructor(ctx: RenderContext, options: SliderOptions);
+    get thumbSize(): number;
+    set thumbSize(value: number);
+    get thumbPosition(): number;
+    set thumbPosition(value: number);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    private setupMouseHandling;
+    private updatePositionFromMouse;
+    private getThumbPosition;
+    private getThumbRect;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+}

package/renderables/Text.d.ts

@@ -1,7 +1,8 @@
 import { Renderable, type RenderableOptions } from "../Renderable";
+import { Selection } from "../lib/selection";
 import { StyledText } from "../lib/styled-text";
 import { RGBA } from "../lib/RGBA";
-import { type SelectionState, type RenderContext } from "../types";
+import { type RenderContext } from "../types";
 import type { OptimizedBuffer } from "../buffer";
 export interface TextOptions extends RenderableOptions<TextRenderable> {
     content?: StyledText | string;
@@ -20,27 +21,43 @@ export declare class TextRenderable extends Renderable {
     private _defaultAttributes;
     private _selectionBg;
     private _selectionFg;
-    private selectionHelper;
+    private lastLocalSelection;
     private textBuffer;
-    private _plainText;
     private _lineInfo;
+    protected _defaultOptions: {
+        content: string;
+        fg: RGBA;
+        bg: RGBA;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+    };
     constructor(ctx: RenderContext, options: TextOptions);
     get content(): StyledText;
     set content(value: StyledText | string);
     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);
     protected onResize(width: number, height: number): void;
-    private syncSelectionToTextBuffer;
+    private updateLocalSelection;
     private updateTextInfo;
     private setupMeasureFunc;
     shouldStartSelection(x: number, y: number): boolean;
-    onSelectionChanged(selection: SelectionState | null): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
     hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
     private updateTextBuffer;
     protected renderSelf(buffer: OptimizedBuffer): void;
     destroy(): void;

package/renderables/composition/vnode.d.ts

@@ -28,11 +28,18 @@ export declare function h<P>(type: Construct<P>, props?: P, ...children: VChild[
 export declare function isVNode(node: any): node is VNode;
 export declare function ensureRenderable(ctx: RenderContext, node: Renderable | VNode<any, any[]>): Renderable;
 export declare function wrapWithDelegates<T extends InstanceType<RenderableConstructor>>(instance: T, delegateMap: Record<string, string> | undefined): T;
-export declare function instantiate(ctx: RenderContext, node: VChild): Renderable;
+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 declare function delegate<TCtor extends RenderableConstructor<any>, K extends keyof InstanceType<TCtor>>(mapping: Partial<Record<K, string>>, vnode: ProxiedVNode<TCtor>): ProxiedVNode<TCtor>;
-export declare function delegate<TCtor extends RenderableConstructor<any>, K extends keyof InstanceType<TCtor>>(mapping: Partial<Record<K, string>>, vnode: VNode<any> & {
-    type: TCtor;
+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 declare function delegate(mapping: Record<string, string>, vnode: VNode<any>): VNode;
-export declare function delegate(mapping: Record<string, string>, renderable: Renderable): Renderable;
+export {};

package/renderables/index.d.ts

@@ -5,6 +5,8 @@ export * from "./ASCIIFont";
 export * from "./Input";
 export * from "./Select";
 export * from "./TabSelect";
+export * from "./ScrollBox";
+export * from "./ScrollBar";
 export * from "./composition/constructs";
 export * from "./composition/vnode";
 export * from "./composition/VRenderable";

package/renderer.d.ts

@@ -43,12 +43,14 @@ export declare class MouseEvent {
     };
     readonly scroll?: ScrollInfo;
     readonly target: Renderable | null;
-    private _defaultPrevented;
-    get defaultPrevented(): boolean;
+    readonly isSelecting?: boolean;
+    private _propagationStopped;
+    get propagationStopped(): boolean;
     constructor(target: Renderable | null, attributes: RawMouseEvent & {
         source?: Renderable;
+        isSelecting?: boolean;
     });
-    preventDefault(): void;
+    stopPropagation(): void;
 }
 export declare enum MouseButton {
     LEFT = 0,
@@ -116,7 +118,6 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private lastOverRenderableNum;
     private lastOverRenderable?;
     private currentSelection;
-    private selectionState;
     private selectionContainers;
     private _splitHeight;
     private renderOffset;
@@ -133,7 +134,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     addToHitGrid(x: number, y: number, width: number, height: number, id: number): void;
     get widthMethod(): WidthMethod;
     private writeOut;
-    needsUpdate(): void;
+    requestRender(): void;
     get useConsole(): boolean;
     set useConsole(value: boolean);
     get isRunning(): boolean;
@@ -191,6 +192,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     requestLive(): void;
     dropLive(): void;
     start(): void;
+    auto(): void;
     private internalStart;
     pause(): void;
     private internalPause;
@@ -213,12 +215,14 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     resetStats(): void;
     setGatherStats(enabled: boolean): void;
     getSelection(): Selection | null;
+    get hasSelection(): boolean;
     getSelectionContainer(): Renderable | null;
-    hasSelection(): boolean;
     clearSelection(): void;
     private startSelection;
     private updateSelection;
+    requestSelectionUpdate(): void;
     private isWithinContainer;
     private finishSelection;
     private notifySelectablesOfSelectionChange;
+    private walkSelectableRenderables;
 }

package/text-buffer.d.ts

@@ -14,18 +14,11 @@ export interface TextChunk {
 export declare class TextBuffer {
     private lib;
     private bufferPtr;
-    private buffer;
     private _length;
     private _capacity;
     private _lineInfo?;
-    constructor(lib: RenderLib, ptr: Pointer, buffer: {
-        char: Uint32Array;
-        fg: Float32Array;
-        bg: Float32Array;
-        attributes: Uint16Array;
-    }, capacity: number);
+    constructor(lib: RenderLib, ptr: Pointer, capacity: number);
     static create(capacity: number | undefined, widthMethod: WidthMethod): TextBuffer;
-    private syncBuffersAfterResize;
     setStyledText(text: StyledText): void;
     setDefaultFg(fg: RGBA | null): void;
     setDefaultBg(bg: RGBA | null): void;
@@ -34,13 +27,19 @@ export declare class TextBuffer {
     get length(): number;
     get capacity(): number;
     get ptr(): Pointer;
+    getSelectedText(): string;
     get lineInfo(): {
         lineStarts: number[];
         lineWidths: number[];
     };
-    toString(): string;
-    concat(other: TextBuffer): TextBuffer;
     setSelection(start: number, end: number, bgColor?: RGBA, fgColor?: RGBA): void;
     resetSelection(): void;
+    setLocalSelection(anchorX: number, anchorY: number, focusX: number, focusY: number, bgColor?: RGBA, fgColor?: RGBA): boolean;
+    resetLocalSelection(): void;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    hasSelection(): boolean;
     destroy(): void;
 }

package/types.d.ts

@@ -1,4 +1,6 @@
 import type { RGBA } from "./lib/RGBA";
+import type { EventEmitter } from "events";
+import type { Selection } from "./lib/selection";
 export declare const TextAttributes: {
     NONE: number;
     BOLD: number;
@@ -18,11 +20,22 @@ export declare enum DebugOverlayCorner {
     bottomRight = 3
 }
 export type WidthMethod = "wcwidth" | "unicode";
-export interface RenderContext {
+export interface RendererEvents {
+    resize: (width: number, height: number) => void;
+    key: (data: Buffer) => void;
+    "memory:snapshot": (snapshot: {
+        heapUsed: number;
+        heapTotal: number;
+        arrayBuffers: number;
+    }) => void;
+    selection: (selection: Selection) => void;
+    "debugOverlay:toggle": (enabled: boolean) => void;
+}
+export interface RenderContext extends EventEmitter {
     addToHitGrid: (x: number, y: number, width: number, height: number, id: number) => void;
     width: number;
     height: number;
-    needsUpdate: () => void;
+    requestRender: () => void;
     setCursorPosition: (x: number, y: number, visible: boolean) => void;
     setCursorStyle: (style: CursorStyle, blinking: boolean) => void;
     setCursorColor: (color: RGBA) => void;
@@ -30,16 +43,14 @@ export interface RenderContext {
     capabilities: any | null;
     requestLive: () => void;
     dropLive: () => void;
+    hasSelection: boolean;
+    getSelection: () => Selection | null;
+    requestSelectionUpdate: () => void;
 }
-export interface SelectionState {
-    anchor: {
-        x: number;
-        y: number;
-    };
-    focus: {
-        x: number;
-        y: number;
-    };
-    isActive: boolean;
-    isSelecting: boolean;
+export type Timeout = ReturnType<typeof setTimeout> | undefined;
+export interface ViewportBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
 }