serverless-spy 0.0.61 → 0.0.62

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

@@ -0,0 +1,85 @@
+import type {Except} from './except';
+import type {RequiredKeysOf} from './required-keys-of';
+import type {Simplify} from './simplify';
+
+type SpreadObject<FirstType extends object, SecondType extends object> = {
+	[Key in keyof FirstType]: Key extends keyof SecondType
+		? FirstType[Key] | Required<SecondType>[Key]
+		: FirstType[Key];
+} & Pick<
+	SecondType,
+	RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
+>;
+
+type TupleOrArray = readonly [...unknown[]];
+
+type SpreadTupleOrArray<
+	FirstType extends TupleOrArray,
+	SecondType extends TupleOrArray,
+> = Array<FirstType[number] | SecondType[number]>;
+
+type Spreadable = object | TupleOrArray;
+
+/**
+Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
+
+@example
+```
+import type {Spread} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+};
+
+type Bar = {
+	b?: number;
+	c: boolean;
+};
+
+const foo = {a: 1, b: '2'};
+const bar = {c: false};
+const fooBar = {...foo, ...bar};
+
+type FooBar = Spread<Foo, Bar>;
+// type FooBar = {
+// 	a: number;
+// 	b?: string | number | undefined;
+// 	c: boolean;
+// }
+
+const baz = (argument: FooBar) => {
+	// Do something
+}
+
+baz(fooBar);
+```
+
+@example
+```
+import type {Spread} from 'type-fest';
+
+const foo = [1, 2, 3];
+const bar = ['4', '5', '6'];
+
+const fooBar = [...foo, ...bar];
+type FooBar = Spread<typeof foo, typeof bar>;
+// FooBar = (string | number)[]
+
+const baz = (argument: FooBar) => {
+	// Do something
+};
+
+baz(fooBar);
+```
+
+@category Object
+*/
+export type Spread<
+    FirstType extends Spreadable,
+    SecondType extends Spreadable,
+> = FirstType extends TupleOrArray
+	? SecondType extends TupleOrArray
+		? SpreadTupleOrArray<FirstType, SecondType>
+		: Simplify<SpreadObject<FirstType, SecondType>>
+	: Simplify<SpreadObject<FirstType, SecondType>>;

package/node_modules/serialize-error/node_modules/type-fest/source/string-key-of.d.ts

@@ -0,0 +1,25 @@
+/**
+Get keys of the given type as strings.
+
+Number keys are converted to strings.
+
+Use-cases:
+- Get string keys from a type which may have number keys.
+- Makes it possible to index using strings retrieved from template types.
+
+@example
+```
+import type {StringKeyOf} from 'type-fest';
+
+type Foo = {
+	1: number,
+	stringKey: string,
+};
+
+type StringKeysOfFoo = StringKeyOf<Foo>;
+//=> '1' | 'stringKey'
+```
+
+@category Object
+*/
+export type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;

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

@@ -0,0 +1,23 @@
+/**
+Create a type with the keys of the given type changed to `string` type.
+
+Use-case: Changing interface values to strings in order to use them in a form model.
+
+@example
+```
+import type {Stringified} from 'type-fest';
+
+type Car {
+	model: string;
+	speed: number;
+}
+
+const carForm: Stringified<Car> = {
+	model: 'Foo',
+	speed: '101'
+};
+```
+
+@category Object
+*/
+export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};

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

@@ -0,0 +1,25 @@
+/**
+Remove spaces from the left side.
+*/
+type TrimLeft<V extends string> = V extends ` ${infer R}` ? TrimLeft<R> : V;
+
+/**
+Remove spaces from the right side.
+*/
+type TrimRight<V extends string> = V extends `${infer R} ` ? TrimRight<R> : V;
+
+/**
+Remove leading and trailing spaces from a string.
+
+@example
+```
+import type {Trim} from 'type-fest';
+
+Trim<' foo '>
+//=> 'foo'
+```
+
+@category String
+@category Template literal
+*/
+export type Trim<V extends string> = TrimLeft<TrimRight<V>>;