cloudstructs 0.6.10 → 0.6.11

package/node_modules/@slack/logger/node_modules/@types/node/stream/consumers.d.ts

@@ -1,22 +1,10 @@
-// Duplicates of interface in lib.dom.ts.
-// Duplicated here rather than referencing lib.dom.ts because doing so causes lib.dom.ts to be loaded for "test-all"
-// Which in turn causes tests to pass that shouldn't pass.
-//
-// This interface is not, and should not be, exported.
-interface Blob {
-    readonly size: number;
-    readonly type: string;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    slice(start?: number, end?: number, contentType?: string): Blob;
-    stream(): NodeJS.ReadableStream;
-    text(): Promise<string>;
-}
 declare module 'stream/consumers' {
+    import { Blob as NodeBlob } from "node:buffer";
     import { Readable } from 'node:stream';
     function buffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Buffer>;
     function text(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<string>;
     function arrayBuffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<ArrayBuffer>;
-    function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Blob>;
+    function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<NodeBlob>;
     function json(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<unknown>;
 }
 declare module 'node:stream/consumers' {

package/node_modules/@slack/logger/node_modules/@types/node/stream.d.ts

@@ -18,6 +18,7 @@
  */
 declare module 'stream' {
     import { EventEmitter, Abortable } from 'node:events';
+    import { Blob as NodeBlob } from "node:buffer";
     import * as streamPromises from 'node:stream/promises';
     import * as streamConsumers from 'node:stream/consumers';
     import * as streamWeb from 'node:stream/web';
@@ -123,12 +124,12 @@ declare module 'stream' {
             readonly readableObjectMode: boolean;
             /**
              * Is `true` after `readable.destroy()` has been called.
-             * @since v18.0.0
+             * @since v8.0.0
              */
             destroyed: boolean;
             /**
              * Is true after 'close' has been emitted.
-             * @since v8.0.0
+             * @since v18.0.0
              */
             readonly closed: boolean;
             /**
@@ -578,7 +579,7 @@ declare module 'stream' {
             destroyed: boolean;
             /**
              * Is true after 'close' has been emitted.
-             * @since v8.0.0
+             * @since v18.0.0
              */
             readonly closed: boolean;
             /**
@@ -892,7 +893,7 @@ declare module 'stream' {
              *
              * @since v16.8.0
              */
-            static from(src: Stream | Blob | ArrayBuffer | string | Iterable<any> | AsyncIterable<any> | AsyncGeneratorFunction | Promise<any> | Object): Duplex;
+            static from(src: Stream | NodeBlob | ArrayBuffer | string | Iterable<any> | AsyncIterable<any> | AsyncGeneratorFunction | Promise<any> | Object): Duplex;
             _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             _writev?(
                 chunks: Array<{

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

@@ -3,6 +3,14 @@
  * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/test.js)
  */
 declare module 'node:test' {
+    /**
+     * Programmatically start the test runner.
+     * @since v18.9.0
+     * @param options Configuration options for running tests.
+     * @returns A {@link TapStream} that emits events about the test execution.
+     */
+    function run(options?: RunOptions): TapStream;
+
     /**
      * The `test()` function is the value imported from the test module. Each invocation of this
      * function results in the creation of a test point in the TAP output.
@@ -42,7 +50,7 @@ declare module 'node:test' {
     function test(options?: TestOptions, fn?: TestFn): Promise<void>;
     function test(fn?: TestFn): Promise<void>;
 
-    /*
+    /**
      * @since v18.6.0
      * @param name The name of the suite, which is displayed when reporting suite results.
      *    Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
@@ -54,7 +62,7 @@ declare module 'node:test' {
     function describe(options?: TestOptions, fn?: SuiteFn): void;
     function describe(fn?: SuiteFn): void;
 
-    /*
+    /**
      * @since v18.6.0
      * @param name The name of the test, which is displayed when reporting test results.
      *    Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
@@ -86,6 +94,122 @@ declare module 'node:test' {
      */
     type ItFn = (done: (result?: any) => void) => any;
 
+    interface RunOptions {
+        /**
+         * @default false
+         */
+        concurrency?: number | boolean;
+
+        /**
+         * An array containing the list of files to run. If unspecified, the test runner execution model will be used.
+         */
+        files?: readonly string[];
+
+        /**
+         * Allows aborting an in-progress test.
+         * @default undefined
+         */
+        signal?: AbortSignal;
+
+        /**
+         * A number of milliseconds the test will fail after. If unspecified, subtests inherit this
+         * value from their parent.
+         * @default Infinity
+         */
+        timeout?: number;
+    }
+
+    /**
+     * A successful call of the run() method will return a new TapStream object, streaming a TAP output.
+     * TapStream will emit events in the order of the tests' definitions.
+     * @since v18.9.0
+     */
+    interface TapStream extends NodeJS.ReadableStream {
+        addListener(event: 'test:diagnostic', listener: (message: string) => void): this;
+        addListener(event: 'test:fail', listener: (data: TestFail) => void): this;
+        addListener(event: 'test:pass', listener: (data: TestPass) => void): this;
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        emit(event: 'test:diagnostic', message: string): boolean;
+        emit(event: 'test:fail', data: TestFail): boolean;
+        emit(event: 'test:pass', data: TestPass): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        on(event: 'test:diagnostic', listener: (message: string) => void): this;
+        on(event: 'test:fail', listener: (data: TestFail) => void): this;
+        on(event: 'test:pass', listener: (data: TestPass) => void): this;
+        on(event: string, listener: (...args: any[]) => void): this;
+        once(event: 'test:diagnostic', listener: (message: string) => void): this;
+        once(event: 'test:fail', listener: (data: TestFail) => void): this;
+        once(event: 'test:pass', listener: (data: TestPass) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: 'test:diagnostic', listener: (message: string) => void): this;
+        prependListener(event: 'test:fail', listener: (data: TestFail) => void): this;
+        prependListener(event: 'test:pass', listener: (data: TestPass) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: 'test:diagnostic', listener: (message: string) => void): this;
+        prependOnceListener(event: 'test:fail', listener: (data: TestFail) => void): this;
+        prependOnceListener(event: 'test:pass', listener: (data: TestPass) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+    }
+
+    interface TestFail {
+        /**
+         * The test duration.
+         */
+        duration: number;
+
+        /**
+         * The failure casing test to fail.
+         */
+        error: Error;
+
+        /**
+         * The test name.
+         */
+        name: string;
+
+        /**
+         * The ordinal number of the test.
+         */
+        testNumber: number;
+
+        /**
+         * Present if `context.todo` is called.
+         */
+        todo?: string;
+
+        /**
+         * Present if `context.skip` is called.
+         */
+        skip?: string;
+    }
+
+    interface TestPass {
+        /**
+         * The test duration.
+         */
+        duration: number;
+
+        /**
+         * The test name.
+         */
+        name: string;
+
+        /**
+         * The ordinal number of the test.
+         */
+        testNumber: number;
+
+        /**
+         * Present if `context.todo` is called.
+         */
+        todo?: string;
+
+        /**
+         * Present if `context.skip` is called.
+         */
+        skip?: string;
+    }
+
     /**
      * An instance of `TestContext` is passed to each test function in order to interact with the
      * test runner. However, the `TestContext` constructor is not exposed as part of the API.
@@ -159,7 +283,7 @@ declare module 'node:test' {
 
         /**
          * Allows aborting an in-progress test.
-         * @since 8.7.0
+         * @since v18.8.0
          */
         signal?: AbortSignal;
 
@@ -174,7 +298,7 @@ declare module 'node:test' {
          * A number of milliseconds the test will fail after. If unspecified, subtests inherit this
          * value from their parent.
          * @default Infinity
-         * @since 8.7.0
+         * @since v18.7.0
          */
         timeout?: number;
 
@@ -186,5 +310,5 @@ declare module 'node:test' {
         todo?: boolean | string;
     }
 
-    export { test as default, test, describe, it };
+    export { test as default, run, test, describe, it };
 }

package/node_modules/@slack/logger/node_modules/@types/node/tls.d.ts

@@ -598,44 +598,44 @@ declare module 'tls' {
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
         addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
         addListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
         addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: 'tlsClientError', err: Error, tlsSocket: TLSSocket): boolean;
-        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
+        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: () => void): boolean;
         emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
-        emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
+        emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void): boolean;
         emit(event: 'secureConnection', tlsSocket: TLSSocket): boolean;
         emit(event: 'keylog', line: Buffer, tlsSocket: TLSSocket): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
         on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
         on(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
         on(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
         once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
         once(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
         once(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
         prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
         prependListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
         prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
         prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
         prependOnceListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
         prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }

package/node_modules/{@types/keyv/node_modules/@types/node → @slack/logger/node_modules/@types/node/ts4.8}/assert.d.ts

@@ -65,6 +65,27 @@ declare module 'assert' {
              */
             calls(exact?: number): () => void;
             calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            /**
+             * Example:
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             * const callsfunc = tracker.calls(func);
+             * callsfunc(1, 2, 3);
+             *
+             * assert.deepStrictEqual(tracker.getCalls(callsfunc),
+             *                        [{ thisArg: this, arguments: [1, 2, 3 ] }]);
+             * ```
+             *
+             * @since v18.8.0, v16.18.0
+             * @params fn
+             * @returns An Array with the calls to a tracked function.
+             */
+            getCalls(fn: Function): CallTrackerCall[];
             /**
              * The arrays contains information about the expected and actual number of calls of
              * the functions that have not been called the expected number of times.
@@ -100,6 +121,31 @@ declare module 'assert' {
              * @return of objects containing information about the wrapper functions returned by `calls`.
              */
             report(): CallTrackerReportInformation[];
+            /**
+             * Reset calls of the call tracker.
+             * If a tracked function is passed as an argument, the calls will be reset for it.
+             * If no arguments are passed, all tracked functions will be reset.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             * const callsfunc = tracker.calls(func);
+             *
+             * callsfunc();
+             * // Tracker was called once
+             * tracker.getCalls(callsfunc).length === 1;
+             *
+             * tracker.reset(callsfunc);
+             * tracker.getCalls(callsfunc).length === 0;
+             * ```
+             *
+             * @since v18.8.0, v16.18.0
+             * @param fn a tracked function to reset.
+             */
+            reset(fn?: Function): void;
             /**
              * Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that
              * have not been called the expected number of times.
@@ -125,6 +171,10 @@ declare module 'assert' {
              */
             verify(): void;
         }
+        interface CallTrackerCall {
+            thisArg: object;
+            arguments: unknown[];
+        }
         interface CallTrackerReportInformation {
             message: string;
             /** The actual number of times the function was called. */

package/node_modules/{@types/keyv/node_modules/@types/node → @slack/logger/node_modules/@types/node/ts4.8}/buffer.d.ts

@@ -45,6 +45,7 @@
  */
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
+    import { ReadableStream as WebReadableStream } from 'node:stream/web';
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -157,13 +158,20 @@ declare module 'buffer' {
          */
         text(): Promise<string>;
         /**
-         * Returns a new `ReadableStream` that allows the content of the `Blob` to be read.
+         * Returns a new (WHATWG) `ReadableStream` that allows the content of the `Blob` to be read.
          * @since v16.7.0
          */
-        stream(): unknown; // pending web streams types
+        stream(): WebReadableStream;
     }
     export import atob = globalThis.atob;
     export import btoa = globalThis.btoa;
+
+    import { Blob as NodeBlob } from 'buffer';
+    // This conditional type will be the existing global Blob in a browser, or
+    // the copy below in a Node environment.
+    type __Blob = typeof globalThis extends { onmessage: any, Blob: any }
+        ? {} : NodeBlob;
+
     global {
         // Buffer class
         type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
@@ -2231,6 +2239,19 @@ declare module 'buffer' {
          * @param data An ASCII (Latin1) string.
          */
         function btoa(data: string): string;
+
+        interface Blob extends __Blob {}
+        /**
+         * `Blob` class is a global reference for `require('node:buffer').Blob`
+         * https://nodejs.org/api/buffer.html#class-blob
+         * @since v18.0.0
+         */
+        var Blob: typeof globalThis extends {
+            onmessage: any;
+            Blob: infer T;
+        }
+            ? T
+            : typeof NodeBlob;
     }
 }
 declare module 'node:buffer' {

package/node_modules/{@types/keyv/node_modules/@types/node → @slack/logger/node_modules/@types/node/ts4.8}/crypto.d.ts

@@ -1478,10 +1478,10 @@ declare module 'crypto' {
      * @param [generator=2]
      * @param generatorEncoding The `encoding` of the `generator` string.
      */
-    function createDiffieHellman(primeLength: number, generator?: number | NodeJS.ArrayBufferView): DiffieHellman;
-    function createDiffieHellman(prime: NodeJS.ArrayBufferView): DiffieHellman;
-    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding): DiffieHellman;
-    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator: number | NodeJS.ArrayBufferView): DiffieHellman;
+    function createDiffieHellman(primeLength: number, generator?: number): DiffieHellman;
+    function createDiffieHellman(prime: ArrayBuffer | NodeJS.ArrayBufferView, generator?: number | ArrayBuffer | NodeJS.ArrayBufferView): DiffieHellman;
+    function createDiffieHellman(prime: ArrayBuffer | NodeJS.ArrayBufferView, generator: string, generatorEncoding: BinaryToTextEncoding): DiffieHellman;
+    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator?: number | ArrayBuffer | NodeJS.ArrayBufferView): DiffieHellman;
     function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator: string, generatorEncoding: BinaryToTextEncoding): DiffieHellman;
     /**
      * The `DiffieHellman` class is a utility for creating Diffie-Hellman key
@@ -1830,7 +1830,7 @@ declare module 'crypto' {
      * Return a random integer `n` such that `min <= n < max`.  This
      * implementation avoids [modulo bias](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias).
      *
-     * The range (`max - min`) must be less than 248. `min` and `max` must
+     * The range (`max - min`) must be less than 2^48. `min` and `max` must
      * be [safe integers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
      *
      * If the `callback` function is not provided, the random integer is
@@ -3417,7 +3417,7 @@ declare module 'crypto' {
     interface CheckPrimeOptions {
         /**
          * The number of Miller-Rabin probabilistic primality iterations to perform.
-         * When the value is 0 (zero), a number of checks is used that yields a false positive rate of at most 2-64 for random input.
+         * When the value is 0 (zero), a number of checks is used that yields a false positive rate of at most `2**-64` for random input.
          * Care must be used when selecting a number of checks.
          * Refer to the OpenSSL documentation for the BN_is_prime_ex function nchecks options for more details.
          *
@@ -3723,7 +3723,9 @@ declare module 'crypto' {
             /**
              * Using the method and parameters specified in `algorithm` and the keying material provided by `baseKey`,
              * `subtle.deriveBits()` attempts to generate `length` bits.
-             * The Node.js implementation requires that `length` is a multiple of `8`.
+             * The Node.js implementation requires that when `length` is a number it must be multiple of `8`.
+             * When `length` is `null` the maximum number of bits for a given algorithm is generated. This is allowed
+             * for the `'ECDH'`, `'X25519'`, and `'X448'` algorithms.
              * If successful, the returned promise will be resolved with an `<ArrayBuffer>` containing the generated data.
              *
              * The algorithms currently supported include:
@@ -3735,7 +3737,8 @@ declare module 'crypto' {
              * - `'PBKDF2'`
              * @since v15.0.0
              */
-            deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
+            deriveBits(algorithm: EcdhKeyDeriveParams, baseKey: CryptoKey, length: number | null): Promise<ArrayBuffer>;
+            deriveBits(algorithm: AlgorithmIdentifier | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
             /**
              * Using the method and parameters specified in `algorithm`, and the keying material provided by `baseKey`,
              * `subtle.deriveKey()` attempts to generate a new <CryptoKey>` based on the method and parameters in `derivedKeyAlgorithm`.

package/node_modules/@slack/logger/node_modules/@types/node/ts4.8/dom-events.d.ts

@@ -0,0 +1,126 @@
+export {}; // Don't export anything!
+
+//// DOM-like Events
+// NB: The Event / EventTarget / EventListener implementations below were copied
+// from lib.dom.d.ts, then edited to reflect Node's documentation at
+// https://nodejs.org/api/events.html#class-eventtarget.
+// Please read that link to understand important implementation differences.
+
+// This conditional type will be the existing global Event in a browser, or
+// the copy below in a Node environment.
+type __Event = typeof globalThis extends { onmessage: any, Event: any }
+? {}
+: {
+    /** This is not used in Node.js and is provided purely for completeness. */
+    readonly bubbles: boolean;
+    /** Alias for event.stopPropagation(). This is not used in Node.js and is provided purely for completeness. */
+    cancelBubble: () => void;
+    /** True if the event was created with the cancelable option */
+    readonly cancelable: boolean;
+    /** This is not used in Node.js and is provided purely for completeness. */
+    readonly composed: boolean;
+    /** Returns an array containing the current EventTarget as the only entry or empty if the event is not being dispatched. This is not used in Node.js and is provided purely for completeness. */
+    composedPath(): [EventTarget?]
+    /** Alias for event.target. */
+    readonly currentTarget: EventTarget | null;
+    /** Is true if cancelable is true and event.preventDefault() has been called. */
+    readonly defaultPrevented: boolean;
+    /** This is not used in Node.js and is provided purely for completeness. */
+    readonly eventPhase: 0 | 2;
+    /** The `AbortSignal` "abort" event is emitted with `isTrusted` set to `true`. The value is `false` in all other cases. */
+    readonly isTrusted: boolean;
+    /** Sets the `defaultPrevented` property to `true` if `cancelable` is `true`. */
+    preventDefault(): void;
+    /** This is not used in Node.js and is provided purely for completeness. */
+    returnValue: boolean;
+    /** Alias for event.target. */
+    readonly srcElement: EventTarget | null;
+    /** Stops the invocation of event listeners after the current one completes. */
+    stopImmediatePropagation(): void;
+    /** This is not used in Node.js and is provided purely for completeness. */
+    stopPropagation(): void;
+    /** The `EventTarget` dispatching the event */
+    readonly target: EventTarget | null;
+    /** The millisecond timestamp when the Event object was created. */
+    readonly timeStamp: number;
+    /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
+    readonly type: string;
+};
+
+// See comment above explaining conditional type
+type __EventTarget = typeof globalThis extends { onmessage: any, EventTarget: any }
+? {}
+: {
+    /**
+     * Adds a new handler for the `type` event. Any given `listener` is added only once per `type` and per `capture` option value.
+     *
+     * If the `once` option is true, the `listener` is removed after the next time a `type` event is dispatched.
+     *
+     * The `capture` option is not used by Node.js in any functional way other than tracking registered event listeners per the `EventTarget` specification.
+     * Specifically, the `capture` option is used as part of the key when registering a `listener`.
+     * Any individual `listener` may be added once with `capture = false`, and once with `capture = true`.
+     */
+    addEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    /** Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. */
+    dispatchEvent(event: Event): boolean;
+    /** Removes the event listener in target's event listener list with the same type, callback, and options. */
+    removeEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: EventListenerOptions | boolean,
+    ): void;
+};
+
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+
+interface EventListenerOptions {
+    /** Not directly used by Node.js. Added for API completeness. Default: `false`. */
+    capture?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+    /** When `true`, the listener is automatically removed when it is first invoked. Default: `false`. */
+    once?: boolean;
+    /** When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method. Default: false. */
+    passive?: boolean;
+}
+
+interface EventListener {
+    (evt: Event): void;
+}
+
+interface EventListenerObject {
+    handleEvent(object: Event): void;
+}
+
+import {} from 'events';    // Make this an ambient declaration
+declare global {
+    /** An event which takes place in the DOM. */
+    interface Event extends __Event {}
+    var Event: typeof globalThis extends { onmessage: any, Event: infer T }
+        ? T
+        : {
+            prototype: __Event;
+            new (type: string, eventInitDict?: EventInit): __Event;
+        };
+
+    /**
+     * EventTarget is a DOM interface implemented by objects that can
+     * receive events and may have listeners for them.
+     */
+    interface EventTarget extends __EventTarget {}
+    var EventTarget: typeof globalThis extends { onmessage: any, EventTarget: infer T }
+        ? T
+        : {
+            prototype: __EventTarget;
+            new (): __EventTarget;
+        };
+}