node-red-contrib-tak-registration 0.14.1 → 0.15.0

package/node_modules/@types/node/test.d.ts

@@ -147,6 +147,7 @@ declare module "node:test" {
         export {
             after,
             afterEach,
+            assert,
             before,
             beforeEach,
             describe,
@@ -564,6 +565,23 @@ declare module "node:test" {
         /**
          * An object containing assertion methods bound to the test context.
          * The top-level functions from the `node:assert` module are exposed here for the purpose of creating test plans.
+         *
+         * **Note:** Some of the functions from `node:assert` contain type assertions. If these are called via the
+         * TestContext `assert` object, then the context parameter in the test's function signature **must be explicitly typed**
+         * (ie. the parameter must have a type annotation), otherwise an error will be raised by the TypeScript compiler:
+         * ```ts
+         * import { test, type TestContext } from 'node:test';
+         *
+         * // The test function's context parameter must have a type annotation.
+         * test('example', (t: TestContext) => {
+         *   t.assert.deepStrictEqual(actual, expected);
+         * });
+         *
+         * // Omitting the type annotation will result in a compilation error.
+         * test('example', t => {
+         *   t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
+         * });
+         * ```
          * @since v22.2.0, v20.15.0
          */
         readonly assert: TestContextAssert;
@@ -630,11 +648,12 @@ declare module "node:test" {
          */
         readonly name: string;
         /**
-         * Used to set the number of assertions and subtests that are expected to run within the test.
-         * If the number of assertions and subtests that run does not match the expected count, the test will fail.
+         * This function is used to set the number of assertions and subtests that are expected to run
+         * within the test. If the number of assertions and subtests that run does not match the
+         * expected count, the test will fail.
+         *
+         * > Note: To make sure assertions are tracked, `t.assert` must be used instead of `assert` directly.
          *
-         * To make sure assertions are tracked, the assert functions on `context.assert` must be used,
-         * instead of importing from the `node:assert` module.
          * ```js
          * test('top level test', (t) => {
          *   t.plan(2);
@@ -643,7 +662,9 @@ declare module "node:test" {
          * });
          * ```
          *
-         * When working with asynchronous code, the `plan` function can be used to ensure that the correct number of assertions are run:
+         * When working with asynchronous code, the `plan` function can be used to ensure that the
+         * correct number of assertions are run:
+         *
          * ```js
          * test('planning with streams', (t, done) => {
          *   function* generate() {
@@ -657,14 +678,35 @@ declare module "node:test" {
          *   stream.on('data', (chunk) => {
          *     t.assert.strictEqual(chunk, expected.shift());
          *   });
+         *
          *   stream.on('end', () => {
          *     done();
          *   });
          * });
          * ```
+         *
+         * When using the `wait` option, you can control how long the test will wait for the expected assertions.
+         * For example, setting a maximum wait time ensures that the test will wait for asynchronous assertions
+         * to complete within the specified timeframe:
+         *
+         * ```js
+         * test('plan with wait: 2000 waits for async assertions', (t) => {
+         *   t.plan(1, { wait: 2000 }); // Waits for up to 2 seconds for the assertion to complete.
+         *
+         *   const asyncActivity = () => {
+         *     setTimeout(() => {
+         *          *       t.assert.ok(true, 'Async assertion completed within the wait time');
+         *     }, 1000); // Completes after 1 second, within the 2-second wait time.
+         *   };
+         *
+         *   asyncActivity(); // The test will pass because the assertion is completed in time.
+         * });
+         * ```
+         *
+         * Note: If a `wait` timeout is specified, it begins counting down only after the test function finishes executing.
          * @since v22.2.0
          */
-        plan(count: number): void;
+        plan(count: number, options?: TestContextPlanOptions): void;
         /**
          * If `shouldRunOnlyTests` is truthy, the test context will only run tests that
          * have the `only` option set. Otherwise, all tests are run. If Node.js was not
@@ -736,144 +778,73 @@ declare module "node:test" {
          * @returns A {@link Promise} resolved with `undefined` once the test completes.
          */
         test: typeof test;
+        /**
+         * This method polls a `condition` function until that function either returns
+         * successfully or the operation times out.
+         * @since v22.14.0
+         * @param condition An assertion function that is invoked
+         * periodically until it completes successfully or the defined polling timeout
+         * elapses. Successful completion is defined as not throwing or rejecting. This
+         * function does not accept any arguments, and is allowed to return any value.
+         * @param options An optional configuration object for the polling operation.
+         * @returns Fulfilled with the value returned by `condition`.
+         */
+        waitFor<T>(condition: () => T, options?: TestContextWaitForOptions): Promise<Awaited<T>>;
         /**
          * Each test provides its own MockTracker instance.
          */
         readonly mock: MockTracker;
     }
-    interface TestContextAssert {
-        /**
-         * Identical to the `deepEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        deepEqual: typeof import("node:assert").deepEqual;
-        /**
-         * Identical to the `deepStrictEqual` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
+    interface TestContextAssert extends
+        Pick<
+            typeof import("assert"),
+            | "deepEqual"
+            | "deepStrictEqual"
+            | "doesNotMatch"
+            | "doesNotReject"
+            | "doesNotThrow"
+            | "equal"
+            | "fail"
+            | "ifError"
+            | "match"
+            | "notDeepEqual"
+            | "notDeepStrictEqual"
+            | "notEqual"
+            | "notStrictEqual"
+            | "ok"
+            | "partialDeepStrictEqual"
+            | "rejects"
+            | "strictEqual"
+            | "throws"
+        >
+    {
+        /**
+         * This function serializes `value` and writes it to the file specified by `path`.
          *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.deepStrictEqual(actual, expected);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        deepStrictEqual: typeof import("node:assert").deepStrictEqual;
-        /**
-         * Identical to the `doesNotMatch` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotMatch: typeof import("node:assert").doesNotMatch;
-        /**
-         * Identical to the `doesNotReject` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotReject: typeof import("node:assert").doesNotReject;
-        /**
-         * Identical to the `doesNotThrow` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotThrow: typeof import("node:assert").doesNotThrow;
-        /**
-         * Identical to the `equal` function from the `node:assert` module, but bound to the test context.
-         */
-        equal: typeof import("node:assert").equal;
-        /**
-         * Identical to the `fail` function from the `node:assert` module, but bound to the test context.
-         */
-        fail: typeof import("node:assert").fail;
-        /**
-         * Identical to the `ifError` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.ifError(err);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.ifError(err); // Error: 't' needs an explicit type annotation.
+         * ```js
+         * test('snapshot test with default serialization', (t) => {
+         *   t.assert.fileSnapshot({ value1: 1, value2: 2 }, './snapshots/snapshot.json');
          * });
          * ```
-         */
-        ifError: typeof import("node:assert").ifError;
-        /**
-         * Identical to the `match` function from the `node:assert` module, but bound to the test context.
-         */
-        match: typeof import("node:assert").match;
-        /**
-         * Identical to the `notDeepEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notDeepEqual: typeof import("node:assert").notDeepEqual;
-        /**
-         * Identical to the `notDeepStrictEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notDeepStrictEqual: typeof import("node:assert").notDeepStrictEqual;
-        /**
-         * Identical to the `notEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notEqual: typeof import("node:assert").notEqual;
-        /**
-         * Identical to the `notStrictEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notStrictEqual: typeof import("node:assert").notStrictEqual;
-        /**
-         * Identical to the `ok` function from the `node:assert` module, but bound to the test context.
          *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
+         * This function differs from `context.assert.snapshot()` in the following ways:
          *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.ok(condition);
-         * });
+         * * The snapshot file path is explicitly provided by the user.
+         * * Each snapshot file is limited to a single snapshot value.
+         * * No additional escaping is performed by the test runner.
          *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.ok(condition)); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        ok: typeof import("node:assert").ok;
-        /**
-         * Identical to the `rejects` function from the `node:assert` module, but bound to the test context.
+         * These differences allow snapshot files to better support features such as syntax
+         * highlighting.
+         * @since v22.14.0
+         * @param value A value to serialize to a string. If Node.js was started with
+         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+         * flag, the serialized value is written to
+         * `path`. Otherwise, the serialized value is compared to the contents of the
+         * existing snapshot file.
+         * @param path The file where the serialized `value` is written.
+         * @param options Optional configuration options.
          */
-        rejects: typeof import("node:assert").rejects;
-        /**
-         * Identical to the `strictEqual` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.strictEqual(actual, expected);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.strictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        strictEqual: typeof import("node:assert").strictEqual;
-        /**
-         * Identical to the `throws` function from the `node:assert` module, but bound to the test context.
-         */
-        throws: typeof import("node:assert").throws;
+        fileSnapshot(value: any, path: string, options?: AssertSnapshotOptions): void;
         /**
          * This function implements assertions for snapshot testing.
          * ```js
@@ -887,12 +858,18 @@ declare module "node:test" {
          *   });
          * });
          * ```
-         *
-         * Only available through the [--experimental-test-snapshots](https://nodejs.org/api/cli.html#--experimental-test-snapshots) flag.
          * @since v22.3.0
-         * @experimental
+         * @param value A value to serialize to a string. If Node.js was started with
+         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+         * flag, the serialized value is written to
+         * the snapshot file. Otherwise, the serialized value is compared to the
+         * corresponding value in the existing snapshot file.
          */
         snapshot(value: any, options?: AssertSnapshotOptions): void;
+        /**
+         * A custom assertion function registered with `assert.register()`.
+         */
+        [name: string]: (...args: any[]) => void;
     }
     interface AssertSnapshotOptions {
         /**
@@ -905,6 +882,34 @@ declare module "node:test" {
          */
         serializers?: ReadonlyArray<(value: any) => any> | undefined;
     }
+    interface TestContextPlanOptions {
+        /**
+         * The wait time for the plan:
+         * * If `true`, the plan waits indefinitely for all assertions and subtests to run.
+         * * If `false`, the plan performs an immediate check after the test function completes,
+         * without waiting for any pending assertions or subtests.
+         * Any assertions or subtests that complete after this check will not be counted towards the plan.
+         * * If a number, it specifies the maximum wait time in milliseconds
+         * before timing out while waiting for expected assertions and subtests to be matched.
+         * If the timeout is reached, the test will fail.
+         * @default false
+         */
+        wait?: boolean | number | undefined;
+    }
+    interface TestContextWaitForOptions {
+        /**
+         * The number of milliseconds to wait after an unsuccessful
+         * invocation of `condition` before trying again.
+         * @default 50
+         */
+        interval?: number | undefined;
+        /**
+         * The poll timeout in milliseconds. If `condition` has not
+         * succeeded by the time this elapses, an error occurs.
+         * @default 1000
+         */
+        timeout?: number | undefined;
+    }
 
     /**
      * An instance of `SuiteContext` is passed to each suite function in order to
@@ -1691,9 +1696,25 @@ declare module "node:test" {
         [Symbol.dispose](): void;
     }
     /**
-     * Only available through the [--experimental-test-snapshots](https://nodejs.org/api/cli.html#--experimental-test-snapshots) flag.
+     * An object whose methods are used to configure available assertions on the
+     * `TestContext` objects in the current process. The methods from `node:assert`
+     * and snapshot testing functions are available by default.
+     *
+     * It is possible to apply the same configuration to all files by placing common
+     * configuration code in a module
+     * preloaded with `--require` or `--import`.
+     * @since v22.14.0
+     */
+    namespace assert {
+        /**
+         * Defines a new assertion function with the provided name and function. If an
+         * assertion already exists with the same name, it is overwritten.
+         * @since v22.14.0
+         */
+        function register(name: string, fn: (this: TestContext, ...args: any[]) => void): void;
+    }
+    /**
      * @since v22.3.0
-     * @experimental
      */
     namespace snapshot {
         /**
@@ -1723,6 +1744,7 @@ declare module "node:test" {
     export {
         after,
         afterEach,
+        assert,
         before,
         beforeEach,
         describe,
@@ -1987,6 +2009,11 @@ interface TestDequeue extends TestLocationInfo {
      * The nesting level of the test.
      */
     nesting: number;
+    /**
+     * The test type. Either `'suite'` or `'test'`.
+     * @since v22.15.0
+     */
+    type: "suite" | "test";
 }
 interface TestEnqueue extends TestLocationInfo {
     /**
@@ -1997,6 +2024,11 @@ interface TestEnqueue extends TestLocationInfo {
      * The nesting level of the test.
      */
     nesting: number;
+    /**
+     * The test type. Either `'suite'` or `'test'`.
+     * @since v22.15.0
+     */
+    type: "suite" | "test";
 }
 interface TestFail extends TestLocationInfo {
     /**

package/node_modules/@types/node/timers/promises.d.ts

@@ -1,6 +1,7 @@
 /**
  * The `timers/promises` API provides an alternative set of timer functions
- * that return `Promise` objects. The API is accessible via `import timersPromises from 'node:timers/promises'`.
+ * that return `Promise` objects. The API is accessible via
+ * `require('node:timers/promises')`.
  *
  * ```js
  * import {
@@ -10,6 +11,7 @@
  * } from 'node:timers/promises';
  * ```
  * @since v15.0.0
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers/promises.js)
  */
 declare module "timers/promises" {
     import { TimerOptions } from "node:timers";
@@ -24,7 +26,8 @@ declare module "timers/promises" {
      * console.log(res);  // Prints 'result'
      * ```
      * @since v15.0.0
-     * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
+     * @param delay The number of milliseconds to wait before fulfilling the
+     * promise. **Default:** `1`.
      * @param value A value with which the promise is fulfilled.
      */
     function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
@@ -62,33 +65,41 @@ declare module "timers/promises" {
      * console.log(Date.now());
      * ```
      * @since v15.9.0
+     * @param delay The number of milliseconds to wait between iterations.
+     * **Default:** `1`.
+     * @param value A value with which the iterator returns.
      */
-    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
+    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): NodeJS.AsyncIterator<T>;
     interface Scheduler {
         /**
-         * An experimental API defined by the [Scheduling APIs](https://github.com/WICG/scheduling-apis) draft specification being developed as a standard Web Platform API.
+         * An experimental API defined by the [Scheduling APIs](https://github.com/WICG/scheduling-apis) draft specification
+         * being developed as a standard Web Platform API.
          *
-         * Calling `timersPromises.scheduler.wait(delay, options)` is roughly equivalent to calling `timersPromises.setTimeout(delay, undefined, options)` except that the `ref`
-         * option is not supported.
+         * Calling `timersPromises.scheduler.wait(delay, options)` is roughly equivalent
+         * to calling `timersPromises.setTimeout(delay, undefined, options)` except that
+         * the `ref` option is not supported.
          *
          * ```js
          * import { scheduler } from 'node:timers/promises';
          *
          * await scheduler.wait(1000); // Wait one second before continuing
          * ```
-         * @since v16.14.0
+         * @since v17.3.0, v16.14.0
          * @experimental
-         * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
+         * @param delay The number of milliseconds to wait before resolving the
+         * promise.
          */
-        wait: (delay?: number, options?: TimerOptions) => Promise<void>;
+        wait(delay: number, options?: { signal?: AbortSignal }): Promise<void>;
         /**
-         * An experimental API defined by the [Scheduling APIs](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking) draft specification
+         * An experimental API defined by the [Scheduling APIs](https://github.com/WICG/scheduling-apis) draft specification
          * being developed as a standard Web Platform API.
-         * Calling `timersPromises.scheduler.yield()` is equivalent to calling `timersPromises.setImmediate()` with no arguments.
-         * @since v16.14.0
+         *
+         * Calling `timersPromises.scheduler.yield()` is equivalent to calling
+         * `timersPromises.setImmediate()` with no arguments.
+         * @since v17.3.0, v16.14.0
          * @experimental
          */
-        yield: () => Promise<void>;
+        yield(): Promise<void>;
     }
     const scheduler: Scheduler;
 }