serverless-spy 0.0.60 → 0.0.62

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

@@ -0,0 +1,170 @@
+type Numeric = number | bigint;
+
+type Zero = 0 | 0n;
+
+/**
+Matches the hidden `Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see NegativeInfinity
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+export type PositiveInfinity = 1e999;
+
+/**
+Matches the hidden `-Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see PositiveInfinity
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+export type NegativeInfinity = -1e999;
+
+/**
+A finite `number`.
+You can't pass a `bigint` as they are already guaranteed to be finite.
+
+Use-case: Validating and documenting parameters.
+
+Note: This can't detect `NaN`, please upvote [this issue](https://github.com/microsoft/TypeScript/issues/28682) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+import type {Finite} from 'type-fest';
+
+declare function setScore<T extends number>(length: Finite<T>): void;
+```
+
+@category Numeric
+*/
+export type Finite<T extends number> = T extends PositiveInfinity | NegativeInfinity ? never : T;
+
+/**
+A `number` that is an integer.
+You can't pass a `bigint` as they are already guaranteed to be integers.
+
+Use-case: Validating and documenting parameters.
+
+@example
+```
+import type {Integer} from 'type-fest';
+
+declare function setYear<T extends number>(length: Integer<T>): void;
+```
+
+@see NegativeInteger
+@see NonNegativeInteger
+
+@category Numeric
+*/
+// `${bigint}` is a type that matches a valid bigint literal without the `n` (ex. 1, 0b1, 0o1, 0x1)
+// Because T is a number and not a string we can effectively use this to filter out any numbers containing decimal points
+export type Integer<T extends number> = `${T}` extends `${bigint}` ? T : never;
+
+/**
+A `number` that is not an integer.
+You can't pass a `bigint` as they are already guaranteed to be integers.
+
+Use-case: Validating and documenting parameters.
+
+@example
+```
+import type {Float} from 'type-fest';
+
+declare function setPercentage<T extends number>(length: Float<T>): void;
+```
+
+@see Integer
+
+@category Numeric
+*/
+export type Float<T extends number> = T extends Integer<T> ? never : T;
+
+/**
+A negative (`-∞ < x < 0`) `number` that is not an integer.
+Equivalent to `Negative<Float<T>>`.
+
+Use-case: Validating and documenting parameters.
+
+@see Negative
+@see Float
+
+@category Numeric
+*/
+export type NegativeFloat<T extends number> = Negative<Float<T>>;
+
+/**
+A negative `number`/`bigint` (`-∞ < x < 0`)
+
+Use-case: Validating and documenting parameters.
+
+@see NegativeInteger
+@see NonNegative
+
+@category Numeric
+*/
+export type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+
+/**
+A negative (`-∞ < x < 0`) `number` that is an integer.
+Equivalent to `Negative<Integer<T>>`.
+
+You can't pass a `bigint` as they are already guaranteed to be integers, instead use `Negative<T>`.
+
+Use-case: Validating and documenting parameters.
+
+@see Negative
+@see Integer
+
+@category Numeric
+*/
+export type NegativeInteger<T extends number> = Negative<Integer<T>>;
+
+/**
+A non-negative `number`/`bigint` (`0 <= x < ∞`).
+
+Use-case: Validating and documenting parameters.
+
+@see NonNegativeInteger
+@see Negative
+
+@example
+```
+import type {NonNegative} from 'type-fest';
+
+declare function setLength<T extends number>(length: NonNegative<T>): void;
+```
+
+@category Numeric
+*/
+export type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> extends never ? T : never;
+
+/**
+A non-negative (`0 <= x < ∞`) `number` that is an integer.
+Equivalent to `NonNegative<Integer<T>>`.
+
+You can't pass a `bigint` as they are already guaranteed to be integers, instead use `NonNegative<T>`.
+
+Use-case: Validating and documenting parameters.
+
+@see NonNegative
+@see Integer
+
+@example
+```
+import type {NonNegativeInteger} from 'type-fest';
+
+declare function setLength<T extends number>(length: NonNegativeInteger<T>): void;
+```
+
+@category Numeric
+*/
+export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;

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

@@ -0,0 +1,62 @@
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guideance on making an `Observable` do not include `closed` propery.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+export type Unsubscribable = {
+	unsubscribe(): void;
+};
+
+/**
+@category Observable
+*/
+type OnNext<ValueType> = (value: ValueType) => void;
+/**
+@category Observable
+*/
+type OnError = (error: unknown) => void;
+/**
+@category Observable
+*/
+type OnComplete = () => void;
+
+/**
+@category Observable
+*/
+export type Observer<ValueType> = {
+	next: OnNext<ValueType>;
+	error: OnError;
+	complete: OnComplete;
+};
+
+/**
+Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
+
+@remarks
+The TC39 Observable proposal defines 2 forms of `subscribe()`:
+1. Three callback arguments: `subscribe(observer: OnNext<ValueType>, onError?: OnError, onComplete?: OnComplete): Unsubscribable;`
+2. A single `observer` argument: (as defined below)
+
+But `Observable` implementations have evolved to preferring case 2 and some implementations choose not to implement case 1. Therefore, an `ObservableLike` cannot be trusted to implement the first case. (xstream and hand built observerables often do not implement case 1)
+
+@see https://github.com/tc39/proposal-observable#observable
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L246-L259
+@see https://benlesh.com/posts/learning-observable-by-building-observable/
+
+@category Observable
+*/
+export interface ObservableLike<ValueType = unknown> {
+	subscribe(observer?: Partial<Observer<ValueType>>): Unsubscribable;
+	[Symbol.observable](): ObservableLike<ValueType>;
+}

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

@@ -0,0 +1,107 @@
+declare const tag: unique symbol;
+
+declare type Tagged<Token> = {
+	readonly [tag]: Token;
+};
+
+/**
+Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
+
+The generic type parameter can be anything. It doesn't have to be an object.
+
+[Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
+
+There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import type {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne (): NewThingOne {
+	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+	return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+	return 2 as AccountNumber;
+}
+
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+	return 4 as AccountBalance;
+}
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will not compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+	id: Opaque<number, Person>;
+	name: string;
+};
+```
+
+@category Type
+*/
+export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
+
+/**
+Revert an opaque type back to its original type by removing the readonly `[tag]`.
+
+Why is this necessary?
+
+1. Use an `Opaque` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Opaque, UnwrapOpaque} from 'type-fest';
+
+type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1
+};
+
+// Without UnwrapOpaque, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
+type WontWork = UnwrapOpaque<string>;
+```
+
+@category Type
+*/
+export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> =
+	OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]>
+		? Type
+		: OpaqueType;

package/node_modules/serialize-error/node_modules/type-fest/source/optional-keys-of.d.ts

@@ -0,0 +1,38 @@
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+export type OptionalKeysOf<BaseType extends object> = Exclude<{
+	[Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]>
+		? never
+		: Key
+}[keyof BaseType], undefined>;