@alchemy.run/sigil 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/index.d.ts

@@ -1,88 +1,8 @@
 import { n as ForegroundColorName } from "./sgr-CMfEpjSk.js";
 import { i as Node } from "./index-DDVME65c.js";
 import { Writable } from "node:stream";
-import { ReactNode, RefObject } from "react";
+import { PropsWithChildren, ReactNode, Ref, RefObject } from "react";
 import { EventEmitter } from "node:events";
-//#region src/components/AppContext.d.ts
-/**
-A handle returned by `suspendTerminal()` when called without a callback.
-
-Call `resume()` to give terminal ownership back to Ink, or use `await using`
-so the suspension is resumed automatically when it leaves scope.
-*/
-type TerminalSuspension = {
-  readonly resume: () => Promise<void>;
-  readonly [Symbol.asyncDispose]: () => Promise<void>;
-};
-/**
-Temporarily hand the terminal over to a child process (e.g. `$EDITOR`, `less`,
-`fzf`), then restore Ink's terminal state and force a full redraw.
-*/
-type SuspendTerminal = {
-  (callback: () => void | Promise<void>): Promise<void>;
-  (): Promise<TerminalSuspension>;
-};
-type Props = {
-  /**
-      Exit (unmount) the whole Ink app.
-  
-      - `exit()` — resolves `waitUntilExit()` with `undefined`.
-      - `exit(new Error('…'))` — rejects `waitUntilExit()` with the error.
-      - `exit(value)` — resolves `waitUntilExit()` with `value`.
-      */
-  readonly exit: (errorOrResult?: unknown) => void;
-  /**
-      Returns a promise that settles after pending render output is flushed to stdout.
-  
-      @example
-      ```jsx
-      import {useEffect} from 'react';
-      import {useApp} from 'ink';
-  
-      const Example = () => {
-          const {waitUntilRenderFlush} = useApp();
-  
-          useEffect(() => {
-              void (async () => {
-                  await waitUntilRenderFlush();
-                  runNextCommand();
-              })();
-          }, [waitUntilRenderFlush]);
-  
-          return …;
-      };
-      ```
-      */
-  readonly waitUntilRenderFlush: () => Promise<void>;
-  /**
-      Temporarily release the terminal so a child process can take it over, then
-      restore Ink's terminal state and force a full redraw.
-  
-      Use the callback form for the common case — Ink restores the terminal even
-      if the callback throws:
-  
-      @example
-      ```jsx
-      import {useApp} from 'ink';
-  
-      const {suspendTerminal} = useApp();
-  
-      await suspendTerminal(async () => {
-          await runEditor();
-      });
-      ```
-  
-      Or hold a suspension and resume it yourself:
-  
-      @example
-      ```jsx
-      await using suspension = await suspendTerminal();
-      await runEditor();
-      ```
-      */
-  readonly suspendTerminal: SuspendTerminal;
-};
-//#endregion
 //#region src/kitty-keyboard.d.ts
 declare const kittyFlags: {
   readonly disambiguateEscapeCodes: 1;
@@ -107,12 +27,6 @@ type KittyKeyboardOptions = {
   flags?: KittyFlagName[];
 };
 //#endregion
-//#region src/cursor-position.d.ts
-type CursorPosition = {
-  x: number;
-  y: number;
-};
-//#endregion
 //#region src/stream.d.ts
 type OutputStream = NodeJS.WritableStream & {
   isTTY?: boolean;
@@ -137,164 +51,31 @@ type RenderMetrics = {
       */
   renderTime: number;
 };
-type Options$3 = {
-  stdout: OutputStream;
-  stdin: NodeJS.ReadableStream;
-  stderr: OutputStream;
-  debug: boolean;
-  exitOnCtrlC: boolean;
+/**
+A live Ink renderer for one stdout stream, created by `createInk`.
+*/
+type Ink = {
   /**
-      Patch console methods so `console.*` output doesn't mix with Ink's output.
-  
-      Pass `"stdio"` to additionally intercept direct `stdout.write` /
-      `stderr.write` calls (from dependencies, native warnings, child tooling)
-      on the streams Ink renders to. Captured output is line-buffered and
-      spliced above the live frame, exactly like console output; Ink's own
-      frame writes bypass the capture.
+      Replace the previous root node with a new one or update props of the current root node.
       */
-  patchConsole: boolean | "stdio";
+  render: (node: ReactNode) => void;
   /**
-      Observe output captured by `patchConsole` before Ink displays it.
-  
-      Called with each captured chunk and its origin: `"console"` for patched
-      `console.*` calls, `"stdio"` for direct stream writes (only emitted with
-      `patchConsole: "stdio"`). Return `true` to take ownership of the chunk —
-      Ink will not display it, letting the app render it itself (for example
-      inside a `<Static>` transcript).
+      Unmount the app and release the terminal.
       */
-  onCapturedOutput?: (stream: "stdout" | "stderr", data: string, source: CapturedOutputSource) => boolean | undefined | void;
-  onRender?: (metrics: RenderMetrics) => void;
-  isScreenReaderEnabled?: boolean;
-  waitUntilExit?: () => Promise<unknown>;
-  maxFps?: number;
-  incrementalRendering?: boolean;
+  unmount: (error?: Error | number | null) => void;
   /**
-      Enable React Concurrent Rendering mode.
-  
-      When enabled:
-      - Suspense boundaries work correctly with async data
-      - `useTransition` and `useDeferredValue` are fully functional
-      - Updates can be interrupted for higher priority work
-  
-      Note: Concurrent mode changes the timing of renders. Some tests may need to use `act()` to properly await updates. Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change the rendering mode or create a fresh instance.
-  
-      @default false
-      @experimental
+      Returns a promise that settles when the app is unmounted.
       */
-  concurrent?: boolean;
-  kittyKeyboard?: KittyKeyboardOptions;
+  waitUntilExit: () => Promise<unknown>;
   /**
-      Override automatic interactive mode detection.
-  
-      By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
-  
-      When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
-  
-      Set to `false` to force non-interactive mode or `true` to force interactive mode when the automatic detection doesn't suit your use case.
-  
-      Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
-  
-      @default true (false if in CI or `stdout.isTTY` is falsy)
-  
-      @see {@link RenderOptions.interactive}
+      Returns a promise that settles after pending render output is flushed to stdout.
       */
-  interactive?: boolean;
+  waitUntilRenderFlush: () => Promise<void>;
   /**
-      Render the app in the terminal's alternate screen buffer. When enabled, the app renders on a separate screen, and the original terminal content is restored when the app exits. This is the same mechanism used by programs like vim, htop, and less.
-  
-      Note: The terminal's scrollback buffer is not available while in the alternate screen. This is standard terminal behavior; programs like vim use the alternate screen specifically to avoid polluting the user's scrollback history.
-  
-      Note: Ink intentionally treats alternate-screen teardown output as disposable. It does not preserve or replay teardown-time frames, hook writes, or `console.*` output after restoring the primary screen.
-  
-      Only works in interactive mode. Ignored when `interactive` is `false` or in a non-interactive environment (CI, piped stdout).
-  
-      Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
-  
-      @default false
-  
-      @see {@link RenderOptions.alternateScreen}
+      Clear output.
       */
-  alternateScreen?: boolean;
+  clear: () => void;
 };
-declare class Ink {
-  /**
-      Whether this instance is using concurrent rendering mode.
-      */
-  readonly isConcurrent: boolean;
-  private readonly options;
-  private readonly log;
-  private cursorPosition;
-  private readonly throttledLog;
-  private readonly isScreenReaderEnabled;
-  private readonly interactive;
-  private readonly renderThrottleMs;
-  private alternateScreen;
-  private isUnmounted;
-  private isUnmounting;
-  private lastOutput;
-  private lastOutputToRender;
-  private lastOutputHeight;
-  private lastTerminalWidth;
-  private lastTerminalHeight;
-  private readonly container;
-  private readonly rootNode;
-  private fullStaticOutput;
-  private readonly exitPromise;
-  private exitResult;
-  private beforeExitHandler?;
-  private restoreConsole?;
-  private readonly captureTargets?;
-  private readonly capturedStdioTails;
-  private readonly unsubscribeResize?;
-  private readonly throttledOnRender?;
-  private hasPendingThrottledRender;
-  private kittyProtocolEnabled;
-  private kittyFlags;
-  private cancelKittyDetection?;
-  private nextRenderCommit?;
-  private isSuspended;
-  private pauseInput?;
-  private resumeInput?;
-  constructor(options: Options$3);
-  resized: () => void;
-  resolveExitPromise: (result?: unknown) => void;
-  rejectExitPromise: (reason?: Error) => void;
-  unsubscribeExit: () => void;
-  handleAppExit: (errorOrResult?: unknown) => void;
-  setCursorPosition: (position: CursorPosition | undefined) => void;
-  restoreLastOutput: () => void;
-  calculateLayout: () => void;
-  handleStaticChange: () => void;
-  onRender: () => void;
-  render(node: ReactNode): void;
-  writeToStdout(data: string): void;
-  writeToStderr(data: string): void;
-  unmount(error?: Error | number | null): void;
-  waitUntilExit(): Promise<unknown>;
-  waitUntilRenderFlush(): Promise<void>;
-  clear(): void;
-  patchConsole(): void;
-  private patchDirectStdio;
-  private handleCapturedStdio;
-  private flushCapturedStdio;
-  registerInputControl(pauseInput: () => void, resumeInput: () => void): void;
-  suspendTerminal(callback: () => void | Promise<void>): Promise<void>;
-  suspendTerminal(): Promise<TerminalSuspension>;
-  private setAlternateScreen;
-  private resolveInteractiveOption;
-  private resolveAlternateScreenOption;
-  private shouldSync;
-  private writeBestEffort;
-  private awaitExit;
-  private hasPendingConcurrentWork;
-  private awaitNextRender;
-  private renderInteractiveFrame;
-  private initKittyKeyboard;
-  private confirmKittySupport;
-  private enableKittyProtocol;
-  private beginSuspend;
-  private endSuspend;
-}
 //#endregion
 //#region src/render.d.ts
 type RenderOptions = {
@@ -395,7 +176,7 @@ type RenderOptions = {
   /**
       Override automatic interactive mode detection.
   
-      By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
+      By default, Ink detects whether the environment is interactive based on CI detection (the `CI` environment variable) and `stdout.isTTY`. Most users should not need to set this.
   
       When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
   
@@ -519,21 +300,8 @@ declare const renderToString: (node: ReactNode, options?: RenderToStringOptions)
 //#region src/render-node-to-output.d.ts
 type OutputTransformer = (s: string, index: number) => string;
 //#endregion
-//#region src/boxes.d.ts
-/**
-Style of the box border.
-*/
-type BoxStyle = {
-  readonly topLeft: string;
-  readonly top: string;
-  readonly topRight: string;
-  readonly right: string;
-  readonly bottomRight: string;
-  readonly bottom: string;
-  readonly bottomLeft: string;
-  readonly left: string;
-};
-declare const boxes: {
+//#region src/glyphs.d.ts
+declare const BOXES: {
   readonly single: {
     readonly topLeft: "┌";
     readonly top: "─";
@@ -615,7 +383,20 @@ declare const boxes: {
     readonly left: "→";
   };
 };
-type Boxes = typeof boxes;
+type BoxStyle = keyof typeof BOXES;
+/**
+The set of glyphs making up a box border, for custom `borderStyle` objects.
+*/
+type BoxGlyphs = {
+  readonly topLeft: string;
+  readonly top: string;
+  readonly topRight: string;
+  readonly right: string;
+  readonly bottomRight: string;
+  readonly bottom: string;
+  readonly bottomLeft: string;
+  readonly left: string;
+};
 //#endregion
 //#region src/types.d.ts
 /**
@@ -624,10 +405,6 @@ without sacrificing auto-completion in IDEs for the literal type part of the
 union.
 */
 type LiteralUnion<LiteralType, BaseType extends string | number> = LiteralType | (BaseType & Record<never, never>);
-/**
-Create a type from an object type without certain keys.
-*/
-type Except<ObjectType, KeysType extends keyof ObjectType> = Omit<ObjectType, KeysType>;
 //#endregion
 //#region src/styles.d.ts
 type Styles = {
@@ -728,7 +505,7 @@ type Styles = {
       */
   readonly flexGrow?: number;
   /**
-      It specifies the “flex shrink factor”, which determines how much the flex item will shrink relative to the rest of the flex items in the flex container when there isn’t enough space on the row.
+      It specifies the “flex shrink factor”, which determines how much the flex item will shrink relative to the rest of the flex items in the flex container when there isn't enough space on the row.
       See [flex-shrink](https://css-tricks.com/almanac/properties/f/flex-shrink/).
       */
   readonly flexShrink?: number;
@@ -806,7 +583,7 @@ type Styles = {
   /**
       Add a border with a specified style. If `borderStyle` is `undefined` (the default), no border will be added.
       */
-  readonly borderStyle?: keyof Boxes | BoxStyle;
+  readonly borderStyle?: BoxStyle | BoxGlyphs;
   /**
       Determines whether the top border is visible.
   
@@ -978,7 +755,7 @@ type DOMNode<T = {
 type DOMNodeAttribute = boolean | string | number;
 //#endregion
 //#region src/components/Box.d.ts
-type Props$1 = Except<Styles, "textWrap"> & {
+type Props$1 = Omit<Styles, "textWrap"> & {
   /**
       A label for the element for screen readers.
       */
@@ -1009,36 +786,9 @@ type Props$1 = Except<Styles, "textWrap"> & {
 /**
 `<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
 */
-declare const Box: import("react").ForwardRefExoticComponent<Except<Styles, "textWrap"> & {
-  /**
-      A label for the element for screen readers.
-      */
-  readonly "aria-label"?: string;
-  /**
-      Hide the element from screen readers.
-      */
-  readonly "aria-hidden"?: boolean;
-  /**
-      The role of the element.
-      */
-  readonly "aria-role"?: "button" | "checkbox" | "combobox" | "list" | "listbox" | "listitem" | "menu" | "menuitem" | "option" | "progressbar" | "radio" | "radiogroup" | "tab" | "tablist" | "table" | "textbox" | "timer" | "toolbar";
-  /**
-      The state of the element.
-      */
-  readonly "aria-state"?: {
-    readonly busy?: boolean;
-    readonly checked?: boolean;
-    readonly disabled?: boolean;
-    readonly expanded?: boolean;
-    readonly multiline?: boolean;
-    readonly multiselectable?: boolean;
-    readonly readonly?: boolean;
-    readonly required?: boolean;
-    readonly selected?: boolean;
-  };
-} & {
-  children?: import("react").ReactNode | undefined;
-} & import("react").RefAttributes<DOMElement>>;
+declare function Box({ children, ref, backgroundColor, "aria-label": ariaLabel, "aria-hidden": ariaHidden, "aria-role": role, "aria-state": ariaState, ...style }: PropsWithChildren<Props$1> & {
+  readonly ref?: Ref<DOMElement>;
+}): import("react").JSX.Element | null;
 //#endregion
 //#region src/components/Text.d.ts
 type Props$6 = {
@@ -1093,6 +843,86 @@ This component can display text and change its style to make it bold, underlined
 */
 declare function Text({ color, backgroundColor, dimColor, bold, italic, underline, strikethrough, inverse, wrap, children, "aria-label": ariaLabel, "aria-hidden": ariaHidden }: Props$6): import("react").JSX.Element | null;
 //#endregion
+//#region src/components/AppContext.d.ts
+/**
+A handle returned by `suspendTerminal()` when called without a callback.
+
+Call `resume()` to give terminal ownership back to Ink, or use `await using`
+so the suspension is resumed automatically when it leaves scope.
+*/
+type TerminalSuspension = {
+  readonly resume: () => Promise<void>;
+  readonly [Symbol.asyncDispose]: () => Promise<void>;
+};
+/**
+Temporarily hand the terminal over to a child process (e.g. `$EDITOR`, `less`,
+`fzf`), then restore Ink's terminal state and force a full redraw.
+*/
+type SuspendTerminal = {
+  (callback: () => void | Promise<void>): Promise<void>;
+  (): Promise<TerminalSuspension>;
+};
+type Props = {
+  /**
+      Exit (unmount) the whole Ink app.
+  
+      - `exit()` — resolves `waitUntilExit()` with `undefined`.
+      - `exit(new Error('…'))` — rejects `waitUntilExit()` with the error.
+      - `exit(value)` — resolves `waitUntilExit()` with `value`.
+      */
+  readonly exit: (errorOrResult?: unknown) => void;
+  /**
+      Returns a promise that settles after pending render output is flushed to stdout.
+  
+      @example
+      ```jsx
+      import {useEffect} from 'react';
+      import {useApp} from 'ink';
+  
+      const Example = () => {
+          const {waitUntilRenderFlush} = useApp();
+  
+          useEffect(() => {
+              void (async () => {
+                  await waitUntilRenderFlush();
+                  runNextCommand();
+              })();
+          }, [waitUntilRenderFlush]);
+  
+          return …;
+      };
+      ```
+      */
+  readonly waitUntilRenderFlush: () => Promise<void>;
+  /**
+      Temporarily release the terminal so a child process can take it over, then
+      restore Ink's terminal state and force a full redraw.
+  
+      Use the callback form for the common case — Ink restores the terminal even
+      if the callback throws:
+  
+      @example
+      ```jsx
+      import {useApp} from 'ink';
+  
+      const {suspendTerminal} = useApp();
+  
+      await suspendTerminal(async () => {
+          await runEditor();
+      });
+      ```
+  
+      Or hold a suspension and resume it yourself:
+  
+      @example
+      ```jsx
+      await using suspension = await suspendTerminal();
+      await runEditor();
+      ```
+      */
+  readonly suspendTerminal: SuspendTerminal;
+};
+//#endregion
 //#region src/components/StdinContext.d.ts
 type PublicProps = {
   /**
@@ -1175,6 +1005,7 @@ Transform a string representation of React components before they're written to
 declare function Transform({ children, transform, accessibilityLabel }: Props$7): import("react").JSX.Element | null;
 //#endregion
 //#region src/components/Newline.d.ts
+/** @jsxImportSource react */
 type Props$2 = {
   /**
       Number of newlines to insert.
@@ -1486,6 +1317,12 @@ This is useful when you want to render different output for screen readers.
 */
 declare const useIsScreenReaderEnabled: () => boolean;
 //#endregion
+//#region src/cursor-position.d.ts
+type CursorPosition = {
+  x: number;
+  y: number;
+};
+//#endregion
 //#region src/hooks/use-cursor.d.ts
 /**
 A React hook that returns methods to control the terminal cursor position.