build(deps-dev): bump @types/node from 20.4.4 to 20.5.0 #1585
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?s=60&v=4){kind=small}
Bumps [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node) from 20.4.4 to 20.5.0. - [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases) - [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node) --- updated-dependencies: - dependency-name: "@types/node" dependency-type: direct:development update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
bot
added
dependencies
Diff between @types/node 20.4.4 and 20.5.0diff --git a/README.md b/README.md
index v20.4.4..v20.5.0 100777
--- a/README.md
+++ b/README.md
@@ -9,8 +9,8 @@
### Additional Details
- * Last updated: Sat, 22 Jul 2023 12:32:49 GMT
+ * Last updated: Sun, 13 Aug 2023 19:32:51 GMT
* Dependencies: none
* Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
# Credits
-These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), [Matteo Collina](https://github.com/mcollina), and [Dmitry Semigradsky](https://github.com/Semigradsky).
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), [Matteo Collina](https://github.com/mcollina), and [Dmitry Semigradsky](https://github.com/Semigradsky).
diff --git a/child_process.d.ts b/child_process.d.ts
index v20.4.4..v20.5.0 100777
--- a/child_process.d.ts
+++ b/child_process.d.ts
@@ -304,4 +304,9 @@
kill(signal?: NodeJS.Signals | number): boolean;
/**
+ * Calls {@link ChildProcess.kill} with `'SIGTERM'`.
+ * @since v20.5.0
+ */
+ [Symbol.dispose](): void;
+ /**
* When an IPC channel has been established between the parent and child (
* i.e. when using {@link fork}), the `subprocess.send()` method can
diff --git a/dgram.d.ts b/dgram.d.ts
index v20.4.4..v20.5.0 100777
--- a/dgram.d.ts
+++ b/dgram.d.ts
@@ -539,4 +539,9 @@
prependOnceListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+ /**
+ * Calls `socket.close()` and returns a promise that fulfills when the socket has closed.
+ * @since v20.5.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
}
diff --git a/events.d.ts b/events.d.ts
index v20.4.4..v20.5.0 100777
--- a/events.d.ts
+++ b/events.d.ts
@@ -340,4 +340,39 @@
static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
/**
+ * Listens once to the `abort` event on the provided `signal`.
+ *
+ * Listening to the `abort` event on abort signals is unsafe and may
+ * lead to resource leaks since another third party with the signal can
+ * call `e.stopImmediatePropagation()`. Unfortunately Node.js cannot change
+ * this since it would violate the web standard. Additionally, the original
+ * API makes it easy to forget to remove listeners.
+ *
+ * This API allows safely using `AbortSignal`s in Node.js APIs by solving these
+ * two issues by listening to the event such that `stopImmediatePropagation` does
+ * not prevent the listener from running.
+ *
+ * Returns a disposable so that it may be unsubscribed from more easily.
+ *
+ * ```js
+ * import { addAbortListener } from 'node:events';
+ *
+ * function example(signal) {
+ * let disposable;
+ * try {
+ * signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
+ * disposable = addAbortListener(signal, (e) => {
+ * // Do something when signal is aborted.
+ * });
+ * } finally {
+ * disposable?.[Symbol.dispose]();
+ * }
+ * }
+ * ```
+ * @since v20.5.0
+ * @experimental
+ * @return that removes the `abort` listener.
+ */
+ static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
+ /**
* This symbol shall be used to install a listener for only monitoring `'error'`events. Listeners installed using this symbol are called before the regular`'error'` listeners are called.
*
diff --git a/globals.d.ts b/globals.d.ts
index v20.4.4..v20.5.0 100777
--- a/globals.d.ts
+++ b/globals.d.ts
@@ -85,4 +85,26 @@
//#endregion borrowed
+//#region Disposable
+interface SymbolConstructor {
+ /**
+ * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
+ */
+ readonly dispose: unique symbol;
+
+ /**
+ * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
+ */
+ readonly asyncDispose: unique symbol;
+}
+
+interface Disposable {
+ [Symbol.dispose](): void;
+}
+
+interface AsyncDisposable {
+ [Symbol.asyncDispose](): PromiseLike<void>;
+}
+//#endregion Disposable
+
//#region ArrayLike.at()
interface RelativeIndexable<T> {
diff --git a/index.d.ts b/index.d.ts
index v20.4.4..v20.5.0 100777
--- a/index.d.ts
+++ b/index.d.ts
@@ -1,3 +1,3 @@
-// Type definitions for non-npm package Node.js 20.4
+// Type definitions for non-npm package Node.js 20.5
// Project: https://nodejs.org/
// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
@@ -22,5 +22,4 @@
// Parambir Singh <https://github.com/parambirs>
// Sebastian Silbermann <https://github.com/eps1lon>
-// Simon Schick <https://github.com/SimonSchick>
// Thomas den Hollander <https://github.com/ThomasdenH>
// Wilco Bakker <https://github.com/WilcoBakker>
diff --git a/net.d.ts b/net.d.ts
index v20.4.4..v20.5.0 100777
--- a/net.d.ts
+++ b/net.d.ts
@@ -640,4 +640,9 @@
prependOnceListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: 'drop', listener: (data?: DropArgument) => void): this;
+ /**
+ * Calls {@link Server.close()} and returns a promise that fulfills when the server has closed.
+ * @since v20.5.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
type IPVersion = 'ipv4' | 'ipv6';
diff --git a/package.json b/package.json
index v20.4.4..v20.5.0 100777
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
{
"name": "@types/node",
- "version": "20.4.4",
+ "version": "20.5.0",
"description": "TypeScript definitions for Node.js",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
@@ -112,9 +112,4 @@
},
{
- "name": "Simon Schick",
- "url": "https://github.com/SimonSchick",
- "githubUsername": "SimonSchick"
- },
- {
"name": "Thomas den Hollander",
"url": "https://github.com/ThomasdenH",
@@ -233,5 +228,5 @@
"scripts": {},
"dependencies": {},
- "typesPublisherContentHash": "3855eba1e7ca267925b74e739e5e432e9cc50d4b0e66091d7500d97ce36348d8",
+ "typesPublisherContentHash": "83e291a6a60ec56a2b56b6b885ae9a0ea199888a482d63f4a22270483f82f2a9",
"typeScriptVersion": "4.3"
}
\ No newline at end of file
diff --git a/perf_hooks.d.ts b/perf_hooks.d.ts
index v20.4.4..v20.5.0 100777
--- a/perf_hooks.d.ts
+++ b/perf_hooks.d.ts
@@ -32,5 +32,5 @@
declare module 'perf_hooks' {
import { AsyncResource } from 'node:async_hooks';
- type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
+ type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http' | 'dns';
interface NodeGCPerformanceDetail {
/**
diff --git a/stream.d.ts b/stream.d.ts
index v20.4.4..v20.5.0 100777
--- a/stream.d.ts
+++ b/stream.d.ts
@@ -23,4 +23,7 @@
import * as streamConsumers from 'node:stream/consumers';
import * as streamWeb from 'node:stream/web';
+
+ type ComposeFnParam = (source: any) => void;
+
class internal extends EventEmitter {
pipe<T extends NodeJS.WritableStream>(
@@ -30,4 +33,5 @@
}
): T;
+ compose<T extends NodeJS.ReadableStream>(stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>, options?: { signal: AbortSignal }): T;
}
import Stream = internal.Stream;
@@ -474,4 +478,9 @@
removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
[Symbol.asyncIterator](): AsyncIterableIterator<any>;
+ /**
+ * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
+ * @since v20.4.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
import WritableOptions = internal.WritableOptions;
diff --git a/test.d.ts b/test.d.ts
index v20.4.4..v20.5.0 100777
--- a/test.d.ts
+++ b/test.d.ts
@@ -77,8 +77,9 @@
* If any tests fail, the process exit code is set to `1`.
* @since v18.0.0, v16.17.0
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/test.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.4.0/lib/test.js)
*/
declare module 'node:test' {
import { Readable } from 'node:stream';
+ import { AsyncResource } from 'node:async_hooks';
/**
* ```js
@@ -259,4 +260,14 @@
*/
type SuiteFn = (s: SuiteContext) => void | Promise<void>;
+ interface TestShard {
+ /**
+ * A positive integer between 1 and `<total>` that specifies the index of the shard to run.
+ */
+ index: number;
+ /**
+ * A positive integer that specifies the total number of shards to split the test files to.
+ */
+ total: number;
+ }
interface RunOptions {
/**
@@ -296,5 +307,28 @@
*/
testNamePatterns?: string | RegExp | string[] | RegExp[];
+ /**
+ * A function that accepts the TestsStream instance and can be used to setup listeners before any tests are run.
+ */
+ setup?: (root: Test) => void | Promise<void>;
+ /**
+ * Whether to run in watch mode or not.
+ * @default false
+ */
+ watch?: boolean | undefined;
+ /**
+ * Running tests in a specific shard.
+ * @default undefined
+ */
+ shard?: TestShard | undefined;
}
+ class Test extends AsyncResource {
+ concurrency: number;
+ nesting: number;
+ only: boolean;
+ reporter: TestsStream;
+ runOnlySubtests: boolean;
+ testNumber: number;
+ timeout: number | null;
+ }
/**
* A successful call to `run()` method will return a new `TestsStream` object, streaming a series of events representing the execution of the tests.`TestsStream` will emit events, in the
@@ -1193,4 +1227,8 @@
*/
runAll(): void;
+ /**
+ * Calls {@link MockTimers.reset()}.
+ */
+ [Symbol.dispose](): void;
}
export { test as default, run, test, describe, it, before, after, beforeEach, afterEach, mock, skip, only, todo };
@@ -1219,9 +1257,14 @@
* The duration of the test in milliseconds.
*/
- duration: number;
+ duration_ms: number;
/**
* The error thrown by the test.
*/
error: Error;
+ /**
+ * The type of the test, used to denote whether this is a suite.
+ * @since 20.0.0, 19.9.0, 18.17.0
+ */
+ type?: 'suite';
};
/**
@@ -1258,5 +1301,10 @@
* The duration of the test in milliseconds.
*/
- duration: number;
+ duration_ms: number;
+ /**
+ * The type of the test, used to denote whether this is a suite.
+ * @since 20.0.0, 19.9.0, 18.17.0
+ */
+ type?: 'suite';
};
/**
@@ -1333,4 +1381,32 @@
message: string;
}
+interface TestEnqueue {
+ /**
+ * The test name
+ */
+ name: string;
+ /**
+ * The path of the test file, undefined if test is not ran through a file.
+ */
+ file?: string;
+ /**
+ * The nesting level of the test.
+ */
+ nesting: number;
+}
+interface TestDequeue {
+ /**
+ * The test name
+ */
+ name: string;
+ /**
+ * The path of the test file, undefined if test is not ran through a file.
+ */
+ file?: string;
+ /**
+ * The nesting level of the test.
+ */
+ nesting: number;
+}
/**
@@ -1361,5 +1437,8 @@
| { type: 'test:start', data: TestStart }
| { type: 'test:stderr', data: TestStderr }
- | { type: 'test:stdout', data: TestStdout };
+ | { type: 'test:stdout', data: TestStdout }
+ | { type: 'test:enqueue', data: TestEnqueue }
+ | { type: 'test:dequeue', data: TestDequeue }
+ | { type: 'test:watch:drained' };
type TestEventGenerator = AsyncGenerator<TestEvent, void>;
@@ -1380,4 +1459,4 @@
constructor();
}
- export { dot, tap, Spec as spec };
+ export { dot, tap, Spec as spec, TestEvent };
}
diff --git a/timers.d.ts b/timers.d.ts
index v20.4.4..v20.5.0 100777
--- a/timers.d.ts
+++ b/timers.d.ts
@@ -69,4 +69,9 @@
hasRef(): boolean;
_onImmediate: Function; // to distinguish it from the Timeout class
+ /**
+ * Cancels the immediate. This is similar to calling `clearImmediate()`.
+ * @since v20.5.0
+ */
+ [Symbol.dispose](): void;
}
/**
@@ -115,4 +120,9 @@
refresh(): this;
[Symbol.toPrimitive](): number;
+ /**
+ * Cancels the timeout.
+ * @since v20.5.0
+ */
+ [Symbol.dispose](): void;
}
}
@@ -164,8 +174,8 @@
* @return for use with {@link clearInterval}
*/
- function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
+ function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
- function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
+ function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
namespace setInterval {
const __promisify__: typeof setIntervalPromise;
diff --git a/fs/promises.d.ts b/fs/promises.d.ts
index v20.4.4..v20.5.0 100777
--- a/fs/promises.d.ts
+++ b/fs/promises.d.ts
@@ -457,4 +457,9 @@
*/
close(): Promise<void>;
+ /**
+ * An alias for {@link FileHandle.close()}.
+ * @since v20.4.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
const constants: typeof fsConstants;
diff --git a/ts4.8/child_process.d.ts b/ts4.8/child_process.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/child_process.d.ts
+++ b/ts4.8/child_process.d.ts
@@ -304,4 +304,9 @@
kill(signal?: NodeJS.Signals | number): boolean;
/**
+ * Calls {@link ChildProcess.kill} with `'SIGTERM'`.
+ * @since v20.5.0
+ */
+ [Symbol.dispose](): void;
+ /**
* When an IPC channel has been established between the parent and child (
* i.e. when using {@link fork}), the `subprocess.send()` method can
diff --git a/ts4.8/dgram.d.ts b/ts4.8/dgram.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/dgram.d.ts
+++ b/ts4.8/dgram.d.ts
@@ -539,4 +539,9 @@
prependOnceListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+ /**
+ * Calls `socket.close()` and returns a promise that fulfills when the socket has closed.
+ * @since v20.5.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
}
diff --git a/ts4.8/events.d.ts b/ts4.8/events.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/events.d.ts
+++ b/ts4.8/events.d.ts
@@ -340,4 +340,39 @@
static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
/**
+ * Listens once to the `abort` event on the provided `signal`.
+ *
+ * Listening to the `abort` event on abort signals is unsafe and may
+ * lead to resource leaks since another third party with the signal can
+ * call `e.stopImmediatePropagation()`. Unfortunately Node.js cannot change
+ * this since it would violate the web standard. Additionally, the original
+ * API makes it easy to forget to remove listeners.
+ *
+ * This API allows safely using `AbortSignal`s in Node.js APIs by solving these
+ * two issues by listening to the event such that `stopImmediatePropagation` does
+ * not prevent the listener from running.
+ *
+ * Returns a disposable so that it may be unsubscribed from more easily.
+ *
+ * ```js
+ * import { addAbortListener } from 'node:events';
+ *
+ * function example(signal) {
+ * let disposable;
+ * try {
+ * signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
+ * disposable = addAbortListener(signal, (e) => {
+ * // Do something when signal is aborted.
+ * });
+ * } finally {
+ * disposable?.[Symbol.dispose]();
+ * }
+ * }
+ * ```
+ * @since v20.5.0
+ * @experimental
+ * @return that removes the `abort` listener.
+ */
+ static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
+ /**
* This symbol shall be used to install a listener for only monitoring `'error'`events. Listeners installed using this symbol are called before the regular`'error'` listeners are called.
*
diff --git a/ts4.8/globals.d.ts b/ts4.8/globals.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/globals.d.ts
+++ b/ts4.8/globals.d.ts
@@ -85,4 +85,26 @@
//#endregion borrowed
+//#region Disposable
+interface SymbolConstructor {
+ /**
+ * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
+ */
+ readonly dispose: unique symbol;
+
+ /**
+ * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
+ */
+ readonly asyncDispose: unique symbol;
+}
+
+interface Disposable {
+ [Symbol.dispose](): void;
+}
+
+interface AsyncDisposable {
+ [Symbol.asyncDispose](): PromiseLike<void>;
+}
+//#endregion Disposable
+
//#region ArrayLike.at()
interface RelativeIndexable<T> {
diff --git a/ts4.8/net.d.ts b/ts4.8/net.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/net.d.ts
+++ b/ts4.8/net.d.ts
@@ -640,4 +640,9 @@
prependOnceListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: 'drop', listener: (data?: DropArgument) => void): this;
+ /**
+ * Calls {@link Server.close()} and returns a promise that fulfills when the server has closed.
+ * @since v20.5.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
type IPVersion = 'ipv4' | 'ipv6';
diff --git a/ts4.8/stream.d.ts b/ts4.8/stream.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/stream.d.ts
+++ b/ts4.8/stream.d.ts
@@ -23,4 +23,7 @@
import * as streamConsumers from 'node:stream/consumers';
import * as streamWeb from 'node:stream/web';
+
+ type ComposeFnParam = (source: any) => void;
+
class internal extends EventEmitter {
pipe<T extends NodeJS.WritableStream>(
@@ -30,5 +33,744 @@
}
): T;
+ compose<T extends NodeJS.ReadableStream>(stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>, options?: { signal: AbortSignal }): T;
}
+ import Stream = internal.Stream;
+ import Readable = internal.Readable;
+ import ReadableOptions = internal.ReadableOptions;
+ class ReadableBase extends Stream implements NodeJS.ReadableStream {
+ /**
+ * A utility method for creating Readable Streams out of iterators.
+ */
+ static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
+ /**
+ * Returns whether the stream has been read from or cancelled.
+ * @since v16.8.0
+ */
+ static isDisturbed(stream: Readable | NodeJS.ReadableStream): boolean;
+ /**
+ * Returns whether the stream was destroyed or errored before emitting `'end'`.
+ * @since v16.8.0
+ * @experimental
+ */
+ readonly readableAborted: boolean;
+ /**
+ * Is `true` if it is safe to call `readable.read()`, which means
+ * the stream has not been destroyed or emitted `'error'` or `'end'`.
+ * @since v11.4.0
+ */
+ readable: boolean;
+ /**
+ * Returns whether `'data'` has been emitted.
+ * @since v16.7.0, v14.18.0
+ * @experimental
+ */
+ readonly readableDidRead: boolean;
+ /**
+ * Getter for the property `encoding` of a given `Readable` stream. The `encoding`property can be set using the `readable.setEncoding()` method.
+ * @since v12.7.0
+ */
+ readonly readableEncoding: BufferEncoding | null;
+ /**
+ * Becomes `true` when `'end'` event is emitted.
+ * @since v12.9.0
+ */
+ readonly readableEnded: boolean;
+ /**
+ * This property reflects the current state of a `Readable` stream as described
+ * in the `Three states` section.
+ * @since v9.4.0
+ */
+ readonly readableFlowing: boolean | null;
+ /**
+ * Returns the value of `highWaterMark` passed when creating this `Readable`.
+ * @since v9.3.0
+ */
+ readonly readableHighWaterMark: number;
+ /**
+ * This property contains the number of bytes (or objects) in the queue
+ * ready to be read. The value provides introspection data regarding
+ * the status of the `highWaterMark`.
+ * @since v9.4.0
+ */
+ readonly readableLength: number;
+ /**
+ * Getter for the property `objectMode` of a given `Readable` stream.
+ * @since v12.3.0
+ */
+ readonly readableObjectMode: boolean;
+ /**
+ * Is `true` after `readable.destroy()` has been called.
+ * @since v8.0.0
+ */
+ destroyed: boolean;
+ /**
+ * Is `true` after `'close'` has been emitted.
+ * @since v18.0.0
+ */
+ readonly closed: boolean;
+ /**
+ * Returns error if the stream has been destroyed with an error.
+ * @since v18.0.0
+ */
+ readonly errored: Error | null;
+ constructor(opts?: ReadableOptions);
+ _construct?(callback: (error?: Error | null) => void): void;
+ _read(size: number): void;
+ /**
+ * The `readable.read()` method reads data out of the internal buffer and
+ * returns it. If no data is available to be read, `null` is returned. By default,
+ * the data is returned as a `Buffer` object unless an encoding has been
+ * specified using the `readable.setEncoding()` method or the stream is operating
+ * in object mode.
+ *
+ * The optional `size` argument specifies a specific number of bytes to read. If`size` bytes are not available to be read, `null` will be returned _unless_the stream has ended, in which
+ * case all of the data remaining in the internal
+ * buffer will be returned.
+ *
+ * If the `size` argument is not specified, all of the data contained in the
+ * internal buffer will be returned.
+ *
+ * The `size` argument must be less than or equal to 1 GiB.
+ *
+ * The `readable.read()` method should only be called on `Readable` streams
+ * operating in paused mode. In flowing mode, `readable.read()` is called
+ * automatically until the internal buffer is fully drained.
+ *
+ * ```js
+ * const readable = getReadableStreamSomehow();
+ *
+ * // 'readable' may be triggered multiple times as data is buffered in
+ * readable.on('readable', () => {
+ * let chunk;
+ * console.log('Stream is readable (new data received in buffer)');
+ * // Use a loop to make sure we read all currently available data
+ * while (null !== (chunk = readable.read())) {
+ * console.log(`Read ${chunk.length} bytes of data...`);
+ * }
+ * });
+ *
+ * // 'end' will be triggered once when there is no more data available
+ * readable.on('end', () => {
+ * console.log('Reached end of stream.');
+ * });
+ * ```
+ *
+ * Each call to `readable.read()` returns a chunk of data, or `null`. The chunks
+ * are not concatenated. A `while` loop is necessary to consume all data
+ * currently in the buffer. When reading a large file `.read()` may return `null`,
+ * having consumed all buffered content so far, but there is still more data to
+ * come not yet buffered. In this case a new `'readable'` event will be emitted
+ * when there is more data in the buffer. Finally the `'end'` event will be
+ * emitted when there is no more data to come.
+ *
+ * Therefore to read a file's whole contents from a `readable`, it is necessary
+ * to collect chunks across multiple `'readable'` events:
+ *
+ * ```js
+ * const chunks = [];
+ *
+ * readable.on('readable', () => {
+ * let chunk;
+ * while (null !== (chunk = readable.read())) {
+ * chunks.push(chunk);
+ * }
+ * });
+ *
+ * readable.on('end', () => {
+ * const content = chunks.join('');
+ * });
+ * ```
+ *
+ * A `Readable` stream in object mode will always return a single item from
+ * a call to `readable.read(size)`, regardless of the value of the`size` argument.
+ *
+ * If the `readable.read()` method returns a chunk of data, a `'data'` event will
+ * also be emitted.
+ *
+ * Calling {@link read} after the `'end'` event has
+ * been emitted will return `null`. No runtime error will be raised.
+ * @since v0.9.4
+ * @param size Optional argument to specify how much data to read.
+ */
+ read(size?: number): any;
+ /**
+ * The `readable.setEncoding()` method sets the character encoding for
+ * data read from the `Readable` stream.
+ *
+ * By default, no encoding is assigned and stream data will be returned as`Buffer` objects. Setting an encoding causes the stream data
+ * to be returned as strings of the specified encoding rather than as `Buffer`objects. For instance, calling `readable.setEncoding('utf8')` will cause the
+ * output data to be interpreted as UTF-8 data, and passed as strings. Calling`readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal
+ * string format.
+ *
+ * The `Readable` stream will properly handle multi-byte characters delivered
+ * through the stream that would otherwise become improperly decoded if simply
+ * pulled from the stream as `Buffer` objects.
+ *
+ * ```js
+ * const readable = getReadableStreamSomehow();
+ * readable.setEncoding('utf8');
+ * readable.on('data', (chunk) => {
+ * assert.equal(typeof chunk, 'string');
+ * console.log('Got %d characters of string data:', chunk.length);
+ * });
+ * ```
+ * @since v0.9.4
+ * @param encoding The encoding to use.
+ */
+ setEncoding(encoding: BufferEncoding): this;
+ /**
+ * The `readable.pause()` method will cause a stream in flowing mode to stop
+ * emitting `'data'` events, switching out of flowing mode. Any data that
+ * becomes available will remain in the internal buffer.
+ *
+ * ```js
+ * const readable = getReadableStreamSomehow();
+ * readable.on('data', (chunk) => {
+ * console.log(`Received ${chunk.length} bytes of data.`);
+ * readable.pause();
+ * console.log('There will be no additional data for 1 second.');
+ * setTimeout(() => {
+ * console.log('Now data will start flowing again.');
+ * readable.resume();
+ * }, 1000);
+ * });
+ * ```
+ *
+ * The `readable.pause()` method has no effect if there is a `'readable'`event listener.
+ * @since v0.9.4
+ */
+ pause(): this;
+ /**
+ * The `readable.resume()` method causes an explicitly paused `Readable` stream to
+ * resume emitting `'data'` events, switching the stream into flowing mode.
+ *
+ * The `readable.resume()` method can be used to fully consume the data from a
+ * stream without actually processing any of that data:
+ *
+ * ```js
+ * getReadableStreamSomehow()
+ * .resume()
+ * .on('end', () => {
+ * console.log('Reached the end, but did not read anything.');
+ * });
+ * ```
+ *
+ * The `readable.resume()` method has no effect if there is a `'readable'`event listener.
+ * @since v0.9.4
+ */
+ resume(): this;
+ /**
+ * The `readable.isPaused()` method returns the current operating state of the`Readable`. This is used primarily by the mechanism that underlies the`readable.pipe()` method. In most
+ * typical cases, there will be no reason to
+ * use this method directly.
+ *
+ * ```js
+ * const readable = new stream.Readable();
+ *
+ * readable.isPaused(); // === false
+ * readable.pause();
+ * readable.isPaused(); // === true
+ * readable.resume();
+ * readable.isPaused(); // === false
+ * ```
+ * @since v0.11.14
+ */
+ isPaused(): boolean;
+ /**
+ * The `readable.unpipe()` method detaches a `Writable` stream previously attached
+ * using the {@link pipe} method.
+ *
+ * If the `destination` is not specified, then _all_ pipes are detached.
+ *
+ * If the `destination` is specified, but no pipe is set up for it, then
+ * the method does nothing.
+ *
+ * ```js
+ * const fs = require('node:fs');
+ * const readable = getReadableStreamSomehow();
+ * const writable = fs.createWriteStream('file.txt');
+ * // All the data from readable goes into 'file.txt',
+ * // but only for the first second.
+ * readable.pipe(writable);
+ * setTimeout(() => {
+ * console.log('Stop writing to file.txt.');
+ * readable.unpipe(writable);
+ * console.log('Manually close the file stream.');
+ * writable.end();
+ * }, 1000);
+ * ```
+ * @since v0.9.4
+ * @param destination Optional specific stream to unpipe
+ */
+ unpipe(destination?: NodeJS.WritableStream): this;
+ /**
+ * Passing `chunk` as `null` signals the end of the stream (EOF) and behaves the
+ * same as `readable.push(null)`, after which no more data can be written. The EOF
+ * signal is put at the end of the buffer and any buffered data will still be
+ * flushed.
+ *
+ * The `readable.unshift()` method pushes a chunk of data back into the internal
+ * buffer. This is useful in certain situations where a stream is being consumed by
+ * code that needs to "un-consume" some amount of data that it has optimistically
+ * pulled out of the source, so that the data can be passed on to some other party.
+ *
+ * The `stream.unshift(chunk)` method cannot be called after the `'end'` event
+ * has been emitted or a runtime error will be thrown.
+ *
+ * Developers using `stream.unshift()` often should consider switching to
+ * use of a `Transform` stream instead. See the `API for stream implementers` section for more information.
+ *
+ * ```js
+ * // Pull off a header delimited by \n\n.
+ * // Use unshift() if we get too much.
+ * // Call the callback with (error, header, stream).
+ * const { StringDecoder } = require('node:string_decoder');
+ * function parseHeader(stream, callback) {
+ * stream.on('error', callback);
+ * stream.on('readable', onReadable);
+ * const decoder = new StringDecoder('utf8');
+ * let header = '';
+ * function onReadable() {
+ * let chunk;
+ * while (null !== (chunk = stream.read())) {
+ * const str = decoder.write(chunk);
+ * if (str.includes('\n\n')) {
+ * // Found the header boundary.
+ * const split = str.split(/\n\n/);
+ * header += split.shift();
+ * const remaining = split.join('\n\n');
+ * const buf = Buffer.from(remaining, 'utf8');
+ * stream.removeListener('error', callback);
+ * // Remove the 'readable' listener before unshifting.
+ * stream.removeListener('readable', onReadable);
+ * if (buf.length)
+ * stream.unshift(buf);
+ * // Now the body of the message can be read from the stream.
+ * callback(null, header, stream);
+ * return;
+ * }
+ * // Still reading the header.
+ * header += str;
+ * }
+ * }
+ * }
+ * ```
+ *
+ * Unlike {@link push}, `stream.unshift(chunk)` will not
+ * end the reading process by resetting the internal reading state of the stream.
+ * This can cause unexpected results if `readable.unshift()` is called during a
+ * read (i.e. from within a {@link _read} implementation on a
+ * custom stream). Following the call to `readable.unshift()` with an immediate {@link push} will reset the reading state appropriately,
+ * however it is best to simply avoid calling `readable.unshift()` while in the
+ * process of performing a read.
+ * @since v0.9.11
+ * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array`, or `null`. For object mode
+ * streams, `chunk` may be any JavaScript value.
+ * @param encoding Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`.
+ */
+ unshift(chunk: any, encoding?: BufferEncoding): void;
+ /**
+ * Prior to Node.js 0.10, streams did not implement the entire `node:stream`module API as it is currently defined. (See `Compatibility` for more
+ * information.)
+ *
+ * When using an older Node.js library that emits `'data'` events and has a {@link pause} method that is advisory only, the`readable.wrap()` method can be used to create a `Readable`
+ * stream that uses
+ * the old stream as its data source.
+ *
+ * It will rarely be necessary to use `readable.wrap()` but the method has been
+ * provided as a convenience for interacting with older Node.js applications and
+ * libraries.
+ *
+ * ```js
+ * const { OldReader } = require('./old-api-module.js');
+ * const { Readable } = require('node:stream');
+ * const oreader = new OldReader();
+ * const myReader = new Readable().wrap(oreader);
+ *
+ * myReader.on('readable', () => {
+ * myReader.read(); // etc.
+ * });
+ * ```
+ * @since v0.9.4
+ * @param stream An "old style" readable stream
+ */
+ wrap(stream: NodeJS.ReadableStream): this;
+ push(chunk: any, encoding?: BufferEncoding): boolean;
+ _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+ /**
+ * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the readable
+ * stream will release any internal resources and subsequent calls to `push()`will be ignored.
+ *
+ * Once `destroy()` has been called any further calls will be a no-op and no
+ * further errors except from `_destroy()` may be emitted as `'error'`.
+ *
+ * Implementors should not override this method, but instead implement `readable._destroy()`.
+ * @since v8.0.0
+ * @param error Error which will be passed as payload in `'error'` event
+ */
+ destroy(error?: Error): this;
+ /**
+ * Event emitter
+ * The defined events on documents including:
+ * 1. close
+ * 2. data
+ * 3. end
+ * 4. error
+ * 5. pause
+ * 6. readable
+ * 7. resume
+ */
+ addListener(event: 'close', listener: () => void): this;
+ addListener(event: 'data', listener: (chunk: any) => void): this;
+ addListener(event: 'end', listener: () => void): this;
+ addListener(event: 'error', listener: (err: Error) => void): this;
+ addListener(event: 'pause', listener: () => void): this;
+ addListener(event: 'readable', listener: () => void): this;
+ addListener(event: 'resume', listener: () => void): this;
+ addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ emit(event: 'close'): boolean;
+ emit(event: 'data', chunk: any): boolean;
+ emit(event: 'end'): boolean;
+ emit(event: 'error', err: Error): boolean;
+ emit(event: 'pause'): boolean;
+ emit(event: 'readable'): boolean;
+ emit(event: 'resume'): boolean;
+ emit(event: string | symbol, ...args: any[]): boolean;
+ on(event: 'close', listener: () => void): this;
+ on(event: 'data', listener: (chunk: any) => void): this;
+ on(event: 'end', listener: () => void): this;
+ on(event: 'error', listener: (err: Error) => void): this;
+ on(event: 'pause', listener: () => void): this;
+ on(event: 'readable', listener: () => void): this;
+ on(event: 'resume', listener: () => void): this;
+ on(event: string | symbol, listener: (...args: any[]) => void): this;
+ once(event: 'close', listener: () => void): this;
+ once(event: 'data', listener: (chunk: any) => void): this;
+ once(event: 'end', listener: () => void): this;
+ once(event: 'error', listener: (err: Error) => void): this;
+ once(event: 'pause', listener: () => void): this;
+ once(event: 'readable', listener: () => void): this;
+ once(event: 'resume', listener: () => void): this;
+ once(event: string | symbol, listener: (...args: any[]) => void): this;
+ prependListener(event: 'close', listener: () => void): this;
+ prependListener(event: 'data', listener: (chunk: any) => void): this;
+ prependListener(event: 'end', listener: () => void): this;
+ prependListener(event: 'error', listener: (err: Error) => void): this;
+ prependListener(event: 'pause', listener: () => void): this;
+ prependListener(event: 'readable', listener: () => void): this;
+ prependListener(event: 'resume', listener: () => void): this;
+ prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ prependOnceListener(event: 'close', listener: () => void): this;
+ prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
+ prependOnceListener(event: 'end', listener: () => void): this;
+ prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+ prependOnceListener(event: 'pause', listener: () => void): this;
+ prependOnceListener(event: 'readable', listener: () => void): this;
+ prependOnceListener(event: 'resume', listener: () => void): this;
+ prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ removeListener(event: 'close', listener: () => void): this;
+ removeListener(event: 'data', listener: (chunk: any) => void): this;
+ removeListener(event: 'end', listener: () => void): this;
+ removeListener(event: 'error', listener: (err: Error) => void): this;
+ removeListener(event: 'pause', listener: () => void): this;
+ removeListener(event: 'readable', listener: () => void): this;
+ removeListener(event: 'resume', listener: () => void): this;
+ removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+ /**
+ * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
+ * @since v20.4.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
+ }
+ import WritableOptions = internal.WritableOptions;
+ class WritableBase extends Stream implements NodeJS.WritableStream {
+ /**
+ * Is `true` if it is safe to call `writable.write()`, which means
+ * the stream has not been destroyed, errored, or ended.
+ * @since v11.4.0
+ */
+ readonly writable: boolean;
+ /**
+ * Is `true` after `writable.end()` has been called. This property
+ * does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead.
+ * @since v12.9.0
+ */
+ readonly writableEnded: boolean;
+ /**
+ * Is set to `true` immediately before the `'finish'` event is emitted.
+ * @since v12.6.0
+ */
+ readonly writableFinished: boolean;
+ /**
+ * Return the value of `highWaterMark` passed when creating this `Writable`.
+ * @since v9.3.0
+ */
+ readonly writableHighWaterMark: number;
+ /**
+ * This property contains the number of bytes (or objects) in the queue
+ * ready to be written. The value provides introspection data regarding
+ * the status of the `highWaterMark`.
+ * @since v9.4.0
+ */
+ readonly writableLength: number;
+ /**
+ * Getter for the property `objectMode` of a given `Writable` stream.
+ * @since v12.3.0
+ */
+ readonly writableObjectMode: boolean;
+ /**
+ * Number of times `writable.uncork()` needs to be
+ * called in order to fully uncork the stream.
+ * @since v13.2.0, v12.16.0
+ */
+ readonly writableCorked: number;
+ /**
+ * Is `true` after `writable.destroy()` has been called.
+ * @since v8.0.0
+ */
+ destroyed: boolean;
+ /**
+ * Is `true` after `'close'` has been emitted.
+ * @since v18.0.0
+ */
+ readonly closed: boolean;
+ /**
+ * Returns error if the stream has been destroyed with an error.
+ * @since v18.0.0
+ */
+ readonly errored: Error | null;
+ /**
+ * Is `true` if the stream's buffer has been full and stream will emit `'drain'`.
+ * @since v15.2.0, v14.17.0
+ */
+ readonly writableNeedDrain: boolean;
+ constructor(opts?: WritableOptions);
+ _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+ _writev?(
+ chunks: Array<{
+ chunk: any;
+ encoding: BufferEncoding;
+ }>,
+ callback: (error?: Error | null) => void
+ ): void;
+ _construct?(callback: (error?: Error | null) => void): void;
+ _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+ _final(callback: (error?: Error | null) => void): void;
+ /**
+ * The `writable.write()` method writes some data to the stream, and calls the
+ * supplied `callback` once the data has been fully handled. If an error
+ * occurs, the `callback` will be called with the error as its
+ * first argument. The `callback` is called asynchronously and before `'error'` is
+ * emitted.
+ *
+ * The return value is `true` if the internal buffer is less than the`highWaterMark` configured when the stream was created after admitting `chunk`.
+ * If `false` is returned, further attempts to write data to the stream should
+ * stop until the `'drain'` event is emitted.
+ *
+ * While a stream is not draining, calls to `write()` will buffer `chunk`, and
+ * return false. Once all currently buffered chunks are drained (accepted for
+ * delivery by the operating system), the `'drain'` event will be emitted.
+ * Once `write()` returns false, do not write more chunks
+ * until the `'drain'` event is emitted. While calling `write()` on a stream that
+ * is not draining is allowed, Node.js will buffer all written chunks until
+ * maximum memory usage occurs, at which point it will abort unconditionally.
+ * Even before it aborts, high memory usage will cause poor garbage collector
+ * performance and high RSS (which is not typically released back to the system,
+ * even after the memory is no longer required). Since TCP sockets may never
+ * drain if the remote peer does not read the data, writing a socket that is
+ * not draining may lead to a remotely exploitable vulnerability.
+ *
+ * Writing data while the stream is not draining is particularly
+ * problematic for a `Transform`, because the `Transform` streams are paused
+ * by default until they are piped or a `'data'` or `'readable'` event handler
+ * is added.
+ *
+ * If the data to be written can be generated or fetched on demand, it is
+ * recommended to encapsulate the logic into a `Readable` and use {@link pipe}. However, if calling `write()` is preferred, it is
+ * possible to respect backpressure and avoid memory issues using the `'drain'` event:
+ *
+ * ```js
+ * function write(data, cb) {
+ * if (!stream.write(data)) {
+ * stream.once('drain', cb);
+ * } else {
+ * process.nextTick(cb);
+ * }
+ * }
+ *
+ * // Wait for cb to be called before doing any other write.
+ * write('hello', () => {
+ * console.log('Write completed, do more writes now.');
+ * });
+ * ```
+ *
+ * A `Writable` stream in object mode will always ignore the `encoding` argument.
+ * @since v0.9.4
+ * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any
+ * JavaScript value other than `null`.
+ * @param [encoding='utf8'] The encoding, if `chunk` is a string.
+ * @param callback Callback for when this chunk of data is flushed.
+ * @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`.
+ */
+ write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
+ write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
+ /**
+ * The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.
+ * @since v0.11.15
+ * @param encoding The new default encoding
+ */
+ setDefaultEncoding(encoding: BufferEncoding): this;
+ /**
+ * Calling the `writable.end()` method signals that no more data will be written
+ * to the `Writable`. The optional `chunk` and `encoding` arguments allow one
+ * final additional chunk of data to be written immediately before closing the
+ * stream.
+ *
+ * Calling the {@link write} method after calling {@link end} will raise an error.
+ *
+ * ```js
+ * // Write 'hello, ' and then end with 'world!'.
+ * const fs = require('node:fs');
+ * const file = fs.createWriteStream('example.txt');
+ * file.write('hello, ');
+ * file.end('world!');
+ * // Writing more now is not allowed!
+ * ```
+ * @since v0.9.4
+ * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any
+ * JavaScript value other than `null`.
+ * @param encoding The encoding if `chunk` is a string
+ * @param callback Callback for when the stream is finished.
+ */
+ end(cb?: () => void): this;
+ end(chunk: any, cb?: () => void): this;
+ end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
+ /**
+ * The `writable.cork()` method forces all written data to be buffered in memory.
+ * The buffered data will be flushed when either the {@link uncork} or {@link end} methods are called.
+ *
+ * The primary intent of `writable.cork()` is to accommodate a situation in which
+ * several small chunks are written to the stream in rapid succession. Instead of
+ * immediately forwarding them to the underlying destination, `writable.cork()`buffers all the chunks until `writable.uncork()` is called, which will pass them
+ * all to `writable._writev()`, if present. This prevents a head-of-line blocking
+ * situation where data is being buffered while waiting for the first small chunk
+ * to be processed. However, use of `writable.cork()` without implementing`writable._writev()` may have an adverse effect on throughput.
+ *
+ * See also: `writable.uncork()`, `writable._writev()`.
+ * @since v0.11.2
+ */
+ cork(): void;
+ /**
+ * The `writable.uncork()` method flushes all data buffered since {@link cork} was called.
+ *
+ * When using `writable.cork()` and `writable.uncork()` to manage the buffering
+ * of writes to a stream, defer calls to `writable.uncork()` using`process.nextTick()`. Doing so allows batching of all`writable.write()` calls that occur within a given Node.js event
+ * loop phase.
+ *
+ * ```js
+ * stream.cork();
+ * stream.write('some ');
+ * stream.write('data ');
+ * process.nextTick(() => stream.uncork());
+ * ```
+ *
+ * If the `writable.cork()` method is called multiple times on a stream, the
+ * same number of calls to `writable.uncork()` must be called to flush the buffered
+ * data.
+ *
+ * ```js
+ * stream.cork();
+ * stream.write('some ');
+ * stream.cork();
+ * stream.write('data ');
+ * process.nextTick(() => {
+ * stream.uncork();
+ * // The data will not be flushed until uncork() is called a second time.
+ * stream.uncork();
+ * });
+ * ```
+ *
+ * See also: `writable.cork()`.
+ * @since v0.11.2
+ */
+ uncork(): void;
+ /**
+ * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the writable
+ * stream has ended and subsequent calls to `write()` or `end()` will result in
+ * an `ERR_STREAM_DESTROYED` error.
+ * This is a destructive and immediate way to destroy a stream. Previous calls to`write()` may not have drained, and may trigger an `ERR_STREAM_DESTROYED` error.
+ * Use `end()` instead of destroy if data should flush before close, or wait for
+ * the `'drain'` event before destroying the stream.
+ *
+ * Once `destroy()` has been called any further calls will be a no-op and no
+ * further errors except from `_destroy()` may be emitted as `'error'`.
+ *
+ * Implementors should not override this method,
+ * but instead implement `writable._destroy()`.
+ * @since v8.0.0
+ * @param error Optional, an error to emit with `'error'` event.
+ */
+ destroy(error?: Error): this;
+ /**
+ * Event emitter
+ * The defined events on documents including:
+ * 1. close
+ * 2. drain
+ * 3. error
+ * 4. finish
+ * 5. pipe
+ * 6. unpipe
+ */
+ addListener(event: 'close', listener: () => void): this;
+ addListener(event: 'drain', listener: () => void): this;
+ addListener(event: 'error', listener: (err: Error) => void): this;
+ addListener(event: 'finish', listener: () => void): this;
+ addListener(event: 'pipe', listener: (src: Readable) => void): this;
+ addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+ addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ emit(event: 'close'): boolean;
+ emit(event: 'drain'): boolean;
+ emit(event: 'error', err: Error): boolean;
+ emit(event: 'finish'): boolean;
+ emit(event: 'pipe', src: Readable): boolean;
+ emit(event: 'unpipe', src: Readable): boolean;
+ emit(event: string | symbol, ...args: any[]): boolean;
+ on(event: 'close', listener: () => void): this;
+ on(event: 'drain', listener: () => void): this;
+ on(event: 'error', listener: (err: Error) => void): this;
+ on(event: 'finish', listener: () => void): this;
+ on(event: 'pipe', listener: (src: Readable) => void): this;
+ on(event: 'unpipe', listener: (src: Readable) => void): this;
+ on(event: string | symbol, listener: (...args: any[]) => void): this;
+ once(event: 'close', listener: () => void): this;
+ once(event: 'drain', listener: () => void): this;
+ once(event: 'error', listener: (err: Error) => void): this;
+ once(event: 'finish', listener: () => void): this;
+ once(event: 'pipe', listener: (src: Readable) => void): this;
+ once(event: 'unpipe', listener: (src: Readable) => void): this;
+ once(event: string | symbol, listener: (...args: any[]) => void): this;
+ prependListener(event: 'close', listener: () => void): this;
+ prependListener(event: 'drain', listener: () => void): this;
+ prependListener(event: 'error', listener: (err: Error) => void): this;
+ prependListener(event: 'finish', listener: () => void): this;
+ prependListener(event: 'pipe', listener: (src: Readable) => void): this;
+ prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+ prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ prependOnceListener(event: 'close', listener: () => void): this;
+ prependOnceListener(event: 'drain', listener: () => void): this;
+ prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+ prependOnceListener(event: 'finish', listener: () => void): this;
+ prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
+ prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+ prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ removeListener(event: 'close', listener: () => void): this;
+ removeListener(event: 'drain', listener: () => void): this;
+ removeListener(event: 'error', listener: (err: Error) => void): this;
+ removeListener(event: 'finish', listener: () => void): this;
+ removeListener(event: 'pipe', listener: (src: Readable) => void): this;
+ removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
+ removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ }
namespace internal {
class Stream extends internal {
@@ -50,10 +792,6 @@
* @since v0.9.4
*/
- class Readable extends Stream implements NodeJS.ReadableStream {
+ class Readable extends ReadableBase {
/**
- * A utility method for creating Readable Streams out of iterators.
- */
- static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
- /**
* A utility method for creating a `Readable` from a web `ReadableStream`.
* @since v17.0.0
@@ -62,9 +800,4 @@
static fromWeb(readableStream: streamWeb.ReadableStream, options?: Pick<ReadableOptions, 'encoding' | 'highWaterMark' | 'objectMode' | 'signal'>): Readable;
/**
- * Returns whether the stream has been read from or cancelled.
- * @since v16.8.0
- */
- static isDisturbed(stream: Readable | NodeJS.ReadableStream): boolean;
- /**
* A utility method for creating a web `ReadableStream` from a `Readable`.
* @since v17.0.0
@@ -72,434 +805,4 @@
*/
static toWeb(streamReadable: Readable): streamWeb.ReadableStream;
- /**
- * Returns whether the stream was destroyed or errored before emitting `'end'`.
- * @since v16.8.0
- * @experimental
- */
- readonly readableAborted: boolean;
- /**
- * Is `true` if it is safe to call `readable.read()`, which means
- * the stream has not been destroyed or emitted `'error'` or `'end'`.
- * @since v11.4.0
- */
- readable: boolean;
- /**
- * Returns whether `'data'` has been emitted.
- * @since v16.7.0, v14.18.0
- * @experimental
- */
- readonly readableDidRead: boolean;
- /**
- * Getter for the property `encoding` of a given `Readable` stream. The `encoding`property can be set using the `readable.setEncoding()` method.
- * @since v12.7.0
- */
- readonly readableEncoding: BufferEncoding | null;
- /**
- * Becomes `true` when `'end'` event is emitted.
- * @since v12.9.0
- */
- readonly readableEnded: boolean;
- /**
- * This property reflects the current state of a `Readable` stream as described
- * in the `Three states` section.
- * @since v9.4.0
- */
- readonly readableFlowing: boolean | null;
- /**
- * Returns the value of `highWaterMark` passed when creating this `Readable`.
- * @since v9.3.0
- */
- readonly readableHighWaterMark: number;
- /**
- * This property contains the number of bytes (or objects) in the queue
- * ready to be read. The value provides introspection data regarding
- * the status of the `highWaterMark`.
- * @since v9.4.0
- */
- readonly readableLength: number;
- /**
- * Getter for the property `objectMode` of a given `Readable` stream.
- * @since v12.3.0
- */
- readonly readableObjectMode: boolean;
- /**
- * Is `true` after `readable.destroy()` has been called.
- * @since v8.0.0
- */
- destroyed: boolean;
- /**
- * Is `true` after `'close'` has been emitted.
- * @since v18.0.0
- */
- readonly closed: boolean;
- /**
- * Returns error if the stream has been destroyed with an error.
- * @since v18.0.0
- */
- readonly errored: Error | null;
- constructor(opts?: ReadableOptions);
- _construct?(callback: (error?: Error | null) => void): void;
- _read(size: number): void;
- /**
- * The `readable.read()` method reads data out of the internal buffer and
- * returns it. If no data is available to be read, `null` is returned. By default,
- * the data is returned as a `Buffer` object unless an encoding has been
- * specified using the `readable.setEncoding()` method or the stream is operating
- * in object mode.
- *
- * The optional `size` argument specifies a specific number of bytes to read. If`size` bytes are not available to be read, `null` will be returned _unless_the stream has ended, in which
- * case all of the data remaining in the internal
- * buffer will be returned.
- *
- * If the `size` argument is not specified, all of the data contained in the
- * internal buffer will be returned.
- *
- * The `size` argument must be less than or equal to 1 GiB.
- *
- * The `readable.read()` method should only be called on `Readable` streams
- * operating in paused mode. In flowing mode, `readable.read()` is called
- * automatically until the internal buffer is fully drained.
- *
- * ```js
- * const readable = getReadableStreamSomehow();
- *
- * // 'readable' may be triggered multiple times as data is buffered in
- * readable.on('readable', () => {
- * let chunk;
- * console.log('Stream is readable (new data received in buffer)');
- * // Use a loop to make sure we read all currently available data
- * while (null !== (chunk = readable.read())) {
- * console.log(`Read ${chunk.length} bytes of data...`);
- * }
- * });
- *
- * // 'end' will be triggered once when there is no more data available
- * readable.on('end', () => {
- * console.log('Reached end of stream.');
- * });
- * ```
- *
- * Each call to `readable.read()` returns a chunk of data, or `null`. The chunks
- * are not concatenated. A `while` loop is necessary to consume all data
- * currently in the buffer. When reading a large file `.read()` may return `null`,
- * having consumed all buffered content so far, but there is still more data to
- * come not yet buffered. In this case a new `'readable'` event will be emitted
- * when there is more data in the buffer. Finally the `'end'` event will be
- * emitted when there is no more data to come.
- *
- * Therefore to read a file's whole contents from a `readable`, it is necessary
- * to collect chunks across multiple `'readable'` events:
- *
- * ```js
- * const chunks = [];
- *
- * readable.on('readable', () => {
- * let chunk;
- * while (null !== (chunk = readable.read())) {
- * chunks.push(chunk);
- * }
- * });
- *
- * readable.on('end', () => {
- * const content = chunks.join('');
- * });
- * ```
- *
- * A `Readable` stream in object mode will always return a single item from
- * a call to `readable.read(size)`, regardless of the value of the`size` argument.
- *
- * If the `readable.read()` method returns a chunk of data, a `'data'` event will
- * also be emitted.
- *
- * Calling {@link read} after the `'end'` event has
- * been emitted will return `null`. No runtime error will be raised.
- * @since v0.9.4
- * @param size Optional argument to specify how much data to read.
- */
- read(size?: number): any;
- /**
- * The `readable.setEncoding()` method sets the character encoding for
- * data read from the `Readable` stream.
- *
- * By default, no encoding is assigned and stream data will be returned as`Buffer` objects. Setting an encoding causes the stream data
- * to be returned as strings of the specified encoding rather than as `Buffer`objects. For instance, calling `readable.setEncoding('utf8')` will cause the
- * output data to be interpreted as UTF-8 data, and passed as strings. Calling`readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal
- * string format.
- *
- * The `Readable` stream will properly handle multi-byte characters delivered
- * through the stream that would otherwise become improperly decoded if simply
- * pulled from the stream as `Buffer` objects.
- *
- * ```js
- * const readable = getReadableStreamSomehow();
- * readable.setEncoding('utf8');
- * readable.on('data', (chunk) => {
- * assert.equal(typeof chunk, 'string');
- * console.log('Got %d characters of string data:', chunk.length);
- * });
- * ```
- * @since v0.9.4
- * @param encoding The encoding to use.
- */
- setEncoding(encoding: BufferEncoding): this;
- /**
- * The `readable.pause()` method will cause a stream in flowing mode to stop
- * emitting `'data'` events, switching out of flowing mode. Any data that
- * becomes available will remain in the internal buffer.
- *
- * ```js
- * const readable = getReadableStreamSomehow();
- * readable.on('data', (chunk) => {
- * console.log(`Received ${chunk.length} bytes of data.`);
- * readable.pause();
- * console.log('There will be no additional data for 1 second.');
- * setTimeout(() => {
- * console.log('Now data will start flowing again.');
- * readable.resume();
- * }, 1000);
- * });
- * ```
- *
- * The `readable.pause()` method has no effect if there is a `'readable'`event listener.
- * @since v0.9.4
- */
- pause(): this;
- /**
- * The `readable.resume()` method causes an explicitly paused `Readable` stream to
- * resume emitting `'data'` events, switching the stream into flowing mode.
- *
- * The `readable.resume()` method can be used to fully consume the data from a
- * stream without actually processing any of that data:
- *
- * ```js
- * getReadableStreamSomehow()
- * .resume()
- * .on('end', () => {
- * console.log('Reached the end, but did not read anything.');
- * });
- * ```
- *
- * The `readable.resume()` method has no effect if there is a `'readable'`event listener.
- * @since v0.9.4
- */
- resume(): this;
- /**
- * The `readable.isPaused()` method returns the current operating state of the`Readable`. This is used primarily by the mechanism that underlies the`readable.pipe()` method. In most
- * typical cases, there will be no reason to
- * use this method directly.
- *
- * ```js
- * const readable = new stream.Readable();
- *
- * readable.isPaused(); // === false
- * readable.pause();
- * readable.isPaused(); // === true
- * readable.resume();
- * readable.isPaused(); // === false
- * ```
- * @since v0.11.14
- */
- isPaused(): boolean;
- /**
- * The `readable.unpipe()` method detaches a `Writable` stream previously attached
- * using the {@link pipe} method.
- *
- * If the `destination` is not specified, then _all_ pipes are detached.
- *
- * If the `destination` is specified, but no pipe is set up for it, then
- * the method does nothing.
- *
- * ```js
- * const fs = require('node:fs');
- * const readable = getReadableStreamSomehow();
- * const writable = fs.createWriteStream('file.txt');
- * // All the data from readable goes into 'file.txt',
- * // but only for the first second.
- * readable.pipe(writable);
- * setTimeout(() => {
- * console.log('Stop writing to file.txt.');
- * readable.unpipe(writable);
- * console.log('Manually close the file stream.');
- * writable.end();
- * }, 1000);
- * ```
- * @since v0.9.4
- * @param destination Optional specific stream to unpipe
- */
- unpipe(destination?: NodeJS.WritableStream): this;
- /**
- * Passing `chunk` as `null` signals the end of the stream (EOF) and behaves the
- * same as `readable.push(null)`, after which no more data can be written. The EOF
- * signal is put at the end of the buffer and any buffered data will still be
- * flushed.
- *
- * The `readable.unshift()` method pushes a chunk of data back into the internal
- * buffer. This is useful in certain situations where a stream is being consumed by
- * code that needs to "un-consume" some amount of data that it has optimistically
- * pulled out of the source, so that the data can be passed on to some other party.
- *
- * The `stream.unshift(chunk)` method cannot be called after the `'end'` event
- * has been emitted or a runtime error will be thrown.
- *
- * Developers using `stream.unshift()` often should consider switching to
- * use of a `Transform` stream instead. See the `API for stream implementers` section for more information.
- *
- * ```js
- * // Pull off a header delimited by \n\n.
- * // Use unshift() if we get too much.
- * // Call the callback with (error, header, stream).
- * const { StringDecoder } = require('node:string_decoder');
- * function parseHeader(stream, callback) {
- * stream.on('error', callback);
- * stream.on('readable', onReadable);
- * const decoder = new StringDecoder('utf8');
- * let header = '';
- * function onReadable() {
- * let chunk;
- * while (null !== (chunk = stream.read())) {
- * const str = decoder.write(chunk);
- * if (str.includes('\n\n')) {
- * // Found the header boundary.
- * const split = str.split(/\n\n/);
- * header += split.shift();
- * const remaining = split.join('\n\n');
- * const buf = Buffer.from(remaining, 'utf8');
- * stream.removeListener('error', callback);
- * // Remove the 'readable' listener before unshifting.
- * stream.removeListener('readable', onReadable);
- * if (buf.length)
- * stream.unshift(buf);
- * // Now the body of the message can be read from the stream.
- * callback(null, header, stream);
- * return;
- * }
- * // Still reading the header.
- * header += str;
- * }
- * }
- * }
- * ```
- *
- * Unlike {@link push}, `stream.unshift(chunk)` will not
- * end the reading process by resetting the internal reading state of the stream.
- * This can cause unexpected results if `readable.unshift()` is called during a
- * read (i.e. from within a {@link _read} implementation on a
- * custom stream). Following the call to `readable.unshift()` with an immediate {@link push} will reset the reading state appropriately,
- * however it is best to simply avoid calling `readable.unshift()` while in the
- * process of performing a read.
- * @since v0.9.11
- * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array`, or `null`. For object mode
- * streams, `chunk` may be any JavaScript value.
- * @param encoding Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`.
- */
- unshift(chunk: any, encoding?: BufferEncoding): void;
- /**
- * Prior to Node.js 0.10, streams did not implement the entire `node:stream`module API as it is currently defined. (See `Compatibility` for more
- * information.)
- *
- * When using an older Node.js library that emits `'data'` events and has a {@link pause} method that is advisory only, the`readable.wrap()` method can be used to create a `Readable`
- * stream that uses
- * the old stream as its data source.
- *
- * It will rarely be necessary to use `readable.wrap()` but the method has been
- * provided as a convenience for interacting with older Node.js applications and
- * libraries.
- *
- * ```js
- * const { OldReader } = require('./old-api-module.js');
- * const { Readable } = require('node:stream');
- * const oreader = new OldReader();
- * const myReader = new Readable().wrap(oreader);
- *
- * myReader.on('readable', () => {
- * myReader.read(); // etc.
- * });
- * ```
- * @since v0.9.4
- * @param stream An "old style" readable stream
- */
- wrap(stream: NodeJS.ReadableStream): this;
- push(chunk: any, encoding?: BufferEncoding): boolean;
- _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
- /**
- * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the readable
- * stream will release any internal resources and subsequent calls to `push()`will be ignored.
- *
- * Once `destroy()` has been called any further calls will be a no-op and no
- * further errors except from `_destroy()` may be emitted as `'error'`.
- *
- * Implementors should not override this method, but instead implement `readable._destroy()`.
- * @since v8.0.0
- * @param error Error which will be passed as payload in `'error'` event
- */
- destroy(error?: Error): this;
- /**
- * Event emitter
- * The defined events on documents including:
- * 1. close
- * 2. data
- * 3. end
- * 4. error
- * 5. pause
- * 6. readable
- * 7. resume
- */
- addListener(event: 'close', listener: () => void): this;
- addListener(event: 'data', listener: (chunk: any) => void): this;
- addListener(event: 'end', listener: () => void): this;
- addListener(event: 'error', listener: (err: Error) => void): this;
- addListener(event: 'pause', listener: () => void): this;
- addListener(event: 'readable', listener: () => void): this;
- addListener(event: 'resume', listener: () => void): this;
- addListener(event: string | symbol, listener: (...args: any[]) => void): this;
- emit(event: 'close'): boolean;
- emit(event: 'data', chunk: any): boolean;
- emit(event: 'end'): boolean;
- emit(event: 'error', err: Error): boolean;
- emit(event: 'pause'): boolean;
- emit(event: 'readable'): boolean;
- emit(event: 'resume'): boolean;
- emit(event: string | symbol, ...args: any[]): boolean;
- on(event: 'close', listener: () => void): this;
- on(event: 'data', listener: (chunk: any) => void): this;
- on(event: 'end', listener: () => void): this;
- on(event: 'error', listener: (err: Error) => void): this;
- on(event: 'pause', listener: () => void): this;
- on(event: 'readable', listener: () => void): this;
- on(event: 'resume', listener: () => void): this;
- on(event: string | symbol, listener: (...args: any[]) => void): this;
- once(event: 'close', listener: () => void): this;
- once(event: 'data', listener: (chunk: any) => void): this;
- once(event: 'end', listener: () => void): this;
- once(event: 'error', listener: (err: Error) => void): this;
- once(event: 'pause', listener: () => void): this;
- once(event: 'readable', listener: () => void): this;
- once(event: 'resume', listener: () => void): this;
- once(event: string | symbol, listener: (...args: any[]) => void): this;
- prependListener(event: 'close', listener: () => void): this;
- prependListener(event: 'data', listener: (chunk: any) => void): this;
- prependListener(event: 'end', listener: () => void): this;
- prependListener(event: 'error', listener: (err: Error) => void): this;
- prependListener(event: 'pause', listener: () => void): this;
- prependListener(event: 'readable', listener: () => void): this;
- prependListener(event: 'resume', listener: () => void): this;
- prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
- prependOnceListener(event: 'close', listener: () => void): this;
- prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
- prependOnceListener(event: 'end', listener: () => void): this;
- prependOnceListener(event: 'error', listener: (err: Error) => void): this;
- prependOnceListener(event: 'pause', listener: () => void): this;
- prependOnceListener(event: 'readable', listener: () => void): this;
- prependOnceListener(event: 'resume', listener: () => void): this;
- prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
- removeListener(event: 'close', listener: () => void): this;
- removeListener(event: 'data', listener: (chunk: any) => void): this;
- removeListener(event: 'end', listener: () => void): this;
- removeListener(event: 'error', listener: (err: Error) => void): this;
- removeListener(event: 'pause', listener: () => void): this;
- removeListener(event: 'readable', listener: () => void): this;
- removeListener(event: 'resume', listener: () => void): this;
- removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
- [Symbol.asyncIterator](): AsyncIterableIterator<any>;
}
interface WritableOptions extends StreamOptions<Writable> {
@@ -520,5 +823,5 @@
* @since v0.9.4
*/
- class Writable extends Stream implements NodeJS.WritableStream {
+ class Writable extends WritableBase {
/**
* A utility method for creating a `Writable` from a web `WritableStream`.
@@ -533,290 +836,4 @@
*/
static toWeb(streamWritable: Writable): streamWeb.WritableStream;
- /**
- * Is `true` if it is safe to call `writable.write()`, which means
- * the stream has not been destroyed, errored, or ended.
- * @since v11.4.0
- */
- readonly writable: boolean;
- /**
- * Is `true` after `writable.end()` has been called. This property
- * does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead.
- * @since v12.9.0
- */
- readonly writableEnded: boolean;
- /**
- * Is set to `true` immediately before the `'finish'` event is emitted.
- * @since v12.6.0
- */
- readonly writableFinished: boolean;
- /**
- * Return the value of `highWaterMark` passed when creating this `Writable`.
- * @since v9.3.0
- */
- readonly writableHighWaterMark: number;
- /**
- * This property contains the number of bytes (or objects) in the queue
- * ready to be written. The value provides introspection data regarding
- * the status of the `highWaterMark`.
- * @since v9.4.0
- */
- readonly writableLength: number;
- /**
- * Getter for the property `objectMode` of a given `Writable` stream.
- * @since v12.3.0
- */
- readonly writableObjectMode: boolean;
- /**
- * Number of times `writable.uncork()` needs to be
- * called in order to fully uncork the stream.
- * @since v13.2.0, v12.16.0
- */
- readonly writableCorked: number;
- /**
- * Is `true` after `writable.destroy()` has been called.
- * @since v8.0.0
- */
- destroyed: boolean;
- /**
- * Is `true` after `'close'` has been emitted.
- * @since v18.0.0
- */
- readonly closed: boolean;
- /**
- * Returns error if the stream has been destroyed with an error.
- * @since v18.0.0
- */
- readonly errored: Error | null;
- /**
- * Is `true` if the stream's buffer has been full and stream will emit `'drain'`.
- * @since v15.2.0, v14.17.0
- */
- readonly writableNeedDrain: boolean;
- constructor(opts?: WritableOptions);
- _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
- _writev?(
- chunks: Array<{
- chunk: any;
- encoding: BufferEncoding;
- }>,
- callback: (error?: Error | null) => void
- ): void;
- _construct?(callback: (error?: Error | null) => void): void;
- _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
- _final(callback: (error?: Error | null) => void): void;
- /**
- * The `writable.write()` method writes some data to the stream, and calls the
- * supplied `callback` once the data has been fully handled. If an error
- * occurs, the `callback` will be called with the error as its
- * first argument. The `callback` is called asynchronously and before `'error'` is
- * emitted.
- *
- * The return value is `true` if the internal buffer is less than the`highWaterMark` configured when the stream was created after admitting `chunk`.
- * If `false` is returned, further attempts to write data to the stream should
- * stop until the `'drain'` event is emitted.
- *
- * While a stream is not draining, calls to `write()` will buffer `chunk`, and
- * return false. Once all currently buffered chunks are drained (accepted for
- * delivery by the operating system), the `'drain'` event will be emitted.
- * Once `write()` returns false, do not write more chunks
- * until the `'drain'` event is emitted. While calling `write()` on a stream that
- * is not draining is allowed, Node.js will buffer all written chunks until
- * maximum memory usage occurs, at which point it will abort unconditionally.
- * Even before it aborts, high memory usage will cause poor garbage collector
- * performance and high RSS (which is not typically released back to the system,
- * even after the memory is no longer required). Since TCP sockets may never
- * drain if the remote peer does not read the data, writing a socket that is
- * not draining may lead to a remotely exploitable vulnerability.
- *
- * Writing data while the stream is not draining is particularly
- * problematic for a `Transform`, because the `Transform` streams are paused
- * by default until they are piped or a `'data'` or `'readable'` event handler
- * is added.
- *
- * If the data to be written can be generated or fetched on demand, it is
- * recommended to encapsulate the logic into a `Readable` and use {@link pipe}. However, if calling `write()` is preferred, it is
- * possible to respect backpressure and avoid memory issues using the `'drain'` event:
- *
- * ```js
- * function write(data, cb) {
- * if (!stream.write(data)) {
- * stream.once('drain', cb);
- * } else {
- * process.nextTick(cb);
- * }
- * }
- *
- * // Wait for cb to be called before doing any other write.
- * write('hello', () => {
- * console.log('Write completed, do more writes now.');
- * });
- * ```
- *
- * A `Writable` stream in object mode will always ignore the `encoding` argument.
- * @since v0.9.4
- * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any
- * JavaScript value other than `null`.
- * @param [encoding='utf8'] The encoding, if `chunk` is a string.
- * @param callback Callback for when this chunk of data is flushed.
- * @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`.
- */
- write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
- write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
- /**
- * The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.
- * @since v0.11.15
- * @param encoding The new default encoding
- */
- setDefaultEncoding(encoding: BufferEncoding): this;
- /**
- * Calling the `writable.end()` method signals that no more data will be written
- * to the `Writable`. The optional `chunk` and `encoding` arguments allow one
- * final additional chunk of data to be written immediately before closing the
- * stream.
- *
- * Calling the {@link write} method after calling {@link end} will raise an error.
- *
- * ```js
- * // Write 'hello, ' and then end with 'world!'.
- * const fs = require('node:fs');
- * const file = fs.createWriteStream('example.txt');
- * file.write('hello, ');
- * file.end('world!');
- * // Writing more now is not allowed!
- * ```
- * @since v0.9.4
- * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any
- * JavaScript value other than `null`.
- * @param encoding The encoding if `chunk` is a string
- * @param callback Callback for when the stream is finished.
- */
- end(cb?: () => void): this;
- end(chunk: any, cb?: () => void): this;
- end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
- /**
- * The `writable.cork()` method forces all written data to be buffered in memory.
- * The buffered data will be flushed when either the {@link uncork} or {@link end} methods are called.
- *
- * The primary intent of `writable.cork()` is to accommodate a situation in which
- * several small chunks are written to the stream in rapid succession. Instead of
- * immediately forwarding them to the underlying destination, `writable.cork()`buffers all the chunks until `writable.uncork()` is called, which will pass them
- * all to `writable._writev()`, if present. This prevents a head-of-line blocking
- * situation where data is being buffered while waiting for the first small chunk
- * to be processed. However, use of `writable.cork()` without implementing`writable._writev()` may have an adverse effect on throughput.
- *
- * See also: `writable.uncork()`, `writable._writev()`.
- * @since v0.11.2
- */
- cork(): void;
- /**
- * The `writable.uncork()` method flushes all data buffered since {@link cork} was called.
- *
- * When using `writable.cork()` and `writable.uncork()` to manage the buffering
- * of writes to a stream, defer calls to `writable.uncork()` using`process.nextTick()`. Doing so allows batching of all`writable.write()` calls that occur within a given Node.js event
- * loop phase.
- *
- * ```js
- * stream.cork();
- * stream.write('some ');
- * stream.write('data ');
- * process.nextTick(() => stream.uncork());
- * ```
- *
- * If the `writable.cork()` method is called multiple times on a stream, the
- * same number of calls to `writable.uncork()` must be called to flush the buffered
- * data.
- *
- * ```js
- * stream.cork();
- * stream.write('some ');
- * stream.cork();
- * stream.write('data ');
- * process.nextTick(() => {
- * stream.uncork();
- * // The data will not be flushed until uncork() is called a second time.
- * stream.uncork();
- * });
- * ```
- *
- * See also: `writable.cork()`.
- * @since v0.11.2
- */
- uncork(): void;
- /**
- * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the writable
- * stream has ended and subsequent calls to `write()` or `end()` will result in
- * an `ERR_STREAM_DESTROYED` error.
- * This is a destructive and immediate way to destroy a stream. Previous calls to`write()` may not have drained, and may trigger an `ERR_STREAM_DESTROYED` error.
- * Use `end()` instead of destroy if data should flush before close, or wait for
- * the `'drain'` event before destroying the stream.
- *
- * Once `destroy()` has been called any further calls will be a no-op and no
- * further errors except from `_destroy()` may be emitted as `'error'`.
- *
- * Implementors should not override this method,
- * but instead implement `writable._destroy()`.
- * @since v8.0.0
- * @param error Optional, an error to emit with `'error'` event.
- */
- destroy(error?: Error): this;
- /**
- * Event emitter
- * The defined events on documents including:
- * 1. close
- * 2. drain
- * 3. error
- * 4. finish
- * 5. pipe
- * 6. unpipe
- */
- addListener(event: 'close', listener: () => void): this;
- addListener(event: 'drain', listener: () => void): this;
- addListener(event: 'error', listener: (err: Error) => void): this;
- addListener(event: 'finish', listener: () => void): this;
- addListener(event: 'pipe', listener: (src: Readable) => void): this;
- addListener(event: 'unpipe', listener: (src: Readable) => void): this;
- addListener(event: string | symbol, listener: (...args: any[]) => void): this;
- emit(event: 'close'): boolean;
- emit(event: 'drain'): boolean;
- emit(event: 'error', err: Error): boolean;
- emit(event: 'finish'): boolean;
- emit(event: 'pipe', src: Readable): boolean;
- emit(event: 'unpipe', src: Readable): boolean;
- emit(event: string | symbol, ...args: any[]): boolean;
- on(event: 'close', listener: () => void): this;
- on(event: 'drain', listener: () => void): this;
- on(event: 'error', listener: (err: Error) => void): this;
- on(event: 'finish', listener: () => void): this;
- on(event: 'pipe', listener: (src: Readable) => void): this;
- on(event: 'unpipe', listener: (src: Readable) => void): this;
- on(event: string | symbol, listener: (...args: any[]) => void): this;
- once(event: 'close', listener: () => void): this;
- once(event: 'drain', listener: () => void): this;
- once(event: 'error', listener: (err: Error) => void): this;
- once(event: 'finish', listener: () => void): this;
- once(event: 'pipe', listener: (src: Readable) => void): this;
- once(event: 'unpipe', listener: (src: Readable) => void): this;
- once(event: string | symbol, listener: (...args: any[]) => void): this;
- prependListener(event: 'close', listener: () => void): this;
- prependListener(event: 'drain', listener: () => void): this;
- prependListener(event: 'error', listener: (err: Error) => void): this;
- prependListener(event: 'finish', listener: () => void): this;
- prependListener(event: 'pipe', listener: (src: Readable) => void): this;
- prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
- prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
- prependOnceListener(event: 'close', listener: () => void): this;
- prependOnceListener(event: 'drain', listener: () => void): this;
- prependOnceListener(event: 'error', listener: (err: Error) => void): this;
- prependOnceListener(event: 'finish', listener: () => void): this;
- prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
- prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
- prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
- removeListener(event: 'close', listener: () => void): this;
- removeListener(event: 'drain', listener: () => void): this;
- removeListener(event: 'error', listener: (err: Error) => void): this;
- removeListener(event: 'finish', listener: () => void): this;
- removeListener(event: 'pipe', listener: (src: Readable) => void): this;
- removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
- removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
}
interface DuplexOptions extends ReadableOptions, WritableOptions {
@@ -851,5 +868,5 @@
* @since v0.9.4
*/
- class Duplex extends Readable implements Writable {
+ class Duplex extends ReadableBase implements WritableBase {
readonly writable: boolean;
readonly writableEnded: boolean;
@@ -914,4 +931,25 @@
uncork(): void;
/**
+ * A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.
+ * @since v17.0.0
+ * @experimental
+ */
+ static toWeb(streamDuplex: Duplex): {
+ readable: streamWeb.ReadableStream;
+ writable: streamWeb.WritableStream;
+ };
+ /**
+ * A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.
+ * @since v17.0.0
+ * @experimental
+ */
+ static fromWeb(
+ duplexStream: {
+ readable: streamWeb.ReadableStream;
+ writable: streamWeb.WritableStream;
+ },
+ options?: Pick<DuplexOptions, 'allowHalfOpen' | 'decodeStrings' | 'encoding' | 'highWaterMark' | 'objectMode' | 'signal'>
+ ): Duplex;
+ /**
* Event emitter
* The defined events on documents including:
diff --git a/ts4.8/test.d.ts b/ts4.8/test.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/test.d.ts
+++ b/ts4.8/test.d.ts
@@ -81,4 +81,5 @@
declare module 'node:test' {
import { Readable } from 'node:stream';
+ import { AsyncResource } from 'node:async_hooks';
/**
* ```js
@@ -162,31 +163,31 @@
* @return Immediately fulfilled with `undefined`.
*/
- function describe(name?: string, options?: TestOptions, fn?: SuiteFn): void;
- function describe(name?: string, fn?: SuiteFn): void;
- function describe(options?: TestOptions, fn?: SuiteFn): void;
- function describe(fn?: SuiteFn): void;
+ function describe(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function describe(name?: string, fn?: SuiteFn): Promise<void>;
+ function describe(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function describe(fn?: SuiteFn): Promise<void>;
namespace describe {
/**
* Shorthand for skipping a suite, same as `describe([name], { skip: true }[, fn])`.
*/
- function skip(name?: string, options?: TestOptions, fn?: SuiteFn): void;
- function skip(name?: string, fn?: SuiteFn): void;
- function skip(options?: TestOptions, fn?: SuiteFn): void;
- function skip(fn?: SuiteFn): void;
+ function skip(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function skip(name?: string, fn?: SuiteFn): Promise<void>;
+ function skip(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function skip(fn?: SuiteFn): Promise<void>;
/**
* Shorthand for marking a suite as `TODO`, same as `describe([name], { todo: true }[, fn])`.
*/
- function todo(name?: string, options?: TestOptions, fn?: SuiteFn): void;
- function todo(name?: string, fn?: SuiteFn): void;
- function todo(options?: TestOptions, fn?: SuiteFn): void;
- function todo(fn?: SuiteFn): void;
+ function todo(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function todo(name?: string, fn?: SuiteFn): Promise<void>;
+ function todo(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function todo(fn?: SuiteFn): Promise<void>;
/**
* Shorthand for marking a suite as `only`, same as `describe([name], { only: true }[, fn])`.
* @since v18.15.0
*/
- function only(name?: string, options?: TestOptions, fn?: SuiteFn): void;
- function only(name?: string, fn?: SuiteFn): void;
- function only(options?: TestOptions, fn?: SuiteFn): void;
- function only(fn?: SuiteFn): void;
+ function only(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function only(name?: string, fn?: SuiteFn): Promise<void>;
+ function only(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+ function only(fn?: SuiteFn): Promise<void>;
}
/**
@@ -196,31 +197,31 @@
* @since v18.6.0, v16.17.0
*/
- function it(name?: string, options?: TestOptions, fn?: TestFn): void;
- function it(name?: string, fn?: TestFn): void;
- function it(options?: TestOptions, fn?: TestFn): void;
- function it(fn?: TestFn): void;
+ function it(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function it(name?: string, fn?: TestFn): Promise<void>;
+ function it(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function it(fn?: TestFn): Promise<void>;
namespace it {
/**
* Shorthand for skipping a test, same as `it([name], { skip: true }[, fn])`.
*/
- function skip(name?: string, options?: TestOptions, fn?: TestFn): void;
- function skip(name?: string, fn?: TestFn): void;
- function skip(options?: TestOptions, fn?: TestFn): void;
- function skip(fn?: TestFn): void;
+ function skip(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function skip(name?: string, fn?: TestFn): Promise<void>;
+ function skip(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function skip(fn?: TestFn): Promise<void>;
/**
* Shorthand for marking a test as `TODO`, same as `it([name], { todo: true }[, fn])`.
*/
- function todo(name?: string, options?: TestOptions, fn?: TestFn): void;
- function todo(name?: string, fn?: TestFn): void;
- function todo(options?: TestOptions, fn?: TestFn): void;
- function todo(fn?: TestFn): void;
+ function todo(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function todo(name?: string, fn?: TestFn): Promise<void>;
+ function todo(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function todo(fn?: TestFn): Promise<void>;
/**
* Shorthand for marking a test as `only`, same as `it([name], { only: true }[, fn])`.
* @since v18.15.0
*/
- function only(name?: string, options?: TestOptions, fn?: TestFn): void;
- function only(name?: string, fn?: TestFn): void;
- function only(options?: TestOptions, fn?: TestFn): void;
- function only(fn?: TestFn): void;
+ function only(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function only(name?: string, fn?: TestFn): Promise<void>;
+ function only(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function only(fn?: TestFn): Promise<void>;
}
/**
@@ -228,24 +229,24 @@
* @since v20.2.0
*/
- function skip(name?: string, options?: TestOptions, fn?: TestFn): void;
- function skip(name?: string, fn?: TestFn): void;
- function skip(options?: TestOptions, fn?: TestFn): void;
- function skip(fn?: TestFn): void;
+ function skip(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function skip(name?: string, fn?: TestFn): Promise<void>;
+ function skip(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function skip(fn?: TestFn): Promise<void>;
/**
* Shorthand for marking a test as `TODO`, same as `test([name], { todo: true }[, fn])`.
* @since v20.2.0
*/
- function todo(name?: string, options?: TestOptions, fn?: TestFn): void;
- function todo(name?: string, fn?: TestFn): void;
- function todo(options?: TestOptions, fn?: TestFn): void;
- function todo(fn?: TestFn): void;
+ function todo(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function todo(name?: string, fn?: TestFn): Promise<void>;
+ function todo(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function todo(fn?: TestFn): Promise<void>;
/**
* Shorthand for marking a test as `only`, same as `test([name], { only: true }[, fn])`.
* @since v20.2.0
*/
- function only(name?: string, options?: TestOptions, fn?: TestFn): void;
- function only(name?: string, fn?: TestFn): void;
- function only(options?: TestOptions, fn?: TestFn): void;
- function only(fn?: TestFn): void;
+ function only(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+ function only(name?: string, fn?: TestFn): Promise<void>;
+ function only(options?: TestOptions, fn?: TestFn): Promise<void>;
+ function only(fn?: TestFn): Promise<void>;
/**
* The type of a function under test. The first argument to this function is a
@@ -253,10 +254,20 @@
* the second argument.
*/
- type TestFn = (t: TestContext, done: (result?: any) => void) => any;
+ type TestFn = (t: TestContext, done: (result?: any) => void) => void | Promise<void>;
/**
* The type of a function under Suite.
* If the test uses callbacks, the callback function is passed as an argument
*/
- type SuiteFn = (done: (result?: any) => void) => void;
+ type SuiteFn = (s: SuiteContext) => void | Promise<void>;
+ interface TestShard {
+ /**
+ * A positive integer between 1 and `<total>` that specifies the index of the shard to run.
+ */
+ index: number;
+ /**
+ * A positive integer that specifies the total number of shards to split the test files to.
+ */
+ total: number;
+ }
interface RunOptions {
/**
@@ -296,5 +307,28 @@
*/
testNamePatterns?: string | RegExp | string[] | RegExp[];
+ /**
+ * A function that accepts the TestsStream instance and can be used to setup listeners before any tests are run.
+ */
+ setup?: (root: unknown) => void | Promise<void>;
+ /**
+ * Whether to run in watch mode or not.
+ * @default false
+ */
+ watch?: boolean | undefined;
+ /**
+ * Running tests in a specific shard.
+ * @default undefined
+ */
+ shard?: TestShard | undefined;
}
+ class Test extends AsyncResource {
+ concurrency: number;
+ nesting: number;
+ only: boolean;
+ reporter: TestsStream;
+ runOnlySubtests: boolean;
+ testNumber: number;
+ timeout: number | null;
+ }
/**
* A successful call to `run()` method will return a new `TestsStream` object, streaming a series of events representing the execution of the tests.`TestsStream` will emit events, in the
@@ -487,4 +521,22 @@
readonly mock: MockTracker;
}
+ /**
+ * An instance of `SuiteContext` is passed to each suite function in order to
+ * interact with the test runner. However, the `SuiteContext` constructor is not
+ * exposed as part of the API.
+ * @since v18.7.0, v16.17.0
+ */
+ class SuiteContext {
+ /**
+ * The name of the suite.
+ * @since v18.8.0, v16.18.0
+ */
+ readonly name: string;
+ /**
+ * Can be used to abort test subtasks when the test has been aborted.
+ * @since v18.7.0, v16.17.0
+ */
+ readonly signal: AbortSignal;
+ }
interface TestOptions {
/**
@@ -1175,4 +1227,8 @@
*/
runAll(): void;
+ /**
+ * Calls {@link MockTimers.reset()}.
+ */
+ [Symbol.dispose](): void;
}
export { test as default, run, test, describe, it, before, after, beforeEach, afterEach, mock, skip, only, todo };
@@ -1201,9 +1257,14 @@
* The duration of the test in milliseconds.
*/
- duration: number;
+ duration_ms: number;
/**
* The error thrown by the test.
*/
error: Error;
+ /**
+ * The type of the test, used to denote whether this is a suite.
+ * @since 20.0.0, 19.9.0, 18.17.0
+ */
+ type?: 'suite';
};
/**
@@ -1240,5 +1301,10 @@
* The duration of the test in milliseconds.
*/
- duration: number;
+ duration_ms: number;
+ /**
+ * The type of the test, used to denote whether this is a suite.
+ * @since 20.0.0, 19.9.0, 18.17.0
+ */
+ type?: 'suite';
};
/**
@@ -1315,4 +1381,32 @@
message: string;
}
+interface TestEnqueue {
+ /**
+ * The test name
+ */
+ name: string;
+ /**
+ * The path of the test file, undefined if test is not ran through a file.
+ */
+ file?: string;
+ /**
+ * The nesting level of the test.
+ */
+ nesting: number;
+}
+interface TestDequeue {
+ /**
+ * The test name
+ */
+ name: string;
+ /**
+ * The path of the test file, undefined if test is not ran through a file.
+ */
+ file?: string;
+ /**
+ * The nesting level of the test.
+ */
+ nesting: number;
+}
/**
@@ -1343,5 +1437,8 @@
| { type: 'test:start', data: TestStart }
| { type: 'test:stderr', data: TestStderr }
- | { type: 'test:stdout', data: TestStdout };
+ | { type: 'test:stdout', data: TestStdout }
+ | { type: 'test:enqueue', data: TestEnqueue }
+ | { type: 'test:dequeue', data: TestDequeue }
+ | { type: 'test:watch:drained' };
type TestEventGenerator = AsyncGenerator<TestEvent, void>;
@@ -1362,4 +1459,4 @@
constructor();
}
- export { dot, tap, Spec as spec };
+ export { dot, tap, Spec as spec, TestEvent };
}
diff --git a/ts4.8/timers.d.ts b/ts4.8/timers.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/timers.d.ts
+++ b/ts4.8/timers.d.ts
@@ -69,4 +69,9 @@
hasRef(): boolean;
_onImmediate: Function; // to distinguish it from the Timeout class
+ /**
+ * Cancels the immediate. This is similar to calling `clearImmediate()`.
+ * @since v20.5.0
+ */
+ [Symbol.dispose](): void;
}
/**
@@ -115,4 +120,9 @@
refresh(): this;
[Symbol.toPrimitive](): number;
+ /**
+ * Cancels the timeout.
+ * @since v20.5.0
+ */
+ [Symbol.dispose](): void;
}
}
@@ -164,8 +174,8 @@
* @return for use with {@link clearInterval}
*/
- function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
+ function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
- function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
+ function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
namespace setInterval {
const __promisify__: typeof setIntervalPromise;
diff --git a/ts4.8/fs/promises.d.ts b/ts4.8/fs/promises.d.ts
index v20.4.4..v20.5.0 100777
--- a/ts4.8/fs/promises.d.ts
+++ b/ts4.8/fs/promises.d.ts
@@ -457,4 +457,9 @@
*/
close(): Promise<void>;
+ /**
+ * An alias for {@link FileHandle.close()}.
+ * @since v20.4.0
+ */
+ [Symbol.asyncDispose](): Promise<void>;
}
const constants: typeof fsConstants;
Command detailsnpm diff --diff=@types/node@20.4.4 --diff=@types/node@20.5.0 --diff-unified=2See also the Reported by ybiquitous/npm-diff-action@v1.4.1 (Node.js 18.17.0 and npm 9.8.1) |
github-actions
bot
deleted the
dependabot/npm_and_yarn/types/node-20.5.0
branch
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Bumps @types/node from 20.4.4 to 20.5.0.
Commits
Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting
@dependabot rebase.Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR:
@dependabot rebasewill rebase this PR@dependabot recreatewill recreate this PR, overwriting any edits that have been made to it@dependabot mergewill merge this PR after your CI passes on it@dependabot squash and mergewill squash and merge this PR after your CI passes on it@dependabot cancel mergewill cancel a previously requested merge and block automerging@dependabot reopenwill reopen this PR if it is closed@dependabot closewill close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually@dependabot show <dependency name> ignore conditionswill show all of the ignore conditions of the specified dependency@dependabot ignore this major versionwill close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this minor versionwill close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this dependencywill close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)