mirror of
https://github.com/Sevichecc/Urara-Blog.git
synced 2025-05-02 21:49:31 +08:00
412 lines
18 KiB
Text
Executable file
412 lines
18 KiB
Text
Executable file
/**
|
||
* The `console` module provides a simple debugging console that is similar to the
|
||
* JavaScript console mechanism provided by web browsers.
|
||
*
|
||
* The module exports two specific components:
|
||
*
|
||
* * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
|
||
* * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
|
||
*
|
||
* _**Warning**_: The global console object's methods are neither consistently
|
||
* synchronous like the browser APIs they resemble, nor are they consistently
|
||
* asynchronous like all other Node.js streams. See the `note on process I/O` for
|
||
* more information.
|
||
*
|
||
* Example using the global `console`:
|
||
*
|
||
* ```js
|
||
* console.log('hello world');
|
||
* // Prints: hello world, to stdout
|
||
* console.log('hello %s', 'world');
|
||
* // Prints: hello world, to stdout
|
||
* console.error(new Error('Whoops, something bad happened'));
|
||
* // Prints error message and stack trace to stderr:
|
||
* // Error: Whoops, something bad happened
|
||
* // at [eval]:5:15
|
||
* // at Script.runInThisContext (node:vm:132:18)
|
||
* // at Object.runInThisContext (node:vm:309:38)
|
||
* // at node:internal/process/execution:77:19
|
||
* // at [eval]-wrapper:6:22
|
||
* // at evalScript (node:internal/process/execution:76:60)
|
||
* // at node:internal/main/eval_string:23:3
|
||
*
|
||
* const name = 'Will Robinson';
|
||
* console.warn(`Danger ${name}! Danger!`);
|
||
* // Prints: Danger Will Robinson! Danger!, to stderr
|
||
* ```
|
||
*
|
||
* Example using the `Console` class:
|
||
*
|
||
* ```js
|
||
* const out = getStreamSomehow();
|
||
* const err = getStreamSomehow();
|
||
* const myConsole = new console.Console(out, err);
|
||
*
|
||
* myConsole.log('hello world');
|
||
* // Prints: hello world, to out
|
||
* myConsole.log('hello %s', 'world');
|
||
* // Prints: hello world, to out
|
||
* myConsole.error(new Error('Whoops, something bad happened'));
|
||
* // Prints: [Error: Whoops, something bad happened], to err
|
||
*
|
||
* const name = 'Will Robinson';
|
||
* myConsole.warn(`Danger ${name}! Danger!`);
|
||
* // Prints: Danger Will Robinson! Danger!, to err
|
||
* ```
|
||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/console.js)
|
||
*/
|
||
declare module 'console' {
|
||
import console = require('node:console');
|
||
export = console;
|
||
}
|
||
declare module 'node:console' {
|
||
import { InspectOptions } from 'node:util';
|
||
global {
|
||
// This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
|
||
interface Console {
|
||
Console: console.ConsoleConstructor;
|
||
/**
|
||
* `console.assert()` writes a message if `value` is [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) or omitted. It only
|
||
* writes a message and does not otherwise affect execution. The output always
|
||
* starts with `"Assertion failed"`. If provided, `message` is formatted using `util.format()`.
|
||
*
|
||
* If `value` is [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy), nothing happens.
|
||
*
|
||
* ```js
|
||
* console.assert(true, 'does nothing');
|
||
*
|
||
* console.assert(false, 'Whoops %s work', 'didn\'t');
|
||
* // Assertion failed: Whoops didn't work
|
||
*
|
||
* console.assert();
|
||
* // Assertion failed
|
||
* ```
|
||
* @since v0.1.101
|
||
* @param value The value tested for being truthy.
|
||
* @param message All arguments besides `value` are used as error message.
|
||
*/
|
||
assert(value: any, message?: string, ...optionalParams: any[]): void;
|
||
/**
|
||
* When `stdout` is a TTY, calling `console.clear()` will attempt to clear the
|
||
* TTY. When `stdout` is not a TTY, this method does nothing.
|
||
*
|
||
* The specific operation of `console.clear()` can vary across operating systems
|
||
* and terminal types. For most Linux operating systems, `console.clear()`operates similarly to the `clear` shell command. On Windows, `console.clear()`will clear only the output in the
|
||
* current terminal viewport for the Node.js
|
||
* binary.
|
||
* @since v8.3.0
|
||
*/
|
||
clear(): void;
|
||
/**
|
||
* Maintains an internal counter specific to `label` and outputs to `stdout` the
|
||
* number of times `console.count()` has been called with the given `label`.
|
||
*
|
||
* ```js
|
||
* > console.count()
|
||
* default: 1
|
||
* undefined
|
||
* > console.count('default')
|
||
* default: 2
|
||
* undefined
|
||
* > console.count('abc')
|
||
* abc: 1
|
||
* undefined
|
||
* > console.count('xyz')
|
||
* xyz: 1
|
||
* undefined
|
||
* > console.count('abc')
|
||
* abc: 2
|
||
* undefined
|
||
* > console.count()
|
||
* default: 3
|
||
* undefined
|
||
* >
|
||
* ```
|
||
* @since v8.3.0
|
||
* @param label The display label for the counter.
|
||
*/
|
||
count(label?: string): void;
|
||
/**
|
||
* Resets the internal counter specific to `label`.
|
||
*
|
||
* ```js
|
||
* > console.count('abc');
|
||
* abc: 1
|
||
* undefined
|
||
* > console.countReset('abc');
|
||
* undefined
|
||
* > console.count('abc');
|
||
* abc: 1
|
||
* undefined
|
||
* >
|
||
* ```
|
||
* @since v8.3.0
|
||
* @param label The display label for the counter.
|
||
*/
|
||
countReset(label?: string): void;
|
||
/**
|
||
* The `console.debug()` function is an alias for {@link log}.
|
||
* @since v8.0.0
|
||
*/
|
||
debug(message?: any, ...optionalParams: any[]): void;
|
||
/**
|
||
* Uses `util.inspect()` on `obj` and prints the resulting string to `stdout`.
|
||
* This function bypasses any custom `inspect()` function defined on `obj`.
|
||
* @since v0.1.101
|
||
*/
|
||
dir(obj: any, options?: InspectOptions): void;
|
||
/**
|
||
* This method calls `console.log()` passing it the arguments received.
|
||
* This method does not produce any XML formatting.
|
||
* @since v8.0.0
|
||
*/
|
||
dirxml(...data: any[]): void;
|
||
/**
|
||
* Prints to `stderr` with newline. Multiple arguments can be passed, with the
|
||
* first used as the primary message and all additional used as substitution
|
||
* values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
|
||
*
|
||
* ```js
|
||
* const code = 5;
|
||
* console.error('error #%d', code);
|
||
* // Prints: error #5, to stderr
|
||
* console.error('error', code);
|
||
* // Prints: error 5, to stderr
|
||
* ```
|
||
*
|
||
* If formatting elements (e.g. `%d`) are not found in the first string then `util.inspect()` is called on each argument and the resulting string
|
||
* values are concatenated. See `util.format()` for more information.
|
||
* @since v0.1.100
|
||
*/
|
||
error(message?: any, ...optionalParams: any[]): void;
|
||
/**
|
||
* Increases indentation of subsequent lines by spaces for `groupIndentation`length.
|
||
*
|
||
* If one or more `label`s are provided, those are printed first without the
|
||
* additional indentation.
|
||
* @since v8.5.0
|
||
*/
|
||
group(...label: any[]): void;
|
||
/**
|
||
* An alias for {@link group}.
|
||
* @since v8.5.0
|
||
*/
|
||
groupCollapsed(...label: any[]): void;
|
||
/**
|
||
* Decreases indentation of subsequent lines by spaces for `groupIndentation`length.
|
||
* @since v8.5.0
|
||
*/
|
||
groupEnd(): void;
|
||
/**
|
||
* The `console.info()` function is an alias for {@link log}.
|
||
* @since v0.1.100
|
||
*/
|
||
info(message?: any, ...optionalParams: any[]): void;
|
||
/**
|
||
* Prints to `stdout` with newline. Multiple arguments can be passed, with the
|
||
* first used as the primary message and all additional used as substitution
|
||
* values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
|
||
*
|
||
* ```js
|
||
* const count = 5;
|
||
* console.log('count: %d', count);
|
||
* // Prints: count: 5, to stdout
|
||
* console.log('count:', count);
|
||
* // Prints: count: 5, to stdout
|
||
* ```
|
||
*
|
||
* See `util.format()` for more information.
|
||
* @since v0.1.100
|
||
*/
|
||
log(message?: any, ...optionalParams: any[]): void;
|
||
/**
|
||
* Try to construct a table with the columns of the properties of `tabularData`(or use `properties`) and rows of `tabularData` and log it. Falls back to just
|
||
* logging the argument if it can’t be parsed as tabular.
|
||
*
|
||
* ```js
|
||
* // These can't be parsed as tabular data
|
||
* console.table(Symbol());
|
||
* // Symbol()
|
||
*
|
||
* console.table(undefined);
|
||
* // undefined
|
||
*
|
||
* console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]);
|
||
* // ┌─────────┬─────┬─────┐
|
||
* // │ (index) │ a │ b │
|
||
* // ├─────────┼─────┼─────┤
|
||
* // │ 0 │ 1 │ 'Y' │
|
||
* // │ 1 │ 'Z' │ 2 │
|
||
* // └─────────┴─────┴─────┘
|
||
*
|
||
* console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], ['a']);
|
||
* // ┌─────────┬─────┐
|
||
* // │ (index) │ a │
|
||
* // ├─────────┼─────┤
|
||
* // │ 0 │ 1 │
|
||
* // │ 1 │ 'Z' │
|
||
* // └─────────┴─────┘
|
||
* ```
|
||
* @since v10.0.0
|
||
* @param properties Alternate properties for constructing the table.
|
||
*/
|
||
table(tabularData: any, properties?: ReadonlyArray<string>): void;
|
||
/**
|
||
* Starts a timer that can be used to compute the duration of an operation. Timers
|
||
* are identified by a unique `label`. Use the same `label` when calling {@link timeEnd} to stop the timer and output the elapsed time in
|
||
* suitable time units to `stdout`. For example, if the elapsed
|
||
* time is 3869ms, `console.timeEnd()` displays "3.869s".
|
||
* @since v0.1.104
|
||
*/
|
||
time(label?: string): void;
|
||
/**
|
||
* Stops a timer that was previously started by calling {@link time} and
|
||
* prints the result to `stdout`:
|
||
*
|
||
* ```js
|
||
* console.time('100-elements');
|
||
* for (let i = 0; i < 100; i++) {}
|
||
* console.timeEnd('100-elements');
|
||
* // prints 100-elements: 225.438ms
|
||
* ```
|
||
* @since v0.1.104
|
||
*/
|
||
timeEnd(label?: string): void;
|
||
/**
|
||
* For a timer that was previously started by calling {@link time}, prints
|
||
* the elapsed time and other `data` arguments to `stdout`:
|
||
*
|
||
* ```js
|
||
* console.time('process');
|
||
* const value = expensiveProcess1(); // Returns 42
|
||
* console.timeLog('process', value);
|
||
* // Prints "process: 365.227ms 42".
|
||
* doExpensiveProcess2(value);
|
||
* console.timeEnd('process');
|
||
* ```
|
||
* @since v10.7.0
|
||
*/
|
||
timeLog(label?: string, ...data: any[]): void;
|
||
/**
|
||
* Prints to `stderr` the string `'Trace: '`, followed by the `util.format()` formatted message and stack trace to the current position in the code.
|
||
*
|
||
* ```js
|
||
* console.trace('Show me');
|
||
* // Prints: (stack trace will vary based on where trace is called)
|
||
* // Trace: Show me
|
||
* // at repl:2:9
|
||
* // at REPLServer.defaultEval (repl.js:248:27)
|
||
* // at bound (domain.js:287:14)
|
||
* // at REPLServer.runBound [as eval] (domain.js:300:12)
|
||
* // at REPLServer.<anonymous> (repl.js:412:12)
|
||
* // at emitOne (events.js:82:20)
|
||
* // at REPLServer.emit (events.js:169:7)
|
||
* // at REPLServer.Interface._onLine (readline.js:210:10)
|
||
* // at REPLServer.Interface._line (readline.js:549:8)
|
||
* // at REPLServer.Interface._ttyWrite (readline.js:826:14)
|
||
* ```
|
||
* @since v0.1.104
|
||
*/
|
||
trace(message?: any, ...optionalParams: any[]): void;
|
||
/**
|
||
* The `console.warn()` function is an alias for {@link error}.
|
||
* @since v0.1.100
|
||
*/
|
||
warn(message?: any, ...optionalParams: any[]): void;
|
||
// --- Inspector mode only ---
|
||
/**
|
||
* This method does not display anything unless used in the inspector.
|
||
* Starts a JavaScript CPU profile with an optional label.
|
||
*/
|
||
profile(label?: string): void;
|
||
/**
|
||
* This method does not display anything unless used in the inspector.
|
||
* Stops the current JavaScript CPU profiling session if one has been started and prints the report to the Profiles panel of the inspector.
|
||
*/
|
||
profileEnd(label?: string): void;
|
||
/**
|
||
* This method does not display anything unless used in the inspector.
|
||
* Adds an event with the label `label` to the Timeline panel of the inspector.
|
||
*/
|
||
timeStamp(label?: string): void;
|
||
}
|
||
/**
|
||
* The `console` module provides a simple debugging console that is similar to the
|
||
* JavaScript console mechanism provided by web browsers.
|
||
*
|
||
* The module exports two specific components:
|
||
*
|
||
* * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
|
||
* * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
|
||
*
|
||
* _**Warning**_: The global console object's methods are neither consistently
|
||
* synchronous like the browser APIs they resemble, nor are they consistently
|
||
* asynchronous like all other Node.js streams. See the `note on process I/O` for
|
||
* more information.
|
||
*
|
||
* Example using the global `console`:
|
||
*
|
||
* ```js
|
||
* console.log('hello world');
|
||
* // Prints: hello world, to stdout
|
||
* console.log('hello %s', 'world');
|
||
* // Prints: hello world, to stdout
|
||
* console.error(new Error('Whoops, something bad happened'));
|
||
* // Prints error message and stack trace to stderr:
|
||
* // Error: Whoops, something bad happened
|
||
* // at [eval]:5:15
|
||
* // at Script.runInThisContext (node:vm:132:18)
|
||
* // at Object.runInThisContext (node:vm:309:38)
|
||
* // at node:internal/process/execution:77:19
|
||
* // at [eval]-wrapper:6:22
|
||
* // at evalScript (node:internal/process/execution:76:60)
|
||
* // at node:internal/main/eval_string:23:3
|
||
*
|
||
* const name = 'Will Robinson';
|
||
* console.warn(`Danger ${name}! Danger!`);
|
||
* // Prints: Danger Will Robinson! Danger!, to stderr
|
||
* ```
|
||
*
|
||
* Example using the `Console` class:
|
||
*
|
||
* ```js
|
||
* const out = getStreamSomehow();
|
||
* const err = getStreamSomehow();
|
||
* const myConsole = new console.Console(out, err);
|
||
*
|
||
* myConsole.log('hello world');
|
||
* // Prints: hello world, to out
|
||
* myConsole.log('hello %s', 'world');
|
||
* // Prints: hello world, to out
|
||
* myConsole.error(new Error('Whoops, something bad happened'));
|
||
* // Prints: [Error: Whoops, something bad happened], to err
|
||
*
|
||
* const name = 'Will Robinson';
|
||
* myConsole.warn(`Danger ${name}! Danger!`);
|
||
* // Prints: Danger Will Robinson! Danger!, to err
|
||
* ```
|
||
* @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/console.js)
|
||
*/
|
||
namespace console {
|
||
interface ConsoleConstructorOptions {
|
||
stdout: NodeJS.WritableStream;
|
||
stderr?: NodeJS.WritableStream | undefined;
|
||
ignoreErrors?: boolean | undefined;
|
||
colorMode?: boolean | 'auto' | undefined;
|
||
inspectOptions?: InspectOptions | undefined;
|
||
/**
|
||
* Set group indentation
|
||
* @default 2
|
||
*/
|
||
groupIndentation?: number | undefined;
|
||
}
|
||
interface ConsoleConstructor {
|
||
prototype: Console;
|
||
new (stdout: NodeJS.WritableStream, stderr?: NodeJS.WritableStream, ignoreErrors?: boolean): Console;
|
||
new (options: ConsoleConstructorOptions): Console;
|
||
}
|
||
}
|
||
var console: Console;
|
||
}
|
||
export = globalThis.console;
|
||
}
|