@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/cli/headless-renderer.d.ts

@@ -0,0 +1,29 @@
+export type HeadlessNode = HeadlessElement | HeadlessText | HeadlessComment;
+export interface HeadlessRoot {
+    children: HeadlessNode[];
+}
+export interface HeadlessElement {
+    type: string;
+    parent: HeadlessElement | HeadlessRoot | null;
+    children: HeadlessNode[];
+    props: Record<string, unknown>;
+    style: Record<string, unknown>;
+    className?: string;
+    textContent?: string;
+    setAttribute?: (key: string, value: string) => void;
+    removeAttribute?: (key: string) => void;
+}
+export interface HeadlessText {
+    type: "text";
+    parent: HeadlessElement | HeadlessRoot | null;
+    text: string;
+}
+export interface HeadlessComment {
+    type: "comment";
+    parent: HeadlessElement | HeadlessRoot | null;
+    text: string;
+}
+declare const renderer: import("vue").Renderer<HeadlessElement | HeadlessRoot>;
+export declare function createHeadlessApp(...args: Parameters<typeof renderer.createApp>): import("vue").App<HeadlessElement | HeadlessRoot>;
+export declare function createHeadlessRoot(): HeadlessRoot;
+export {};

package/dist/cli/input.d.ts

@@ -0,0 +1,49 @@
+import type { TerminalEventRecord } from "../events/recording.js";
+type Stdin = NodeJS.ReadStream;
+type KeyboardProtocol = "auto" | "kitty" | "xterm" | "off";
+export type StdinDriver = Readonly<{
+    dispose: () => void;
+}>;
+type CleanupSignal = "SIGINT" | "SIGTERM" | "SIGHUP" | "SIGBREAK";
+export type TerminalCleanupSignalPolicy = "cleanup-only" | "exit" | "reraise";
+export type TerminalCleanupOptions = Readonly<{
+    signals?: readonly CleanupSignal[];
+    /**
+     * Defaults to "reraise": cleanup runs, vue-tui removes its own listener,
+     * then the signal is sent again when no other listener owns the signal.
+     */
+    signalPolicy?: TerminalCleanupSignalPolicy;
+    cleanupOnUnhandledRejection?: boolean;
+    rethrowUnhandledRejection?: boolean;
+}>;
+export type TerminalCleanupHandle = Readonly<{
+    cleanup: () => void;
+    uninstall: () => void;
+}>;
+export declare function resolveCleanupSignalAction(signal: CleanupSignal, policy: TerminalCleanupSignalPolicy): {
+    type: "none";
+} | {
+    type: "exit";
+    code: number;
+} | {
+    type: "reraise";
+    signal: CleanupSignal;
+};
+export declare function installTerminalCleanup(dispose: () => void, options?: TerminalCleanupOptions): TerminalCleanupHandle;
+export declare function createStdinDriver(options: Readonly<{
+    dispatch: (event: TerminalEventRecord) => boolean | void;
+    stdin?: Stdin;
+    stdout?: NodeJS.WriteStream;
+    env?: Readonly<Record<string, unknown>>;
+    enableMouse?: boolean;
+    keyboardProtocol?: KeyboardProtocol;
+    /**
+     * Enable "any-motion" mouse tracking (xterm DECSET ?1003).
+     * This is required for hover interactions in the CLI, but can increase event volume.
+     */
+    enableMouseMotion?: boolean;
+    onTerminalFocusChange?: (focused: boolean) => void;
+    onExit?: () => void;
+    autoCleanup?: boolean | TerminalCleanupOptions;
+}>): StdinDriver;
+export {};

package/dist/cli/node-file-writers.d.ts

@@ -0,0 +1,13 @@
+import { appendFileSync } from "node:fs";
+export declare const nodeProfilerFileWriter: {
+    appendFileSync: typeof appendFileSync;
+};
+export declare function defaultVueTuiProfileLogPath(): string;
+export declare function defaultVueTuiFramePerfLogPath(): string;
+export declare function defaultVueTuiDebugLogPath(): string;
+export declare function defaultVueTuiMouseDebugLogPath(): string;
+export declare function shouldInstallFileWriters(env: Readonly<Record<string, unknown>> | undefined): boolean;
+export declare function installNodeFileWriters(options?: Readonly<{
+    force?: boolean;
+}>): void;
+export declare function resetNodeFileWriters(): void;

package/dist/cli/node-module.d.ts

@@ -0,0 +1,2 @@
+export declare function isNodeRuntime(): boolean;
+export declare function importNodeModule<T>(specifier: string): Promise<T | null>;

package/dist/cli/parse-kitty.d.ts

@@ -0,0 +1,2 @@
+import type { ParseResult } from "./parse-utils.js";
+export declare function parseKittySequence(sequence: string): ParseResult;

package/dist/cli/parse-mouse.d.ts

@@ -0,0 +1,2 @@
+import type { ParseResult } from "./parse-utils.js";
+export declare function parseMouseSequence(sequence: string): ParseResult;

package/dist/cli/parse-utils.d.ts

@@ -0,0 +1,14 @@
+import type { TerminalEventRecord } from "../events/recording.js";
+export type KeyMods = Partial<{
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+}>;
+export interface ParseResult {
+    event: TerminalEventRecord | null;
+    handled: boolean;
+}
+export declare function keyEvent(key: string, code?: string, mods?: KeyMods, repeat?: boolean): TerminalEventRecord;
+export declare function modsFromXtermModifier(mod: number | null | undefined): KeyMods | null;
+export declare function modsFromKittyModifier(mod: number | null | undefined): KeyMods | null;

package/dist/cli/parse-xterm.d.ts

@@ -0,0 +1,2 @@
+import type { ParseResult } from "./parse-utils.js";
+export declare function parseXtermSequence(sequence: string): ParseResult;

package/dist/cli/path-provider-types.d.ts

@@ -0,0 +1 @@
+export type { FsDirEntry, FsEntryKind, FsStat, PathPickerProvider, } from "../core/path-provider-types.js";

package/dist/cli/path-provider.d.ts

@@ -0,0 +1,4 @@
+import type { PathPickerProvider } from "../core/path-provider-types.js";
+export type { FsDirEntry, FsEntryKind, FsStat, PathPickerProvider, } from "../core/path-provider-types.js";
+export declare function createNodePathPickerProvider(): PathPickerProvider;
+export declare function absPathFromEntry(absDir: string, entryName: string): string;

package/dist/cli/path-suggest-core.d.ts

@@ -0,0 +1 @@
+export { parsePathQuery, resolveUserPath, suggestParentHint, suggestPaths, type PathPickMode, type PathSuggestion, type SuggestPathsResult, } from "../core/path-suggest.js";

package/dist/cli/path-suggest.d.ts

@@ -0,0 +1,15 @@
+import type { FsDirEntry } from "../core/path-provider-types.js";
+import type { PathPickMode, SuggestPathsResult } from "../core/path-suggest.js";
+export type { PathPickMode, PathSuggestion, SuggestPathsResult } from "../core/path-suggest.js";
+export { parsePathQuery, suggestParentHint } from "../core/path-suggest.js";
+export declare function suggestPaths(options: Readonly<{
+    workspaceAbs: string;
+    input: string;
+    mode: PathPickMode;
+    max: number;
+    showHidden?: boolean;
+    listDir: (absDir: string) => Promise<FsDirEntry[]>;
+    maxDepth?: number;
+    gitignore?: "blocking" | "nonBlocking";
+}>): Promise<SuggestPathsResult>;
+export declare function resolveUserPath(workspaceAbs: string, input: string): string;

package/dist/cli/recording.d.ts

@@ -0,0 +1,4 @@
+import type { TerminalEventRecord } from "../events/recording.js";
+export declare function writeEventLog(path: string, events: readonly TerminalEventRecord[]): Promise<void>;
+export declare function writeSnapshot(path: string, lines: readonly string[]): Promise<void>;
+export declare function readEventLog(path: string): Promise<TerminalEventRecord[]>;

package/dist/cli/stdin-buffer.d.ts

@@ -0,0 +1,33 @@
+import { Buffer } from "node:buffer";
+import { EventEmitter } from "node:events";
+export interface StdinBufferOptions {
+    timeout?: number;
+    /**
+     * Flush timeout used specifically when the buffer contains only a lone ESC.
+     *
+     * Terminals send many escape sequences (CSI/OSC/SGR mouse) that start with ESC,
+     * but stream chunking can split the leading ESC from the rest of the sequence.
+     * Using a slightly longer timeout for a lone ESC reduces cases where ESC is
+     * emitted as a standalone key and the remaining bytes leak as literal input.
+     */
+    escTimeout?: number;
+}
+export interface StdinBufferEventMap {
+    data: [string];
+    paste: [string];
+}
+export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
+    private buffer;
+    private timeout;
+    private readonly timeoutMs;
+    private readonly escTimeoutMs;
+    private pendingEscContinuationAt;
+    private pasteMode;
+    private pasteBuffer;
+    constructor(options?: StdinBufferOptions);
+    process(data: string | Buffer): void;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}