151 lines
6.0 KiB
Plaintext
151 lines
6.0 KiB
Plaintext
/**
|
|
* @since v17.0.0
|
|
* @experimental
|
|
*/
|
|
declare module "readline/promises" {
|
|
import { AsyncCompleter, Completer, Direction, Interface as _Interface, ReadLineOptions } from "node:readline";
|
|
import { Abortable } from "node:events";
|
|
/**
|
|
* Instances of the `readlinePromises.Interface` class are constructed using the`readlinePromises.createInterface()` method. Every instance is associated with a
|
|
* single `input` `Readable` stream and a single `output` `Writable` stream.
|
|
* The `output` stream is used to print prompts for user input that arrives on,
|
|
* and is read from, the `input` stream.
|
|
* @since v17.0.0
|
|
*/
|
|
class Interface extends _Interface {
|
|
/**
|
|
* The `rl.question()` method displays the `query` by writing it to the `output`,
|
|
* waits for user input to be provided on `input`, then invokes the `callback`function passing the provided input as the first argument.
|
|
*
|
|
* When called, `rl.question()` will resume the `input` stream if it has been
|
|
* paused.
|
|
*
|
|
* If the `Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
|
|
*
|
|
* If the question is called after `rl.close()`, it returns a rejected promise.
|
|
*
|
|
* Example usage:
|
|
*
|
|
* ```js
|
|
* const answer = await rl.question('What is your favorite food? ');
|
|
* console.log(`Oh, so your favorite food is ${answer}`);
|
|
* ```
|
|
*
|
|
* Using an `AbortSignal` to cancel a question.
|
|
*
|
|
* ```js
|
|
* const signal = AbortSignal.timeout(10_000);
|
|
*
|
|
* signal.addEventListener('abort', () => {
|
|
* console.log('The food question timed out');
|
|
* }, { once: true });
|
|
*
|
|
* const answer = await rl.question('What is your favorite food? ', { signal });
|
|
* console.log(`Oh, so your favorite food is ${answer}`);
|
|
* ```
|
|
* @since v17.0.0
|
|
* @param query A statement or query to write to `output`, prepended to the prompt.
|
|
* @return A promise that is fulfilled with the user's input in response to the `query`.
|
|
*/
|
|
question(query: string): Promise<string>;
|
|
question(query: string, options: Abortable): Promise<string>;
|
|
}
|
|
/**
|
|
* @since v17.0.0
|
|
*/
|
|
class Readline {
|
|
/**
|
|
* @param stream A TTY stream.
|
|
*/
|
|
constructor(
|
|
stream: NodeJS.WritableStream,
|
|
options?: {
|
|
autoCommit?: boolean;
|
|
},
|
|
);
|
|
/**
|
|
* The `rl.clearLine()` method adds to the internal list of pending action an
|
|
* action that clears current line of the associated `stream` in a specified
|
|
* direction identified by `dir`.
|
|
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
|
|
* @since v17.0.0
|
|
* @return this
|
|
*/
|
|
clearLine(dir: Direction): this;
|
|
/**
|
|
* The `rl.clearScreenDown()` method adds to the internal list of pending action an
|
|
* action that clears the associated stream from the current position of the
|
|
* cursor down.
|
|
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
|
|
* @since v17.0.0
|
|
* @return this
|
|
*/
|
|
clearScreenDown(): this;
|
|
/**
|
|
* The `rl.commit()` method sends all the pending actions to the associated`stream` and clears the internal list of pending actions.
|
|
* @since v17.0.0
|
|
*/
|
|
commit(): Promise<void>;
|
|
/**
|
|
* The `rl.cursorTo()` method adds to the internal list of pending action an action
|
|
* that moves cursor to the specified position in the associated `stream`.
|
|
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
|
|
* @since v17.0.0
|
|
* @return this
|
|
*/
|
|
cursorTo(x: number, y?: number): this;
|
|
/**
|
|
* The `rl.moveCursor()` method adds to the internal list of pending action an
|
|
* action that moves the cursor _relative_ to its current position in the
|
|
* associated `stream`.
|
|
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
|
|
* @since v17.0.0
|
|
* @return this
|
|
*/
|
|
moveCursor(dx: number, dy: number): this;
|
|
/**
|
|
* The `rl.rollback` methods clears the internal list of pending actions without
|
|
* sending it to the associated `stream`.
|
|
* @since v17.0.0
|
|
* @return this
|
|
*/
|
|
rollback(): this;
|
|
}
|
|
/**
|
|
* The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface`instance.
|
|
*
|
|
* ```js
|
|
* const readlinePromises = require('node:readline/promises');
|
|
* const rl = readlinePromises.createInterface({
|
|
* input: process.stdin,
|
|
* output: process.stdout,
|
|
* });
|
|
* ```
|
|
*
|
|
* Once the `readlinePromises.Interface` instance is created, the most common case
|
|
* is to listen for the `'line'` event:
|
|
*
|
|
* ```js
|
|
* rl.on('line', (line) => {
|
|
* console.log(`Received: ${line}`);
|
|
* });
|
|
* ```
|
|
*
|
|
* If `terminal` is `true` for this instance then the `output` stream will get
|
|
* the best compatibility if it defines an `output.columns` property and emits
|
|
* a `'resize'` event on the `output` if or when the columns ever change
|
|
* (`process.stdout` does this automatically when it is a TTY).
|
|
* @since v17.0.0
|
|
*/
|
|
function createInterface(
|
|
input: NodeJS.ReadableStream,
|
|
output?: NodeJS.WritableStream,
|
|
completer?: Completer | AsyncCompleter,
|
|
terminal?: boolean,
|
|
): Interface;
|
|
function createInterface(options: ReadLineOptions): Interface;
|
|
}
|
|
declare module "node:readline/promises" {
|
|
export * from "readline/promises";
|
|
}
|