Spaces:
Running
Running
/** | |
* @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"; | |
} | |