cloudstructs 0.6.21 → 0.6.22

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/buffer.d.ts

@@ -46,6 +46,7 @@
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
     import { ReadableStream as WebReadableStream } from 'node:stream/web';
+    export function isUtf8(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -169,12 +170,22 @@ declare module 'buffer' {
     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;
+    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';
+        type BufferEncoding =
+            | 'ascii'
+            | 'utf8'
+            | 'utf-8'
+            | 'utf16le'
+            | 'ucs2'
+            | 'ucs-2'
+            | 'base64'
+            | 'base64url'
+            | 'latin1'
+            | 'binary'
+            | 'hex';
         type WithImplicitCoercion<T> =
             | T
             | {
@@ -248,7 +259,11 @@ declare module 'buffer' {
              * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.
              * @since v5.10.0
              */
-            from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
+            from(
+                arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
+                byteOffset?: number,
+                length?: number,
+            ): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param data data to create a new Buffer
@@ -266,7 +281,7 @@ declare module 'buffer' {
                     | {
                           [Symbol.toPrimitive](hint: 'string'): string;
                       },
-                encoding?: BufferEncoding
+                encoding?: BufferEncoding,
             ): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
@@ -340,7 +355,10 @@ declare module 'buffer' {
              * @param [encoding='utf8'] If `string` is a string, this is its encoding.
              * @return The number of bytes contained within `string`.
              */
-            byteLength(string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
+            byteLength(
+                string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
+                encoding?: BufferEncoding,
+            ): number;
             /**
              * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together.
              *
@@ -711,7 +729,13 @@ declare module 'buffer' {
              * @param [sourceStart=0] The offset within `buf` at which to begin comparison.
              * @param [sourceEnd=buf.length] The offset within `buf` at which to end comparison (not inclusive).
              */
-            compare(target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1;
+            compare(
+                target: Uint8Array,
+                targetStart?: number,
+                targetEnd?: number,
+                sourceStart?: number,
+                sourceEnd?: number,
+            ): -1 | 0 | 1;
             /**
              * Copies data from a region of `buf` to a region in `target`, even if the `target`memory region overlaps with `buf`.
              *

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/test.d.ts

@@ -264,6 +264,15 @@ declare module 'node:test' {
          */
         beforeEach: typeof beforeEach;
 
+        /**
+         * This function is used to create a hook that runs after the current test finishes.
+         * @param fn The hook function. If the hook uses callbacks, the callback function is passed as
+         *    the second argument. Default: A no-op function.
+         * @param options Configuration options for the hook.
+         * @since v18.13.0
+         */
+        after: typeof after;
+
         /**
          * This function is used to create a hook running after each subtest of the current test.
          * @param fn The hook function. If the hook uses callbacks, the callback function is passed as
@@ -333,6 +342,10 @@ declare module 'node:test' {
          * @returns A {@link Promise} resolved with `undefined` once the test completes.
          */
         test: typeof test;
+        /**
+         * Each test provides its own MockTracker instance.
+         */
+        readonly mock: MockTracker;
     }
 
     interface TestOptions {
@@ -442,5 +455,238 @@ declare module 'node:test' {
         timeout?: number | undefined;
     }
 
-    export { test as default, run, test, describe, it, before, after, beforeEach, afterEach };
+    interface MockFunctionOptions {
+        /**
+         * The number of times that the mock will use the behavior of `implementation`.
+         * Once the mock function has been called `times` times,
+         * it will automatically restore the behavior of `original`.
+         * This value must be an integer greater than zero.
+         * @default Infinity
+         */
+        times?: number | undefined;
+    }
+
+    interface MockMethodOptions extends MockFunctionOptions {
+        /**
+         * If `true`, `object[methodName]` is treated as a getter.
+         * This option cannot be used with the `setter` option.
+         */
+        getter?: boolean | undefined;
+
+        /**
+         * If `true`, `object[methodName]` is treated as a setter.
+         * This option cannot be used with the `getter` option.
+         */
+        setter?: boolean | undefined;
+    }
+
+    type Mock<F extends Function> = F & {
+        mock: MockFunctionContext<F>;
+    };
+
+    type NoOpFunction = (...args: any[]) => undefined;
+
+    type FunctionPropertyNames<T> = {
+        [K in keyof T]: T[K] extends Function ? K : never;
+    }[keyof T];
+
+    interface MockTracker {
+        /**
+         * This function is used to create a mock function.
+         * @param original An optional function to create a mock on.
+         * @param implementation An optional function used as the mock implementation for `original`.
+         *  This is useful for creating mocks that exhibit one behavior for a specified number of calls and then restore the behavior of `original`.
+         * @param options Optional configuration options for the mock function.
+         */
+        fn<F extends Function = NoOpFunction>(original?: F, options?: MockFunctionOptions): Mock<F>;
+        fn<F extends Function = NoOpFunction, Implementation extends Function = F>(original?: F, 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.
+         * @param methodName The identifier of the method on `object` to mock. If `object[methodName]` is not a function, an error is thrown.
+         * @param implementation An optional function used as the mock implementation for `object[methodName]`.
+         * @param options Optional configuration options for the mock method.
+         */
+        method<
+            MockedObject extends object,
+            MethodName extends FunctionPropertyNames<MockedObject>,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            options?: MockFunctionOptions,
+        ): MockedObject[MethodName] extends Function
+            ? Mock<MockedObject[MethodName]>
+            : never;
+        method<
+            MockedObject extends object,
+            MethodName extends FunctionPropertyNames<MockedObject>,
+            Implementation extends Function,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            implementation: Implementation,
+            options?: MockFunctionOptions,
+        ): MockedObject[MethodName] extends Function
+            ? Mock<MockedObject[MethodName] | Implementation>
+            : never;
+        method<MockedObject extends object>(
+            object: MockedObject,
+            methodName: keyof MockedObject,
+            options: MockMethodOptions,
+        ): Mock<Function>;
+        method<MockedObject extends object>(
+            object: MockedObject,
+            methodName: keyof MockedObject,
+            implementation: Function,
+            options: MockMethodOptions,
+        ): Mock<Function>;
+
+        /**
+         * This function is syntax sugar for {@link MockTracker.method} with `options.getter` set to `true`.
+         */
+        getter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            options?: MockFunctionOptions,
+        ): Mock<() => MockedObject[MethodName]>;
+        getter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+            Implementation extends Function,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            implementation?: Implementation,
+            options?: MockFunctionOptions,
+        ): Mock<(() => MockedObject[MethodName]) | Implementation>;
+
+        /**
+         * This function is syntax sugar for {@link MockTracker.method} with `options.setter` set to `true`.
+         */
+        setter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            options?: MockFunctionOptions,
+        ): Mock<(value: MockedObject[MethodName]) => void>;
+        setter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+            Implementation extends Function,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            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,
+         * but the `MockTracker` instance can no longer be used to reset their behavior or otherwise interact with them.
+         *
+         * After each test completes, this function is called on the test context's `MockTracker`.
+         * 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;
+    }
+
+    const mock: MockTracker;
+
+    interface MockFunctionCall<
+        F extends Function,
+        ReturnType = F extends (...args: any) => infer T
+            ? T
+            : F extends abstract new (...args: any) => infer T
+                ? T
+                : unknown,
+        Args = F extends (...args: infer Y) => any
+            ? Y
+            : F extends abstract new (...args: infer Y) => any
+                ? Y
+                : unknown[],
+    > {
+        /**
+         * An array of the arguments passed to the mock function.
+         */
+        arguments: Args;
+        /**
+         * If the mocked function threw then this property contains the thrown value.
+         */
+        error: unknown | undefined;
+        /**
+         * The value returned by the mocked function.
+         *
+         * If the mocked function threw, it will be `undefined`.
+         */
+        result: ReturnType | undefined;
+        /**
+         * An `Error` object whose stack can be used to determine the callsite of the mocked function invocation.
+         */
+        stack: Error;
+        /**
+         * If the mocked function is a constructor, this field contains the class being constructed.
+         * Otherwise this will be `undefined`.
+         */
+        target: F extends abstract new (...args: any) => any ? F : undefined;
+        /**
+         * The mocked function's `this` value.
+         */
+        this: unknown;
+    }
+
+    interface MockFunctionContext<F extends Function> {
+        /**
+         * A getter that returns a copy of the internal array used to track calls to the mock.
+         */
+        readonly calls: Array<MockFunctionCall<F>>;
+
+        /**
+         * This function returns the number of times that this mock has been invoked.
+         * This function is more efficient than checking `ctx.calls.length`
+         * because `ctx.calls` is a getter that creates a copy of the internal call tracking array.
+         */
+        callCount(): number;
+
+        /**
+         * This function is used to change the behavior of an existing mock.
+         * @param implementation The function to be used as the mock's new implementation.
+         */
+        mockImplementation(implementation: Function): void;
+
+        /**
+         * This function is used to change the behavior of an existing mock for a single invocation.
+         * Once invocation `onCall` has occurred, the mock will revert to whatever behavior
+         * it would have used had `mockImplementationOnce()` not been called.
+         * @param implementation The function to be used as the mock's implementation for the invocation number specified by `onCall`.
+         * @param onCall The invocation number that will use `implementation`.
+         *  If the specified invocation has already occurred then an exception is thrown.
+         */
+        mockImplementationOnce(implementation: Function, onCall?: number): void;
+
+        /**
+         * Resets the call history of the mock function.
+         */
+        resetCalls(): void;
+
+        /**
+         * Resets the implementation of the mock function to its original behavior.
+         * The mock can still be used after calling this function.
+         */
+        restore(): void;
+    }
+
+    export { test as default, run, test, describe, it, before, after, beforeEach, afterEach, mock };
 }

package/node_modules/@types/keyv/node_modules/@types/node/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.
 
 ### Additional Details
- * Last updated: Tue, 07 Feb 2023 08:32:36 GMT
+ * Last updated: Thu, 23 Feb 2023 11:02:31 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

package/node_modules/@types/keyv/node_modules/@types/node/buffer.d.ts

@@ -46,6 +46,7 @@
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
     import { ReadableStream as WebReadableStream } from 'node:stream/web';
+    export function isUtf8(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -169,11 +170,21 @@ declare module 'buffer' {
     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: infer T }
-        ? T : NodeBlob;
+    type __Blob = typeof globalThis extends { onmessage: any; Blob: infer T } ? T : NodeBlob;
     global {
         // Buffer class
-        type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
+        type BufferEncoding =
+            | 'ascii'
+            | 'utf8'
+            | 'utf-8'
+            | 'utf16le'
+            | 'ucs2'
+            | 'ucs-2'
+            | 'base64'
+            | 'base64url'
+            | 'latin1'
+            | 'binary'
+            | 'hex';
         type WithImplicitCoercion<T> =
             | T
             | {
@@ -247,7 +258,11 @@ declare module 'buffer' {
              * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.
              * @since v5.10.0
              */
-            from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
+            from(
+                arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
+                byteOffset?: number,
+                length?: number,
+            ): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param data data to create a new Buffer
@@ -265,7 +280,7 @@ declare module 'buffer' {
                     | {
                           [Symbol.toPrimitive](hint: 'string'): string;
                       },
-                encoding?: BufferEncoding
+                encoding?: BufferEncoding,
             ): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
@@ -339,7 +354,10 @@ declare module 'buffer' {
              * @param [encoding='utf8'] If `string` is a string, this is its encoding.
              * @return The number of bytes contained within `string`.
              */
-            byteLength(string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
+            byteLength(
+                string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
+                encoding?: BufferEncoding,
+            ): number;
             /**
              * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together.
              *
@@ -710,7 +728,13 @@ declare module 'buffer' {
              * @param [sourceStart=0] The offset within `buf` at which to begin comparison.
              * @param [sourceEnd=buf.length] The offset within `buf` at which to end comparison (not inclusive).
              */
-            compare(target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1;
+            compare(
+                target: Uint8Array,
+                targetStart?: number,
+                targetEnd?: number,
+                sourceStart?: number,
+                sourceEnd?: number,
+            ): -1 | 0 | 1;
             /**
              * Copies data from a region of `buf` to a region in `target`, even if the `target`memory region overlaps with `buf`.
              *

package/node_modules/@types/keyv/node_modules/@types/node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 18.13
+// Type definitions for non-npm package Node.js 18.14
 // Project: https://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>

package/node_modules/@types/keyv/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.13.0",
+    "version": "18.14.1",
     "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": "6c5087993475c3d03552602e518e6747e3493f7e7dec65e81e1f206b013ad890",
+    "typesPublisherContentHash": "4b700d8e69578ec73360139a785868405bb684e4fe62cd395573dccfde90213e",
     "typeScriptVersion": "4.2"
 }