@opentui/core 0.0.0-20251108-0c7899b1 → 0.0.0-20251112-613689c1

package/lib/KeyHandler.d.ts

@@ -36,16 +36,11 @@ export type KeyHandlerEventMap = {
     paste: [PasteEvent];
 };
 export declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
-    protected stdin: NodeJS.ReadStream;
     protected useKittyKeyboard: boolean;
-    protected pasteMode: boolean;
-    protected pasteBuffer: string[];
     private suspended;
-    private stdinBuffer;
-    private dataListener;
-    constructor(stdin?: NodeJS.ReadStream, useKittyKeyboard?: boolean);
-    private processSequence;
-    destroy(): void;
+    constructor(useKittyKeyboard?: boolean);
+    processInput(data: string): boolean;
+    processPaste(data: string): void;
     suspend(): void;
     resume(): void;
 }
@@ -55,7 +50,7 @@ export declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
  */
 export declare class InternalKeyHandler extends KeyHandler {
     private renderableHandlers;
-    constructor(stdin?: NodeJS.ReadStream, useKittyKeyboard?: boolean);
+    constructor(useKittyKeyboard?: boolean);
     emit<K extends keyof KeyHandlerEventMap>(event: K, ...args: KeyHandlerEventMap[K]): boolean;
     private emitWithPriority;
     onInternal<K extends keyof KeyHandlerEventMap>(event: K, handler: (...args: KeyHandlerEventMap[K]) => void): void;

package/lib/ascii.font.d.ts

@@ -1,5 +1,5 @@
 import { OptimizedBuffer } from "../buffer";
-import { RGBA } from "./RGBA";
+import { type ColorInput } from "./RGBA";
 export type ASCIIFontName = "tiny" | "block" | "shade" | "slick";
 export declare const fonts: {
     tiny: {
@@ -288,12 +288,12 @@ export declare function measureText({ text, font }: {
 };
 export declare function getCharacterPositions(text: string, font?: keyof typeof fonts): number[];
 export declare function coordinateToCharacterIndex(x: number, text: string, font?: keyof typeof fonts): number;
-export declare function renderFontToFrameBuffer(buffer: OptimizedBuffer, { text, x, y, fg, bg, font, }: {
+export declare function renderFontToFrameBuffer(buffer: OptimizedBuffer, { text, x, y, color, backgroundColor, font, }: {
     text: string;
     x?: number;
     y?: number;
-    fg?: RGBA | RGBA[];
-    bg?: RGBA;
+    color?: ColorInput | ColorInput[];
+    backgroundColor?: ColorInput;
     font?: keyof typeof fonts;
 }): {
     width: number;

package/lib/extmarks.d.ts

@@ -67,7 +67,7 @@ export declare class ExtmarksController {
     private offsetToPosition;
     private positionToOffset;
     private updateHighlights;
-    private offsetToCharOffset;
+    private offsetExcludingNewlines;
     create(options: ExtmarkOptions): number;
     delete(id: number): boolean;
     get(id: number): Extmark | null;

package/lib/keymapping.d.ts

@@ -3,6 +3,7 @@ export interface KeyBinding<Action extends string = string> {
     ctrl?: boolean;
     shift?: boolean;
     meta?: boolean;
+    super?: boolean;
     action: Action;
 }
 export declare function mergeKeyBindings<Action extends string>(defaults: KeyBinding<Action>[], custom: KeyBinding<Action>[]): KeyBinding<Action>[];

package/lib/stdin-buffer.d.ts

@@ -1,5 +1,5 @@
 /**
- * StdinBuffer wraps a stdin stream and emits complete sequences.
+ * StdinBuffer buffers input and emits complete sequences.
  *
  * This is necessary because stdin data events can arrive in partial chunks,
  * especially for escape sequences like mouse events. Without buffering,
@@ -11,6 +11,7 @@
  * - Event 3: `;20;5m`
  *
  * The buffer accumulates these until a complete sequence is detected.
+ * Call the `process()` method to feed input data.
  */
 import { EventEmitter } from "events";
 export type StdinBufferOptions = {
@@ -22,19 +23,20 @@ export type StdinBufferOptions = {
 };
 export type StdinBufferEventMap = {
     data: [string];
+    paste: [string];
 };
 /**
- * Wraps a stdin stream and emits complete sequences via the 'data' event.
+ * Buffers stdin input and emits complete sequences via the 'data' event.
  * Handles partial escape sequences that arrive across multiple chunks.
  */
 export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
     private buffer;
     private timeout;
     private readonly timeoutMs;
-    private readonly stdin;
-    private readonly stdinListener;
-    constructor(stdin: NodeJS.ReadStream, options?: StdinBufferOptions);
-    private handleData;
+    private pasteMode;
+    private pasteBuffer;
+    constructor(options?: StdinBufferOptions);
+    process(data: string | Buffer): void;
     flush(): string[];
     clear(): void;
     getBuffer(): string;

package/lib/terminal-capability-detection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Terminal capability response detection utilities.
+ *
+ * Detects various terminal capability response sequences:
+ * - DECRPM (DEC Request Mode): ESC[?...;N$y where N is 0,1,2,3,4
+ * - CPR (Cursor Position Report): ESC[row;colR (used for width detection)
+ * - XTVersion: ESC P >| ... ESC \
+ * - Kitty Graphics: ESC _ G ... ESC \
+ * - Kitty Keyboard Query: ESC[?Nu where N is 0,1,2,etc
+ * - DA1 (Device Attributes): ESC[?...c
+ * - Pixel Resolution: ESC[4;height;widtht
+ */
+/**
+ * Check if a sequence is a terminal capability response.
+ * Returns true if the sequence matches any known capability response pattern.
+ */
+export declare function isCapabilityResponse(sequence: string): boolean;
+/**
+ * Check if a sequence is a pixel resolution response.
+ * Format: ESC[4;height;widtht
+ */
+export declare function isPixelResolutionResponse(sequence: string): boolean;
+/**
+ * Parse pixel resolution from response sequence.
+ * Returns { width, height } or null if not a valid resolution response.
+ */
+export declare function parsePixelResolution(sequence: string): {
+    width: number;
+    height: number;
+} | null;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.0.0-20251108-0c7899b1",
+  "version": "0.0.0-20251112-613689c1",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,7 @@
     }
   },
   "dependencies": {
-    "bun-ffi-structs": "^0.1.0",
+    "bun-ffi-structs": "0.1.2",
     "jimp": "1.6.0",
     "yoga-layout": "3.2.1"
   },
@@ -55,11 +55,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.0.0-20251108-0c7899b1",
-    "@opentui/core-darwin-arm64": "0.0.0-20251108-0c7899b1",
-    "@opentui/core-linux-x64": "0.0.0-20251108-0c7899b1",
-    "@opentui/core-linux-arm64": "0.0.0-20251108-0c7899b1",
-    "@opentui/core-win32-x64": "0.0.0-20251108-0c7899b1",
-    "@opentui/core-win32-arm64": "0.0.0-20251108-0c7899b1"
+    "@opentui/core-darwin-x64": "0.0.0-20251112-613689c1",
+    "@opentui/core-darwin-arm64": "0.0.0-20251112-613689c1",
+    "@opentui/core-linux-x64": "0.0.0-20251112-613689c1",
+    "@opentui/core-linux-arm64": "0.0.0-20251112-613689c1",
+    "@opentui/core-win32-x64": "0.0.0-20251112-613689c1",
+    "@opentui/core-win32-arm64": "0.0.0-20251112-613689c1"
   }
 }

package/renderables/ASCIIFont.d.ts

@@ -1,37 +1,46 @@
+import { type ASCIIFontName, type fonts } from "../lib/ascii.font";
+import { type ColorInput } from "../lib/RGBA";
+import { Selection, type LocalSelectionBounds } from "../lib/selection";
 import type { RenderableOptions } from "../Renderable";
-import { Selection } from "../lib/selection";
-import { type fonts, type ASCIIFontName } from "../lib/ascii.font";
-import { RGBA } from "../lib/RGBA";
-import { FrameBufferRenderable } from "./FrameBuffer";
 import type { RenderContext } from "../types";
+import { FrameBufferRenderable } from "./FrameBuffer";
 export interface ASCIIFontOptions extends Omit<RenderableOptions<ASCIIFontRenderable>, "width" | "height"> {
     text?: string;
     font?: ASCIIFontName;
-    fg?: RGBA | RGBA[];
-    bg?: RGBA;
-    selectionBg?: string | RGBA;
-    selectionFg?: string | RGBA;
+    color?: ColorInput | ColorInput[];
+    backgroundColor?: ColorInput;
+    selectionBg?: ColorInput;
+    selectionFg?: ColorInput;
     selectable?: boolean;
 }
 export declare class ASCIIFontRenderable extends FrameBufferRenderable {
     selectable: boolean;
-    private _text;
-    private _font;
-    private _fg;
-    private _bg;
-    private _selectionBg;
-    private _selectionFg;
-    private lastLocalSelection;
+    protected static readonly _defaultOptions: {
+        text: string;
+        font: "tiny";
+        color: string;
+        backgroundColor: string;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+    };
+    protected _text: string;
+    protected _font: keyof typeof fonts;
+    protected _color: ColorInput | ColorInput[];
+    protected _backgroundColor: ColorInput;
+    protected _selectionBg: ColorInput | undefined;
+    protected _selectionFg: ColorInput | undefined;
+    protected lastLocalSelection: LocalSelectionBounds | null;
     private selectionHelper;
     constructor(ctx: RenderContext, options: ASCIIFontOptions);
     get text(): string;
     set text(value: string);
     get font(): keyof typeof fonts;
     set font(value: keyof typeof fonts);
-    get fg(): RGBA[];
-    set fg(value: RGBA | RGBA[] | string | string[]);
-    get bg(): RGBA;
-    set bg(value: RGBA | string);
+    get color(): ColorInput | ColorInput[];
+    set color(value: ColorInput | ColorInput[]);
+    get backgroundColor(): ColorInput;
+    set backgroundColor(value: ColorInput);
     private updateDimensions;
     shouldStartSelection(x: number, y: number): boolean;
     onSelectionChanged(selection: Selection | null): boolean;

package/renderables/Textarea.d.ts

@@ -5,7 +5,7 @@ import { RGBA, type ColorInput } from "../lib/RGBA";
 import { type KeyBinding as BaseKeyBinding } from "../lib/keymapping";
 import { type StyledText } from "../lib/styled-text";
 import type { ExtmarksController } from "../lib/extmarks";
-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" | "buffer-home" | "buffer-end" | "delete-line" | "delete-to-line-end" | "backspace" | "delete" | "newline" | "undo" | "redo" | "word-forward" | "word-backward" | "select-word-forward" | "select-word-backward" | "delete-word-forward" | "delete-word-backward" | "submit";
+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" | "buffer-home" | "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" | "submit";
 export type KeyBinding = BaseKeyBinding<TextareaAction>;
 export interface SubmitEvent {
 }
@@ -65,6 +65,7 @@ export declare class TextareaRenderable extends EditBufferRenderable {
     gotoBufferHome(): boolean;
     gotoBufferEnd(): boolean;
     deleteToLineEnd(): boolean;
+    deleteToLineStart(): boolean;
     undo(): boolean;
     redo(): boolean;
     moveWordForward(options?: {

package/renderables/__tests__/renderable-test-utils.d.ts

@@ -0,0 +1,7 @@
+import { TextareaRenderable } from "../Textarea";
+import { type TestRenderer } from "../../testing/test-renderer";
+import { type TextareaOptions } from "../Textarea";
+export declare function createTextareaRenderable(renderer: TestRenderer, renderOnce: () => Promise<void>, options: TextareaOptions): Promise<{
+    textarea: TextareaRenderable;
+    root: any;
+}>;

package/renderer.d.ts

@@ -30,6 +30,8 @@ export interface CliRendererConfig {
     useKittyKeyboard?: boolean;
     backgroundColor?: ColorInput;
     openConsoleOnError?: boolean;
+    prependInputHandlers?: ((sequence: string) => boolean)[];
+    onDestroy?: () => void;
 }
 export type PixelResolution = {
     width: number;
@@ -126,6 +128,7 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private _console;
     private _resolution;
     private _keyHandler;
+    private _stdinBuffer;
     private animationRequest;
     private resizeTimeoutId;
     private resizeDebounceDelay;
@@ -157,6 +160,9 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private _paletteDetector;
     private _cachedPalette;
     private _paletteDetectionPromise;
+    private _onDestroy?;
+    private inputHandlers;
+    private prependedInputHandlers;
     private handleError;
     private dumpOutputCache;
     private exitHandler;
@@ -202,6 +208,11 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     set useThread(useThread: boolean);
     setupTerminal(): Promise<void>;
     private stdinListener;
+    addInputHandler(handler: (sequence: string) => boolean): void;
+    prependInputHandler(handler: (sequence: string) => boolean): void;
+    removeInputHandler(handler: (sequence: string) => boolean): void;
+    private capabilityHandler;
+    private focusHandler;
     private setupInput;
     private handleMouseData;
     private takeMemorySnapshot;

package/testing/mock-keys.d.ts

@@ -26,7 +26,11 @@ export declare const KeyCodes: {
     readonly F12: "\u001B[24~";
 };
 export type KeyInput = string | keyof typeof KeyCodes;
-export declare function createMockKeys(renderer: CliRenderer): {
+export interface MockKeysOptions {
+    kittyKeyboard?: boolean;
+    otherModifiersMode?: boolean;
+}
+export declare function createMockKeys(renderer: CliRenderer, options?: MockKeysOptions): {
     pressKeys: (keys: KeyInput[], delayMs?: number) => Promise<void>;
     pressKey: (key: KeyInput, modifiers?: {
         shift?: boolean;

package/testing/test-renderer.d.ts

@@ -4,6 +4,8 @@ import { createMockMouse } from "./mock-mouse";
 export interface TestRendererOptions extends CliRendererConfig {
     width?: number;
     height?: number;
+    kittyKeyboard?: boolean;
+    otherModifiersMode?: boolean;
 }
 export interface TestRenderer extends CliRenderer {
 }

package/testing.js

@@ -4,7 +4,7 @@ import {
   CliRenderer,
   TreeSitterClient,
   resolveRenderLib
-} from "./index-z5bb2h2z.js";
+} from "./index-y49e47t2.js";
 
 // src/testing/mock-keys.ts
 var KeyCodes = {
@@ -34,22 +34,88 @@ var KeyCodes = {
   F11: "\x1B[23~",
   F12: "\x1B[24~"
 };
-function createMockKeys(renderer) {
+var kittyKeyCodeMap = {
+  escape: 27,
+  tab: 9,
+  return: 13,
+  backspace: 127,
+  insert: 57348,
+  delete: 57349,
+  left: 57350,
+  right: 57351,
+  up: 57352,
+  down: 57353,
+  pageup: 57354,
+  pagedown: 57355,
+  home: 57356,
+  end: 57357,
+  f1: 57364,
+  f2: 57365,
+  f3: 57366,
+  f4: 57367,
+  f5: 57368,
+  f6: 57369,
+  f7: 57370,
+  f8: 57371,
+  f9: 57372,
+  f10: 57373,
+  f11: 57374,
+  f12: 57375
+};
+function encodeKittySequence(codepoint, modifiers) {
+  let modMask = 0;
+  if (modifiers?.shift)
+    modMask |= 1;
+  if (modifiers?.meta)
+    modMask |= 2;
+  if (modifiers?.ctrl)
+    modMask |= 4;
+  if (modMask === 0) {
+    return `\x1B[${codepoint}u`;
+  } else {
+    return `\x1B[${codepoint};${modMask + 1}u`;
+  }
+}
+function encodeModifyOtherKeysSequence(charCode, modifiers) {
+  let modMask = 0;
+  if (modifiers?.shift)
+    modMask |= 1;
+  if (modifiers?.meta)
+    modMask |= 2;
+  if (modifiers?.ctrl)
+    modMask |= 4;
+  if (modMask === 0) {
+    return String.fromCharCode(charCode);
+  }
+  return `\x1B[27;${modMask + 1};${charCode}~`;
+}
+function resolveKeyInput(key) {
+  let keyValue;
+  let keyName;
+  if (typeof key === "string") {
+    if (key in KeyCodes) {
+      keyValue = KeyCodes[key];
+      keyName = key.toLowerCase();
+    } else {
+      keyValue = key;
+      keyName = undefined;
+    }
+  } else {
+    keyValue = KeyCodes[key];
+    if (!keyValue) {
+      throw new Error(`Unknown key: ${key}`);
+    }
+    keyName = String(key).toLowerCase();
+  }
+  return { keyValue, keyName };
+}
+function createMockKeys(renderer, options) {
+  const useKittyKeyboard = options?.kittyKeyboard ?? false;
+  const useOtherModifiersMode = options?.otherModifiersMode ?? false;
+  const effectiveOtherModifiersMode = useOtherModifiersMode && !useKittyKeyboard;
   const pressKeys = async (keys, delayMs = 0) => {
     for (const key of keys) {
-      let keyCode;
-      if (typeof key === "string") {
-        if (key in KeyCodes) {
-          keyCode = KeyCodes[key];
-        } else {
-          keyCode = key;
-        }
-      } else {
-        keyCode = KeyCodes[key];
-        if (!keyCode) {
-          throw new Error(`Unknown key: ${key}`);
-        }
-      }
+      const { keyValue: keyCode } = resolveKeyInput(key);
       renderer.stdin.emit("data", Buffer.from(keyCode));
       if (delayMs > 0) {
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -57,19 +123,66 @@ function createMockKeys(renderer) {
     }
   };
   const pressKey = (key, modifiers) => {
-    let keyCode;
-    if (typeof key === "string") {
-      if (key in KeyCodes) {
-        keyCode = KeyCodes[key];
-      } else {
-        keyCode = key;
+    if (useKittyKeyboard) {
+      let { keyValue, keyName } = resolveKeyInput(key);
+      const valueToKeyNameMap = {
+        "\b": "backspace",
+        "\r": "return",
+        "\n": "return",
+        "\t": "tab",
+        "\x1B": "escape",
+        "\x1B[A": "up",
+        "\x1B[B": "down",
+        "\x1B[C": "right",
+        "\x1B[D": "left",
+        "\x1B[H": "home",
+        "\x1B[F": "end",
+        "\x1B[3~": "delete"
+      };
+      if (keyValue && valueToKeyNameMap[keyValue]) {
+        keyName = valueToKeyNameMap[keyValue];
       }
-    } else {
-      keyCode = KeyCodes[key];
-      if (!keyCode) {
-        throw new Error(`Unknown key: ${key}`);
+      if (keyName && keyName.startsWith("arrow_")) {
+        keyName = keyName.substring(6);
+      }
+      if (keyName && kittyKeyCodeMap[keyName]) {
+        const kittyCode = kittyKeyCodeMap[keyName];
+        const sequence = encodeKittySequence(kittyCode, modifiers);
+        renderer.stdin.emit("data", Buffer.from(sequence));
+        return;
+      }
+      if (keyValue && keyValue.length === 1 && !keyValue.startsWith("\x1B")) {
+        const codepoint = keyValue.codePointAt(0);
+        if (codepoint) {
+          const sequence = encodeKittySequence(codepoint, modifiers);
+          renderer.stdin.emit("data", Buffer.from(sequence));
+          return;
+        }
       }
     }
+    if (effectiveOtherModifiersMode && modifiers) {
+      let { keyValue, keyName } = resolveKeyInput(key);
+      const valueToCharCodeMap = {
+        "\b": 127,
+        "\r": 13,
+        "\n": 13,
+        "\t": 9,
+        "\x1B": 27,
+        " ": 32
+      };
+      let charCode;
+      if (keyValue && valueToCharCodeMap[keyValue] !== undefined) {
+        charCode = valueToCharCodeMap[keyValue];
+      } else if (keyValue && keyValue.length === 1 && !keyValue.startsWith("\x1B")) {
+        charCode = keyValue.charCodeAt(0);
+      }
+      if (charCode !== undefined) {
+        const sequence = encodeModifyOtherKeysSequence(charCode, modifiers);
+        renderer.stdin.emit("data", Buffer.from(sequence));
+        return;
+      }
+    }
+    let keyCode = resolveKeyInput(key).keyValue;
     if (modifiers) {
       if (keyCode.startsWith("\x1B[") && keyCode.length > 2) {
         const modifier = 1 + (modifiers.shift ? 1 : 0) + (modifiers.meta ? 2 : 0) + (modifiers.ctrl ? 4 : 0);
@@ -84,6 +197,24 @@ function createMockKeys(renderer) {
             keyCode = String.fromCharCode(char.charCodeAt(0) - 96);
           } else if (char >= "A" && char <= "Z") {
             keyCode = String.fromCharCode(char.charCodeAt(0) - 64);
+          } else {
+            const specialCtrlMap = {
+              "[": "\x1B",
+              "\\": "\x1C",
+              "]": "\x1D",
+              "^": "\x1E",
+              _: "\x1F",
+              "?": "\x7F",
+              "/": "\x1F",
+              "-": "\x1F",
+              ".": "\x1E",
+              ",": "\x1C",
+              "@": "\x00",
+              " ": "\x00"
+            };
+            if (char in specialCtrlMap) {
+              keyCode = specialCtrlMap[char];
+            }
           }
           if (modifiers.meta) {
             keyCode = `\x1B${keyCode}`;
@@ -305,7 +436,10 @@ async function createTestRenderer(options) {
     useConsole: false
   });
   renderer.disableStdoutInterception();
-  const mockInput = createMockKeys(renderer);
+  const mockInput = createMockKeys(renderer, {
+    kittyKeyboard: options.kittyKeyboard,
+    otherModifiersMode: options.otherModifiersMode
+  });
   const mockMouse = createMockMouse(renderer);
   const renderOnce = async () => {
     await renderer.loop();
@@ -344,6 +478,7 @@ async function setupTestRenderer(config) {
   }
   ziglib.setUseThread(rendererPtr, config.useThread);
   const renderer = new CliRenderer(ziglib, rendererPtr, stdin, stdout, width, height, config);
+  process.off("SIGWINCH", renderer["sigwinchHandler"]);
   return renderer;
 }
 // src/testing/mock-tree-sitter-client.ts
@@ -401,5 +536,5 @@ export {
   KeyCodes
 };
 
-//# debugId=334F11C8682F8A0A64756E2164756E21
+//# debugId=87F3E86F73786CEC64756E2164756E21
 //# sourceMappingURL=testing.js.map