@visulima/tui 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/testing/index.d.ts

@@ -1,144 +1,287 @@
-import type { ReactElement } from "react";
-import type { RenderOptions } from "../ink/render.d.ts";
-import type { KeySender } from "./keys.d.ts";
-import { createKeySender, KEY } from "./keys.d.ts";
-import type { Screen } from "./screen.d.ts";
-import { createScreen } from "./screen.d.ts";
-import type { WaitForOptions } from "./wait-for.d.ts";
-import { waitFor } from "./wait-for.d.ts";
-export type TestInstanceStdout = {
-    /**
-     * All rendered frames captured from stdout.
-     */
-    readonly frames: ReadonlyArray<string>;
-    /**
-     * Returns the most recently rendered frame, or `undefined` if no frames have been written.
-     */
-    lastFrame: () => string | undefined;
-    /**
-     * Write data to the mock stdout stream (used internally by the renderer).
-     */
-    write: (frame: string) => boolean;
+import { ReactElement } from 'react';
+import { R as RenderOptions } from "../packem_shared/render.d-DuyG0zip.js";
+import "../packem_shared/dom.d-C1IxuLJ9.js";
+import 'yoga-layout';
+import "../packem_shared/cursor-helpers.d-BONB9tky.js";
+import '@visulima/colorize';
+import 'cli-boxes';
+import "../packem_shared/styles.d-cMo36xQz.js";
+import 'type-fest';
+import 'node:stream';
+declare const KEY: {
+  readonly backspace: "";
+  readonly ctrlC: "";
+  readonly delete: "\x1B[3~";
+  readonly down: "\x1B[B";
+  readonly end: "\x1B[F";
+  readonly escape: "\x1B";
+  readonly home: "\x1B[H";
+  readonly left: "\x1B[D";
+  readonly pageDown: "\x1B[6~";
+  readonly pageUp: "\x1B[5~";
+  readonly return: "\r";
+  readonly right: "\x1B[C";
+  readonly space: " ";
+  readonly tab: "	";
+  readonly up: "\x1B[A";
 };
-export type TestInstanceStderr = {
-    /**
-     * All rendered frames captured from stderr.
-     */
-    readonly frames: ReadonlyArray<string>;
-    /**
-     * Returns the most recently rendered frame, or `undefined` if no frames have been written.
-     */
-    lastFrame: () => string | undefined;
-    /**
-     * Write data to the mock stderr stream (used internally by the renderer).
-     */
-    write: (frame: string) => boolean;
+type KeyName = keyof typeof KEY;
+interface KeySender {
+  /**
+  * Simulate pressing the backspace key.
+  */
+  backspace: () => void;
+  /**
+  * Simulate pressing the delete key.
+  */
+  delete: () => void;
+  /**
+  * Simulate pressing the down arrow key.
+  */
+  down: () => void;
+  /**
+  * Simulate pressing the end key.
+  */
+  end: () => void;
+  /**
+  * Simulate pressing the enter/return key.
+  */
+  enter: () => void;
+  /**
+  * Simulate pressing the escape key.
+  */
+  escape: () => void;
+  /**
+  * Simulate pressing the home key.
+  */
+  home: () => void;
+  /**
+  * Simulate pressing the left arrow key.
+  */
+  left: () => void;
+  /**
+  * Simulate pressing the page down key.
+  */
+  pageDown: () => void;
+  /**
+  * Simulate pressing the page up key.
+  */
+  pageUp: () => void;
+  /**
+  * Send a single character as a key press.
+  */
+  press: (char: string) => void;
+  /**
+  * Send arbitrary raw data to stdin.
+  */
+  raw: (data: string) => void;
+  /**
+  * Simulate pressing the right arrow key.
+  */
+  right: () => void;
+  /**
+  * Simulate pressing the space key.
+  */
+  space: () => void;
+  /**
+  * Simulate pressing the tab key.
+  */
+  tab: () => void;
+  /**
+  * Type a string character by character.
+  */
+  type: (text: string) => void;
+  /**
+  * Simulate pressing the up arrow key.
+  */
+  up: () => void;
+}
+declare const createKeySender: (write: (data: string) => void) => KeySender;
+interface Screen {
+  /**
+  * Check if the current screen output contains the given text (ANSI-stripped).
+  */
+  contains: (text: string) => boolean;
+  /**
+  * Get all captured frames with ANSI codes stripped.
+  */
+  frames: () => string[];
+  /**
+  * Get a specific line by zero-based index from the current screen output.
+  */
+  line: (n: number) => string;
+  /**
+  * Get all non-empty lines from the current screen output.
+  */
+  lines: () => string[];
+  /**
+  * Check if the current screen output matches the given pattern (ANSI-stripped).
+  */
+  matches: (pattern: RegExp) => boolean;
+  /**
+  * Get all captured frames with ANSI codes preserved.
+  */
+  rawFrames: () => string[];
+  /**
+  * Get the last rendered frame with ANSI codes preserved.
+  */
+  rawText: () => string;
+  /**
+  * Get the last rendered frame with ANSI codes stripped.
+  */
+  text: () => string;
+}
+declare const createScreen: (lastFrame: () => string | undefined, allFrames: ReadonlyArray<string>) => Screen;
+interface WaitForOptions {
+  /**
+  * Polling interval in milliseconds.
+  * @default 50
+  */
+  interval?: number;
+  /**
+  * Maximum time to wait in milliseconds before throwing.
+  * @default 3000
+  */
+  timeout?: number;
+}
+/**
+* Wait for a condition to be met by polling at a regular interval.
+*
+* If `condition` is a string, waits until `screenText()` contains it.
+* If `condition` is a function, waits until it stops throwing.
+* @throws The last error encountered if the timeout is reached.
+*/
+declare const waitFor: (condition: (() => void) | string, screenText: () => string, options?: WaitForOptions) => Promise<void>;
+type TestInstanceStdout = {
+  /**
+  * All rendered frames captured from stdout.
+  */
+  readonly frames: ReadonlyArray<string>;
+  /**
+  * Returns the most recently rendered frame, or `undefined` if no frames have been written.
+  */
+  lastFrame: () => string | undefined;
+  /**
+  * Write data to the mock stdout stream (used internally by the renderer).
+  */
+  write: (frame: string) => boolean;
+};
+type TestInstanceStderr = {
+  /**
+  * All rendered frames captured from stderr.
+  */
+  readonly frames: ReadonlyArray<string>;
+  /**
+  * Returns the most recently rendered frame, or `undefined` if no frames have been written.
+  */
+  lastFrame: () => string | undefined;
+  /**
+  * Write data to the mock stderr stream (used internally by the renderer).
+  */
+  write: (frame: string) => boolean;
 };
-export type TestInstanceStdin = {
-    /**
-     * Whether the stdin is a TTY.
-     */
-    readonly isTTY: boolean;
-    /**
-     * Simulate user input by writing data to stdin.
-     */
-    write: (data: string) => boolean;
+type TestInstanceStdin = {
+  /**
+  * Whether the stdin is a TTY.
+  */
+  readonly isTTY: boolean;
+  /**
+  * Simulate user input by writing data to stdin.
+  */
+  write: (data: string) => boolean;
 };
-export type TestInstance = {
-    /**
-     * Unmount the app and clean up resources.
-     */
-    cleanup: () => void;
-    /**
-     * Wait for pending React renders to flush (two microtick delay).
-     */
-    flush: () => Promise<void>;
-    /**
-     * All rendered frames captured from stdout (shorthand for `stdout.frames`).
-     */
-    readonly frames: ReadonlyArray<string>;
-    /**
-     * Keyboard input helpers for simulating key presses.
-     */
-    keys: KeySender;
-    /**
-     * Returns the most recently rendered frame from stdout (shorthand for `stdout.lastFrame()`).
-     */
-    lastFrame: () => string | undefined;
-    /**
-     * Replace the previous root node with a new one or update props.
-     */
-    rerender: (node: ReactElement) => void;
-    /**
-     * Screen query helpers for inspecting rendered output with ANSI stripping.
-     */
-    screen: Screen;
-    /**
-     * Mock stderr stream with frame capture.
-     */
-    stderr: TestInstanceStderr;
-    /**
-     * Mock stdin stream for simulating user input.
-     */
-    stdin: TestInstanceStdin;
-    /**
-     * Mock stdout stream with frame capture.
-     */
-    stdout: TestInstanceStdout;
-    /**
-     * Manually unmount the whole app.
-     */
-    unmount: () => void;
-    /**
-     * Wait for a condition to be met by polling.
-     *
-     * If `condition` is a string, waits until the screen contains it.
-     * If `condition` is a function, waits until it stops throwing.
-     */
-    waitFor: (condition: (() => void) | string, options?: WaitForOptions) => Promise<void>;
+type TestInstance = {
+  /**
+  * Unmount the app and clean up resources.
+  */
+  cleanup: () => void;
+  /**
+  * Wait for pending React renders to flush (two microtick delay).
+  */
+  flush: () => Promise<void>;
+  /**
+  * All rendered frames captured from stdout (shorthand for `stdout.frames`).
+  */
+  readonly frames: ReadonlyArray<string>;
+  /**
+  * Keyboard input helpers for simulating key presses.
+  */
+  keys: KeySender;
+  /**
+  * Returns the most recently rendered frame from stdout (shorthand for `stdout.lastFrame()`).
+  */
+  lastFrame: () => string | undefined;
+  /**
+  * Replace the previous root node with a new one or update props.
+  */
+  rerender: (node: ReactElement) => void;
+  /**
+  * Screen query helpers for inspecting rendered output with ANSI stripping.
+  */
+  screen: Screen;
+  /**
+  * Mock stderr stream with frame capture.
+  */
+  stderr: TestInstanceStderr;
+  /**
+  * Mock stdin stream for simulating user input.
+  */
+  stdin: TestInstanceStdin;
+  /**
+  * Mock stdout stream with frame capture.
+  */
+  stdout: TestInstanceStdout;
+  /**
+  * Manually unmount the whole app.
+  */
+  unmount: () => void;
+  /**
+  * Wait for a condition to be met by polling.
+  *
+  * If `condition` is a string, waits until the screen contains it.
+  * If `condition` is a function, waits until it stops throwing.
+  */
+  waitFor: (condition: (() => void) | string, options?: WaitForOptions) => Promise<void>;
 };
-export type TestRenderOptions = {
-    /**
-     * Terminal column width for the mock stdout/stderr streams.
-     * @default 100
-     */
-    columns?: number;
-    /**
-     * Additional render options passed through to the underlying render function.
-     */
-    options?: Omit<RenderOptions, "debug" | "exitOnCtrlC" | "patchConsole" | "stderr" | "stdin" | "stdout">;
+type TestRenderOptions = {
+  /**
+  * Terminal column width for the mock stdout/stderr streams.
+  * @default 100
+  */
+  columns?: number;
+  /**
+  * Additional render options passed through to the underlying render function.
+  */
+  options?: Omit<RenderOptions, "debug" | "exitOnCtrlC" | "patchConsole" | "stderr" | "stdin" | "stdout">;
 };
 /**
- * Render a React element for testing, capturing output in mock streams.
- *
- * Returns an object with methods to inspect rendered output, simulate input,
- * and control the component lifecycle.
- * @example
- * ```tsx
- * import { render } from "@visulima/tui/test";
- * import { Text } from "@visulima/tui";
- *
- * const { lastFrame } = render(<Text>Hello</Text>);
- * console.log(lastFrame()); // "Hello"
- * ```
- */
+* Render a React element for testing, capturing output in mock streams.
+*
+* Returns an object with methods to inspect rendered output, simulate input,
+* and control the component lifecycle.
+* @example
+* ```tsx
+* import { render } from "@visulima/tui/test";
+* import { Text } from "@visulima/tui";
+*
+* const { lastFrame } = render(<Text>Hello</Text>);
+* console.log(lastFrame()); // "Hello"
+* ```
+*/
 declare const testRender: (node: ReactElement, testOptions?: TestRenderOptions) => TestInstance;
 /**
- * Unmount and clean up all rendered test instances.
- *
- * Call this in your test teardown (e.g., `afterEach`) to ensure
- * no test instances leak between tests.
- * @example
- * ```ts
- * import { cleanup } from "@visulima/tui/test";
- *
- * afterEach(() => {
- *     cleanup();
- * });
- * ```
- */
+* Unmount and clean up all rendered test instances.
+*
+* Call this in your test teardown (e.g., `afterEach`) to ensure
+* no test instances leak between tests.
+* @example
+* ```ts
+* import { cleanup } from "@visulima/tui/test";
+*
+* afterEach(() => {
+*     cleanup();
+* });
+* ```
+*/
 declare const cleanup: () => void;
-export { cleanup, createKeySender, createScreen, KEY, testRender as render, waitFor };
-export type { KeyName, KeySender } from "./keys.d.ts";
-export type { Screen } from "./screen.d.ts";
-export type { WaitForOptions } from "./wait-for.d.ts";
+export { KEY, type KeyName, type KeySender, type Screen, TestInstance, TestInstanceStderr, TestInstanceStdin, TestInstanceStdout, TestRenderOptions, type WaitForOptions, cleanup, createKeySender, createScreen, testRender as render, waitFor };

package/dist/testing/index.js

@@ -1,260 +1 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-const EventEmitter = __cjs_getBuiltinModule("node:events");
-import render from '../packem_shared/render-BAwdjfki.js';
-import { strip } from '@visulima/ansi';
-
-const KEY = {
-  backspace: "",
-  ctrlC: "",
-  delete: "\x1B[3~",
-  down: "\x1B[B",
-  end: "\x1B[F",
-  escape: "\x1B",
-  home: "\x1B[H",
-  left: "\x1B[D",
-  pageDown: "\x1B[6~",
-  pageUp: "\x1B[5~",
-  return: "\r",
-  right: "\x1B[C",
-  space: " ",
-  tab: "	",
-  up: "\x1B[A"
-};
-const createKeySender = (write) => ({
-  backspace: () => write(KEY.backspace),
-  delete: () => write(KEY.delete),
-  down: () => write(KEY.down),
-  end: () => write(KEY.end),
-  enter: () => write(KEY.return),
-  escape: () => write(KEY.escape),
-  home: () => write(KEY.home),
-  left: () => write(KEY.left),
-  pageDown: () => write(KEY.pageDown),
-  pageUp: () => write(KEY.pageUp),
-  press(char) {
-    write(char);
-  },
-  raw: write,
-  right: () => write(KEY.right),
-  space: () => write(KEY.space),
-  tab: () => write(KEY.tab),
-  type(text) {
-    for (const char of text) {
-      write(char);
-    }
-  },
-  up: () => write(KEY.up)
-});
-
-const createScreen = (lastFrame, allFrames) => {
-  const clean = (s) => s ? strip(s) : "";
-  return {
-    contains(text) {
-      return this.text().includes(text);
-    },
-    frames() {
-      return allFrames.map((f) => strip(f));
-    },
-    line(n) {
-      return this.text().split("\n")[n] ?? "";
-    },
-    lines() {
-      return this.text().split("\n").filter((l) => l.trim() !== "");
-    },
-    matches(pattern) {
-      return pattern.test(this.text());
-    },
-    rawFrames() {
-      return [...allFrames];
-    },
-    rawText() {
-      return lastFrame() ?? "";
-    },
-    text() {
-      return clean(lastFrame());
-    }
-  };
-};
-
-const waitFor = async (condition, screenText, options = {}) => {
-  const timeout = options.timeout ?? 3e3;
-  const interval = options.interval ?? 50;
-  const start = Date.now();
-  let lastError;
-  const check = () => {
-    if (typeof condition === "string") {
-      const current = screenText();
-      if (!current.includes(condition)) {
-        throw new Error(`Timed out waiting for text: "${condition}"
-
-Screen content:
-${current}`);
-      }
-    } else {
-      condition();
-    }
-  };
-  while (Date.now() - start < timeout) {
-    try {
-      check();
-      return;
-    } catch (error) {
-      lastError = error;
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, interval);
-    });
-  }
-  try {
-    check();
-    return;
-  } catch (error) {
-    lastError = error;
-  }
-  throw lastError ?? new Error("waitFor timed out");
-};
-
-class Stdout extends EventEmitter {
-  columns;
-  _lastFrame;
-  _frames = [];
-  constructor(columns = 100) {
-    super();
-    this.columns = columns;
-  }
-  get frames() {
-    return this._frames;
-  }
-  lastFrame() {
-    return this._lastFrame;
-  }
-  write = (frame) => {
-    this._frames.push(frame);
-    this._lastFrame = frame;
-    return true;
-  };
-}
-class Stderr extends EventEmitter {
-  columns;
-  _lastFrame;
-  _frames = [];
-  constructor(columns = 100) {
-    super();
-    this.columns = columns;
-  }
-  get frames() {
-    return this._frames;
-  }
-  lastFrame() {
-    return this._lastFrame;
-  }
-  write = (frame) => {
-    this._frames.push(frame);
-    this._lastFrame = frame;
-    return true;
-  };
-}
-class Stdin extends EventEmitter {
-  isTTY = true;
-  pendingData;
-  write = (data) => {
-    this.pendingData = data;
-    this.emit("readable");
-    this.emit("data", data);
-    return true;
-  };
-  read() {
-    const { pendingData } = this;
-    this.pendingData = void 0;
-    return pendingData;
-  }
-  setEncoding() {
-    return this;
-  }
-  setRawMode() {
-    return this;
-  }
-  resume() {
-    return this;
-  }
-  pause() {
-    return this;
-  }
-  ref() {
-    return this;
-  }
-  unref() {
-    return this;
-  }
-}
-const instances = [];
-const testRender = (node, testOptions = {}) => {
-  const { columns, options: renderOptions } = testOptions;
-  const stdout = new Stdout(columns);
-  const stderr = new Stderr(columns);
-  const stdin = new Stdin();
-  const instance = render(node, {
-    debug: true,
-    exitOnCtrlC: false,
-    patchConsole: false,
-    stderr,
-    stdin,
-    stdout,
-    ...renderOptions
-  });
-  instances.push(instance);
-  const screen = createScreen(() => stdout.lastFrame(), stdout.frames);
-  const keys = createKeySender((data) => stdin.write(data));
-  const flush = async () => {
-    await new Promise((resolve) => {
-      setTimeout(resolve, 0);
-    });
-    await new Promise((resolve) => {
-      setTimeout(resolve, 0);
-    });
-  };
-  return {
-    cleanup: instance.cleanup,
-    flush,
-    get frames() {
-      return stdout.frames;
-    },
-    keys,
-    lastFrame: () => stdout.lastFrame(),
-    rerender: instance.rerender,
-    screen,
-    stderr,
-    stdin,
-    stdout,
-    unmount: instance.unmount,
-    async waitFor(condition, options) {
-      await waitFor(condition, () => screen.text(), options);
-    }
-  };
-};
-const cleanup = () => {
-  for (const instance of instances) {
-    instance.cleanup();
-  }
-  instances.length = 0;
-};
-
-export { KEY, cleanup, createKeySender, createScreen, testRender as render, waitFor };
+var w=Object.defineProperty;var a=(t,e)=>w(t,"name",{value:e,configurable:!0});import{createRequire as F}from"node:module";import x from"../packem_shared/render-BFio00DS.js";import{createKeySender as y}from"../packem_shared/KEY-Bk8B-3h_.js";import{KEY as $}from"../packem_shared/KEY-Bk8B-3h_.js";import{createScreen as T}from"../packem_shared/createScreen-CrLrxA6t.js";import{waitFor as j}from"../packem_shared/waitFor-Dj5zfL5s.js";const b=F(import.meta.url),o=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,v=a(t=>{if(typeof o<"u"&&o.versions&&o.versions.node){const[e,i]=o.versions.node.split(".").map(Number);if(e>22||e===22&&i>=3||e===20&&i>=16)return o.getBuiltinModule(t)}return b(t)},"__cjs_getBuiltinModule"),l=v("node:events");var R=Object.defineProperty,r=a((t,e)=>R(t,"name",{value:e,configurable:!0}),"t");class S extends l{static{a(this,"v")}static{r(this,"Stdout")}columns;_lastFrame;_frames=[];constructor(e=100){super(),this.columns=e}get frames(){return this._frames}lastFrame(){return this._lastFrame}write=r(e=>(this._frames.push(e),this._lastFrame=e,!0),"write")}class D extends l{static{a(this,"x")}static{r(this,"Stderr")}columns;_lastFrame;_frames=[];constructor(e=100){super(),this.columns=e}get frames(){return this._frames}lastFrame(){return this._lastFrame}write=r(e=>(this._frames.push(e),this._lastFrame=e,!0),"write")}class P extends l{static{a(this,"R")}static{r(this,"Stdin")}isTTY=!0;pendingData;write=r(e=>(this.pendingData=e,this.emit("readable"),this.emit("data",e),!0),"write");read(){const{pendingData:e}=this;return this.pendingData=void 0,e}setEncoding(){return this}setRawMode(){return this}resume(){return this}pause(){return this}ref(){return this}unref(){return this}}const c=[],O=r((t,e={})=>{const{columns:i,options:p}=e,n=new S(i),d=new D(i),m=new P,u=x(t,{debug:!0,exitOnCtrlC:!1,patchConsole:!1,stderr:d,stdin:m,stdout:n,...p});c.push(u);const f=T(()=>n.lastFrame(),n.frames),h=y(s=>m.write(s)),_=r(async()=>{await new Promise(s=>{setTimeout(s,0)}),await new Promise(s=>{setTimeout(s,0)})},"flush");return{cleanup:u.cleanup,flush:_,get frames(){return n.frames},keys:h,lastFrame:r(()=>n.lastFrame(),"lastFrame"),rerender:u.rerender,screen:f,stderr:d,stdin:m,stdout:n,unmount:u.unmount,async waitFor(s,g){await j(s,()=>f.text(),g)}}},"testRender"),Y=r(()=>{for(const t of c)t.cleanup();c.length=0},"cleanup");export{$ as KEY,Y as cleanup,y as createKeySender,T as createScreen,O as render,j as waitFor};