dep 1.0.0 → 1.2.0

package/node_modules/boxen/node_modules/type-fest/source/required-deep.d.ts

@@ -1,78 +0,0 @@
-import type {BuiltIns, HasMultipleCallSignatures} from './internal';
-
-type ExcludeUndefined<T> = Exclude<T, undefined>;
-
-/**
-Create a type from another type with all keys and nested keys set to required.
-
-Use-cases:
-- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
-- Modeling the resulting type after a deep merge with a set of defaults.
-
-@example
-```
-import type {RequiredDeep} from 'type-fest';
-
-type Settings = {
-	textEditor?: {
-		fontSize?: number | undefined;
-		fontColor?: string | undefined;
-		fontWeight?: number | undefined;
-	}
-	autocomplete?: boolean | undefined;
-	autosave?: boolean | undefined;
-};
-
-type RequiredSettings = RequiredDeep<Settings>;
-// type RequiredSettings = {
-// 	textEditor: {
-// 		fontSize: number;
-// 		fontColor: string;
-// 		fontWeight: number;
-// 	}
-// 	autocomplete: boolean;
-// 	autosave: boolean;
-// }
-```
-
-Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
-
-@category Utilities
-@category Object
-@category Array
-@category Set
-@category Map
-*/
-export type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns
-	? E
-	: E extends Map<infer KeyType, infer ValueType>
-		? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
-		: E extends Set<infer ItemType>
-			? Set<RequiredDeep<ItemType>>
-			: E extends ReadonlyMap<infer KeyType, infer ValueType>
-				? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
-				: E extends ReadonlySet<infer ItemType>
-					? ReadonlySet<RequiredDeep<ItemType>>
-					: E extends WeakMap<infer KeyType, infer ValueType>
-						? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
-						: E extends WeakSet<infer ItemType>
-							? WeakSet<RequiredDeep<ItemType>>
-							: E extends Promise<infer ValueType>
-								? Promise<RequiredDeep<ValueType>>
-								: E extends (...arguments_: any[]) => unknown
-									? {} extends RequiredObjectDeep<E>
-										? E
-										: HasMultipleCallSignatures<E> extends true
-											? E
-											: ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
-									: E extends object
-										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-											? ItemType[] extends E // Test for arrays (non-tuples) specifically
-												? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
-												: RequiredObjectDeep<E> // Tuples behave properly
-											: RequiredObjectDeep<E>
-										: unknown;
-
-type RequiredObjectDeep<ObjectType extends object> = {
-	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
-};

package/node_modules/boxen/node_modules/type-fest/source/required-keys-of.d.ts

@@ -1,30 +0,0 @@
-import type {OptionalKeysOf} from './optional-keys-of';
-
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
-
-interface User {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-```
-
-@category Utilities
-*/
-export type RequiredKeysOf<BaseType extends object> =
-	BaseType extends unknown // For distributing `BaseType`
-		? Exclude<keyof BaseType, OptionalKeysOf<BaseType>>
-		: never; // Should never happen

package/node_modules/boxen/node_modules/type-fest/source/schema.d.ts

@@ -1,114 +0,0 @@
-/**
-Create a deep version of another object type where property values are recursively replaced into a given value type.
-
-Use-cases:
-- Form validation: Define how each field should be validated.
-- Form settings: Define configuration for input fields.
-- Parsing: Define types that specify special behavior for specific fields.
-
-@example
-```
-import type {Schema} from 'type-fest';
-
-interface User {
-	id: string;
-	name: {
-		firstname: string;
-		lastname: string;
-	};
-	created: Date;
-	active: boolean;
-	passwordHash: string;
-	attributes: ['Foo', 'Bar']
-}
-
-type UserMask = Schema<User, 'mask' | 'hide' | 'show'>;
-
-const userMaskSettings: UserMask = {
-	id: 'show',
-	name: {
-		firstname: 'show',
-		lastname: 'mask',
-	},
-	created: 'show',
-	active: 'show',
-	passwordHash: 'hide',
-	attributes: ['mask', 'show']
-}
-```
-
-@category Object
-*/
-export type Schema<ObjectType, ValueType, Options extends SchemaOptions = {}> = ObjectType extends string
-	? ValueType
-	: ObjectType extends Map<unknown, unknown>
-		? ValueType
-		: ObjectType extends Set<unknown>
-			? ValueType
-			: ObjectType extends ReadonlyMap<unknown, unknown>
-				? ValueType
-				: ObjectType extends ReadonlySet<unknown>
-					? ValueType
-					: ObjectType extends Array<infer U>
-						? Options['recurseIntoArrays'] extends false | undefined
-							? ValueType
-							: Array<Schema<U, ValueType>>
-						: ObjectType extends (...arguments_: unknown[]) => unknown
-							? ValueType
-							: ObjectType extends Date
-								? ValueType
-								: ObjectType extends Function
-									? ValueType
-									: ObjectType extends RegExp
-										? ValueType
-										: ObjectType extends object
-											? SchemaObject<ObjectType, ValueType, Options>
-											: ValueType;
-
-/**
-Same as `Schema`, but accepts only `object`s as inputs. Internal helper for `Schema`.
-*/
-type SchemaObject<
-	ObjectType extends object,
-	K,
-	Options extends SchemaOptions,
-> = {
-	[KeyType in keyof ObjectType]: ObjectType[KeyType] extends
-	| readonly unknown[]
-	| unknown[]
-		? Options['recurseIntoArrays'] extends false | undefined
-			? K
-			: Schema<ObjectType[KeyType], K, Options>
-		: Schema<ObjectType[KeyType], K, Options> | K;
-};
-
-/**
-@see Schema
-*/
-export type SchemaOptions = {
-	/**
-	By default, this affects elements in array and tuple types. You can change this by passing `{recurseIntoArrays: false}` as the third type argument:
-	- If `recurseIntoArrays` is set to `true` (default), array elements will be recursively processed as well.
-	- If `recurseIntoArrays` is set to `false`, arrays will not be recursively processed, and the entire array will be replaced with the given value type.
-
-	@example
-	```
-	type UserMask = Schema<User, 'mask' | 'hide' | 'show', {recurseIntoArrays: false}>;
-
-	const userMaskSettings: UserMask = {
-		id: 'show',
-		name: {
-			firstname: 'show',
-			lastname: 'mask',
-		},
-		created: 'show',
-		active: 'show',
-		passwordHash: 'hide',
-		attributes: 'hide'
-	}
-	```
-
-	@default true
-	*/
-	readonly recurseIntoArrays?: boolean | undefined;
-};

package/node_modules/boxen/node_modules/type-fest/source/screaming-snake-case.d.ts

@@ -1,28 +0,0 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {SnakeCase} from './snake-case';
-import type {WordsOptions} from './words';
-
-/**
-Convert a string literal to screaming-snake-case.
-
-This can be useful when, for example, converting a camel-cased object property to a screaming-snake-cased SQL column name.
-
-@example
-```
-import type {ScreamingSnakeCase} from 'type-fest';
-
-const someVariable: ScreamingSnakeCase<'fooBar'> = 'FOO_BAR';
-const someVariableNoSplitOnNumbers: ScreamingSnakeCase<'p2pNetwork', {splitOnNumbers: false}> = 'P2P_NETWORK';
-
-```
-
-@category Change case
-@category Template literal
- */
-export type ScreamingSnakeCase<
-	Value,
-	Options extends WordsOptions = {},
-> = Value extends string
-	? Uppercase<SnakeCase<Value, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>>
-	: Value;

package/node_modules/boxen/node_modules/type-fest/source/set-field-type.d.ts

@@ -1,65 +0,0 @@
-import type {ApplyDefaultOptions} from './internal';
-import type {Simplify} from './simplify';
-
-type SetFieldTypeOptions = {
-	/**
-	Preserve optional and readonly modifiers for properties being updated.
-
-	NOTE: Property modifiers will always be preserved for properties that are not being updated.
-
-	@default true
-	*/
-	preservePropertyModifiers?: boolean;
-};
-
-type DefaultSetFieldTypeOptions = {
-	preservePropertyModifiers: true;
-};
-
-/**
-Create a type that changes the type of the given keys.
-
-Use-cases:
-- Creating variations of a base model.
-- Fixing incorrect external types.
-
-@see `Merge` if you need to change multiple properties to different types.
-
-@example
-```
-import type {SetFieldType} from 'type-fest';
-
-type MyModel = {
-	readonly id: number;
-	readonly createdAt: Date;
-	updatedAt?: Date;
-};
-
-type MyModelApi = SetFieldType<MyModel, 'createdAt' | 'updatedAt', string>;
-// {
-// 	readonly id: number;
-// 	readonly createdAt: string;
-// 	updatedAt?: string;
-// }
-
-// `preservePropertyModifiers` option can be set to `false` if you want to remove property modifiers for properties being updated
-type MyModelApi = SetFieldType<MyModel, 'createdAt' | 'updatedAt', string, {preservePropertyModifiers: false}>;
-// {
-// 	readonly id: number;
-// 	createdAt: string; // no longer readonly
-// 	updatedAt: string; // no longer optional
-// }
-```
-
-@category Object
-*/
-export type SetFieldType<BaseType, Keys extends keyof BaseType, NewType, Options extends SetFieldTypeOptions = {}> =
-	_SetFieldType<BaseType, Keys, NewType, ApplyDefaultOptions<SetFieldTypeOptions, DefaultSetFieldTypeOptions, Options>>;
-
-type _SetFieldType<BaseType, Keys extends keyof BaseType, NewType, Options extends Required<SetFieldTypeOptions>> =
-	Simplify<{
-		[P in keyof BaseType]: P extends Keys ? NewType : BaseType[P];
-	} & (
-		// `Record` is used to remove property modifiers
-		Options['preservePropertyModifiers'] extends false ? Record<Keys, NewType> : unknown
-	)>;

package/node_modules/boxen/node_modules/type-fest/source/set-non-nullable-deep.d.ts

@@ -1,83 +0,0 @@
-import type {NonRecursiveType, StringToNumber} from './internal';
-import type {Paths} from './paths';
-import type {SetNonNullable} from './set-non-nullable';
-import type {Simplify} from './simplify';
-import type {UnionToTuple} from './union-to-tuple';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Create a type that makes the specified keys non-nullable (removes `null` and `undefined`), supports deeply nested key paths, and leaves all other keys unchanged.
-
-NOTE: Optional modifiers (`?`) are not removed from properties. For example, `SetNonNullableDeep<{foo?: string | null | undefined}, 'foo'>` will result in `{foo?: string}`.
-
-@example
-```
-import type {SetNonNullableDeep} from 'type-fest';
-
-type User = {
-	name: string;
-	address: {
-		city: string | undefined;
-		street?: string | null;
-	};
-	contact: {
-		email?: string | null | undefined;
-		phone: string | undefined;
-	};
-};
-
-type UpdatedUser = SetNonNullableDeep<User, 'address.street' | 'contact.email' | 'contact.phone'>;
-//=> {
-// 	name: string;
-// 	address: {
-// 		city: string | undefined;
-// 		street?: string;
-// 	};
-// 	contact: {
-// 		email?: string;
-// 		phone: string;
-// 	};
-// };
-```
-
-@example
-```
-import type {SetNonNullableDeep} from 'type-fest';
-
-// Set specific indices in an array to be non-nullable.
-type ArrayExample1 = SetNonNullableDeep<{a: [number | null, number | null, number | undefined]}, 'a.1' | 'a.2'>;
-//=> {a: [number | null, number, number]}
-
-// Optional modifier (`?`) is not removed.
-type ArrayExample2 = SetNonNullableDeep<{a: [(number | null)?, (number | null)?]}, 'a.1'>;
-//=> {a: [(number | null)?, number?]}
-```
-
-@category Object
-*/
-export type SetNonNullableDeep<BaseType, KeyPaths extends Paths<BaseType>> =
-	SetNonNullableDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
-
-/**
-Internal helper for {@link SetNonNullableDeep}.
-
-Recursively transforms the `BaseType` by applying {@link SetNonNullableDeepSinglePath} for each path in `KeyPathsTuple`.
-*/
-type SetNonNullableDeepHelper<BaseType, KeyPathsTuple extends UnknownArray> =
-	KeyPathsTuple extends [infer KeyPath, ...infer RestPaths]
-		? SetNonNullableDeepHelper<SetNonNullableDeepSinglePath<BaseType, KeyPath>, RestPaths>
-		: BaseType;
-
-/**
-Makes a single path non-nullable in `BaseType`.
-*/
-type SetNonNullableDeepSinglePath<BaseType, KeyPath> =
-	BaseType extends NonRecursiveType | ReadonlySet<unknown> | ReadonlyMap<unknown, unknown> // Also distributes `BaseType`
-		? BaseType
-		: KeyPath extends `${infer Property}.${infer RestPath}`
-			? {
-				[Key in keyof BaseType]: Property extends `${Key & (string | number)}`
-					? SetNonNullableDeepSinglePath<BaseType[Key], RestPath>
-					: BaseType[Key];
-			}
-			: Simplify<SetNonNullable<BaseType, (KeyPath | StringToNumber<KeyPath & string>) & keyof BaseType>>;

package/node_modules/boxen/node_modules/type-fest/source/set-non-nullable.d.ts

@@ -1,39 +0,0 @@
-/**
-Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
-
-If no keys are given, all keys will be made non-nullable.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some or all of the keys are non-nullable.
-
-@example
-```
-import type {SetNonNullable} from 'type-fest';
-
-type Foo = {
-	a: number | null;
-	b: string | undefined;
-	c?: boolean | null;
-}
-
-type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
-// type SomeNonNullable = {
-// 	a: number | null;
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
-
-type AllNonNullable = SetNonNullable<Foo>;
-// type AllNonNullable = {
-// 	a: number; // Can no longer be null.
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
-```
-
-@category Object
-*/
-export type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> = {
-	[Key in keyof BaseType]: Key extends Keys
-		? NonNullable<BaseType[Key]>
-		: BaseType[Key];
-};

package/node_modules/boxen/node_modules/type-fest/source/set-optional.d.ts

@@ -1,38 +0,0 @@
-import type {Except} from './except';
-import type {HomomorphicPick} from './internal';
-import type {Simplify} from './simplify';
-
-/**
-Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
-
-@example
-```
-import type {SetOptional} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b?: string;
-	c: boolean;
-}
-
-type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
-// type SomeOptional = {
-// 	a: number;
-// 	b?: string; // Was already optional and still is.
-// 	c?: boolean; // Is now optional.
-// }
-```
-
-@category Object
-*/
-export type SetOptional<BaseType, Keys extends keyof BaseType> =
-	BaseType extends unknown // To distribute `BaseType` when it's a union type.
-		? Simplify<
-		// Pick just the keys that are readonly from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be mutable from the base type and make them mutable.
-		Partial<HomomorphicPick<BaseType, Keys>>
-		>
-		: never;

package/node_modules/boxen/node_modules/type-fest/source/set-parameter-type.d.ts

@@ -1,117 +0,0 @@
-import type {IsUnknown} from './is-unknown';
-import type {StaticPartOfArray, VariablePartOfArray} from './internal';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Create an array that replaces the given `TArray`'s elements with the given `TObject`'s values at the given indices.
-
-`TArray` and `TObject` supports tailing spread array like `[string, ...boolean[]]`, but does not support `[string, ...boolean[], number]`.
-
-@example:
-```ts
-// object
-type A = MergeObjectToArray<[string, number], {0: boolean}>;
-//=> [boolean, number]
-
-// array
-type B = MergeObjectToArray<[string, number], [boolean]>;
-//=> [boolean, number]
-
-// tailing spread array
-type C = MergeObjectToArray<[string, ...boolean[]], {1: number}>;
-//=> [string, ...number[]]
-
-type D = MergeObjectToArray<[string, ...boolean[]], [number, ...string[]]>;
-//=> [number, ...string[]]
-```
-*/
-type MergeObjectToArray<TArray extends UnknownArray, TObject, TArrayCopy extends UnknownArray = TArray> =
-	// If `TObject` is an array like `[0, 1, 2]`
-	TObject extends UnknownArray
-		// If `TObject` is a variable length array, we should use `TObject`'s type as the result type.
-		? number extends TObject['length']
-			? TObject
-			: {
-				[K in keyof TArray]:
-				number extends K
-					? VariablePartOfArray<TArray>[number]
-					: K extends keyof TObject ? TObject[K] : TArray[K]
-			}
-		: TObject extends object
-			// If `TObject` is a object witch key is number like `{0: string, 1: number}`
-			? {
-				[K in keyof TArray]:
-				K extends `${infer NumberK extends number}`
-					? NumberK extends keyof TObject ? TObject[NumberK] : TArray[K]
-					: number extends K
-					// If array key `K` is `number`, means it's a rest parameter, we should set the rest parameter type to corresponding type in `TObject`.
-					// example: `MergeObjectToParamterArray<[string, ...boolean[]], {1: number}>` => `[string, ...number[]]`
-						? StaticPartOfArray<TArrayCopy>['length'] extends keyof TObject
-							? TObject[StaticPartOfArray<TArrayCopy>['length']]
-							: TArray[K]
-						: never
-			} : never;
-
-/**
-Create a function that replaces some parameters with the given parameters.
-
-The parameters that are not specified will be kept as-is.
-
-Note:
-- This type will ignore the given function's generic type.
-- If you change the parameter type that return type depends on, the return type will not change:
-	```
-	const fn = (a: number) => a;
-	//=> fn: (a: number) => number;
-
- 	// We change type of `a` to `string`, but return type is still `number`.
-	type Fn = SetParameterType<typeof fn, {0: string}>;
- 	//=> (a: string) => number;
-	```
-
-Use-case:
-- Define a wrapped function that receives something different while returning the same type.
-- Mocking and testing.
-- Overload function type. (See example)
-
-@example
-```
-import type {SetParameterType} from 'type-fest';
-
-type HandleMessage = (data: Data, message: string, ...arguments: any[]) => void;
-
-type HandleOk = SetParameterType<HandleMessage, {0: SuccessData, 1: 'ok'}>;
-//=> type HandleOk = (data: SuccessData, message: 'ok') => void;
-
-// Another way to define the parameters to replace.
-type HandleError = SetParameterType<HandleMessage, [data: ErrorData, message: 'error']>;
-//=> type HandleError = (data: ErrorData, message: 'error') => void;
-
-// Change single parameter type.
-type HandleWarn = SetParameterType<HandleMessage, {1: 'warn'}>;
-//=> type HandleWarn = (data: Data, message: 'warn') => void;
-
-// Change rest parameter type.
-
-// Way 1: Input full parameter type.
-type HandleLog = SetParameterType<HandleMessage, [data: Data, message: 'log', ...arguments: string[]]>;
-//=> type HandleLog = (data: Data, message: 'log', ...arguments: string[]) => void;
-
-// Way 2: Input rest parameter type by Object index.
-type HandleLog2 = SetParameterType<HandleMessage, {2: string}>;
-//=> type HandleLog2 = (data: Data, message: string, ...arguments: string[]) => void;
-```
-
-@category Function
-*/
-export type SetParameterType<Function_ extends (...arguments_: any[]) => unknown, P extends Record<number, unknown>> =
-	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
-	Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => unknown
-		? (
-			// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
-			// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
-			IsUnknown<ThisArgument> extends true
-				? (...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
-				: (this: ThisArgument, ...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
-		)
-		: Function_;	// This part should be unreachable

package/node_modules/boxen/node_modules/type-fest/source/set-readonly.d.ts

@@ -1,39 +0,0 @@
-import type {Except} from './except';
-import type {HomomorphicPick} from './internal';
-import type {Simplify} from './simplify';
-
-/**
-Create a type that makes the given keys readonly. The remaining keys are kept as is.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are readonly.
-
-@example
-```
-import type {SetReadonly} from 'type-fest';
-
-type Foo = {
-	a: number;
-	readonly b: string;
-	c: boolean;
-}
-
-type SomeReadonly = SetReadonly<Foo, 'b' | 'c'>;
-// type SomeReadonly = {
-// 	a: number;
-// 	readonly b: string; // Was already readonly and still is.
-// 	readonly c: boolean; // Is now readonly.
-// }
-```
-
-@category Object
-*/
-export type SetReadonly<BaseType, Keys extends keyof BaseType> =
-	// `extends unknown` is always going to be the case and is used to convert any
-	// union into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	BaseType extends unknown
-		? Simplify<
-		Except<BaseType, Keys> &
-		Readonly<HomomorphicPick<BaseType, Keys>>
-		>
-		: never;