Interface - node__readline.d.ts - Node

class Interface

extends EventEmitter

Usage in Deno

```typescript import { Interface } from "node:node__readline.d.ts"; ```

Instances of the `readline.Interface` class are constructed using the `readline.createInterface()` method. Every instance is associated with a single `input` [Readable](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream and a single `output` [Writable](https://nodejs.org/docs/latest-v22.x/api/stream.html#writable-streams) stream. The `output` stream is used to print prompts for user input that arrives on, and is read from, the `input` stream.

Constructors

new



Interface(input: ReadableStream,
output?: WritableStream,
completer?: Completer | AsyncCompleter,
terminal?: boolean,
)

NOTE: According to the documentation: > Instances of the `readline.Interface` class are constructed using the > `readline.createInterface()` method.

new



Interface(options: ReadLineOptions)

NOTE: According to the documentation: > Instances of the `readline.Interface` class are constructed using the > `readline.createInterface()` method.

Properties

readonly



cursor: number

The cursor position relative to `rl.line`. This will track where the current cursor lands in the input string, when reading input from a TTY stream. The position of cursor determines the portion of the input string that will be modified as input is processed, as well as the column where the terminal caret will be rendered.

readonly



line: string

The current input data being processed by node. This can be used when collecting input from a TTY stream to retrieve the current value that has been processed thus far, prior to the `line` event being emitted. Once the `line` event has been emitted, this property will be an empty string. Be aware that modifying the value during the instance runtime may have unintended consequences if `rl.cursor` is not also controlled. **If not using a TTY stream for input, use the `'line'` event.** One possible use case would be as follows: ```js const values = ['lorem ipsum', 'dolor sit amet']; const rl = readline.createInterface(process.stdin); const showResults = debounce(() => { console.log( '\n', values.filter((val) => val.startsWith(rl.line)).join(' '), ); }, 300); process.stdin.on('keypress', (c, k) => { showResults(); }); ```

readonly



terminal: boolean

Methods



[Symbol.asyncIterator](): AsyncIterableIterator<string>



addListener(event: string,
listener: (...args: any[]) => void,
): this

events.EventEmitter 1. close 2. line 3. pause 4. resume 5. SIGCONT 6. SIGINT 7. SIGTSTP 8. history



addListener(event: "close",
listener: () => void,
): this



addListener(event: "line",
listener: (input: string) => void,
): this



addListener(event: "pause",
listener: () => void,
): this



addListener(event: "resume",
listener: () => void,
): this



addListener(event: "SIGCONT",
listener: () => void,
): this



addListener(event: "SIGINT",
listener: () => void,
): this



addListener(event: "SIGTSTP",
listener: () => void,
): this



addListener(event: "history",
listener: (history: string[]) => void,
): this



close(): void

The `rl.close()` method closes the `Interface` instance and relinquishes control over the `input` and `output` streams. When called, the `'close'` event will be emitted. Calling `rl.close()` does not immediately stop other events (including `'line'`) from being emitted by the `Interface` instance.



emit(event: string | symbol,
...args: any[],
): boolean



emit(event: "close"): boolean



emit(event: "line",
input: string,
): boolean



emit(event: "pause"): boolean



emit(event: "resume"): boolean



emit(event: "SIGCONT"): boolean



emit(event: "SIGINT"): boolean



emit(event: "SIGTSTP"): boolean



emit(event: "history",
history: string[],
): boolean



getCursorPos(): CursorPos

Returns the real position of the cursor in relation to the input prompt + string. Long input (wrapping) strings, as well as multiple line prompts are included in the calculations.



getPrompt(): string

The `rl.getPrompt()` method returns the current prompt used by `rl.prompt()`.



on(event: string,
listener: (...args: any[]) => void,
): this



on(event: "close",
listener: () => void,
): this



on(event: "line",
listener: (input: string) => void,
): this



on(event: "pause",
listener: () => void,
): this



on(event: "resume",
listener: () => void,
): this



on(event: "SIGCONT",
listener: () => void,
): this



on(event: "SIGINT",
listener: () => void,
): this



on(event: "SIGTSTP",
listener: () => void,
): this



on(event: "history",
listener: (history: string[]) => void,
): this



once(event: string,
listener: (...args: any[]) => void,
): this



once(event: "close",
listener: () => void,
): this



once(event: "line",
listener: (input: string) => void,
): this



once(event: "pause",
listener: () => void,
): this



once(event: "resume",
listener: () => void,
): this



once(event: "SIGCONT",
listener: () => void,
): this



once(event: "SIGINT",
listener: () => void,
): this



once(event: "SIGTSTP",
listener: () => void,
): this



once(event: "history",
listener: (history: string[]) => void,
): this



pause(): this

The `rl.pause()` method pauses the `input` stream, allowing it to be resumed later if necessary. Calling `rl.pause()` does not immediately pause other events (including `'line'`) from being emitted by the `Interface` instance.



prependListener(event: string,
listener: (...args: any[]) => void,
): this



prependListener(event: "close",
listener: () => void,
): this



prependListener(event: "line",
listener: (input: string) => void,
): this



prependListener(event: "pause",
listener: () => void,
): this



prependListener(event: "resume",
listener: () => void,
): this



prependListener(event: "SIGCONT",
listener: () => void,
): this



prependListener(event: "SIGINT",
listener: () => void,
): this



prependListener(event: "SIGTSTP",
listener: () => void,
): this



prependListener(event: "history",
listener: (history: string[]) => void,
): this



prependOnceListener(event: string,
listener: (...args: any[]) => void,
): this



prependOnceListener(event: "close",
listener: () => void,
): this



prependOnceListener(event: "line",
listener: (input: string) => void,
): this



prependOnceListener(event: "pause",
listener: () => void,
): this



prependOnceListener(event: "resume",
listener: () => void,
): this



prependOnceListener(event: "SIGCONT",
listener: () => void,
): this



prependOnceListener(event: "SIGINT",
listener: () => void,
): this



prependOnceListener(event: "SIGTSTP",
listener: () => void,
): this



prependOnceListener(event: "history",
listener: (history: string[]) => void,
): this



prompt(preserveCursor?: boolean): void

The `rl.prompt()` method writes the `Interface` instances configured`prompt` to a new line in `output` in order to provide a user with a new location at which to provide input. When called, `rl.prompt()` will resume the `input` stream if it has been paused. If the `Interface` was created with `output` set to `null` or `undefined` the prompt is not written.



question(query: string,
callback: (answer: string) => void,
): void

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. The `callback` function passed to `rl.question()` does not follow the typical pattern of accepting an `Error` object or `null` as the first argument. The `callback` is called with the provided answer as the only argument. An error will be thrown if calling `rl.question()` after `rl.close()`. Example usage: ```js rl.question('What is your favorite food? ', (answer) => { console.log(`Oh, so your favorite food is ${answer}`); }); ``` Using an `AbortController` to cancel a question. ```js const ac = new AbortController(); const signal = ac.signal; rl.question('What is your favorite food? ', { signal }, (answer) => { console.log(`Oh, so your favorite food is ${answer}`); }); signal.addEventListener('abort', () => { console.log('The food question timed out'); }, { once: true }); setTimeout(() => ac.abort(), 10000); ```



question(query: string,
options: Abortable,
callback: (answer: string) => void,
): void



resume(): this

The `rl.resume()` method resumes the `input` stream if it has been paused.



setPrompt(prompt: string): void

The `rl.setPrompt()` method sets the prompt that will be written to `output` whenever `rl.prompt()` is called.



write(data: string | Buffer,
key?: Key,
): void

The `rl.write()` method will write either `data` or a key sequence identified by `key` to the `output`. The `key` argument is supported only if `output` is a `TTY` text terminal. See `TTY keybindings` for a list of key combinations. If `key` is specified, `data` is ignored. When called, `rl.write()` will resume the `input` stream if it has been paused. If the `Interface` was created with `output` set to `null` or `undefined` the `data` and `key` are not written. ```js rl.write('Delete this!'); // Simulate Ctrl+U to delete the line written previously rl.write(null, { ctrl: true, name: 'u' }); ``` The `rl.write()` method will write the data to the `readline` `Interface`'s `input` _as if it were provided by the user_.



write(data: undefined
 | null
 | string
 | Buffer,
key: Key,
): void