serverless-spy 0.0.61 → 0.0.63

package/node_modules/serialize-error/node_modules/type-fest/source/iterable-element.d.ts

@@ -0,0 +1,54 @@
+/**
+Get the element type of an `Iterable`/`AsyncIterable`. For example, an array or a generator.
+
+This can be useful, for example, if you want to get the type that is yielded in a generator function. Often the return type of those functions are not specified.
+
+This type works with both `Iterable`s and `AsyncIterable`s, so it can be use with synchronous and asynchronous generators.
+
+Here is an example of `IterableElement` in action with a generator function:
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+function * iAmGenerator() {
+	yield 1;
+	yield 2;
+}
+
+type MeNumber = IterableElement<ReturnType<typeof iAmGenerator>>
+```
+
+And here is an example with an async generator:
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+async function * iAmGeneratorAsync() {
+	yield 'hi';
+	yield true;
+}
+
+type MeStringOrBoolean = IterableElement<ReturnType<typeof iAmGeneratorAsync>>
+```
+
+Many types in JavaScript/TypeScript are iterables. This type works on all types that implement those interfaces. For example, `Array`, `Set`, `Map`, `stream.Readable`, etc.
+
+An example with an array of strings:
+
+@example
+```
+import type {IterableElement} from 'type-fest';
+
+type MeString = IterableElement<string[]>
+```
+
+@category Iterable
+*/
+export type IterableElement<TargetIterable> =
+	TargetIterable extends Iterable<infer ElementType> ?
+	ElementType :
+	TargetIterable extends AsyncIterable<infer ElementType> ?
+	ElementType :
+	never;

package/node_modules/serialize-error/node_modules/type-fest/source/join.d.ts

@@ -0,0 +1,30 @@
+/**
+Join an array of strings and/or numbers using the given string as a delimiter.
+
+Use-case: Defining key paths in a nested object. For example, for dot-notation fields in MongoDB queries.
+
+@example
+```
+import type {Join} from 'type-fest';
+
+// Mixed (strings & numbers) items; result is: 'foo.0.baz'
+const path: Join<['foo', 0, 'baz'], '.'> = ['foo', 0, 'baz'].join('.');
+
+// Only string items; result is: 'foo.bar.baz'
+const path: Join<['foo', 'bar', 'baz'], '.'> = ['foo', 'bar', 'baz'].join('.');
+
+// Only number items; result is: '1.2.3'
+const path: Join<[1, 2, 3], '.'> = [1, 2, 3].join('.');
+```
+
+@category Array
+@category Template literal
+*/
+export type Join<
+	Strings extends Array<string | number>,
+	Delimiter extends string,
+> = Strings extends [] ? '' :
+	Strings extends [string | number] ? `${Strings[0]}` :
+	// @ts-expect-error `Rest` is inferred as `unknown` here: https://github.com/microsoft/TypeScript/issues/45281
+	Strings extends [string | number, ...infer Rest] ? `${Strings[0]}${Delimiter}${Join<Rest, Delimiter>}` :
+	string;

package/node_modules/serialize-error/node_modules/type-fest/source/jsonify.d.ts

@@ -0,0 +1,90 @@
+import type {JsonPrimitive, JsonValue} from './basic';
+import {Finite, NegativeInfinity, PositiveInfinity} from './numeric';
+import {TypedArray} from './typed-array';
+
+// Note: The return value has to be `any` and not `unknown` so it can match `void`.
+type NotJsonable = ((...args: any[]) => any) | undefined | symbol;
+
+/**
+Transform a type to one that is assignable to the `JsonValue` type.
+
+This includes:
+1. Transforming JSON `interface` to a `type` that is assignable to `JsonValue`.
+2. Transforming non-JSON value that is *jsonable* to a type that is assignable to `JsonValue`, where *jsonable* means the non-JSON value implements the `.toJSON()` method that returns a value that is assignable to `JsonValue`.
+
+@remarks
+
+An interface cannot be structurally compared to `JsonValue` because an interface can be re-opened to add properties that may not be satisfy `JsonValue`.
+
+@example
+```
+import type {Jsonify} from 'type-fest';
+
+interface Geometry {
+	type: 'Point' | 'Polygon';
+	coordinates: [number, number];
+}
+
+const point: Geometry = {
+	type: 'Point',
+	coordinates: [1, 1]
+};
+
+const problemFn = (data: JsonValue) => {
+	// Does something with data
+};
+
+problemFn(point); // Error: type Geometry is not assignable to parameter of type JsonValue because it is an interface
+
+const fixedFn = <T>(data: Jsonify<T>) => {
+	// Does something with data
+};
+
+fixedFn(point); // Good: point is assignable. Jsonify<T> transforms Geometry into value assignable to JsonValue
+fixedFn(new Date()); // Error: As expected, Date is not assignable. Jsonify<T> cannot transforms Date into value assignable to JsonValue
+```
+
+Non-JSON values such as `Date` implement `.toJSON()`, so they can be transformed to a value assignable to `JsonValue`:
+
+@example
+```
+import type {Jsonify} from 'type-fest';
+
+const time = {
+	timeValue: new Date()
+};
+
+// `Jsonify<typeof time>` is equivalent to `{timeValue: string}`
+const timeJson = JSON.parse(JSON.stringify(time)) as Jsonify<typeof time>;
+```
+
+@link https://github.com/Microsoft/TypeScript/issues/1897#issuecomment-710744173
+
+@category JSON
+*/
+type Jsonify<T> =
+	// Check if there are any non-JSONable types represented in the union.
+	// Note: The use of tuples in this first condition side-steps distributive conditional types
+	// (see https://github.com/microsoft/TypeScript/issues/29368#issuecomment-453529532)
+	[Extract<T, NotJsonable | bigint>] extends [never]
+		? T extends PositiveInfinity | NegativeInfinity	? null
+			: T extends JsonPrimitive ? T // Primitive is acceptable
+			: T extends object
+				// Any object with toJSON is special case
+				? T extends {toJSON(): infer J} ? (() => J) extends (() => JsonValue) // Is J assignable to JsonValue?
+					? J // Then T is Jsonable and its Jsonable value is J
+					: never // Not Jsonable because its toJSON() method does not return JsonValue
+				// Instanced primitives are objects
+				: T extends Number ? number
+				: T extends String ? string
+				: T extends Boolean ? boolean
+				: T extends Map<any, any> | Set<any> ? {}
+				: T extends TypedArray ? Record<string, number>
+				: T extends any[]
+					? {[I in keyof T]: T[I] extends NotJsonable ? null : Jsonify<T[I]>}
+				: {[P in keyof T as P extends symbol ? never
+					: T[P] extends NotJsonable ? never
+					: P
+				]: Jsonify<Required<T>[P]>} // Recursive call for its children
+			: never // Otherwise any other non-object is removed
+		: never; // Otherwise non-JSONable type union was found not empty

package/node_modules/serialize-error/node_modules/type-fest/source/kebab-case.d.ts

@@ -0,0 +1,38 @@
+import type {DelimiterCase} from './delimiter-case';
+
+/**
+Convert a string literal to kebab-case.
+
+This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
+
+@example
+```
+import type {KebabCase} from 'type-fest';
+
+// Simple
+
+const someVariable: KebabCase<'fooBar'> = 'foo-bar';
+
+// Advanced
+
+type KebabCasedProperties<T> = {
+	[K in keyof T as KebabCase<K>]: T[K]
+};
+
+interface CliOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: KebabCasedProperties<CliOptions> = {
+	'dry-run': true,
+	'include-file': 'bar.js',
+	foo: 123
+};
+```
+
+@category Change case
+@category Template literal
+*/
+export type KebabCase<Value> = DelimiterCase<Value, '-'>;

package/node_modules/serialize-error/node_modules/type-fest/source/kebab-cased-properties-deep.d.ts

@@ -0,0 +1,47 @@
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
+
+/**
+Convert object properties to kebab case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see KebabCase
+@see KebabCasedProperties
+
+@example
+```
+import type [KebabCasedPropertiesDeep] from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: KebabCasedPropertiesDeep<UserWithFriends> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom',
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry',
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike',
+		},
+	],
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '-'>;

package/node_modules/serialize-error/node_modules/type-fest/source/kebab-cased-properties.d.ts

@@ -0,0 +1,30 @@
+import type {DelimiterCasedProperties} from './delimiter-cased-properties';
+
+/**
+Convert object properties to kebab case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see KebabCase
+@see KebabCasedPropertiesDeep
+
+@example
+```
+import type {KebabCasedProperties} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+const result: KebabCasedProperties<User> = {
+	'user-id': 1,
+	'user-name': 'Tom',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedProperties<Value> = DelimiterCasedProperties<Value, '-'>;

package/node_modules/serialize-error/node_modules/type-fest/source/last-array-element.d.ts

@@ -0,0 +1,28 @@
+/**
+Extracts the type of the last element of an array.
+
+Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+
+@example
+```
+import type {LastArrayElement} from 'type-fest';
+
+declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
+
+const array = ['foo', 2];
+
+typeof lastOf(array);
+//=> number
+```
+
+@category Array
+@category Template literal
+*/
+export type LastArrayElement<ValueType extends readonly unknown[]> =
+	ValueType extends readonly [infer ElementType]
+		? ElementType
+		: ValueType extends readonly [infer _, ...infer Tail]
+		? LastArrayElement<Tail>
+		: ValueType extends ReadonlyArray<infer ElementType>
+		? ElementType
+		: never;

package/node_modules/serialize-error/node_modules/type-fest/source/literal-to-primitive.d.ts

@@ -0,0 +1,36 @@
+/**
+Given a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) return the {@link Primitive | primitive type} it belongs to, or `never` if it's not a primitive.
+
+Use-case: Working with generic types that may be literal types.
+
+@example
+```
+import type {LiteralToPrimitive} from 'type-fest';
+
+// No overloads needed to get the correct return type
+function plus<T extends number | bigint | string>(x: T, y: T): LiteralToPrimitive<T> {
+	return x + (y as any);
+}
+
+plus('a', 'b'); // string
+plus(1, 2); // number
+plus(1n, 2n); // bigint
+```
+
+@category Type
+*/
+export type LiteralToPrimitive<T> = T extends number
+	? number
+	: T extends bigint
+	? bigint
+	: T extends string
+	? string
+	: T extends boolean
+	? boolean
+	: T extends symbol
+	? symbol
+	: T extends null
+	? null
+	: T extends undefined
+	? undefined
+	: never;

package/node_modules/serialize-error/node_modules/type-fest/source/literal-union.d.ts

@@ -0,0 +1,35 @@
+import type {Primitive} from './primitive';
+
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const pet: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const pet: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+export type LiteralUnion<
+	LiteralType,
+	BaseType extends Primitive,
+> = LiteralType | (BaseType & Record<never, never>);

package/node_modules/serialize-error/node_modules/type-fest/source/merge-exclusive.d.ts

@@ -0,0 +1,41 @@
+// Helper type. Not useful on its own.
+type Without<FirstType, SecondType> = {[KeyType in Exclude<keyof FirstType, keyof SecondType>]?: never};
+
+/**
+Create a type that has mutually exclusive keys.
+
+This type was inspired by [this comment](https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-373782604).
+
+This type works with a helper type, called `Without`. `Without<FirstType, SecondType>` produces a type that has only keys from `FirstType` which are not present on `SecondType` and sets the value type for these keys to `never`. This helper type is then used in `MergeExclusive` to remove keys from either `FirstType` or `SecondType`.
+
+@example
+```
+import type {MergeExclusive} from 'type-fest';
+
+interface ExclusiveVariation1 {
+	exclusive1: boolean;
+}
+
+interface ExclusiveVariation2 {
+	exclusive2: string;
+}
+
+type ExclusiveOptions = MergeExclusive<ExclusiveVariation1, ExclusiveVariation2>;
+
+let exclusiveOptions: ExclusiveOptions;
+
+exclusiveOptions = {exclusive1: true};
+//=> Works
+exclusiveOptions = {exclusive2: 'hi'};
+//=> Works
+exclusiveOptions = {exclusive1: true, exclusive2: 'hi'};
+//=> Error
+```
+
+@category Object
+*/
+export type MergeExclusive<FirstType, SecondType> =
+	(FirstType | SecondType) extends object ?
+		(Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) :
+		FirstType | SecondType;
+

package/node_modules/serialize-error/node_modules/type-fest/source/merge.d.ts

@@ -0,0 +1,27 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+type Merge_<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type Bar = {
+	b: number;
+};
+
+const ab: Merge<Foo, Bar> = {a: 1, b: 2};
+```
+
+@category Object
+*/
+export type Merge<FirstType, SecondType> = Simplify<Merge_<FirstType, SecondType>>;

package/node_modules/serialize-error/node_modules/type-fest/source/multidimensional-array.d.ts

@@ -0,0 +1,43 @@
+import type {IsEqual, Subtract} from './internal';
+
+type Recursive<T> = Array<Recursive<T>>;
+
+/**
+Creates a type that represents a multidimensional array of the given type and dimension.
+
+Use-cases:
+- Return a n-dimensional array from functions.
+- Declare a n-dimensional array by defining its dimensions rather than declaring `[]` repetitively.
+- Infer the dimensions of a n-dimensional array automatically from function arguments.
+- Avoid the need to know in advance the dimensions of a n-dimensional array allowing them to be dynamic.
+
+@example
+```
+import type {MultidimensionalArray} from 'type-fest';
+
+function emptyMatrix<T extends number>(dimensions: T): MultidimensionalArray<unknown, T> {
+	const matrix: unknown[] = [];
+
+	let subMatrix = matrix;
+	for (let dimension = 1; dimension < dimensions; ++dimension) {
+		console.log(`Initializing dimension #${dimension}`);
+
+		subMatrix[0] = [];
+		subMatrix = subMatrix[0] as unknown[];
+	}
+
+	return matrix as MultidimensionalArray<unknown, T>;
+}
+
+const matrix = emptyMatrix(3);
+
+matrix[0][0][0] = 42;
+```
+
+@category Array
+*/
+export type MultidimensionalArray<Element, Dimensions extends number> = number extends Dimensions
+	? Recursive<Element>
+	: IsEqual<Dimensions, 0> extends true
+		? Element
+		: Array<MultidimensionalArray<Element, Subtract<Dimensions, 1>>>;

package/node_modules/serialize-error/node_modules/type-fest/source/multidimensional-readonly-array.d.ts

@@ -0,0 +1,47 @@
+import type {IsEqual, Subtract} from './internal';
+
+type Recursive<T> = ReadonlyArray<Recursive<T>>;
+
+/**
+Creates a type that represents a multidimensional readonly array that of the given type and dimension.
+
+Use-cases:
+- Return a n-dimensional array from functions.
+- Declare a n-dimensional array by defining its dimensions rather than declaring `[]` repetitively.
+- Infer the dimensions of a n-dimensional array automatically from function arguments.
+- Avoid the need to know in advance the dimensions of a n-dimensional array allowing them to be dynamic.
+
+@example
+```
+import type {MultidimensionalReadonlyArray} from 'type-fest';
+
+function emptyMatrix<T extends number>(dimensions: T): MultidimensionalReadonlyArray<unknown, T> {
+	const matrix: unknown[] = [];
+
+	let subMatrix = matrix;
+	for (let dimension = 1; dimension < dimensions; ++dimension) {
+		console.log(`Initializing dimension #${dimension}`);
+
+		subMatrix[0] = [];
+		if (dimension < dimensions - 1) {
+			subMatrix = subMatrix[0] as unknown[];
+		} else {
+			subMatrix[0] = 42;
+		}
+	}
+
+	return matrix as MultidimensionalReadonlyArray<unknown, T>;
+}
+
+const matrix = emptyMatrix(3);
+
+const answer = matrix[0][0][0]; // 42
+```
+
+@category Array
+*/
+export type MultidimensionalReadonlyArray<Element, Dimensions extends number> = number extends Dimensions
+	? Recursive<Element>
+	: IsEqual<Dimensions, 0> extends true
+		? Element
+		: ReadonlyArray<MultidimensionalReadonlyArray<Element, Subtract<Dimensions, 1>>>;

package/node_modules/serialize-error/node_modules/type-fest/source/mutable.d.ts

@@ -0,0 +1,5 @@
+import type {Writable} from './writable';
+
+/** @deprecated @see Writable */
+export type Mutable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	Writable<BaseType, Keys>;