@opentuah/core 0.1.94 → 0.1.96

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,8 +4,8 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.94",
-  "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
+  "version": "0.1.96",
+  "description": "OpenTUI is a TypeScript library on a native Zig core for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -54,16 +54,16 @@
   },
   "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",
-    "@opentuah/core-darwin-x64": "0.1.94",
-    "@opentuah/core-darwin-arm64": "0.1.94",
-    "@opentuah/core-linux-x64": "0.1.94",
-    "@opentuah/core-linux-arm64": "0.1.94",
-    "@opentuah/core-win32-x64": "0.1.94",
-    "@opentuah/core-win32-arm64": "0.1.94",
-    "@opentuah/core-linux-x64-musl": "0.1.94",
-    "@opentuah/core-linux-arm64-musl": "0.1.94"
+    "@opentuah/core-darwin-x64": "0.1.96",
+    "@opentuah/core-darwin-arm64": "0.1.96",
+    "@opentuah/core-linux-x64": "0.1.96",
+    "@opentuah/core-linux-arm64": "0.1.96",
+    "@opentuah/core-linux-x64-musl": "0.1.96",
+    "@opentuah/core-linux-arm64-musl": "0.1.96",
+    "@opentuah/core-win32-x64": "0.1.96",
+    "@opentuah/core-win32-arm64": "0.1.96"
   }
 }

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";
@@ -178,5 +179,11 @@ export declare class DiffRenderable extends Renderable {
     set addedWordBg(value: string | RGBA);
     get removedWordBg(): RGBA;
     set removedWordBg(value: string | RGBA);
+    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;
 }
 export {};

package/renderables/LineNumberRenderable.d.ts

@@ -93,4 +93,6 @@ export declare class LineNumberRenderable extends Renderable {
      * Clears all inline highlights.
      */
     clearInlineHighlights(): void;
+    highlightLines(startLine: number, endLine: number, color: string | RGBA | LineColorConfig): void;
+    clearHighlightLines(startLine: number, endLine: number): void;
 }

package/renderables/TextTable.d.ts

@@ -0,0 +1,126 @@
+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" | "fill";
+export interface TextTableOptions extends RenderableOptions<TextTableRenderable> {
+    content?: TextTableContent;
+    wrapMode?: "none" | "char" | "word";
+    columnWidthMode?: TextTableColumnWidthMode;
+    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 _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 _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 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 computeColumnWidths;
+    private expandColumnWidths;
+    private fitColumnWidths;
+    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 findRowForLocalY;
+    private getSelectionRowRange;
+    private getDirtySelectionRowRange;
+    private resetRowSelection;
+    private resetCellSelections;
+    private createEmptyLayout;
+    private resolveLayoutWidthConstraint;
+    private getHorizontalCellPadding;
+    private getVerticalCellPadding;
+    private resolveCellPadding;
+    private invalidateLayoutAndRaster;
+    private invalidateRasterOnly;
+}

package/renderables/Textarea.d.ts

@@ -95,7 +95,7 @@ export declare class TextareaRenderable extends EditBufferRenderable {
     focus(): void;
     blur(): void;
     get placeholder(): StyledText | string | null;
-    set placeholder(value: StyledText | string | null);
+    set placeholder(value: StyledText | string | null | undefined);
     get placeholderColor(): RGBA;
     set placeholderColor(value: ColorInput);
     get backgroundColor(): RGBA;

package/renderables/index.d.ts

@@ -13,6 +13,7 @@ export * from "./ScrollBar";
 export * from "./ScrollBox";
 export * from "./Select";
 export * from "./Slider";
+export * from "./TextTable";
 export * from "./TabSelect";
 export * from "./Terminal";
 export * from "./Text";

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";
@@ -17,6 +17,7 @@ export interface CliRendererConfig {
     remote?: boolean;
     exitOnCtrlC?: boolean;
     exitSignals?: NodeJS.Signals[];
+    forwardEnvKeys?: string[];
     debounceDelay?: number;
     targetFps?: number;
     maxFps?: number;
@@ -194,6 +195,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 +278,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 +308,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-bm6w895a.js";
+} from "./index-yc0yx782.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,6 +40,22 @@ 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 declare const GridDrawOptionsStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["drawInner", "bool_u8", {
+    readonly default: true;
+}], readonly ["drawOuter", "bool_u8", {
+    readonly default: true;
+}]], {}>;
 export type GrowthPolicy = "grow" | "block";
 export type NativeSpanFeedOptions = {
     chunkSize?: number;

package/zig.d.ts

@@ -1,5 +1,5 @@
 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";
@@ -43,6 +43,7 @@ export interface RenderLib {
         testing?: boolean;
         remote?: boolean;
     }) => Pointer | null;
+    setTerminalEnvVar: (renderer: Pointer, key: string, value: string) => boolean;
     destroyRenderer: (renderer: Pointer) => void;
     setUseThread: (renderer: Pointer, useThread: boolean) => void;
     setBackgroundColor: (renderer: Pointer, color: RGBA) => void;
@@ -75,13 +76,17 @@ export interface RenderLib {
     bufferDrawPackedBuffer: (buffer: Pointer, dataPtr: Pointer, dataLen: number, posX: number, posY: number, terminalWidthCells: number, terminalHeightCells: number) => void;
     bufferDrawGrayscaleBuffer: (buffer: Pointer, posX: number, posY: number, intensitiesPtr: Pointer, srcWidth: number, srcHeight: number, fg: RGBA | null, bg: RGBA | null) => void;
     bufferDrawGrayscaleBufferSupersampled: (buffer: Pointer, posX: number, posY: number, intensitiesPtr: Pointer, srcWidth: number, srcHeight: number, fg: RGBA | null, bg: RGBA | null) => void;
+    bufferDrawGrid: (buffer: Pointer, borderChars: Uint32Array, borderFg: RGBA, borderBg: RGBA, columnOffsets: Int32Array, columnCount: number, rowOffsets: Int32Array, rowCount: number, options: {
+        drawInner: boolean;
+        drawOuter: boolean;
+    }) => void;
     bufferDrawBox: (buffer: Pointer, x: number, y: number, width: number, height: number, borderChars: Uint32Array, packedOptions: number, borderColor: RGBA, backgroundColor: RGBA, title: string | null) => void;
     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;