@jitl/opentui-core 0.1.97 → 0.2.15

package/platform/node22-ffi.d.ts

@@ -0,0 +1,33 @@
+import { type FfiBackend, type Pointer } from "./ffi.js";
+type KoffiExternal = object & {
+    __koffi_external__: true;
+};
+type KoffiFunction = ((...args: unknown[]) => unknown) & {
+    async?: unknown;
+};
+type KoffiRegisteredCallback = KoffiExternal;
+type KoffiTypeSpec = unknown;
+type UnsafePointerOf = (value: ArrayBuffer) => Pointer;
+type UnsafeArrayBufferAt = (pointer: Pointer, offset: number | undefined, length: number) => ArrayBuffer;
+interface KoffiModule {
+    address(pointer: KoffiExternal): bigint | number;
+    extension: string;
+    load(path: string): KoffiLib;
+    opaque(name?: string): KoffiTypeSpec;
+    pointer(nameOrType: string | KoffiTypeSpec, type?: KoffiTypeSpec): KoffiTypeSpec;
+    proto(returns: KoffiTypeSpec, args: KoffiTypeSpec[]): KoffiTypeSpec;
+    register(callback: (...args: any[]) => any, type: KoffiTypeSpec): KoffiRegisteredCallback;
+    unregister(callback: KoffiRegisteredCallback): void;
+    types: Record<string, KoffiTypeSpec>;
+}
+interface KoffiLib {
+    func(name: string, returns: KoffiTypeSpec, args: KoffiTypeSpec[]): KoffiFunction;
+    unload(): void;
+}
+interface Node22Modules {
+    koffi: KoffiModule;
+    unsafePointerOf: UnsafePointerOf;
+    unsafeArrayBufferAt: UnsafeArrayBufferAt;
+}
+export declare function createNode22Backend(modules?: Node22Modules): FfiBackend;
+export {};

package/{compat → platform}/runtime.d.ts

@@ -2,7 +2,13 @@ export interface WriteFileOptions {
     createPath?: boolean;
     mode?: number;
 }
+interface FileImportModule {
+    default: string;
+}
+type FilePathFallback = string | URL | (() => string | URL);
 export declare const sleep: (msOrDate: number | Date) => Promise<void>;
 export declare const stringWidth: (text: string) => number;
 export declare const stripANSI: (text: string) => string;
 export declare const writeFile: (destination: string | URL, data: string | ArrayBufferView, options?: WriteFileOptions) => Promise<number>;
+export declare function resolveBundledFilePath(loadBundledFile: () => Promise<FileImportModule>, fallbackPath: FilePathFallback, metaUrl: string): Promise<string>;
+export {};

package/platform/worker.d.ts

@@ -0,0 +1,4 @@
+export declare const Worker: {
+    new (scriptURL: string | URL, options?: WorkerOptions): Worker;
+    prototype: Worker;
+};

package/renderables/Code.d.ts

@@ -23,6 +23,7 @@ export interface CodeOptions extends TextBufferOptions {
     conceal?: boolean;
     drawUnstyledText?: boolean;
     streaming?: boolean;
+    baseHighlight?: string;
     onHighlight?: OnHighlightCallback;
     onChunks?: OnChunksCallback;
 }
@@ -40,6 +41,7 @@ export declare class CodeRenderable extends TextBufferRenderable {
     private _streaming;
     private _hadInitialContent;
     private _lastHighlights;
+    private _baseHighlight?;
     private _onHighlight?;
     private _onChunks?;
     private _highlightingPromise;
@@ -65,6 +67,8 @@ export declare class CodeRenderable extends TextBufferRenderable {
     get treeSitterClient(): TreeSitterClient;
     set treeSitterClient(value: TreeSitterClient);
     get onHighlight(): OnHighlightCallback | undefined;
+    get baseHighlight(): string | undefined;
+    set baseHighlight(value: string | undefined);
     set onHighlight(value: OnHighlightCallback | undefined);
     get onChunks(): OnChunksCallback | undefined;
     set onChunks(value: OnChunksCallback | undefined);

package/renderables/Markdown.d.ts

@@ -8,7 +8,16 @@ import { type TextTableColumnFitter, type TextTableColumnWidthMode, type TextTab
 import type { TreeSitterClient } from "../lib/tree-sitter/index.js";
 import { type ParseState } from "./markdown-parser.js";
 import type { OptimizedBuffer } from "../buffer.js";
+export type MarkdownTableStyle = "grid" | "columns";
 export interface MarkdownTableOptions {
+    /**
+     * Visual style preset for markdown tables.
+     * - "grid": boxed table with visible borders.
+     * - "columns": borderless columns optimized for separated block output.
+     *
+     * Defaults to "columns" in `internalBlockMode: "top-level"`, otherwise "grid".
+     */
+    style?: MarkdownTableStyle;
     /**
      * Strategy for sizing table columns.
      * - "content": columns fit to intrinsic content width.
@@ -27,6 +36,14 @@ export interface MarkdownTableOptions {
      * Padding applied on all sides of each table cell.
      */
     cellPadding?: number;
+    /**
+     * Horizontal padding applied on the left and right of each table cell.
+     */
+    cellPaddingX?: number;
+    /**
+     * Vertical padding applied above and below each table cell.
+     */
+    cellPaddingY?: number;
     /**
      * Enables/disables table border rendering.
      */
@@ -81,6 +98,12 @@ export interface MarkdownOptions extends RenderableOptions<MarkdownRenderable> {
      * or undefined/null to use default rendering.
      */
     renderNode?: (token: Token, context: RenderNodeContext) => Renderable | undefined | null;
+    /**
+     * Internal only.
+     * - "coalesced": combine ordinary markdown into larger render blocks.
+     * - "top-level": preserve top-level markdown blocks as separate render blocks.
+     */
+    internalBlockMode?: "coalesced" | "top-level";
 }
 export interface RenderNodeContext {
     syntaxStyle: SyntaxStyle;
@@ -97,6 +120,7 @@ interface TableContentCache {
 export interface BlockState {
     token: MarkedToken;
     tokenRaw: string;
+    marginTop?: number;
     renderable: Renderable;
     tableContentCache?: TableContentCache;
 }
@@ -111,9 +135,11 @@ export declare class MarkdownRenderable extends Renderable {
     private _treeSitterClient?;
     private _tableOptions?;
     private _renderNode?;
+    private _internalBlockMode;
     _parseState: ParseState | null;
     private _streaming;
     _blockStates: BlockState[];
+    _stableBlockCount: number;
     private _styleDirty;
     private _linkifyMarkdownChunks;
     protected _contentDefaultOptions: {
@@ -121,6 +147,7 @@ export declare class MarkdownRenderable extends Renderable {
         conceal: true;
         concealCode: false;
         streaming: false;
+        internalBlockMode: "coalesced";
     };
     constructor(ctx: RenderContext, options: MarkdownOptions);
     get content(): string;
@@ -139,21 +166,47 @@ export declare class MarkdownRenderable extends Renderable {
     set streaming(value: boolean);
     get tableOptions(): MarkdownTableOptions | undefined;
     set tableOptions(value: MarkdownTableOptions | undefined);
+    get renderNode(): MarkdownOptions["renderNode"] | undefined;
+    set renderNode(value: MarkdownOptions["renderNode"] | undefined);
+    get internalBlockMode(): "coalesced" | "top-level";
+    set internalBlockMode(value: "coalesced" | "top-level");
     private getStyle;
     private createChunk;
     private createDefaultChunk;
     private renderInlineContent;
     private renderInlineToken;
     private renderInlineTokenWithStyle;
+    private applyMargins;
     private createMarkdownCodeRenderable;
+    private getBlockquoteContent;
+    private getBlockquoteBorderColor;
+    private createBlockquoteRenderable;
+    private createListRenderable;
+    private getListItemInputs;
+    private applyListRenderable;
+    private createListItemRenderable;
+    private applyListItemRenderable;
+    private applyListItemChildren;
+    private getRenderableListItemTokens;
+    private applyListChildRenderable;
+    private destroyListItemChildrenAfter;
+    private getListChildMarkdownRaw;
+    private applyListItemMarker;
+    private createListChildRenderable;
+    private createHorizontalRuleRenderable;
     private createCodeRenderable;
     private applyMarkdownCodeRenderable;
+    private applyBlockquoteRenderable;
     private applyCodeBlockRenderable;
     private shouldRenderSeparately;
     private getInterBlockMargin;
     private createMarkdownBlockToken;
     private normalizeMarkdownBlockRaw;
+    private normalizeScrollbackMarkdownBlockRaw;
     private buildRenderableTokens;
+    private buildTopLevelRenderBlocks;
+    private shouldAddTopLevelMargin;
+    private isSeparatedTopLevelBlock;
     private getTableRowsToRender;
     private hashString;
     private hashTableToken;
@@ -161,13 +214,22 @@ export declare class MarkdownRenderable extends Renderable {
     private createTableDataCellChunks;
     private createTableHeaderCellChunks;
     private buildTableContentCache;
+    private resolveTableStyle;
+    private usesBorderlessColumnSpacing;
     private resolveTableRenderableOptions;
     private applyTableRenderableOptions;
     private applyTableOptionsToBlocks;
     private createTextTableRenderable;
     private createTableBlock;
+    private getStableBlockCount;
+    private syncTopLevelBlockState;
+    private getTopLevelBlockRaw;
+    private createTopLevelDefaultRenderable;
+    private createTopLevelRenderable;
     private createDefaultRenderable;
     private updateBlockRenderable;
+    private updateTopLevelBlocks;
+    private canUpdateBlockRenderable;
     private updateBlocks;
     private clearBlockStates;
     /**

package/renderables/ScrollBox.d.ts

@@ -12,6 +12,7 @@ declare class ContentRenderable extends BoxRenderable {
     constructor(ctx: RenderContext, viewport: BoxRenderable, viewportCulling: boolean, options: RenderableOptions<BoxRenderable>);
     get viewportCulling(): boolean;
     set viewportCulling(value: boolean);
+    protected _hasVisibleChildFilter(): boolean;
     protected _getVisibleChildren(): number[];
 }
 export interface ScrollBoxOptions extends BoxOptions<ScrollBoxRenderable> {

package/renderables/Select.d.ts

@@ -4,7 +4,8 @@ import type { KeyEvent } from "../lib/KeyHandler.js";
 import { type ColorInput } from "../lib/RGBA.js";
 import { Renderable, type RenderableOptions } from "../Renderable.js";
 import type { RenderContext } from "../types.js";
-import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping.js";
+import { type KeyBinding as BaseKeyBinding } from "../lib/keybinding.internal.js";
+type KeyAliasMap = Record<string, string>;
 export interface SelectOption {
     name: string;
     description: string;
@@ -113,3 +114,4 @@ export declare class SelectRenderable extends Renderable {
     set keyAliasMap(aliases: KeyAliasMap);
     set selectedIndex(value: number);
 }
+export {};

package/renderables/TabSelect.d.ts

@@ -3,7 +3,8 @@ import { OptimizedBuffer } from "../buffer.js";
 import { type ColorInput } from "../lib/RGBA.js";
 import type { KeyEvent } from "../lib/KeyHandler.js";
 import type { RenderContext } from "../types.js";
-import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping.js";
+import { type KeyBinding as BaseKeyBinding } from "../lib/keybinding.internal.js";
+type KeyAliasMap = Record<string, string>;
 export interface TabSelectOption {
     name: string;
     description: string;
@@ -94,3 +95,4 @@ export declare class TabSelectRenderable extends Renderable {
     set keyBindings(bindings: TabSelectKeyBinding[]);
     set keyAliasMap(aliases: KeyAliasMap);
 }
+export {};

package/renderables/TextBufferRenderable.d.ts

@@ -33,6 +33,7 @@ export declare abstract class TextBufferRenderable extends Renderable implements
     protected _scrollX: number;
     protected _scrollY: number;
     protected _truncate: boolean;
+    protected _firstLineOffset: number;
     protected textBuffer: TextBuffer;
     protected textBufferView: TextBufferView;
     protected _textBufferSyntaxStyle: SyntaxStyle;

package/renderables/TextTable.d.ts

@@ -15,6 +15,9 @@ export interface TextTableOptions extends RenderableOptions<TextTableRenderable>
     columnWidthMode?: TextTableColumnWidthMode;
     columnFitter?: TextTableColumnFitter;
     cellPadding?: number;
+    cellPaddingX?: number;
+    cellPaddingY?: number;
+    columnGap?: number;
     showBorders?: boolean;
     border?: boolean;
     outerBorder?: boolean;
@@ -34,7 +37,9 @@ export declare class TextTableRenderable extends Renderable {
     private _wrapMode;
     private _columnWidthMode;
     private _columnFitter;
-    private _cellPadding;
+    private _cellPaddingX;
+    private _cellPaddingY;
+    private _columnGap;
     private _showBorders;
     private _border;
     private _outerBorder;
@@ -71,6 +76,12 @@ export declare class TextTableRenderable extends Renderable {
     set columnFitter(value: TextTableColumnFitter);
     get cellPadding(): number;
     set cellPadding(value: number);
+    get cellPaddingX(): number;
+    set cellPaddingX(value: number);
+    get cellPaddingY(): number;
+    set cellPaddingY(value: number);
+    get columnGap(): number;
+    set columnGap(value: number);
     get showBorders(): boolean;
     set showBorders(value: boolean);
     get outerBorder(): boolean;
@@ -109,6 +120,8 @@ export declare class TextTableRenderable extends Renderable {
     private allocateShrinkByWeight;
     private computeRowHeights;
     private computeOffsets;
+    private getInterColumnGap;
+    private getTotalInterColumnGap;
     private applyLayoutToViews;
     private resolveBorderLayout;
     private getVerticalBorderCount;
@@ -135,6 +148,7 @@ export declare class TextTableRenderable extends Renderable {
     private getVerticalCellPadding;
     private resolveColumnFitter;
     private resolveCellPadding;
+    private resolveColumnGap;
     private invalidateLayoutAndRaster;
     private invalidateRasterOnly;
 }

package/renderables/Textarea.d.ts

@@ -2,11 +2,13 @@ import type { KeyEvent, PasteEvent } from "../lib/KeyHandler.js";
 import { RGBA, type ColorInput } from "../lib/RGBA.js";
 import { type RenderContext } from "../types.js";
 import { EditBufferRenderable, type EditBufferOptions } from "./EditBufferRenderable.js";
-import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping.js";
+import { type KeyBinding as BaseKeyBinding } from "../lib/keybinding.internal.js";
 import { type StyledText } from "../lib/styled-text.js";
 import type { ExtmarksController } from "../lib/extmarks.js";
 export type TextareaAction = "move-left" | "move-right" | "move-up" | "move-down" | "select-left" | "select-right" | "select-up" | "select-down" | "line-home" | "line-end" | "select-line-home" | "select-line-end" | "visual-line-home" | "visual-line-end" | "select-visual-line-home" | "select-visual-line-end" | "buffer-home" | "buffer-end" | "select-buffer-home" | "select-buffer-end" | "delete-line" | "delete-to-line-end" | "delete-to-line-start" | "backspace" | "delete" | "newline" | "undo" | "redo" | "word-forward" | "word-backward" | "select-word-forward" | "select-word-backward" | "delete-word-forward" | "delete-word-backward" | "select-all" | "submit";
 export type KeyBinding = BaseKeyBinding<TextareaAction>;
+export type TextareaKeyAliasMap = Record<string, string>;
+export declare const defaultTextareaKeyBindings: KeyBinding[];
 export interface SubmitEvent {
 }
 export interface TextareaOptions extends EditBufferOptions {
@@ -18,7 +20,7 @@ export interface TextareaOptions extends EditBufferOptions {
     placeholder?: StyledText | string | null;
     placeholderColor?: ColorInput;
     keyBindings?: KeyBinding[];
-    keyAliasMap?: KeyAliasMap;
+    keyAliasMap?: TextareaKeyAliasMap;
     onSubmit?: (event: SubmitEvent) => void;
 }
 export declare class TextareaRenderable extends EditBufferRenderable {
@@ -58,6 +60,6 @@ export declare class TextareaRenderable extends EditBufferRenderable {
     set onSubmit(handler: ((event: SubmitEvent) => void) | undefined);
     get onSubmit(): ((event: SubmitEvent) => void) | undefined;
     set keyBindings(bindings: KeyBinding[]);
-    set keyAliasMap(aliases: KeyAliasMap);
+    set keyAliasMap(aliases: TextareaKeyAliasMap);
     get extmarks(): ExtmarksController;
 }

package/renderables/markdown-parser.d.ts

@@ -2,6 +2,7 @@ import { type MarkedToken } from "marked";
 export interface ParseState {
     content: string;
     tokens: MarkedToken[];
+    stableTokenCount?: number;
 }
 /**
  * Incrementally parse markdown, reusing unchanged tokens from previous parse.

package/renderer-theme-mode.d.ts

@@ -0,0 +1,29 @@
+import { type Clock } from "./lib/clock.js";
+import type { ThemeMode } from "./types.js";
+export interface RendererThemeModeHost {
+    queryThemeColors(): void;
+}
+export declare class RendererThemeMode {
+    private readonly host;
+    private readonly clock;
+    private static readonly QUERY_TIMEOUT_MS;
+    private _themeMode;
+    private themeQueryPending;
+    private themeOscForeground;
+    private themeOscBackground;
+    private themeRefreshTimeoutId;
+    private waiters;
+    constructor(host: RendererThemeModeHost, clock: Clock);
+    get themeMode(): ThemeMode | null;
+    waitForThemeMode(timeoutMs: number, isDestroyed: boolean): Promise<ThemeMode | null>;
+    cancelRefresh(): void;
+    dispose(): void;
+    handleSequence(sequence: string): {
+        handled: boolean;
+        changedMode: ThemeMode | null;
+    };
+    private clearThemeRefreshTimeout;
+    private completeThemeQuery;
+    private requestThemeOscColors;
+    private applyThemeMode;
+}