@types/node 18.18.14 → 18.19.0

{node v18.18 → node v18.19}/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v18.
 
 ### Additional Details
- * Last updated: Wed, 29 Nov 2023 19:35:57 GMT
+ * Last updated: Thu, 30 Nov 2023 20:35:52 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

{node v18.18/ts4.8 → node v18.19}/module.d.ts

@@ -120,7 +120,9 @@ declare module "module" {
              */
             findOrigin(lineNumber: number, columnNumber: number): SourceOrigin | {};
         }
-        interface ImportAssertions extends NodeJS.Dict<string> {
+        /** @deprecated Use `ImportAttributes` instead */
+        interface ImportAssertions extends ImportAttributes {}
+        interface ImportAttributes extends NodeJS.Dict<string> {
             type?: string | undefined;
         }
         type ModuleFormat = "builtin" | "commonjs" | "json" | "module" | "wasm";
@@ -129,6 +131,9 @@ declare module "module" {
             port: MessagePort;
         }
         /**
+         * @deprecated This hook will be removed in a future version.
+         * Use `initialize` instead. When a loader has an `initialize` export, `globalPreload` will be ignored.
+         *
          * Sometimes it might be necessary to run some code inside of the same global scope that the application runs in.
          * This hook allows the return of a string that is run as a sloppy-mode script on startup.
          *
@@ -136,15 +141,27 @@ declare module "module" {
          * @return Code to run before application startup
          */
         type GlobalPreloadHook = (context: GlobalPreloadContext) => string;
+        /**
+         * The `initialize` hook provides a way to define a custom function that runs in the hooks thread
+         * when the hooks module is initialized. Initialization happens when the hooks module is registered via `register`.
+         *
+         * This hook can receive data from a `register` invocation, including ports and other transferrable objects.
+         * The return value of `initialize` can be a `Promise`, in which case it will be awaited before the main application thread execution resumes.
+         */
+        type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
         interface ResolveHookContext {
             /**
              * Export conditions of the relevant `package.json`
              */
             conditions: string[];
+            /**
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions: ImportAttributes;
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: ImportAssertions;
+            importAttributes: ImportAttributes;
             /**
              * The module importing this one, or undefined if this is the Node.js entry point
              */
@@ -156,9 +173,13 @@ declare module "module" {
              */
             format?: ModuleFormat | null | undefined;
             /**
-             * The import assertions to use when caching the module (optional; if excluded the input will be used)
+             * @deprecated Use `importAttributes` instead
              */
-            importAssertions?: ImportAssertions | undefined;
+            importAssertions?: ImportAttributes | undefined;
+            /**
+             * The import attributes to use when caching the module (optional; if excluded the input will be used)
+             */
+            importAttributes?: ImportAttributes | undefined;
             /**
              * A signal that this hook intends to terminate the chain of `resolve` hooks.
              * @default false
@@ -195,10 +216,14 @@ declare module "module" {
              * The format optionally supplied by the `resolve` hook chain
              */
             format: ModuleFormat;
+            /**
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions: ImportAttributes;
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: ImportAssertions;
+            importAttributes: ImportAttributes;
         }
         interface LoadFnOutput {
             format: ModuleFormat;
@@ -226,6 +251,11 @@ declare module "module" {
             nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>,
         ) => LoadFnOutput | Promise<LoadFnOutput>;
     }
+    interface RegisterOptions<Data> {
+        parentURL: string | URL;
+        data?: Data | undefined;
+        transferList?: any[] | undefined;
+    }
     interface Module extends NodeModule {}
     class Module {
         static runMain(): void;
@@ -234,6 +264,12 @@ declare module "module" {
         static builtinModules: string[];
         static isBuiltin(moduleName: string): boolean;
         static Module: typeof Module;
+        static register<Data = any>(
+            specifier: string | URL,
+            parentURL?: string | URL,
+            options?: RegisterOptions<Data>,
+        ): void;
+        static register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
         constructor(id: string, parent?: Module);
     }
     global {

{node v18.18 → node v18.19}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.18.14",
+    "version": "18.19.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -229,7 +229,7 @@
     "dependencies": {
         "undici-types": "~5.26.4"
     },
-    "typesPublisherContentHash": "d5af3cf2d005a6d2962993f11359c75f5fd371f76d1dce518e1fba4d8ee748e6",
+    "typesPublisherContentHash": "4973930634975ec1b7e1081f49fa048b7df346ef21a6dceaf5ccc8b7fe0c5a0d",
     "typeScriptVersion": "4.6",
     "nonNpm": true
 }

{node v18.18/ts4.8 → node v18.19}/process.d.ts

@@ -901,6 +901,12 @@ declare module "process" {
                  * @experimental
                  */
                 setSourceMapsEnabled(value: boolean): void;
+                /**
+                 * The `process.sourceMapsEnabled` property returns whether the [Source Map v3](https://sourcemaps.info/spec.html) support for stack traces is enabled.
+                 * @since v18.19.0
+                 * @experimental
+                 */
+                readonly sourceMapsEnabled: boolean;
                 /**
                  * The `process.version` property contains the Node.js version string.
                  *

{node v18.18/ts4.8 → node v18.19}/test.d.ts

@@ -148,19 +148,26 @@ declare module "node:test" {
     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
      * {@link TestContext} object. If the test uses callbacks, the callback function is passed as
      * the second argument.
      */
     type TestFn = (t: TestContext, done: (result?: any) => void) => any;
-
     /**
      * The type of a function under Suite.
      */
     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 {
         /**
          * If a number is provided, then that many files would run in parallel.
@@ -170,26 +177,22 @@ declare module "node:test" {
          * @default true
          */
         concurrency?: number | boolean | undefined;
-
         /**
          * An array containing the list of files to run.
          * If unspecified, the test runner execution model will be used.
          */
         files?: readonly string[] | undefined;
-
         /**
          * Allows aborting an in-progress test execution.
          * @default undefined
          */
         signal?: AbortSignal | undefined;
-
         /**
          * A number of milliseconds the test will fail after.
          * If unspecified, subtests inherit this value from their parent.
          * @default Infinity
          */
         timeout?: number | undefined;
-
         /**
          * Sets inspector port of test child process.
          * If a nullish value is provided, each process gets its own port,
@@ -202,6 +205,11 @@ declare module "node:test" {
          * For each test that is executed, any corresponding test hooks, such as `beforeEach()`, are also run.
          */
         testNamePatterns?: string | RegExp | string[] | RegExp[];
+        /**
+         * If truthy, the test context will only run tests that have the `only` option set
+         * @since v18.19.0
+         */
+        only?: boolean;
         /**
          * A function that accepts the TestsStream instance and can be used to setup listeners before any tests are run.
          */
@@ -211,6 +219,12 @@ declare module "node:test" {
          * @default false
          */
         watch?: boolean | undefined;
+        /**
+         * Running tests in a specific shard.
+         * @since v18.19.0
+         * @default undefined
+         */
+        shard?: TestShard | undefined;
     }
     class Test extends AsyncResource {
         concurrency: number;
@@ -561,7 +575,6 @@ declare module "node:test" {
             implementation?: Implementation,
             options?: MockFunctionOptions,
         ): Mock<F | Implementation>;
-
         /**
          * This function is used to create a mock on an existing object method.
          * @param object The object whose method is being mocked.
@@ -600,7 +613,6 @@ declare module "node:test" {
             implementation: Function,
             options: MockMethodOptions,
         ): Mock<Function>;
-
         /**
          * This function is syntax sugar for {@link MockTracker.method} with `options.getter` set to `true`.
          */
@@ -622,7 +634,6 @@ declare module "node:test" {
             implementation?: Implementation,
             options?: MockFunctionOptions,
         ): Mock<(() => MockedObject[MethodName]) | Implementation>;
-
         /**
          * This function is syntax sugar for {@link MockTracker.method} with `options.setter` set to `true`.
          */
@@ -644,7 +655,6 @@ declare module "node:test" {
             implementation?: Implementation,
             options?: MockFunctionOptions,
         ): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
-
         /**
          * This function restores the default behavior of all mocks that were previously created by this `MockTracker`
          * and disassociates the mocks from the `MockTracker` instance. Once disassociated, the mocks can still be used,
@@ -654,12 +664,12 @@ declare module "node:test" {
          * If the global `MockTracker` is used extensively, calling this function manually is recommended.
          */
         reset(): void;
-
         /**
          * This function restores the default behavior of all mocks that were previously created by this `MockTracker`.
          * Unlike `mock.reset()`, `mock.restoreAll()` does not disassociate the mocks from the `MockTracker` instance.
          */
         restoreAll(): void;
+        timers: MockTimers;
     }
 
     const mock: MockTracker;
@@ -742,11 +752,172 @@ declare module "node:test" {
          */
         restore(): void;
     }
+    type Timer = "setInterval" | "clearInterval" | "setTimeout" | "clearTimeout";
+    /**
+     * Mocking timers is a technique commonly used in software testing to simulate and
+     * control the behavior of timers, such as `setInterval` and `setTimeout`,
+     * without actually waiting for the specified time intervals.
+     *
+     * The `MockTracker` provides a top-level `timers` export
+     * which is a `MockTimers` instance.
+     * @since v18.19.0
+     * @experimental
+     */
+    class MockTimers {
+        /**
+         * Enables timer mocking for the specified timers.
+         *
+         * **Note:** When you enable mocking for a specific timer, its associated
+         * clear function will also be implicitly mocked.
+         *
+         * Example usage:
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable(['setInterval']);
+         * ```
+         *
+         * The above example enables mocking for the `setInterval` timer and
+         * implicitly mocks the `clearInterval` function. Only the `setInterval`and `clearInterval` functions from `node:timers`,`node:timers/promises`, and`globalThis` will be mocked.
+         *
+         * Alternatively, if you call `mock.timers.enable()` without any parameters:
+         *
+         * All timers (`'setInterval'`, `'clearInterval'`, `'setTimeout'`, and `'clearTimeout'`)
+         * will be mocked. The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout`functions from `node:timers`, `node:timers/promises`,
+         * and `globalThis` will be mocked.
+         * @since v18.19.0
+         */
+        enable(timers?: Timer[]): void;
+        /**
+         * This function restores the default behavior of all mocks that were previously
+         * created by this `MockTimers` instance and disassociates the mocks
+         * from the `MockTracker` instance.
+         *
+         * **Note:** After each test completes, this function is called on
+         * the test context's `MockTracker`.
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.reset();
+         * ```
+         * @since v18.19.0
+         */
+        reset(): void;
+        /**
+         * Advances time for all mocked timers.
+         *
+         * **Note:** This diverges from how `setTimeout` in Node.js behaves and accepts
+         * only positive numbers. In Node.js, `setTimeout` with negative numbers is
+         * only supported for web compatibility reasons.
+         *
+         * The following example mocks a `setTimeout` function and
+         * by using `.tick` advances in
+         * time triggering all pending timers.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *
+         *   context.mock.timers.enable(['setTimeout']);
+         *
+         *   setTimeout(fn, 9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * Alternativelly, the `.tick` function can be called many times
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const nineSecs = 9000;
+         *   setTimeout(fn, nineSecs);
+         *
+         *   const twoSeconds = 3000;
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         * @since v18.19.0
+         */
+        tick(milliseconds: number): void;
+        /**
+         * Triggers all pending mocked timers immediately.
+         *
+         * The example below triggers all pending timers immediately,
+         * causing them to execute without any delay.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('runAll functions following the given order', (context) => {
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const results = [];
+         *   setTimeout(() => results.push(1), 9999);
+         *
+         *   // Notice that if both timers have the same timeout,
+         *   // the order of execution is guaranteed
+         *   setTimeout(() => results.push(3), 8888);
+         *   setTimeout(() => results.push(2), 8888);
+         *
+         *   assert.deepStrictEqual(results, []);
+         *
+         *   context.mock.timers.runAll();
+         *
+         *   assert.deepStrictEqual(results, [3, 2, 1]);
+         * });
+         * ```
+         *
+         * **Note:** The `runAll()` function is specifically designed for
+         * triggering timers in the context of timer mocking.
+         * It does not have any effect on real-time system
+         * clocks or actual timers outside of the mocking environment.
+         * @since v18.19.0
+         */
+        runAll(): void;
+        /**
+         * Calls {@link MockTimers.reset()}.
+         */
+        [Symbol.dispose](): void;
+    }
 
     export { after, afterEach, before, beforeEach, describe, it, mock, run, test, test as default };
 }
 
-interface DiagnosticData {
+interface TestLocationInfo {
+    /**
+     * The column number where the test is defined, or
+     * `undefined` if the test was run through the REPL.
+     */
+    column?: number;
+    /**
+     * The path of the test file, `undefined` if test is not ran through a file.
+     */
+    file?: string;
+    /**
+     * The line number where the test is defined, or
+     * `undefined` if the test was run through the REPL.
+     */
+    line?: number;
+}
+interface DiagnosticData extends TestLocationInfo {
     /**
      * The diagnostic message.
      */
@@ -755,12 +926,8 @@ interface DiagnosticData {
      * The nesting level of the test.
      */
     nesting: number;
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
 }
-interface TestFail {
+interface TestFail extends TestLocationInfo {
     /**
      * Additional execution metadata.
      */
@@ -799,12 +966,8 @@ interface TestFail {
      * Present if `context.skip` is called.
      */
     skip?: string | boolean;
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
 }
-interface TestPass {
+interface TestPass extends TestLocationInfo {
     /**
      * Additional execution metadata.
      */
@@ -839,12 +1002,8 @@ interface TestPass {
      * Present if `context.skip` is called.
      */
     skip?: string | boolean;
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
 }
-interface TestPlan {
+interface TestPlan extends TestLocationInfo {
     /**
      * The nesting level of the test.
      */
@@ -853,12 +1012,8 @@ interface TestPlan {
      * The number of subtests that have ran.
      */
     count: number;
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
 }
-interface TestStart {
+interface TestStart extends TestLocationInfo {
     /**
      * The test name.
      */
@@ -867,54 +1022,34 @@ interface TestStart {
      * The nesting level of the test.
      */
     nesting: number;
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
 }
-interface TestStderr {
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
+interface TestStderr extends TestLocationInfo {
     /**
      * The message written to `stderr`
      */
     message: string;
 }
-interface TestStdout {
-    /**
-     * The path of the test file, undefined if test is not ran through a file.
-     */
-    file?: string;
+interface TestStdout extends TestLocationInfo {
     /**
      * The message written to `stdout`
      */
     message: string;
 }
-interface TestEnqueue {
+interface TestEnqueue extends TestLocationInfo {
     /**
      * 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 {
+interface TestDequeue extends TestLocationInfo {
     /**
      * 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.
      */
@@ -970,5 +1105,9 @@ declare module "node:test/reporters" {
     class Spec extends Transform {
         constructor();
     }
-    export { dot, Spec as spec, tap, TestEvent };
+    /**
+     * The `junit` reporter outputs test results in a jUnit XML format
+     */
+    function junit(source: TestEventGenerator): AsyncGenerator<string, void>;
+    export { dot, junit, Spec as spec, tap, TestEvent };
 }

{node v18.18 → node v18.19}/tls.d.ts

@@ -797,6 +797,18 @@ declare module "tls" {
     }
     type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
     interface SecureContextOptions {
+        /**
+         * If set, this will be called when a client opens a connection using the ALPN extension.
+         * One argument will be passed to the callback: an object containing `servername` and `protocols` fields,
+         * respectively containing the server name from the SNI extension (if any) and an array of
+         * ALPN protocol name strings. The callback must return either one of the strings listed in `protocols`,
+         * which will be returned to the client as the selected ALPN protocol, or `undefined`,
+         * to reject the connection with a fatal alert. If a string is returned that does not match one of
+         * the client's ALPN protocols, an error will be thrown.
+         * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
+         * @since v18.19.0
+         */
+        ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely