You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
9.6 KiB
204 lines
9.6 KiB
/** |
|
* The `tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes. |
|
* In most cases, it will not be necessary or possible to use this module directly. |
|
* However, it can be accessed using: |
|
* |
|
* ```js |
|
* const tty = require('tty'); |
|
* ``` |
|
* |
|
* When Node.js detects that it is being run with a text terminal ("TTY") |
|
* attached, `process.stdin` will, by default, be initialized as an instance of`tty.ReadStream` and both `process.stdout` and `process.stderr` will, by |
|
* default, be instances of `tty.WriteStream`. The preferred method of determining |
|
* whether Node.js is being run within a TTY context is to check that the value of |
|
* the `process.stdout.isTTY` property is `true`: |
|
* |
|
* ```console |
|
* $ node -p -e "Boolean(process.stdout.isTTY)" |
|
* true |
|
* $ node -p -e "Boolean(process.stdout.isTTY)" | cat |
|
* false |
|
* ``` |
|
* |
|
* In most cases, there should be little to no reason for an application to |
|
* manually create instances of the `tty.ReadStream` and `tty.WriteStream`classes. |
|
* @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/tty.js) |
|
*/ |
|
declare module 'tty' { |
|
import * as net from 'node:net'; |
|
/** |
|
* The `tty.isatty()` method returns `true` if the given `fd` is associated with |
|
* a TTY and `false` if it is not, including whenever `fd` is not a non-negative |
|
* integer. |
|
* @since v0.5.8 |
|
* @param fd A numeric file descriptor |
|
*/ |
|
function isatty(fd: number): boolean; |
|
/** |
|
* Represents the readable side of a TTY. In normal circumstances `process.stdin` will be the only `tty.ReadStream` instance in a Node.js |
|
* process and there should be no reason to create additional instances. |
|
* @since v0.5.8 |
|
*/ |
|
class ReadStream extends net.Socket { |
|
constructor(fd: number, options?: net.SocketConstructorOpts); |
|
/** |
|
* A `boolean` that is `true` if the TTY is currently configured to operate as a |
|
* raw device. Defaults to `false`. |
|
* @since v0.7.7 |
|
*/ |
|
isRaw: boolean; |
|
/** |
|
* Allows configuration of `tty.ReadStream` so that it operates as a raw device. |
|
* |
|
* When in raw mode, input is always available character-by-character, not |
|
* including modifiers. Additionally, all special processing of characters by the |
|
* terminal is disabled, including echoing input characters.Ctrl+C will no longer cause a `SIGINT` when in this mode. |
|
* @since v0.7.7 |
|
* @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw` |
|
* property will be set to the resulting mode. |
|
* @return The read stream instance. |
|
*/ |
|
setRawMode(mode: boolean): this; |
|
/** |
|
* A `boolean` that is always `true` for `tty.ReadStream` instances. |
|
* @since v0.5.8 |
|
*/ |
|
isTTY: boolean; |
|
} |
|
/** |
|
* -1 - to the left from cursor |
|
* 0 - the entire line |
|
* 1 - to the right from cursor |
|
*/ |
|
type Direction = -1 | 0 | 1; |
|
/** |
|
* Represents the writable side of a TTY. In normal circumstances,`process.stdout` and `process.stderr` will be the only`tty.WriteStream` instances created for a Node.js process and there |
|
* should be no reason to create additional instances. |
|
* @since v0.5.8 |
|
*/ |
|
class WriteStream extends net.Socket { |
|
constructor(fd: number); |
|
addListener(event: string, listener: (...args: any[]) => void): this; |
|
addListener(event: 'resize', listener: () => void): this; |
|
emit(event: string | symbol, ...args: any[]): boolean; |
|
emit(event: 'resize'): boolean; |
|
on(event: string, listener: (...args: any[]) => void): this; |
|
on(event: 'resize', listener: () => void): this; |
|
once(event: string, listener: (...args: any[]) => void): this; |
|
once(event: 'resize', listener: () => void): this; |
|
prependListener(event: string, listener: (...args: any[]) => void): this; |
|
prependListener(event: 'resize', listener: () => void): this; |
|
prependOnceListener(event: string, listener: (...args: any[]) => void): this; |
|
prependOnceListener(event: 'resize', listener: () => void): this; |
|
/** |
|
* `writeStream.clearLine()` clears the current line of this `WriteStream` in a |
|
* direction identified by `dir`. |
|
* @since v0.7.7 |
|
* @param callback Invoked once the operation completes. |
|
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`. |
|
*/ |
|
clearLine(dir: Direction, callback?: () => void): boolean; |
|
/** |
|
* `writeStream.clearScreenDown()` clears this `WriteStream` from the current |
|
* cursor down. |
|
* @since v0.7.7 |
|
* @param callback Invoked once the operation completes. |
|
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`. |
|
*/ |
|
clearScreenDown(callback?: () => void): boolean; |
|
/** |
|
* `writeStream.cursorTo()` moves this `WriteStream`'s cursor to the specified |
|
* position. |
|
* @since v0.7.7 |
|
* @param callback Invoked once the operation completes. |
|
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`. |
|
*/ |
|
cursorTo(x: number, y?: number, callback?: () => void): boolean; |
|
cursorTo(x: number, callback: () => void): boolean; |
|
/** |
|
* `writeStream.moveCursor()` moves this `WriteStream`'s cursor _relative_ to its |
|
* current position. |
|
* @since v0.7.7 |
|
* @param callback Invoked once the operation completes. |
|
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`. |
|
*/ |
|
moveCursor(dx: number, dy: number, callback?: () => void): boolean; |
|
/** |
|
* Returns: |
|
* |
|
* * `1` for 2, |
|
* * `4` for 16, |
|
* * `8` for 256, |
|
* * `24` for 16,777,216 colors supported. |
|
* |
|
* Use this to determine what colors the terminal supports. Due to the nature of |
|
* colors in terminals it is possible to either have false positives or false |
|
* negatives. It depends on process information and the environment variables that |
|
* may lie about what terminal is used. |
|
* It is possible to pass in an `env` object to simulate the usage of a specific |
|
* terminal. This can be useful to check how specific environment settings behave. |
|
* |
|
* To enforce a specific color support, use one of the below environment settings. |
|
* |
|
* * 2 colors: `FORCE_COLOR = 0` (Disables colors) |
|
* * 16 colors: `FORCE_COLOR = 1` |
|
* * 256 colors: `FORCE_COLOR = 2` |
|
* * 16,777,216 colors: `FORCE_COLOR = 3` |
|
* |
|
* Disabling color support is also possible by using the `NO_COLOR` and`NODE_DISABLE_COLORS` environment variables. |
|
* @since v9.9.0 |
|
* @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal. |
|
*/ |
|
getColorDepth(env?: object): number; |
|
/** |
|
* Returns `true` if the `writeStream` supports at least as many colors as provided |
|
* in `count`. Minimum support is 2 (black and white). |
|
* |
|
* This has the same false positives and negatives as described in `writeStream.getColorDepth()`. |
|
* |
|
* ```js |
|
* process.stdout.hasColors(); |
|
* // Returns true or false depending on if `stdout` supports at least 16 colors. |
|
* process.stdout.hasColors(256); |
|
* // Returns true or false depending on if `stdout` supports at least 256 colors. |
|
* process.stdout.hasColors({ TMUX: '1' }); |
|
* // Returns true. |
|
* process.stdout.hasColors(2 ** 24, { TMUX: '1' }); |
|
* // Returns false (the environment setting pretends to support 2 ** 8 colors). |
|
* ``` |
|
* @since v11.13.0, v10.16.0 |
|
* @param [count=16] The number of colors that are requested (minimum 2). |
|
* @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal. |
|
*/ |
|
hasColors(count?: number): boolean; |
|
hasColors(env?: object): boolean; |
|
hasColors(count: number, env?: object): boolean; |
|
/** |
|
* `writeStream.getWindowSize()` returns the size of the TTY |
|
* corresponding to this `WriteStream`. The array is of the type`[numColumns, numRows]` where `numColumns` and `numRows` represent the number |
|
* of columns and rows in the corresponding TTY. |
|
* @since v0.7.7 |
|
*/ |
|
getWindowSize(): [number, number]; |
|
/** |
|
* A `number` specifying the number of columns the TTY currently has. This property |
|
* is updated whenever the `'resize'` event is emitted. |
|
* @since v0.7.7 |
|
*/ |
|
columns: number; |
|
/** |
|
* A `number` specifying the number of rows the TTY currently has. This property |
|
* is updated whenever the `'resize'` event is emitted. |
|
* @since v0.7.7 |
|
*/ |
|
rows: number; |
|
/** |
|
* A `boolean` that is always `true`. |
|
* @since v0.5.8 |
|
*/ |
|
isTTY: boolean; |
|
} |
|
} |
|
declare module 'node:tty' { |
|
export * from 'tty'; |
|
}
|
|
|