@opentui/core 0.1.81 → 0.1.82

package/package.json

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

package/renderables/Markdown.d.ts

@@ -2,6 +2,7 @@ import { Renderable, type RenderableOptions } from "../Renderable";
 import { type RenderContext } from "../types";
 import { SyntaxStyle } from "../syntax-style";
 import { type MarkedToken, type Token } from "marked";
+import { type TextTableContent } from "./TextTable";
 import type { TreeSitterClient } from "../lib/tree-sitter";
 import { type ParseState } from "./markdown-parser";
 import type { OptimizedBuffer } from "../buffer";
@@ -28,10 +29,15 @@ export interface RenderNodeContext {
     /** Creates default renderable for this token */
     defaultRender: () => Renderable | null;
 }
+interface TableContentCache {
+    content: TextTableContent;
+    cellKeys: Uint32Array[];
+}
 export interface BlockState {
     token: MarkedToken;
     tokenRaw: string;
     renderable: Renderable;
+    tableContentCache?: TableContentCache;
 }
 export type { ParseState };
 export declare class MarkdownRenderable extends Renderable {
@@ -72,12 +78,15 @@ export declare class MarkdownRenderable extends Renderable {
     private renderTokenToChunks;
     private createTextRenderable;
     private createCodeRenderable;
-    /**
-     * Update an existing table renderable in-place for style/conceal changes.
-     * Much faster than rebuilding the entire table structure.
-     */
-    private updateTableRenderable;
-    private createTableRenderable;
+    private getTableRowsToRender;
+    private hashString;
+    private hashTableToken;
+    private getTableCellKey;
+    private createTableDataCellChunks;
+    private createTableHeaderCellChunks;
+    private buildTableContentCache;
+    private createTextTableRenderable;
+    private createTableBlock;
     private createDefaultRenderable;
     private updateBlockRenderable;
     private updateBlocks;
@@ -88,5 +97,6 @@ export declare class MarkdownRenderable extends Renderable {
      */
     private rerenderBlocks;
     clearCache(): void;
+    refreshStyles(): void;
     protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
 }

package/renderables/TextBufferRenderable.d.ts

@@ -6,6 +6,7 @@ import { RGBA } from "../lib/RGBA";
 import { type RenderContext, type LineInfoProvider } from "../types";
 import type { OptimizedBuffer } from "../buffer";
 import type { LineInfo } from "../zig";
+import { SyntaxStyle } from "../syntax-style";
 export interface TextBufferOptions extends RenderableOptions<TextBufferRenderable> {
     fg?: string | RGBA;
     bg?: string | RGBA;
@@ -34,6 +35,7 @@ export declare abstract class TextBufferRenderable extends Renderable implements
     protected _truncate: boolean;
     protected textBuffer: TextBuffer;
     protected textBufferView: TextBufferView;
+    protected _textBufferSyntaxStyle: SyntaxStyle;
     protected _defaultOptions: {
         fg: RGBA;
         bg: RGBA;

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/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 "./Text";
 export * from "./TextBufferRenderable";

package/renderer.d.ts

@@ -15,8 +15,10 @@ export interface CliRendererConfig {
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
     remote?: boolean;
+    testing?: boolean;
     exitOnCtrlC?: boolean;
     exitSignals?: NodeJS.Signals[];
+    forwardEnvKeys?: string[];
     debounceDelay?: number;
     targetFps?: number;
     maxFps?: number;

package/testing.js

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

package/zig-structs.d.ts

@@ -1,5 +1,14 @@
 import { type Pointer } from "bun:ffi";
 import { RGBA } from "./lib/RGBA";
+type StyledChunkInput = {
+    text: string;
+    fg?: RGBA | null;
+    bg?: RGBA | null;
+    attributes?: number | null;
+    link?: {
+        url: string;
+    } | string | null;
+};
 export declare const StyledChunkStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["text", "char*"], readonly ["text_len", "u64", {
     readonly lengthOf: "text";
 }], readonly ["fg", "pointer", {
@@ -11,8 +20,14 @@ export declare const StyledChunkStruct: import("bun-ffi-structs").DefineStructRe
     readonly packTransform: (rgba?: RGBA) => Pointer | null;
     readonly unpackTransform: (ptr?: Pointer) => RGBA | undefined;
 }], readonly ["attributes", "u32", {
-    readonly optional: true;
-}]], {}>;
+    readonly default: 0;
+}], readonly ["link", "char*", {
+    readonly default: "";
+}], readonly ["link_len", "u64", {
+    readonly lengthOf: "link";
+}]], {
+    readonly mapValue: (chunk: StyledChunkInput) => StyledChunkInput;
+}>;
 export declare const HighlightStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["start", "u32"], readonly ["end", "u32"], readonly ["styleId", "u32"], readonly ["priority", "u8", {
     readonly default: 0;
 }], readonly ["hlRef", "u16", {
@@ -51,6 +66,24 @@ export declare const CursorStyleOptionsStruct: import("bun-ffi-structs").DefineS
 }], 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 BuildOptions = {
+    gpaSafeStats: boolean;
+    gpaMemoryLimitTracking: boolean;
+};
+export declare const BuildOptionsStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["gpaSafeStats", "bool_u8"], readonly ["gpaMemoryLimitTracking", "bool_u8"]], {}>;
+export type AllocatorStats = {
+    totalRequestedBytes: number;
+    activeAllocations: number;
+    smallAllocations: number;
+    largeAllocations: number;
+    requestedBytesValid: boolean;
+};
+export declare const AllocatorStatsStruct: import("bun-ffi-structs").DefineStructReturnType<[readonly ["totalRequestedBytes", "u64"], readonly ["activeAllocations", "u64"], readonly ["smallAllocations", "u64"], readonly ["largeAllocations", "u64"], readonly ["requestedBytesValid", "bool_u8"]], {}>;
 export type GrowthPolicy = "grow" | "block";
 export type NativeSpanFeedOptions = {
     chunkSize?: number;
@@ -119,3 +152,4 @@ export declare const ReserveInfoStruct: import("bun-ffi-structs").DefineStructRe
         len: number;
     };
 }>;
+export {};

package/zig.d.ts

@@ -1,10 +1,10 @@
 import { type Pointer } from "bun:ffi";
 import { type CursorStyle, type CursorStyleOptions, type DebugOverlayCorner, type WidthMethod, type Highlight, type LineInfo } from "./types";
-export type { LineInfo };
+export type { LineInfo, AllocatorStats, BuildOptions };
 import { RGBA } from "./lib/RGBA";
 import { OptimizedBuffer } from "./buffer";
 import { TextBuffer } from "./text-buffer";
-import type { NativeSpanFeedOptions, NativeSpanFeedStats, ReserveInfo } from "./zig-structs";
+import type { NativeSpanFeedOptions, NativeSpanFeedStats, ReserveInfo, BuildOptions, AllocatorStats } from "./zig-structs";
 export declare enum LogLevel {
     Error = 0,
     Warn = 1,
@@ -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,6 +76,10 @@ 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;
@@ -297,6 +302,8 @@ export interface RenderLib {
     textBufferGetLineHighlights: (buffer: Pointer, lineIdx: number) => Array<Highlight>;
     textBufferGetHighlightCount: (buffer: Pointer) => number;
     getArenaAllocatedBytes: () => number;
+    getBuildOptions: () => BuildOptions;
+    getAllocatorStats: () => AllocatorStats;
     createSyntaxStyle: () => Pointer;
     destroySyntaxStyle: (style: Pointer) => void;
     syntaxStyleRegister: (style: Pointer, name: string, fg: RGBA | null, bg: RGBA | null, attributes: number) => number;