@opentui/core 0.1.19-snapshot4-010c3be8 → 0.1.19

package/lib/styled-text.d.ts

@@ -1,3 +1,4 @@
+import type { TextRenderable } from "../renderables/Text";
 import type { TextChunk } from "../text-buffer";
 import { type ColorInput } from "./RGBA";
 export type Color = ColorInput;
@@ -13,11 +14,21 @@ export interface StyleAttrs {
     blink?: boolean;
 }
 export declare class StyledText {
-    readonly chunks: TextChunk[];
+    chunks: TextChunk[];
+    textRenderable?: TextRenderable;
     constructor(chunks: TextChunk[]);
-    private static _createInstance;
+    mount(textRenderable: TextRenderable): void;
+    /**
+     * @deprecated: Use textRenderable.insertChunk instead
+     */
     insert(chunk: TextChunk, index?: number): StyledText;
+    /**
+     * @deprecated: Use textRenderable.removeChunk instead
+     */
     remove(chunk: TextChunk): StyledText;
+    /**
+     * @deprecated: Use textRenderable.replaceChunk instead
+     */
     replace(chunk: TextChunk, oldChunk: TextChunk): StyledText;
 }
 export declare function stringToStyledText(content: string): StyledText;
@@ -59,10 +70,4 @@ export declare const bg: (color: Color) => (input: StylableInput) => TextChunk;
  * Template literal handler for styled text (non-cached version).
  * Returns a StyledText object containing chunks of text with optional styles.
  */
-export declare function tn(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;
-/**
- * Template literal handler for styled text (cached version).
- * Returns a StyledText object containing chunks of text with optional styles.
- * Uses caching to avoid re-encoding the same template strings.
- */
 export declare function t(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.19-snapshot4-010c3be8",
+  "version": "0.1.19",
   "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.19-snapshot4-010c3be8",
-    "@opentui/core-darwin-arm64": "0.1.19-snapshot4-010c3be8",
-    "@opentui/core-linux-x64": "0.1.19-snapshot4-010c3be8",
-    "@opentui/core-linux-arm64": "0.1.19-snapshot4-010c3be8",
-    "@opentui/core-win32-x64": "0.1.19-snapshot4-010c3be8",
-    "@opentui/core-win32-arm64": "0.1.19-snapshot4-010c3be8"
+    "@opentui/core-darwin-x64": "0.1.19",
+    "@opentui/core-darwin-arm64": "0.1.19",
+    "@opentui/core-linux-x64": "0.1.19",
+    "@opentui/core-linux-arm64": "0.1.19",
+    "@opentui/core-win32-x64": "0.1.19",
+    "@opentui/core-win32-arm64": "0.1.19"
   }
 }

package/renderables/Text.d.ts

@@ -1,6 +1,7 @@
-import { Renderable, type RenderableOptions } from "../Renderable";
+import { BaseRenderable, Renderable, type RenderableOptions } from "../Renderable";
 import { Selection } from "../lib/selection";
 import { StyledText } from "../lib/styled-text";
+import { type TextChunk } from "../text-buffer";
 import { RGBA } from "../lib/RGBA";
 import { type RenderContext } from "../types";
 import type { OptimizedBuffer } from "../buffer";
@@ -24,6 +25,7 @@ export declare class TextRenderable extends Renderable {
     private lastLocalSelection;
     private textBuffer;
     private _lineInfo;
+    private rootTextNode;
     protected _defaultOptions: {
         content: string;
         fg: RGBA;
@@ -34,7 +36,12 @@ export declare class TextRenderable extends Renderable {
         attributes: number;
     };
     constructor(ctx: RenderContext, options: TextOptions);
+    private updateTextBuffer;
+    private clearChunks;
     get content(): StyledText;
+    get plainText(): string;
+    get textLength(): number;
+    get chunks(): TextChunk[];
     set content(value: StyledText | string);
     get fg(): RGBA;
     set fg(value: RGBA | string | undefined);
@@ -50,6 +57,14 @@ export declare class TextRenderable extends Renderable {
     private updateLocalSelection;
     private updateTextInfo;
     private setupMeasureFunc;
+    insertChunk(chunk: TextChunk, index?: number): void;
+    removeChunk(chunk: TextChunk): void;
+    replaceChunk(chunk: TextChunk, oldChunk: TextChunk): void;
+    private updateTextFromNodes;
+    add(obj: Renderable | any, index?: number): number;
+    remove(id: string): void;
+    insertBefore(obj: BaseRenderable | any, anchor?: BaseRenderable): number;
+    clear(): void;
     shouldStartSelection(x: number, y: number): boolean;
     onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
@@ -58,7 +73,7 @@ export declare class TextRenderable extends Renderable {
         start: number;
         end: number;
     } | null;
-    private updateTextBuffer;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
     protected renderSelf(buffer: OptimizedBuffer): void;
     destroy(): void;
 }

package/renderables/TextNode.d.ts

@@ -0,0 +1,57 @@
+import { BaseRenderable, type BaseRenderableOptions } from "../Renderable";
+import { RGBA } from "../lib/RGBA";
+import { type TextChunk } from "../text-buffer";
+import type { RenderContext } from "../types";
+export interface TextNodeOptions extends BaseRenderableOptions {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    attributes?: number;
+}
+declare const BrandedTextNodeRenderable: unique symbol;
+export declare function isTextNodeRenderable(obj: any): obj is TextNodeRenderable;
+export declare class TextNodeRenderable extends BaseRenderable {
+    [BrandedTextNodeRenderable]: boolean;
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes: number;
+    private _children;
+    parent: TextNodeRenderable | null;
+    constructor(options: TextNodeOptions);
+    get children(): (string | TextNodeRenderable)[];
+    set children(children: (string | TextNodeRenderable)[]);
+    requestRender(): void;
+    add(obj: TextNodeRenderable | string, index?: number): number;
+    insertBefore(child: string | TextNodeRenderable, anchorNode: string | TextNodeRenderable): this;
+    remove(child: string | TextNodeRenderable): this;
+    clear(): void;
+    mergeStyles(parentStyle: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    }): {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    };
+    gatherWithInheritedStyle(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    }): TextChunk[];
+    static fromString(text: string, options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    static fromNodes(nodes: TextNodeRenderable[], options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    toChunks(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+    }): TextChunk[];
+    getChildren(): BaseRenderable[];
+    getChildrenCount(): number;
+    getRenderable(id: string): BaseRenderable | undefined;
+}
+export declare class RootTextNodeRenderable extends TextNodeRenderable {
+    private readonly ctx;
+    constructor(ctx: RenderContext, options: TextNodeOptions);
+    requestRender(): void;
+}
+export {};

package/renderables/composition/constructs.d.ts

@@ -1,12 +1,33 @@
 import { ASCIIFontRenderable, BoxRenderable, InputRenderable, SelectRenderable, TabSelectRenderable, TextRenderable, VRenderable, type ASCIIFontOptions, type BoxOptions, type TextOptions, type VRenderableOptions, type InputRenderableOptions, type SelectRenderableOptions, type TabSelectRenderableOptions, FrameBufferRenderable, type FrameBufferOptions } from "../";
-import { type VChild, type ProxiedVNode } from "./vnode";
-export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof VRenderable>;
-export declare function Box(props?: BoxOptions, ...children: VChild[]): ProxiedVNode<typeof BoxRenderable>;
+import { TextNodeRenderable } from "../TextNode";
+import { type VChild } from "./vnode";
+import type { RGBA } from "../../lib/RGBA";
+export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof VRenderable>;
+export declare function Box(props?: BoxOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof BoxRenderable>;
 export declare function Text(props?: TextOptions & {
     content?: any;
-}, ...children: VChild[]): ProxiedVNode<typeof TextRenderable>;
-export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): ProxiedVNode<typeof ASCIIFontRenderable>;
-export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof InputRenderable>;
-export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof SelectRenderable>;
-export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof TabSelectRenderable>;
-export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): ProxiedVNode<typeof FrameBufferRenderable>;
+}, ...children: VChild[] | TextNodeRenderable[]): import("./vnode").ProxiedVNode<typeof TextRenderable>;
+export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof ASCIIFontRenderable>;
+export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof InputRenderable>;
+export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof SelectRenderable>;
+export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof TabSelectRenderable>;
+export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): import("./vnode").ProxiedVNode<typeof FrameBufferRenderable>;
+export declare const vstyles: {
+    bold: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    italic: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    underline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    dim: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    blink: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    inverse: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    hidden: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    strikethrough: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldItalic: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    italicUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    boldItalicUnderline: (...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    color: (color: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    bgColor: (bgColor: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    fg: (color: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    bg: (bgColor: string | RGBA, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+    styled: (attributes?: number, ...children: (string | TextNodeRenderable)[]) => TextNodeRenderable;
+};

package/renderables/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./Box";
 export * from "./FrameBuffer";
 export * from "./Text";
+export * from "./TextNode";
 export * from "./ASCIIFont";
 export * from "./Input";
 export * from "./Select";

package/text-buffer.d.ts

@@ -5,8 +5,7 @@ import { type Pointer } from "bun:ffi";
 import { type WidthMethod } from "./types";
 export interface TextChunk {
     __isChunk: true;
-    text: Uint8Array;
-    plainText: string;
+    text: string;
     fg?: RGBA;
     bg?: RGBA;
     attributes?: number;
@@ -28,6 +27,7 @@ export declare class TextBuffer {
     get capacity(): number;
     get ptr(): Pointer;
     getSelectedText(): string;
+    getPlainText(): string;
     get lineInfo(): {
         lineStarts: number[];
         lineWidths: number[];
@@ -41,5 +41,11 @@ export declare class TextBuffer {
         end: number;
     } | null;
     hasSelection(): boolean;
+    insertChunkGroup(index: number, text: string, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    insertEncodedChunkGroup(index: number, textBytes: Uint8Array, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    removeChunkGroup(index: number): void;
+    replaceChunkGroup(index: number, text: string, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    replaceEncodedChunkGroup(index: number, textBytes: Uint8Array, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    get chunkGroupCount(): number;
     destroy(): void;
 }

package/zig.d.ts

@@ -86,6 +86,8 @@ export interface RenderLib {
         end: number;
     } | null;
     getSelectedTextBytes: (buffer: Pointer, maxLength: number) => Uint8Array | null;
+    getPlainTextBytes: (buffer: Pointer, maxLength: number) => Uint8Array | null;
+    readonly encoder: TextEncoder;
     readonly decoder: TextDecoder;
     bufferDrawTextBuffer: (buffer: Pointer, textBuffer: Pointer, x: number, y: number, clipRect?: {
         x: number;
@@ -96,6 +98,11 @@ export interface RenderLib {
     bufferPushScissorRect: (buffer: Pointer, x: number, y: number, width: number, height: number) => void;
     bufferPopScissorRect: (buffer: Pointer) => void;
     bufferClearScissorRects: (buffer: Pointer) => void;
+    textBufferInsertChunkGroup: (buffer: Pointer, index: number, textBytes: Uint8Array, fg: RGBA | null, bg: RGBA | null, attributes: number | null) => number;
+    textBufferRemoveChunkGroup: (buffer: Pointer, index: number) => number;
+    textBufferReplaceChunkGroup: (buffer: Pointer, index: number, textBytes: Uint8Array, fg: RGBA | null, bg: RGBA | null, attributes: number | null) => number;
+    textBufferGetChunkGroupCount: (buffer: Pointer) => number;
+    getArenaAllocatedBytes: () => number;
     getTerminalCapabilities: (renderer: Pointer) => any;
     processCapabilityResponse: (renderer: Pointer, response: string) => void;
 }