@xincli/opentui-core 0.4.6 → 0.4.7

package/lib/styled-text.d.ts

@@ -0,0 +1,63 @@
+import type { TextChunk } from "../text-buffer.js";
+import { type ColorInput } from "./RGBA.js";
+declare const BrandedStyledText: unique symbol;
+export type Color = ColorInput;
+export interface StyleAttrs {
+    fg?: Color;
+    bg?: Color;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    dim?: boolean;
+    reverse?: boolean;
+    blink?: boolean;
+}
+export declare function isStyledText(obj: any): obj is StyledText;
+export declare class StyledText {
+    [BrandedStyledText]: boolean;
+    chunks: TextChunk[];
+    constructor(chunks: TextChunk[]);
+}
+export declare function stringToStyledText(content: string): StyledText;
+export type StylableInput = string | number | boolean | TextChunk;
+export declare const black: (input: StylableInput) => TextChunk;
+export declare const red: (input: StylableInput) => TextChunk;
+export declare const green: (input: StylableInput) => TextChunk;
+export declare const yellow: (input: StylableInput) => TextChunk;
+export declare const blue: (input: StylableInput) => TextChunk;
+export declare const magenta: (input: StylableInput) => TextChunk;
+export declare const cyan: (input: StylableInput) => TextChunk;
+export declare const white: (input: StylableInput) => TextChunk;
+export declare const brightBlack: (input: StylableInput) => TextChunk;
+export declare const brightRed: (input: StylableInput) => TextChunk;
+export declare const brightGreen: (input: StylableInput) => TextChunk;
+export declare const brightYellow: (input: StylableInput) => TextChunk;
+export declare const brightBlue: (input: StylableInput) => TextChunk;
+export declare const brightMagenta: (input: StylableInput) => TextChunk;
+export declare const brightCyan: (input: StylableInput) => TextChunk;
+export declare const brightWhite: (input: StylableInput) => TextChunk;
+export declare const bgBlack: (input: StylableInput) => TextChunk;
+export declare const bgRed: (input: StylableInput) => TextChunk;
+export declare const bgGreen: (input: StylableInput) => TextChunk;
+export declare const bgYellow: (input: StylableInput) => TextChunk;
+export declare const bgBlue: (input: StylableInput) => TextChunk;
+export declare const bgMagenta: (input: StylableInput) => TextChunk;
+export declare const bgCyan: (input: StylableInput) => TextChunk;
+export declare const bgWhite: (input: StylableInput) => TextChunk;
+export declare const bold: (input: StylableInput) => TextChunk;
+export declare const italic: (input: StylableInput) => TextChunk;
+export declare const underline: (input: StylableInput) => TextChunk;
+export declare const strikethrough: (input: StylableInput) => TextChunk;
+export declare const dim: (input: StylableInput) => TextChunk;
+export declare const reverse: (input: StylableInput) => TextChunk;
+export declare const blink: (input: StylableInput) => TextChunk;
+export declare const fg: (color: Color) => (input: StylableInput) => TextChunk;
+export declare const bg: (color: Color) => (input: StylableInput) => TextChunk;
+export declare const link: (url: string) => (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 t(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;
+export {};

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

@@ -0,0 +1,32 @@
+/**
+ * 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
+ * - OSC 99 notification capability query response
+ * - iTerm2 OSC 1337 feature-reporting response
+ */
+/**
+ * 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/lib/terminal-palette.d.ts

@@ -0,0 +1,65 @@
+import { RGBA } from "./RGBA.js";
+import { type Clock } from "./clock.js";
+type Hex = string | null;
+export type WriteFunction = (data: string | Buffer) => boolean;
+export interface TerminalColors {
+    palette: Hex[];
+    defaultForeground: Hex;
+    defaultBackground: Hex;
+    cursorColor: Hex;
+    mouseForeground: Hex;
+    mouseBackground: Hex;
+    tekForeground: Hex;
+    tekBackground: Hex;
+    highlightBackground: Hex;
+    highlightForeground: Hex;
+}
+export interface GetPaletteOptions {
+    timeout?: number;
+    size?: number;
+}
+export interface TerminalPaletteDetector {
+    detect(options?: GetPaletteOptions): Promise<TerminalColors>;
+    detectOSCSupport(timeoutMs?: number): Promise<boolean>;
+    cleanup(): void;
+}
+export interface NormalizedTerminalPalette {
+    palette: RGBA[];
+    defaultForeground: RGBA;
+    defaultBackground: RGBA;
+}
+export type OscSubscriptionSource = {
+    subscribeOsc(handler: (sequence: string) => void): () => void;
+};
+export interface TerminalPaletteOptions {
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WriteStream;
+    writeFn?: WriteFunction;
+    isLegacyTmux?: boolean;
+    isTmux?: boolean;
+    oscSource?: OscSubscriptionSource;
+    clock?: Clock;
+}
+export declare class TerminalPalette implements TerminalPaletteDetector {
+    private stdin;
+    private stdout;
+    private writeFn;
+    private activeQuerySessions;
+    private inLegacyTmux;
+    private inTmux;
+    private oscSource?;
+    private readonly clock;
+    constructor(options: TerminalPaletteOptions);
+    private writeOsc;
+    cleanup(): void;
+    private subscribeInput;
+    private createQuerySession;
+    detectOSCSupport(timeoutMs?: number): Promise<boolean>;
+    private queryPalette;
+    private querySpecialColors;
+    detect(options?: GetPaletteOptions): Promise<TerminalColors>;
+}
+export declare function createTerminalPalette(options: TerminalPaletteOptions): TerminalPaletteDetector;
+export declare function normalizeTerminalPalette(colors?: TerminalColors | null): NormalizedTerminalPalette;
+export declare function buildTerminalPaletteSignature(colors?: TerminalColors | null): string;
+export {};

package/lib/tree-sitter/assets/update.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+export interface UpdateOptions {
+    /** Path to parsers-config.json */
+    configPath: string;
+    /** Directory where .wasm and .scm files will be downloaded */
+    assetsDir: string;
+    /** Path where the generated TypeScript file will be written */
+    outputPath: string;
+}
+declare function main(options?: Partial<UpdateOptions>): Promise<void>;
+export declare function runUpdateAssetsCli(): Promise<void>;
+export { main as updateAssets };

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

@@ -0,0 +1,65 @@
+import { EventEmitter } from "events";
+import type { TreeSitterClientOptions, TreeSitterClientEvents, BufferState, FiletypeParserOptions, Edit, PerformanceStats, SimpleHighlight } from "./types.js";
+declare global {
+    const OTUI_TREE_SITTER_WORKER_PATH: string;
+}
+interface TreeSitterClientInternalOptions {
+    autoStartWorker?: boolean;
+}
+export declare function addDefaultParsers(parsers: FiletypeParserOptions[]): void;
+export declare class TreeSitterClient extends EventEmitter<TreeSitterClientEvents> {
+    private initialized;
+    private worker;
+    private buffers;
+    private initializePromise;
+    private initializeResolvers;
+    private messageCallbacks;
+    private messageIdCounter;
+    private editQueues;
+    private debouncer;
+    private options;
+    private destroyCallbacks;
+    private lifecycleGeneration;
+    private rejectInitialization;
+    private destroyPromise;
+    private workerTerminationFailed;
+    constructor(options: TreeSitterClientOptions, internalOptions?: TreeSitterClientInternalOptions);
+    onDestroy(callback: () => void): () => void;
+    private emitError;
+    private emitWarning;
+    private startWorker;
+    private sendWorkerMessage;
+    private rejectPendingRequests;
+    private rejectActiveInitialization;
+    private handleWorkerFailure;
+    private resolveWorkerPath;
+    private stopWorker;
+    private handleReset;
+    initialize(): Promise<void>;
+    private assertCurrentInitialization;
+    private initializeClient;
+    private registerDefaultParsers;
+    private resolvePath;
+    addFiletypeParser(filetypeParser: FiletypeParserOptions): void;
+    private resolveFiletypeParser;
+    getPerformance(): Promise<PerformanceStats>;
+    highlightOnce(content: string, filetype: string): Promise<{
+        highlights?: SimpleHighlight[];
+        warning?: string;
+        error?: string;
+    }>;
+    private handleWorkerMessage;
+    preloadParser(filetype: string): Promise<boolean>;
+    createBuffer(id: number, content: string, filetype: string, version?: number, autoInitialize?: boolean): Promise<boolean>;
+    updateBuffer(id: number, edits: Edit[], newContent: string, version: number): Promise<void>;
+    private processEdit;
+    removeBuffer(bufferId: number): Promise<void>;
+    destroy(): Promise<void>;
+    resetBuffer(bufferId: number, version: number, content: string): Promise<void>;
+    getBuffer(bufferId: number): BufferState | undefined;
+    getAllBuffers(): BufferState[];
+    isInitialized(): boolean;
+    setDataPath(dataPath: string): Promise<void>;
+    clearCache(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import type { FiletypeParserOptions } from "./types.js";
+export declare function getParsers(): Promise<FiletypeParserOptions[]>;

package/lib/tree-sitter/download-utils.d.ts

@@ -0,0 +1,21 @@
+export interface DownloadResult {
+    content?: Buffer;
+    filePath?: string;
+    error?: string;
+}
+export declare class DownloadUtils {
+    private static hashUrl;
+    /**
+     * Download a file from URL or load from local path, with caching support
+     */
+    static downloadOrLoad(source: string, cacheDir: string, cacheSubdir: string, fileExtension: string, useHashForCache?: boolean, filetype?: string): Promise<DownloadResult>;
+    /**
+     * Download and save a file to a specific target path
+     */
+    static downloadToPath(source: string, targetPath: string): Promise<DownloadResult>;
+    /**
+     * Fetch multiple highlight queries and concatenate them
+     */
+    static fetchHighlightQueries(sources: string[], cacheDir: string, filetype: string): Promise<string>;
+    private static fetchHighlightQuery;
+}

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

@@ -0,0 +1,7 @@
+import { TreeSitterClient } from "./client.js";
+export * from "./client.js";
+export * from "../tree-sitter-styled-text.js";
+export * from "./types.js";
+export * from "./resolve-ft.js";
+export declare function getTreeSitterClient(): TreeSitterClient;
+export declare function destroyTreeSitterClient(): Promise<void>;

package/lib/tree-sitter/parser.worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,53 @@
+/**
+ * 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;
+        aliases: 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;
+                jsx: string;
+                javascriptreact: string;
+                typescript: string;
+                ts: string;
+                tsx: string;
+                typescriptreact: string;
+                markdown: string;
+                md: string;
+            };
+        };
+        aliases?: undefined;
+    } | {
+        filetype: string;
+        wasm: string;
+        queries: {
+            highlights: string[];
+            injections?: undefined;
+        };
+        aliases?: undefined;
+        injectionMapping?: undefined;
+    })[];
+};
+export default _default;

package/lib/tree-sitter/resolve-ft.d.ts

@@ -0,0 +1,5 @@
+export declare const extensionToFiletype: Map<string, string>;
+export declare const basenameToFiletype: Map<string, string>;
+export declare function extToFiletype(extension: string): string | undefined;
+export declare function pathToFiletype(path: string): string | undefined;
+export declare function infoStringToFiletype(infoString: string): string | undefined;

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

@@ -0,0 +1,185 @@
+export interface HighlightRange {
+    startCol: number;
+    endCol: number;
+    group: string;
+}
+export interface HighlightResponse {
+    line: number;
+    highlights: HighlightRange[];
+    droppedHighlights: HighlightRange[];
+}
+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;
+    aliases?: string[];
+    queries: {
+        highlights: string[];
+        injections?: string[];
+    };
+    wasm: string;
+    injectionMapping?: InjectionMapping;
+}
+export interface BufferState {
+    id: number;
+    version: number;
+    content: string;
+    filetype: string;
+    hasParser: boolean;
+}
+export interface ParsedBuffer extends BufferState {
+    hasParser: true;
+}
+export type TreeSitterWorkerLogType = "log" | "error" | "warn";
+export type TreeSitterWorkerRequest = {
+    type: "INIT";
+    dataPath: string;
+} | {
+    type: "ADD_FILETYPE_PARSER";
+    filetypeParser: FiletypeParserOptions;
+} | {
+    type: "PRELOAD_PARSER";
+    filetype: string;
+    messageId: string;
+} | {
+    type: "INITIALIZE_PARSER";
+    bufferId: number;
+    version: number;
+    content: string;
+    filetype: string;
+    messageId: string;
+} | {
+    type: "HANDLE_EDITS";
+    bufferId: number;
+    version: number;
+    content: string;
+    edits: Edit[];
+} | {
+    type: "GET_PERFORMANCE";
+    messageId: string;
+} | {
+    type: "RESET_BUFFER";
+    bufferId: number;
+    version: number;
+    content: string;
+    edits: Edit[];
+} | {
+    type: "DISPOSE_BUFFER";
+    bufferId: number;
+} | {
+    type: "ONESHOT_HIGHLIGHT";
+    content: string;
+    filetype: string;
+    messageId: string;
+} | {
+    type: "UPDATE_DATA_PATH";
+    dataPath: string;
+    messageId: string;
+} | {
+    type: "CLEAR_CACHE";
+    messageId: string;
+};
+export type TreeSitterWorkerResponse = {
+    type: "INIT_RESPONSE";
+    error?: string;
+} | {
+    type: "PARSER_INIT_RESPONSE";
+    bufferId: number;
+    messageId: string;
+    hasParser: boolean;
+    warning?: string;
+    error?: string;
+} | {
+    type: "HIGHLIGHT_RESPONSE";
+    bufferId: number;
+    version: number;
+    highlights: HighlightResponse[];
+} | {
+    type: "PRELOAD_PARSER_RESPONSE";
+    messageId: string;
+    hasParser: boolean;
+} | {
+    type: "BUFFER_DISPOSED";
+    bufferId: number;
+} | {
+    type: "PERFORMANCE_RESPONSE";
+    performance: PerformanceStats;
+    messageId: string;
+} | {
+    type: "ONESHOT_HIGHLIGHT_RESPONSE";
+    messageId: string;
+    hasParser: boolean;
+    highlights?: SimpleHighlight[];
+    warning?: string;
+    error?: string;
+} | {
+    type: "UPDATE_DATA_PATH_RESPONSE";
+    messageId: string;
+    error?: string;
+} | {
+    type: "CLEAR_CACHE_RESPONSE";
+    messageId: string;
+    error?: string;
+} | {
+    type: "WARNING";
+    bufferId?: number;
+    warning: string;
+} | {
+    type: "ERROR";
+    bufferId?: number;
+    error: string;
+} | {
+    type: "WORKER_LOG";
+    logType: TreeSitterWorkerLogType;
+    data: unknown[];
+};
+export interface TreeSitterClientEvents {
+    "highlights:response": [bufferId: number, version: number, highlights: HighlightResponse[]];
+    "buffer:initialized": [bufferId: number, hasParser: boolean];
+    "buffer:disposed": [bufferId: number];
+    "worker:log": [logType: TreeSitterWorkerLogType, message: string];
+    error: [error: string, bufferId?: number];
+    warning: [warning: string, bufferId?: number];
+}
+export interface TreeSitterClientOptions {
+    dataPath: string;
+    workerPath?: string | URL;
+    initTimeout?: number;
+}
+export interface Edit {
+    startIndex: number;
+    oldEndIndex: number;
+    newEndIndex: number;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    oldEndPosition: {
+        row: number;
+        column: number;
+    };
+    newEndPosition: {
+        row: number;
+        column: number;
+    };
+}
+export interface PerformanceStats {
+    averageParseTime: number;
+    parseTimes: number[];
+    averageQueryTime: number;
+    queryTimes: number[];
+}

package/lib/tree-sitter/update-assets.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export { runUpdateAssetsCli, updateAssets } from "./assets/update.js";
+export type { UpdateOptions } from "./assets/update.js";