@opentui/core 0.1.30 → 0.1.32

package/lib/KeyHandler.d.ts

@@ -10,6 +10,7 @@ export declare class KeyEvent implements ParsedKey {
     number: boolean;
     raw: string;
     eventType: KeyEventType;
+    source: "raw" | "kitty";
     code?: string;
     super?: boolean;
     hyper?: boolean;
@@ -37,11 +38,13 @@ export type KeyHandlerEventMap = {
 export declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
     protected stdin: NodeJS.ReadStream;
     protected useKittyKeyboard: boolean;
-    protected listener: (key: Buffer) => void;
     protected pasteMode: boolean;
     protected pasteBuffer: string[];
     private suspended;
+    private stdinBuffer;
+    private dataListener;
     constructor(stdin?: NodeJS.ReadStream, useKittyKeyboard?: boolean);
+    private processSequence;
     destroy(): void;
     suspend(): void;
     resume(): void;

package/lib/extmarks-history.d.ts

@@ -0,0 +1,17 @@
+import type { Extmark } from "./extmarks";
+export interface ExtmarksSnapshot {
+    extmarks: Map<number, Extmark>;
+    nextId: number;
+}
+export declare class ExtmarksHistory {
+    private undoStack;
+    private redoStack;
+    saveSnapshot(extmarks: Map<number, Extmark>, nextId: number): void;
+    undo(): ExtmarksSnapshot | null;
+    redo(): ExtmarksSnapshot | null;
+    pushRedo(snapshot: ExtmarksSnapshot): void;
+    pushUndo(snapshot: ExtmarksSnapshot): void;
+    clear(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}

package/lib/extmarks.d.ts

@@ -0,0 +1,88 @@
+import type { EditBuffer } from "../edit-buffer";
+import type { EditorView } from "../editor-view";
+export interface Extmark {
+    id: number;
+    start: number;
+    end: number;
+    virtual: boolean;
+    styleId?: number;
+    priority?: number;
+    data?: any;
+    typeId: number;
+}
+export interface ExtmarkOptions {
+    start: number;
+    end: number;
+    virtual?: boolean;
+    styleId?: number;
+    priority?: number;
+    data?: any;
+    typeId?: number;
+    metadata?: any;
+}
+/**
+ * WARNING: This is simulating extmarks in the edit buffer
+ * and will move to a real native implementation in the future.
+ * Use with caution.
+ */
+export declare class ExtmarksController {
+    private editBuffer;
+    private editorView;
+    private extmarks;
+    private extmarksByTypeId;
+    private metadata;
+    private nextId;
+    private destroyed;
+    private history;
+    private typeNameToId;
+    private typeIdToName;
+    private nextTypeId;
+    private originalMoveCursorLeft;
+    private originalMoveCursorRight;
+    private originalSetCursorByOffset;
+    private originalMoveUpVisual;
+    private originalMoveDownVisual;
+    private originalDeleteCharBackward;
+    private originalDeleteChar;
+    private originalInsertText;
+    private originalInsertChar;
+    private originalDeleteRange;
+    private originalSetText;
+    private originalClear;
+    private originalNewLine;
+    private originalDeleteLine;
+    private originalEditorViewDeleteSelectedText;
+    private originalUndo;
+    private originalRedo;
+    constructor(editBuffer: EditBuffer, editorView: EditorView);
+    private wrapCursorMovement;
+    private wrapDeletion;
+    private wrapInsertion;
+    private wrapEditorViewDeleteSelectedText;
+    private setupContentChangeListener;
+    private deleteExtmarkById;
+    private findVirtualExtmarkContaining;
+    private adjustExtmarksAfterInsertion;
+    adjustExtmarksAfterDeletion(deleteOffset: number, length: number): void;
+    private offsetToPosition;
+    private positionToOffset;
+    private updateHighlights;
+    private offsetToCharOffset;
+    create(options: ExtmarkOptions): number;
+    delete(id: number): boolean;
+    get(id: number): Extmark | null;
+    getAll(): Extmark[];
+    getVirtual(): Extmark[];
+    getAtOffset(offset: number): Extmark[];
+    getAllForTypeId(typeId: number): Extmark[];
+    clear(): void;
+    private saveSnapshot;
+    private restoreSnapshot;
+    private wrapUndoRedo;
+    registerType(typeName: string): number;
+    getTypeId(typeName: string): number | null;
+    getTypeName(typeId: number): string | null;
+    getMetadataFor(extmarkId: number): any;
+    destroy(): void;
+}
+export declare function createExtmarksController(editBuffer: EditBuffer, editorView: EditorView): ExtmarksController;

package/lib/index.d.ts

@@ -5,6 +5,7 @@ export * from "./hast-styled-text";
 export * from "./RGBA";
 export * from "./parse.keypress";
 export * from "./scroll-acceleration";
+export * from "./stdin-buffer";
 export * from "./styled-text";
 export * from "./yoga.options";
 export * from "./parse.mouse";
@@ -13,3 +14,4 @@ export * from "./env";
 export * from "./tree-sitter-styled-text";
 export * from "./tree-sitter";
 export * from "./data-paths";
+export * from "./extmarks";

package/lib/parse.keypress.d.ts

@@ -11,6 +11,7 @@ export interface ParsedKey {
     number: boolean;
     raw: string;
     eventType: KeyEventType;
+    source: "raw" | "kitty";
     code?: string;
     super?: boolean;
     hyper?: boolean;
@@ -21,4 +22,4 @@ export interface ParsedKey {
 export type ParseKeypressOptions = {
     useKittyKeyboard?: boolean;
 };
-export declare const parseKeypress: (s?: Buffer | string, options?: ParseKeypressOptions) => ParsedKey;
+export declare const parseKeypress: (s?: Buffer | string, options?: ParseKeypressOptions) => ParsedKey | null;

package/lib/stdin-buffer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * StdinBuffer wraps a stdin stream 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,
+ * partial sequences can be misinterpreted as regular keypresses.
+ *
+ * For example, the mouse SGR sequence `\x1b[<35;20;5m` might arrive as:
+ * - Event 1: `\x1b`
+ * - Event 2: `[<35`
+ * - Event 3: `;20;5m`
+ *
+ * The buffer accumulates these until a complete sequence is detected.
+ */
+import { EventEmitter } from "events";
+export type StdinBufferOptions = {
+    /**
+     * Maximum time to wait for sequence completion (default: 10ms)
+     * After this time, the buffer is flushed even if incomplete
+     */
+    timeout?: number;
+};
+export type StdinBufferEventMap = {
+    data: [string];
+};
+/**
+ * Wraps a stdin stream 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;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}

package/lib/tree-sitter/client.d.ts

@@ -43,4 +43,5 @@ export declare class TreeSitterClient extends EventEmitter<TreeSitterClientEvent
     getAllBuffers(): BufferState[];
     isInitialized(): boolean;
     setDataPath(dataPath: string): Promise<void>;
+    clearCache(): Promise<void>;
 }

package/lib/tree-sitter/parsers-config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * This file contains the configuration for the defaulttree-sitter parsers.
+ * It is used by ./assets/update.ts to generate the default-parsers.ts file.
+ * For changes here to be reflected in the default-parsers.ts file, you need to run `bun run ./assets/update.ts`
+ */
+declare const _default: {
+    parsers: ({
+        filetype: string;
+        wasm: string;
+        queries: {
+            highlights: string[];
+            injections?: undefined;
+        };
+        injectionMapping?: undefined;
+    } | {
+        filetype: string;
+        wasm: string;
+        queries: {
+            highlights: string[];
+            injections: string[];
+        };
+        injectionMapping: {
+            nodeTypes: {
+                inline: string;
+                pipe_table_cell: string;
+            };
+            infoStringMap: {
+                javascript: string;
+                js: string;
+                typescript: string;
+                ts: string;
+                markdown: string;
+                md: string;
+            };
+        };
+    })[];
+};
+export default _default;

package/lib/tree-sitter/types.d.ts

@@ -8,13 +8,30 @@ export interface HighlightResponse {
     highlights: HighlightRange[];
     droppedHighlights: HighlightRange[];
 }
-export type SimpleHighlight = [number, number, string];
+export interface HighlightMeta {
+    isInjection?: boolean;
+    injectionLang?: string;
+    containsInjection?: boolean;
+    conceal?: string | null;
+    concealLines?: string | null;
+}
+export type SimpleHighlight = [number, number, string, HighlightMeta?];
+export interface InjectionMapping {
+    nodeTypes?: {
+        [nodeType: string]: string;
+    };
+    infoStringMap?: {
+        [infoString: string]: string;
+    };
+}
 export interface FiletypeParserOptions {
     filetype: string;
     queries: {
         highlights: string[];
+        injections?: string[];
     };
     wasm: string;
+    injectionMapping?: InjectionMapping;
 }
 export interface BufferState {
     id: number;

package/lib/tree-sitter-styled-text.d.ts

@@ -3,5 +3,12 @@ import { StyledText } from "./styled-text";
 import { SyntaxStyle } from "../syntax-style";
 import { TreeSitterClient } from "./tree-sitter/client";
 import type { SimpleHighlight } from "./tree-sitter/types";
-export declare function treeSitterToTextChunks(content: string, highlights: SimpleHighlight[], syntaxStyle: SyntaxStyle): TextChunk[];
-export declare function treeSitterToStyledText(content: string, filetype: string, syntaxStyle: SyntaxStyle, client: TreeSitterClient): Promise<StyledText>;
+interface ConcealOptions {
+    enabled: boolean;
+}
+export declare function treeSitterToTextChunks(content: string, highlights: SimpleHighlight[], syntaxStyle: SyntaxStyle, options?: ConcealOptions): TextChunk[];
+export interface TreeSitterToStyledTextOptions {
+    conceal?: ConcealOptions;
+}
+export declare function treeSitterToStyledText(content: string, filetype: string, syntaxStyle: SyntaxStyle, client: TreeSitterClient, options?: TreeSitterToStyledTextOptions): Promise<StyledText>;
+export {};

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -45,21 +45,21 @@
     "@types/three": "0.177.0",
     "commander": "^13.1.0",
     "typescript": "^5",
-    "web-tree-sitter": "^0.26.0"
+    "web-tree-sitter": "0.25.10"
   },
   "peerDependencies": {
-    "web-tree-sitter": ">=0.26.0"
+    "web-tree-sitter": "0.25.10"
   },
   "optionalDependencies": {
     "@dimforge/rapier2d-simd-compat": "^0.17.3",
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.30",
-    "@opentui/core-darwin-arm64": "0.1.30",
-    "@opentui/core-linux-x64": "0.1.30",
-    "@opentui/core-linux-arm64": "0.1.30",
-    "@opentui/core-win32-x64": "0.1.30",
-    "@opentui/core-win32-arm64": "0.1.30"
+    "@opentui/core-darwin-x64": "0.1.32",
+    "@opentui/core-darwin-arm64": "0.1.32",
+    "@opentui/core-linux-x64": "0.1.32",
+    "@opentui/core-linux-arm64": "0.1.32",
+    "@opentui/core-win32-x64": "0.1.32",
+    "@opentui/core-win32-arm64": "0.1.32"
   }
 }