@opentui/core 0.1.78 → 0.1.80

package/lib/parse.mouse.d.ts

@@ -19,5 +19,12 @@ export declare class MouseParser {
     private mouseButtonsPressed;
     private static readonly SCROLL_DIRECTIONS;
     reset(): void;
+    private decodeInput;
     parseMouseEvent(data: Buffer): RawMouseEvent | null;
+    parseAllMouseEvents(data: Buffer): RawMouseEvent[];
+    private parseMouseSequenceAt;
+    private parseSgrSequence;
+    private parseBasicSequence;
+    private decodeSgrEvent;
+    private decodeBasicEvent;
 }

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -54,14 +54,14 @@
   },
   "optionalDependencies": {
     "@dimforge/rapier2d-simd-compat": "^0.17.3",
-    "bun-webgpu": "0.1.4",
+    "bun-webgpu": "0.1.5",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.78",
-    "@opentui/core-darwin-arm64": "0.1.78",
-    "@opentui/core-linux-x64": "0.1.78",
-    "@opentui/core-linux-arm64": "0.1.78",
-    "@opentui/core-win32-x64": "0.1.78",
-    "@opentui/core-win32-arm64": "0.1.78"
+    "@opentui/core-darwin-x64": "0.1.80",
+    "@opentui/core-darwin-arm64": "0.1.80",
+    "@opentui/core-linux-x64": "0.1.80",
+    "@opentui/core-linux-arm64": "0.1.80",
+    "@opentui/core-win32-x64": "0.1.80",
+    "@opentui/core-win32-arm64": "0.1.80"
   }
 }

package/renderables/Diff.d.ts

@@ -1,5 +1,6 @@
 import { Renderable, type RenderableOptions } from "../Renderable";
 import type { RenderContext } from "../types";
+import { type LineColorConfig } from "./LineNumberRenderable";
 import { RGBA } from "../lib/RGBA";
 import { SyntaxStyle } from "../syntax-style";
 import type { TreeSitterClient } from "../lib/tree-sitter";
@@ -125,4 +126,10 @@ export declare class DiffRenderable extends Renderable {
     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;
 }

package/renderables/Input.d.ts

@@ -51,6 +51,13 @@ export declare class InputRenderable extends TextareaRenderable {
     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;

package/renderables/LineNumberRenderable.d.ts

@@ -69,4 +69,6 @@ export declare class LineNumberRenderable extends Renderable {
     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;
 }

package/renderer.d.ts

@@ -1,5 +1,5 @@
 import { Renderable, RootRenderable } from "./Renderable";
-import { type CursorStyle, DebugOverlayCorner, type RenderContext, type ThemeMode, type WidthMethod } from "./types";
+import { DebugOverlayCorner, type CursorStyleOptions, type MousePointerStyle, type RenderContext, type ThemeMode, type WidthMethod } from "./types";
 import { RGBA, type ColorInput } from "./lib/RGBA";
 import type { Pointer } from "bun:ffi";
 import { OptimizedBuffer } from "./buffer";
@@ -194,6 +194,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private _latestPointer;
     private _hasPointer;
     private _lastPointerModifiers;
+    private _currentMousePointerStyle;
     private _currentFocusedRenderable;
     private lifecyclePasses;
     private _openConsoleOnError;
@@ -276,12 +277,14 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private setupInput;
     private dispatchMouseEvent;
     private handleMouseData;
+    private processSingleMouseEvent;
     /**
      * Recheck hover state after hit grid changes.
      * Called after render when native code detects the hit grid changed.
      * Fires out/over events if the element under the cursor changed.
      */
     private recheckHoverState;
+    setMousePointer(style: MousePointerStyle): void;
     hitTest(x: number, y: number): number;
     private takeMemorySnapshot;
     private startMemorySnapshotTimer;
@@ -304,10 +307,10 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     dumpBuffers(timestamp?: number): void;
     dumpStdoutBuffer(timestamp?: number): void;
     static setCursorPosition(renderer: CliRenderer, x: number, y: number, visible?: boolean): void;
-    static setCursorStyle(renderer: CliRenderer, style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    static setCursorStyle(renderer: CliRenderer, options: CursorStyleOptions): void;
     static setCursorColor(renderer: CliRenderer, color: RGBA): void;
     setCursorPosition(x: number, y: number, visible?: boolean): void;
-    setCursorStyle(style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    setCursorStyle(options: CursorStyleOptions): void;
     setCursorColor(color: RGBA): void;
     getCursorState(): import("./zig").CursorState;
     addPostProcessFn(processFn: (buffer: OptimizedBuffer, deltaTime: number) => void): void;

package/testing.js

@@ -4,7 +4,7 @@ import {
   CliRenderer,
   TreeSitterClient,
   resolveRenderLib
-} from "./index-rje6z21e.js";
+} from "./index-vnvba6q9.js";
 
 // src/testing/test-renderer.ts
 import { Readable } from "stream";

package/types.d.ts

@@ -23,9 +23,12 @@ export declare const ATTRIBUTE_BASE_MASK = 255;
 export declare function getBaseAttributes(attr: number): number;
 export type ThemeMode = "dark" | "light";
 export type CursorStyle = "block" | "line" | "underline";
+export type MousePointerStyle = "default" | "pointer" | "text" | "crosshair" | "move" | "not-allowed";
 export interface CursorStyleOptions {
-    style: CursorStyle;
-    blinking: boolean;
+    style?: CursorStyle;
+    blinking?: boolean;
+    color?: RGBA;
+    cursor?: MousePointerStyle;
 }
 export declare enum DebugOverlayCorner {
     topLeft = 0,
@@ -55,8 +58,9 @@ export interface RenderContext extends EventEmitter {
     height: number;
     requestRender: () => void;
     setCursorPosition: (x: number, y: number, visible: boolean) => void;
-    setCursorStyle: (style: CursorStyle, blinking: boolean) => void;
+    setCursorStyle: (options: CursorStyleOptions) => void;
     setCursorColor: (color: RGBA) => void;
+    setMousePointer: (shape: MousePointerStyle) => void;
     widthMethod: WidthMethod;
     capabilities: any | null;
     requestLive: () => void;

package/zig-structs.d.ts

@@ -40,3 +40,82 @@ export declare const LineInfoStruct: import("bun-ffi-structs").DefineStructRetur
 }], readonly ["maxWidth", "u32"]], {}>;
 export declare const MeasureResultStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["lineCount", "u32"], readonly ["maxWidth", "u32"]], {}>;
 export declare const CursorStateStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["x", "u32"], readonly ["y", "u32"], readonly ["visible", "bool_u8"], readonly ["style", "u8"], readonly ["blinking", "bool_u8"], readonly ["r", "f32"], readonly ["g", "f32"], readonly ["b", "f32"], readonly ["a", "f32"]], {}>;
+export declare const CursorStyleOptionsStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["style", "u8", {
+    readonly default: 255;
+}], readonly ["blinking", "u8", {
+    readonly default: 255;
+}], readonly ["color", "pointer", {
+    readonly optional: true;
+    readonly packTransform: (rgba?: RGBA) => Pointer | null;
+    readonly unpackTransform: (ptr?: Pointer) => RGBA | undefined;
+}], readonly ["cursor", "u8", {
+    readonly default: 255;
+}]], {}>;
+export type GrowthPolicy = "grow" | "block";
+export type NativeSpanFeedOptions = {
+    chunkSize?: number;
+    initialChunks?: number;
+    maxBytes?: bigint;
+    growthPolicy?: GrowthPolicy;
+    autoCommitOnFull?: boolean;
+    spanQueueCapacity?: number;
+};
+export type NativeSpanFeedStats = {
+    bytesWritten: bigint;
+    spansCommitted: bigint;
+    chunks: number;
+    pendingSpans: number;
+};
+export type SpanInfo = {
+    chunkPtr: Pointer;
+    offset: number;
+    len: number;
+    chunkIndex: number;
+};
+export type ReserveInfo = {
+    ptr: Pointer;
+    len: number;
+};
+export declare const NativeSpanFeedOptionsStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["chunkSize", "u32", {
+    readonly default: number;
+}], readonly ["initialChunks", "u32", {
+    readonly default: 2;
+}], readonly ["maxBytes", "u64", {
+    readonly default: 0n;
+}], readonly ["growthPolicy", import("bun-ffi-structs").EnumDef<{
+    grow: number;
+    block: number;
+}>, {
+    readonly default: "grow";
+}], readonly ["autoCommitOnFull", "bool_u8", {
+    readonly default: true;
+}], readonly ["spanQueueCapacity", "u32", {
+    readonly default: 0;
+}]], {}>;
+export declare const NativeSpanFeedStatsStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["bytesWritten", "u64"], readonly ["spansCommitted", "u64"], readonly ["chunks", "u32"], readonly ["pendingSpans", "u32"]], {}>;
+export declare const SpanInfoStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["chunkPtr", "pointer"], readonly ["offset", "u32"], readonly ["len", "u32"], readonly ["chunkIndex", "u32"], readonly ["reserved", "u32", {
+    readonly default: 0;
+}]], {
+    readonly reduceValue: (value: {
+        chunkPtr: Pointer;
+        offset: number;
+        len: number;
+        chunkIndex: number;
+    }) => {
+        chunkPtr: Pointer;
+        offset: number;
+        len: number;
+        chunkIndex: number;
+    };
+}>;
+export declare const ReserveInfoStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["ptr", "pointer"], readonly ["len", "u32"], readonly ["reserved", "u32", {
+    readonly default: 0;
+}]], {
+    readonly reduceValue: (value: {
+        ptr: Pointer;
+        len: number;
+    }) => {
+        ptr: Pointer;
+        len: number;
+    };
+}>;

package/zig.d.ts

@@ -1,9 +1,10 @@
 import { type Pointer } from "bun:ffi";
-import { type CursorStyle, type DebugOverlayCorner, type WidthMethod, type Highlight, type LineInfo } from "./types";
+import { type CursorStyle, type CursorStyleOptions, type DebugOverlayCorner, type WidthMethod, type Highlight, type LineInfo } from "./types";
 export type { LineInfo };
 import { RGBA } from "./lib/RGBA";
 import { OptimizedBuffer } from "./buffer";
 import { TextBuffer } from "./text-buffer";
+import type { NativeSpanFeedOptions, NativeSpanFeedStats, ReserveInfo } from "./zig-structs";
 export declare enum LogLevel {
     Error = 0,
     Warn = 1,
@@ -36,6 +37,7 @@ export interface CursorState {
     blinking: boolean;
     color: RGBA;
 }
+export type NativeSpanFeedEventHandler = (eventId: number, arg0: Pointer, arg1: number | bigint) => void;
 export interface RenderLib {
     createRenderer: (width: number, height: number, options?: {
         testing?: boolean;
@@ -77,9 +79,9 @@ export interface RenderLib {
     bufferResize: (buffer: Pointer, width: number, height: number) => void;
     resizeRenderer: (renderer: Pointer, width: number, height: number) => void;
     setCursorPosition: (renderer: Pointer, x: number, y: number, visible: boolean) => void;
-    setCursorStyle: (renderer: Pointer, style: CursorStyle, blinking: boolean) => void;
     setCursorColor: (renderer: Pointer, color: RGBA) => void;
     getCursorState: (renderer: Pointer) => CursorState;
+    setCursorStyleOptions: (renderer: Pointer, options: CursorStyleOptions) => void;
     setDebugOverlay: (renderer: Pointer, enabled: boolean, corner: DebugOverlayCorner) => void;
     clearTerminal: (renderer: Pointer) => void;
     setTerminalTitle: (renderer: Pointer, title: string) => void;
@@ -317,6 +319,22 @@ export interface RenderLib {
         }>;
     }) => void;
     bufferDrawChar: (buffer: Pointer, char: number, x: number, y: number, fg: RGBA, bg: RGBA, attributes?: number) => void;
+    registerNativeSpanFeedStream: (stream: Pointer, handler: NativeSpanFeedEventHandler) => void;
+    unregisterNativeSpanFeedStream: (stream: Pointer) => void;
+    createNativeSpanFeed: (options?: NativeSpanFeedOptions | null) => Pointer;
+    attachNativeSpanFeed: (stream: Pointer) => number;
+    destroyNativeSpanFeed: (stream: Pointer) => void;
+    streamWrite: (stream: Pointer, data: Uint8Array | string) => number;
+    streamCommit: (stream: Pointer) => number;
+    streamDrainSpans: (stream: Pointer, outBuffer: Uint8Array, maxSpans: number) => number;
+    streamClose: (stream: Pointer) => number;
+    streamSetOptions: (stream: Pointer, options: NativeSpanFeedOptions) => number;
+    streamGetStats: (stream: Pointer) => NativeSpanFeedStats | null;
+    streamReserve: (stream: Pointer, minLen: number) => {
+        status: number;
+        info: ReserveInfo | null;
+    };
+    streamCommitReserved: (stream: Pointer, length: number) => number;
     onNativeEvent: (name: string, handler: (data: ArrayBuffer) => void) => void;
     onceNativeEvent: (name: string, handler: (data: ArrayBuffer) => void) => void;
     offNativeEvent: (name: string, handler: (data: ArrayBuffer) => void) => void;