controlroom/ink

import { Box, Newline, Spacer, … } from 'controlroom/ink';

function measureElement(node: DOMElement): ElementMetrics;

function Newline({ count }: NewlineProps): ReactElement;

function render(node: React.ReactNode, options?: RenderOptions | NodeJS.WritableStream): Instance;

function renderToString(node: React.ReactNode, options?: RenderToStringOptions): string;

function Spacer(): ReactElement;

function Static<T>({ items, children: render, style: customStyle }: StaticProps<T>): ReactElement;

function Text({ color, backgroundColor, dimColor, bold, italic, underline, strikethrough, inverse, wrap, children, 'aria-label': ariaLabel, 'aria-hidden': ariaHidden }: TextProps): ReactElement | null;

function Transform({ children, transform, accessibilityLabel }: TransformProps): ReactElement | null;

function useAnimation(options?: {
    interval?: number;
    isActive?: boolean;
}): AnimationResult;

function useBoxMetrics(ref: React.RefObject<DOMElement | null>): UseBoxMetricsResult;

function useCursor(): {
    setCursorPosition: (position: CursorPosition | undefined) => void;
};

function useFocus({ isActive, autoFocus, id: customId }?: {
    isActive?: boolean;
    autoFocus?: boolean;
    id?: string;
}): {
    isFocused: boolean;
    focus: (id: string) => void;
};

function useFocusManager(): Pick<React.ContextType<typeof FocusContext>, 'enableFocus' | 'disableFocus' | 'focusNext' | 'focusPrevious' | 'focus' | 'activeId'>;

function useInput(handler: (input: string, key: Key) => void, options?: {
    isActive?: boolean;
}): void;

function usePaste(handler: (text: string) => void, options?: {
    isActive?: boolean;
}): void;

function useWindowSize(): WindowSize;

const Box: import("react").ForwardRefExoticComponent<Omit<Styles, "textWrap"> & {
    readonly children?: Node | undefined;
    readonly 'aria-label'?: string | undefined;
    readonly 'aria-hidden'?: boolean | undefined;
    readonly 'aria-role'?: string | undefined;
    readonly 'aria-state'?: Accessibility["state"] | undefined;
} & import("react").RefAttributes<DOMElement>>;

const kittyFlags: {
    readonly disambiguateEscapeCodes: 1;
    readonly reportEventTypes: 2;
    readonly reportAlternateKeys: 4;
    readonly reportAllKeysAsEscapeCodes: 8;
    readonly reportAssociatedText: 16;
};

const kittyModifiers: {
    readonly shift: 1;
    readonly alt: 2;
    readonly ctrl: 4;
    readonly super: 8;
    readonly hyper: 16;
    readonly meta: 32;
    readonly capsLock: 64;
    readonly numLock: 128;
};

const useApp: () => AppProps;

const useIsScreenReaderEnabled: () => boolean;

const useStderr: () => StderrProps;

const useStdin: () => Pick<StdinProps, "stdin" | "setRawMode" | "isRawModeSupported">;

const useStdout: () => StdoutProps;

interface AnimationResult {
    readonly frame: number;
    readonly time: number;
    readonly delta: number;
    readonly reset: () => void;
}

interface AppProps {
    /** Exit (unmount) the whole app; an `Error` rejects `waitUntilExit()`, anything else resolves it. */
    readonly exit: (errorOrResult?: unknown) => void;
    /** Settles once pending render output has reached stdout. */
    readonly waitUntilRenderFlush: () => Promise<void>;
    /** Hand the terminal to a child process, then take it back and redraw. */
    readonly suspendTerminal: SuspendTerminal;
}

interface BoxMetrics {
    readonly width: number;
    readonly height: number;
    readonly left: number;
    readonly top: number;
    readonly clientWidth: number;
    readonly clientHeight: number;
}

interface CursorPosition {
    x: number;
    y: number;
}

interface DOMElement {
    nodeName: ElementName;
    attributes: Record<string, unknown>;
    childNodes: DOMNode[];
    parentNode: DOMElement | undefined;
    style: Styles;
    /** The node's flex item; `undefined` for virtual text, which lays out inside its `Text`, and once freed. */
    yogaNode: FlexNode | undefined;
    /** Set by Suspense: the node keeps its place in the tree and takes no space. */
    isHidden?: boolean;
    internal_static?: boolean;
    internal_transform?: Transformer | undefined;
    internal_accessibility?: Accessibility;
    isStaticDirty?: boolean;
    staticNode?: DOMElement | undefined;
    previousStaticNode?: DOMElement | undefined;
    onComputeLayout?: (() => void) | undefined;
    onRender?: (() => void) | undefined;
    onImmediateRender?: (() => void) | undefined;
    onStaticChange?: (() => void) | undefined;
    internal_layoutListeners?: Set<LayoutListener>;
}

interface ElementMetrics {
    x: number;
    y: number;
    width: number;
    height: number;
    clientWidth: number;
    clientHeight: number;
}

interface Instance {
    rerender: (node: React.ReactNode) => void;
    unmount: () => void;
    waitUntilExit: () => Promise<unknown>;
    waitUntilRenderFlush: () => Promise<void>;
    cleanup: () => void;
    clear: () => void;
}

interface Key {
    upArrow: boolean;
    downArrow: boolean;
    leftArrow: boolean;
    rightArrow: boolean;
    pageDown: boolean;
    pageUp: boolean;
    home: boolean;
    end: boolean;
    return: boolean;
    escape: boolean;
    ctrl: boolean;
    shift: boolean;
    tab: boolean;
    backspace: boolean;
    delete: boolean;
    meta: boolean;
    super: boolean;
    hyper: boolean;
    capsLock: boolean;
    numLock: boolean;
    eventType?: 'press' | 'repeat' | 'release' | undefined;
}

interface KittyKeyboardOptions {
    mode?: 'auto' | 'enabled' | 'disabled';
    flags?: KittyFlagName[];
}

interface NewlineProps {
    /** Newlines to insert. Default 1. */
    readonly count?: number;
}

interface RenderMetrics {
    renderTime: number;
}

interface RenderOptions {
    stdout?: NodeJS.WriteStream | NodeJS.WritableStream;
    stdin?: NodeJS.ReadStream | NodeJS.ReadableStream;
    stderr?: NodeJS.WriteStream | NodeJS.WritableStream;
    debug?: boolean;
    exitOnCtrlC?: boolean;
    patchConsole?: boolean;
    maxFps?: number;
    incrementalRendering?: boolean;
    concurrent?: boolean;
    isScreenReaderEnabled?: boolean;
    onRender?: (metrics: RenderMetrics) => void;
    kittyKeyboard?: KittyKeyboardOptions;
    interactive?: boolean;
    alternateScreen?: boolean;
}

interface RenderToStringOptions {
    /** Columns of the virtual terminal. Default 80. */
    columns?: number;
}

interface StaticProps<T> {
    readonly items: T[];
    readonly style?: Styles | undefined;
    readonly children: (item: T, index: number) => Node;
}

interface StderrProps {
    readonly stderr: NodeJS.WriteStream;
    readonly write: (data: string) => void;
}

interface StdinProps {
    readonly stdin: NodeJS.ReadStream;
    readonly setRawMode: (value: boolean) => void;
    readonly setBracketedPasteMode: (value: boolean) => void;
    readonly isRawModeSupported: boolean;
    readonly internal_exitOnCtrlC: boolean;
    readonly internal_eventEmitter: EventEmitter;
}

interface StdoutProps {
    readonly stdout: NodeJS.WriteStream;
    readonly write: (data: string) => void;
}

interface SuspendTerminal {
    (callback: () => void | Promise<void>): Promise<void>;
    (): Promise<TerminalSuspension>;
}

interface TerminalSuspension {
    readonly resume: () => Promise<void>;
    readonly [Symbol.asyncDispose]: () => Promise<void>;
}

interface TextProps {
    readonly color?: string | undefined;
    readonly backgroundColor?: string | undefined;
    readonly dimColor?: boolean | undefined;
    readonly bold?: boolean | undefined;
    readonly italic?: boolean | undefined;
    readonly underline?: boolean | undefined;
    readonly strikethrough?: boolean | undefined;
    readonly inverse?: boolean | undefined;
    readonly wrap?: TextWrap | undefined;
    readonly children?: Node | undefined;
    readonly 'aria-label'?: string | undefined;
    readonly 'aria-hidden'?: boolean | undefined;
}

interface TransformProps {
    readonly transform: (children: string, index: number) => string;
    readonly accessibilityLabel?: string | undefined;
    readonly children?: Node | undefined;
}

interface WindowSize {
    readonly columns: number;
    readonly rows: number;
}

type BoxProps = Omit<Styles, 'textWrap'> & {
    readonly children?: Node | undefined;
    readonly 'aria-label'?: string | undefined;
    readonly 'aria-hidden'?: boolean | undefined;
    readonly 'aria-role'?: string | undefined;
    readonly 'aria-state'?: Accessibility['state'] | undefined;
};

type KittyFlagName = keyof typeof kittyFlags;

type UseBoxMetricsResult = BoxMetrics & {
    readonly hasMeasured: boolean;
};