@types/node 18.17.9 → 18.17.11

node v18.17/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v18.
 
 ### Additional Details
- * Last updated: Wed, 23 Aug 2023 21:03:06 GMT
+ * Last updated: Thu, 24 Aug 2023 22:03:17 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

node v18.17/module.d.ts

@@ -79,6 +79,9 @@ declare module 'module' {
              */
             findEntry(line: number, column: number): SourceMapping;
         }
+        interface ImportAssertions extends NodeJS.Dict<string> {
+            type?: string | undefined;
+        }
         type ModuleFormat = 'builtin' | 'commonjs' | 'json' | 'module' | 'wasm';
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
         interface GlobalPreloadContext {
@@ -100,7 +103,7 @@ declare module 'module' {
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: Object;
+            importAssertions: ImportAssertions;
             /**
              * The module importing this one, or undefined if this is the Node.js entry point
              */
@@ -114,7 +117,7 @@ declare module 'module' {
             /**
              * The import assertions to use when caching the module (optional; if excluded the input will be used)
              */
-            importAssertions?: Object | undefined;
+            importAssertions?: ImportAssertions | undefined;
             /**
              * A signal that this hook intends to terminate the chain of `resolve` hooks.
              * @default false
@@ -137,7 +140,7 @@ declare module 'module' {
         type ResolveHook = (
             specifier: string,
             context: ResolveHookContext,
-            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput
+            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput | Promise<ResolveFnOutput>
         ) => ResolveFnOutput | Promise<ResolveFnOutput>;
         interface LoadHookContext {
             /**
@@ -151,7 +154,7 @@ declare module 'module' {
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: Object;
+            importAssertions: ImportAssertions;
         }
         interface LoadFnOutput {
             format: ModuleFormat;
@@ -173,7 +176,11 @@ declare module 'module' {
          * @param context Metadata about the module
          * @param nextLoad The subsequent `load` hook in the chain, or the Node.js default `load` hook after the last user-supplied `load` hook
          */
-        type LoadHook = (url: string, context: LoadHookContext, nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput) => LoadFnOutput | Promise<LoadFnOutput>;
+        type LoadHook = (
+            url: string,
+            context: LoadHookContext,
+            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>
+        ) => LoadFnOutput | Promise<LoadFnOutput>;
     }
     interface Module extends NodeModule {}
     class Module {

node v18.17/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.17.9",
+    "version": "18.17.11",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -232,6 +232,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "1ac2d87015f8895c0d056cf53ed50f7936b5306c403b9b7ee02a7191e4deb8ec",
+    "typesPublisherContentHash": "2c7fab874e636c1fe036a027917b5774caaf6b5d1ecd18b0e9ea9355e359d769",
     "typeScriptVersion": "4.3"
 }

node v18.17/stream.d.ts

@@ -50,6 +50,12 @@ declare module 'stream' {
             encoding?: BufferEncoding | undefined;
             read?(this: Readable, size: number): void;
         }
+        interface ArrayOptions {
+            /** the maximum concurrent invocations of `fn` to call on the stream at once. **Default: 1**. */
+            concurrency?: number;
+            /** allows destroying the stream if the signal is aborted. */
+            signal?: AbortSignal;
+        }
         /**
          * @since v0.9.4
          */
@@ -424,6 +430,138 @@ declare module 'stream' {
              */
             wrap(stream: NodeJS.ReadableStream): this;
             push(chunk: any, encoding?: BufferEncoding): boolean;
+            /**
+             * The iterator created by this method gives users the option to cancel the destruction
+             * of the stream if the `for await...of` loop is exited by `return`, `break`, or `throw`,
+             * or if the iterator should destroy the stream if the stream emitted an error during iteration.
+             * @since v16.3.0
+             * @param options.destroyOnReturn When set to `false`, calling `return` on the async iterator,
+             * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
+             * **Default: `true`**.
+             */
+            iterator(options?: {destroyOnReturn?: boolean}): AsyncIterableIterator<any>;
+            /**
+             * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
+             * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
+             * @since v17.4.0, v16.14.0
+             * @param fn a function to map over every chunk in the stream. Async or not.
+             * @returns a stream mapped with the function *fn*.
+             */
+            map(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
+            /**
+             * This method allows filtering the stream. For each chunk in the stream the *fn* function will be called
+             * and if it returns a truthy value, the chunk will be passed to the result stream.
+             * If the *fn* function returns a promise - that promise will be `await`ed.
+             * @since v17.4.0, v16.14.0
+             * @param fn a function to filter chunks from the stream. Async or not.
+             * @returns a stream filtered with the predicate *fn*.
+             */
+            filter(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Readable;
+            /**
+             * This method allows iterating a stream. For each chunk in the stream the *fn* function will be called.
+             * If the *fn* function returns a promise - that promise will be `await`ed.
+             *
+             * This method is different from `for await...of` loops in that it can optionally process chunks concurrently.
+             * In addition, a `forEach` iteration can only be stopped by having passed a `signal` option
+             * and aborting the related AbortController while `for await...of` can be stopped with `break` or `return`.
+             * In either case the stream will be destroyed.
+             *
+             * This method is different from listening to the `'data'` event in that it uses the `readable` event
+             * in the underlying machinary and can limit the number of concurrent *fn* calls.
+             * @since v17.5.0
+             * @param fn a function to call on each chunk of the stream. Async or not.
+             * @returns a promise for when the stream has finished.
+             */
+            forEach(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>, options?: ArrayOptions): Promise<void>;
+            /**
+             * This method allows easily obtaining the contents of a stream.
+             *
+             * As this method reads the entire stream into memory, it negates the benefits of streams. It's intended
+             * for interoperability and convenience, not as the primary way to consume streams.
+             * @since v17.5.0
+             * @returns a promise containing an array with the contents of the stream.
+             */
+            toArray(options?: Pick<ArrayOptions, "signal">): Promise<any[]>;
+            /**
+             * This method is similar to `Array.prototype.some` and calls *fn* on each chunk in the stream
+             * until the awaited return value is `true` (or any truthy value). Once an *fn* call on a chunk
+             * `await`ed return value is truthy, the stream is destroyed and the promise is fulfilled with `true`.
+             * If none of the *fn* calls on the chunks return a truthy value, the promise is fulfilled with `false`.
+             * @since v17.5.0
+             * @param fn a function to call on each chunk of the stream. Async or not.
+             * @returns a promise evaluating to `true` if *fn* returned a truthy value for at least one of the chunks.
+             */
+            some(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Promise<boolean>;
+            /**
+             * This method is similar to `Array.prototype.find` and calls *fn* on each chunk in the stream
+             * to find a chunk with a truthy value for *fn*. Once an *fn* call's awaited return value is truthy,
+             * the stream is destroyed and the promise is fulfilled with value for which *fn* returned a truthy value.
+             * If all of the *fn* calls on the chunks return a falsy value, the promise is fulfilled with `undefined`.
+             * @since v17.5.0
+             * @param fn a function to call on each chunk of the stream. Async or not.
+             * @returns a promise evaluating to the first chunk for which *fn* evaluated with a truthy value,
+             * or `undefined` if no element was found.
+             */
+            find<T>(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => data is T, options?: ArrayOptions): Promise<T | undefined>;
+            find(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Promise<any>;
+            /**
+             * This method is similar to `Array.prototype.every` and calls *fn* on each chunk in the stream
+             * to check if all awaited return values are truthy value for *fn*. Once an *fn* call on a chunk
+             * `await`ed return value is falsy, the stream is destroyed and the promise is fulfilled with `false`.
+             * If all of the *fn* calls on the chunks return a truthy value, the promise is fulfilled with `true`.
+             * @since v17.5.0
+             * @param fn a function to call on each chunk of the stream. Async or not.
+             * @returns a promise evaluating to `true` if *fn* returned a truthy value for every one of the chunks.
+             */
+            every(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Promise<boolean>;
+            /**
+             * This method returns a new stream by applying the given callback to each chunk of the stream
+             * and then flattening the result.
+             *
+             * It is possible to return a stream or another iterable or async iterable from *fn* and the result streams
+             * will be merged (flattened) into the returned stream.
+             * @since v17.5.0
+             * @param fn a function to map over every chunk in the stream. May be async. May be a stream or generator.
+             * @returns a stream flat-mapped with the function *fn*.
+             */
+            flatMap(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
+            /**
+             * This method returns a new stream with the first *limit* chunks dropped from the start.
+             * @since v17.5.0
+             * @param limit the number of chunks to drop from the readable.
+             * @returns a stream with *limit* chunks dropped from the start.
+             */
+            drop(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
+            /**
+             * This method returns a new stream with the first *limit* chunks.
+             * @since v17.5.0
+             * @param limit the number of chunks to take from the readable.
+             * @returns a stream with *limit* chunks taken.
+             */
+            take(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
+            /**
+             * This method returns a new stream with chunks of the underlying stream paired with a counter
+             * in the form `[index, chunk]`. The first index value is `0` and it increases by 1 for each chunk produced.
+             * @since v17.5.0
+             * @returns a stream of indexed pairs.
+             */
+            asIndexedPairs(options?: Pick<ArrayOptions, "signal">): Readable;
+            /**
+             * This method calls *fn* on each chunk of the stream in order, passing it the result from the calculation
+             * on the previous element. It returns a promise for the final value of the reduction.
+             *
+             * If no *initial* value is supplied the first chunk of the stream is used as the initial value.
+             * If the stream is empty, the promise is rejected with a `TypeError` with the `ERR_INVALID_ARGS` code property.
+             *
+             * The reducer function iterates the stream element-by-element which means that there is no *concurrency* parameter
+             * or parallelism. To perform a reduce concurrently, you can extract the async function to `readable.map` method.
+             * @since v17.5.0
+             * @param fn a reducer function to call over every chunk in the stream. Async or not.
+             * @param initial the initial value to use in the reduction.
+             * @returns a promise for the final value of the reduction.
+             */
+            reduce<T = any>(fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T, initial?: undefined, options?: Pick<ArrayOptions, "signal">): Promise<T>;
+            reduce<T = any>(fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T, initial: T, options?: Pick<ArrayOptions, "signal">): Promise<T>;
             _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

node v18.17/ts4.8/module.d.ts

@@ -79,6 +79,9 @@ declare module 'module' {
              */
             findEntry(line: number, column: number): SourceMapping;
         }
+        interface ImportAssertions extends NodeJS.Dict<string> {
+            type?: string | undefined;
+        }
         type ModuleFormat = 'builtin' | 'commonjs' | 'json' | 'module' | 'wasm';
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
         interface GlobalPreloadContext {
@@ -100,7 +103,7 @@ declare module 'module' {
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: Object;
+            importAssertions: ImportAssertions;
             /**
              * The module importing this one, or undefined if this is the Node.js entry point
              */
@@ -114,7 +117,7 @@ declare module 'module' {
             /**
              * The import assertions to use when caching the module (optional; if excluded the input will be used)
              */
-            importAssertions?: Object | undefined;
+            importAssertions?: ImportAssertions | undefined;
             /**
              * A signal that this hook intends to terminate the chain of `resolve` hooks.
              * @default false
@@ -137,7 +140,7 @@ declare module 'module' {
         type ResolveHook = (
             specifier: string,
             context: ResolveHookContext,
-            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput
+            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput | Promise<ResolveFnOutput>
         ) => ResolveFnOutput | Promise<ResolveFnOutput>;
         interface LoadHookContext {
             /**
@@ -151,7 +154,7 @@ declare module 'module' {
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: Object;
+            importAssertions: ImportAssertions;
         }
         interface LoadFnOutput {
             format: ModuleFormat;
@@ -173,7 +176,11 @@ declare module 'module' {
          * @param context Metadata about the module
          * @param nextLoad The subsequent `load` hook in the chain, or the Node.js default `load` hook after the last user-supplied `load` hook
          */
-        type LoadHook = (url: string, context: LoadHookContext, nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput) => LoadFnOutput | Promise<LoadFnOutput>;
+        type LoadHook = (
+            url: string,
+            context: LoadHookContext,
+            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>
+        ) => LoadFnOutput | Promise<LoadFnOutput>;
     }
     interface Module extends NodeModule {}
     class Module {

node v18.17/ts4.8/vm.d.ts

@@ -37,6 +37,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/vm.js)
  */
 declare module 'vm' {
+    import { ImportAssertions } from 'node:module';
     interface Context extends NodeJS.Dict<any> {}
     interface BaseOptions {
         /**
@@ -66,7 +67,7 @@ declare module 'vm' {
          * Called during evaluation of this module when `import()` is called.
          * If this option is not specified, calls to `import()` will reject with `ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`.
          */
-        importModuleDynamically?: ((specifier: string, script: Script, importAssertions: Object) => Module) | undefined;
+        importModuleDynamically?: ((specifier: string, script: Script, importAssertions: ImportAssertions) => Module) | undefined;
     }
     interface RunningScriptOptions extends BaseOptions {
         /**

node v18.17/vm.d.ts

@@ -37,6 +37,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/vm.js)
  */
 declare module 'vm' {
+    import { ImportAssertions } from 'node:module';
     interface Context extends NodeJS.Dict<any> {}
     interface BaseOptions {
         /**
@@ -66,7 +67,7 @@ declare module 'vm' {
          * Called during evaluation of this module when `import()` is called.
          * If this option is not specified, calls to `import()` will reject with `ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`.
          */
-        importModuleDynamically?: ((specifier: string, script: Script, importAssertions: Object) => Module) | undefined;
+        importModuleDynamically?: ((specifier: string, script: Script, importAssertions: ImportAssertions) => Module) | undefined;
     }
     interface RunningScriptOptions extends BaseOptions {
         /**