@epic-web/workshop-app 5.1.0 → 5.1.1

package/node_modules/type-fest/source/partial-deep.d.ts

@@ -1,109 +0,0 @@
-import type {BuiltIns} from './internal';
-
-/**
-@see PartialDeep
-*/
-export type PartialDeepOptions = {
-	/**
-	Whether to affect the individual elements of arrays and tuples.
-
-	@default false
-	*/
-	readonly recurseIntoArrays?: boolean;
-};
-
-/**
-Create a type from another type with all keys and nested keys set to optional.
-
-Use-cases:
-- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
-- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
-
-@example
-```
-import type {PartialDeep} from 'type-fest';
-
-const settings: Settings = {
-	textEditor: {
-		fontSize: 14;
-		fontColor: '#000000';
-		fontWeight: 400;
-	}
-	autocomplete: false;
-	autosave: true;
-};
-
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
-
-settings = applySavedSettings({textEditor: {fontWeight: 500}});
-```
-
-By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
-
-```
-import type {PartialDeep} from 'type-fest';
-
-interface Settings {
-	languages: string[];
-}
-
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
-};
-```
-
-@category Object
-@category Array
-@category Set
-@category Map
-*/
-export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
-	? T
-	: T extends Map<infer KeyType, infer ValueType>
-		? PartialMapDeep<KeyType, ValueType, Options>
-		: T extends Set<infer ItemType>
-			? PartialSetDeep<ItemType, Options>
-			: T extends ReadonlyMap<infer KeyType, infer ValueType>
-				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-				: T extends ReadonlySet<infer ItemType>
-					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends object
-						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-							? Options['recurseIntoArrays'] extends true
-								? ItemType[] extends T // Test for arrays (non-tuples) specifically
-									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-										? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
-										: Array<PartialDeep<ItemType | undefined, Options>>
-									: PartialObjectDeep<T, Options> // Tuples behave properly
-								: T // If they don't opt into array testing, just use the original type
-							: PartialObjectDeep<T, Options>
-						: unknown;
-
-/**
-Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialSetDeep<T, Options extends PartialDeepOptions> = {} & Set<PartialDeep<T, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialReadonlySetDeep<T, Options extends PartialDeepOptions> = {} & ReadonlySet<PartialDeep<T, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
-	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>
-};

package/node_modules/type-fest/source/partial-on-undefined-deep.d.ts

@@ -1,71 +0,0 @@
-import type {IfUnknown} from './if-unknown';
-import type {BuiltIns, LiteralKeyOf} from './internal';
-import type {Merge} from './merge';
-
-/**
-@see PartialOnUndefinedDeep
-*/
-export type PartialOnUndefinedDeepOptions = {
-	/**
-	Whether to affect the individual elements of arrays and tuples.
-
-	@default false
-	*/
-	readonly recurseIntoArrays?: boolean;
-};
-
-/**
-Create a deep version of another type where all keys accepting `undefined` type are set to optional.
-
-This utility type is recursive, transforming at any level deep. By default, it does not affect arrays and tuples items unless you explicitly pass `{recurseIntoArrays: true}` as the second type argument.
-
-Use-cases:
-- Make all properties of a type that can be undefined optional to not have to specify keys with undefined value.
-
-@example
-```
-import type {PartialOnUndefinedDeep} from 'type-fest';
-
-interface Settings {
-	optionA: string;
-	optionB: number | undefined;
-	subOption: {
-		subOptionA: boolean;
-		subOptionB: boolean | undefined;
-	}
-};
-
-const testSettings: PartialOnUndefinedDeep<Settings> = {
-	optionA: 'foo',
-	// 👉 optionB is now optional and can be omitted
-	subOption: {
-		subOptionA: true,
-		// 👉 subOptionB is now optional as well and can be omitted
-	},
-};
-```
-
-@category Object
-*/
-export type PartialOnUndefinedDeep<T, Options extends PartialOnUndefinedDeepOptions = {}> = T extends Record<any, any> | undefined
-	? {[KeyType in keyof T as undefined extends T[KeyType] ? IfUnknown<T[KeyType], never, KeyType> : never]?: PartialOnUndefinedDeepValue<T[KeyType], Options>} extends infer U // Make a partial type with all value types accepting undefined (and set them optional)
-		? Merge<{[KeyType in keyof T as KeyType extends LiteralKeyOf<U> ? never : KeyType]: PartialOnUndefinedDeepValue<T[KeyType], Options>}, U> // Join all remaining keys not treated in U
-		: never // Should not happen
-	: T;
-
-/**
-Utility type to get the value type by key and recursively call `PartialOnUndefinedDeep` to transform sub-objects.
-*/
-type PartialOnUndefinedDeepValue<T, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments_: any[]) => unknown)
-	? T
-	: T extends ReadonlyArray<infer U> // Test if type is array or tuple
-		? Options['recurseIntoArrays'] extends true // Check if option is activated
-			? U[] extends T // Check if array not tuple
-				? readonly U[] extends T
-					? ReadonlyArray<PartialOnUndefinedDeep<U, Options>> // Readonly array treatment
-					: Array<PartialOnUndefinedDeep<U, Options>> // Mutable array treatment
-				: PartialOnUndefinedDeep<{[Key in keyof T]: PartialOnUndefinedDeep<T[Key], Options>}, Options> // Tuple treatment
-			: T
-		: T extends Record<any, any> | undefined
-			? PartialOnUndefinedDeep<T, Options>
-			: unknown;

package/node_modules/type-fest/source/pascal-case.d.ts

@@ -1,38 +0,0 @@
-import type {CamelCase, CamelCaseOptions} from './camel-case';
-
-/**
-Converts a string literal to pascal-case.
-
-@example
-```
-import type {PascalCase} from 'type-fest';
-
-// Simple
-
-const someVariable: PascalCase<'foo-bar'> = 'FooBar';
-
-// Advanced
-
-type PascalCaseProps<T> = {
-	[K in keyof T as PascalCase<K>]: T[K]
-};
-
-interface RawOptions {
-	'dry-run': boolean;
-	'full_family_name': string;
-	foo: number;
-}
-
-const dbResult: CamelCasedProperties<ModelProps> = {
-	DryRun: true,
-	FullFamilyName: 'bar.js',
-	Foo: 123
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type PascalCase<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = CamelCase<Value, Options> extends string
-	? Capitalize<CamelCase<Value, Options>>
-	: CamelCase<Value, Options>;

package/node_modules/type-fest/source/pascal-cased-properties-deep.d.ts

@@ -1,55 +0,0 @@
-import type {CamelCaseOptions} from './camel-case';
-import type {PascalCase} from './pascal-case';
-
-/**
-Convert object properties to pascal case recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see PascalCase
-@see PascalCasedProperties
-
-@example
-```
-import type {PascalCasedPropertiesDeep} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-interface UserWithFriends {
-	userInfo: User;
-	userFriends: User[];
-}
-
-const result: PascalCasedPropertiesDeep<UserWithFriends> = {
-	UserInfo: {
-		UserId: 1,
-		UserName: 'Tom',
-	},
-	UserFriends: [
-		{
-			UserId: 2,
-			UserName: 'Jerry',
-		},
-		{
-			UserId: 3,
-			UserName: 'Spike',
-		},
-	],
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type PascalCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Value extends Function | Date | RegExp
-	? Value
-	: Value extends Array<infer U>
-		? Array<PascalCasedPropertiesDeep<U, Options>>
-		: Value extends Set<infer U>
-			? Set<PascalCasedPropertiesDeep<U, Options>> : {
-				[K in keyof Value as PascalCase<K, Options>]: PascalCasedPropertiesDeep<Value[K], Options>;
-			};

package/node_modules/type-fest/source/pascal-cased-properties.d.ts

@@ -1,35 +0,0 @@
-import type {CamelCaseOptions} from './camel-case';
-import type {PascalCase} from './pascal-case';
-
-/**
-Convert object properties to pascal case but not recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see PascalCase
-@see PascalCasedPropertiesDeep
-
-@example
-```
-import type {PascalCasedProperties} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-const result: PascalCasedProperties<User> = {
-	UserId: 1,
-	UserName: 'Tom',
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type PascalCasedProperties<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Value extends Function
-	? Value
-	: Value extends Array<infer U>
-		? Value
-		: {[K in keyof Value as PascalCase<K, Options>]: Value[K]};

package/node_modules/type-fest/source/paths.d.ts

@@ -1,85 +0,0 @@
-import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString} from './internal';
-import type {EmptyObject} from './empty-object';
-import type {IsAny} from './is-any';
-import type {IsNever} from './is-never';
-import type {UnknownArray} from './unknown-array';
-import type {Sum} from './sum';
-import type {LessThan} from './less-than';
-
-/**
-Generate a union of all possible paths to properties in the given object.
-
-It also works with arrays.
-
-Use-case: You want a type-safe way to access deeply nested properties in an object.
-
-@example
-```
-import type {Paths} from 'type-fest';
-
-type Project = {
-	filename: string;
-	listA: string[];
-	listB: [{filename: string}];
-	folder: {
-		subfolder: {
-			filename: string;
-		};
-	};
-};
-
-type ProjectPaths = Paths<Project>;
-//=> 'filename' | 'listA' | 'listB' | 'folder' | `listA.${number}` | 'listB.0' | 'listB.0.filename' | 'folder.subfolder' | 'folder.subfolder.filename'
-
-declare function open<Path extends ProjectPaths>(path: Path): void;
-
-open('filename'); // Pass
-open('folder.subfolder'); // Pass
-open('folder.subfolder.filename'); // Pass
-open('foo'); // TypeError
-
-// Also works with arrays
-open('listA.1'); // Pass
-open('listB.0'); // Pass
-open('listB.1'); // TypeError. Because listB only has one element.
-```
-
-@category Object
-@category Array
-*/
-export type Paths<T> = Paths_<T>;
-
-type Paths_<T, Depth extends number = 0> =
-	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
-		? never
-		: IsAny<T> extends true
-			? never
-			: T extends UnknownArray
-				? number extends T['length']
-					// We need to handle the fixed and non-fixed index part of the array separately.
-					? InternalPaths<StaticPartOfArray<T>, Depth>
-					| InternalPaths<Array<VariablePartOfArray<T>[number]>, Depth>
-					: InternalPaths<T, Depth>
-				: T extends object
-					? InternalPaths<T, Depth>
-					: never;
-
-export type InternalPaths<_T, Depth extends number = 0, T = Required<_T>> =
-	T extends EmptyObject | readonly []
-		? never
-		: {
-			[Key in keyof T]:
-			Key extends string | number // Limit `Key` to string or number.
-				// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-				?
-				| Key
-				| ToString<Key>
-				| (
-					LessThan<Depth, 15> extends true // Limit the depth to prevent infinite recursion
-						? IsNever<Paths_<T[Key], Sum<Depth, 1>>> extends false
-							? `${Key}.${Paths_<T[Key], Sum<Depth, 1>>}`
-							: never
-						: never
-				)
-				: never
-		}[keyof T & (T extends UnknownArray ? number : unknown)];

package/node_modules/type-fest/source/pick-deep.d.ts

@@ -1,149 +0,0 @@
-import type {BuildObject, BuildTuple, NonRecursiveType, ObjectValue} from './internal';
-import type {IsNever} from './is-never';
-import type {Paths} from './paths';
-import type {Simplify} from './simplify.d';
-import type {UnionToIntersection} from './union-to-intersection.d';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Pick properties from a deeply-nested object.
-
-It supports recursing into arrays.
-
-Use-case: Distill complex objects down to the components you need to target.
-
-@example
-```
-import type {PickDeep, PartialDeep} from 'type-fest';
-
-type Configuration = {
-	userConfig: {
-		name: string;
-		age: number;
-		address: [
-			{
-				city1: string;
-				street1: string;
-			},
-			{
-				city2: string;
-				street2: string;
-			}
-		]
-	};
-	otherConfig: any;
-};
-
-type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
-// type NameConfig = {
-// 	userConfig: {
-// 		name: string;
-// 	}
-// };
-
-// Supports optional properties
-type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig.age'>;
-// type User = {
-// 	userConfig?: {
-// 		name?: string;
-// 		age?: number;
-// 	};
-// };
-
-// Supports array
-type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
-// type AddressConfig = {
-// 	userConfig: {
-// 		address: [{
-// 			city1: string;
-// 			street1: string;
-// 		}];
-// 	};
-// }
-
-// Supports recurse into array
-type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
-// type Street = {
-// 	userConfig: {
-// 		address: [
-// 			unknown,
-// 			{street2: string}
-// 		];
-// 	};
-// }
-```
-
-@category Object
-@category Array
-*/
-export type PickDeep<T, PathUnion extends Paths<T>> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray
-			? UnionToIntersection<{
-				[P in PathUnion]: InternalPickDeep<T, P>;
-			}[PathUnion]
-			>
-			: T extends object
-				? Simplify<UnionToIntersection<{
-					[P in PathUnion]: InternalPickDeep<T, P>;
-				}[PathUnion]>>
-				: never;
-
-/**
-Pick an object/array from the given object/array by one path.
-*/
-type InternalPickDeep<T, Path extends string | number> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray ? PickDeepArray<T, Path>
-			: T extends object ? Simplify<PickDeepObject<T, Path>>
-				: never;
-
-/**
-Pick an object from the given object by one path.
-*/
-type PickDeepObject<RecordType extends object, P extends string | number> =
-	P extends `${infer RecordKeyInPath}.${infer SubPath}`
-		? ObjectValue<RecordType, RecordKeyInPath> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<ObjectV>, SubPath>, RecordType>
-				: never
-			: never
-		: ObjectValue<RecordType, P> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<P, ObjectV, RecordType>
-				: never
-			: never;
-
-/**
-Pick an array from the given array by one path.
-*/
-type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
-	// Handle paths that are `${number}.${string}`
-	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
-		// When `ArrayIndex` is equal to `number`
-		? number extends ArrayIndex
-			? ArrayType extends unknown[]
-				? Array<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-				: ArrayType extends readonly unknown[]
-					? ReadonlyArray<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-					: never
-			// When `ArrayIndex` is a number literal
-			: ArrayType extends unknown[]
-				? [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-				: ArrayType extends readonly unknown[]
-					? readonly [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-					: never
-		// When the path is equal to `number`
-		: P extends `${infer ArrayIndex extends number}`
-			// When `ArrayIndex` is `number`
-			? number extends ArrayIndex
-				? ArrayType
-				// When `ArrayIndex` is a number literal
-				: ArrayType extends unknown[]
-					? [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
-					: ArrayType extends readonly unknown[]
-						? readonly [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
-						: never
-			: never;

package/node_modules/type-fest/source/pick-index-signature.d.ts

@@ -1,102 +0,0 @@
-/**
-Pick only index signatures from the given object type, leaving out all explicitly defined properties.
-
-This is the counterpart of `OmitIndexSignature`.
-
-When you use a type that will iterate through an object that has indexed keys and explicitly defined keys you end up with a type where only the indexed keys are kept. This is because `keyof` of an indexed type always returns `string | number | symbol`, because every key is possible in that object. With this type, you can save the indexed keys and reinject them later, like in the second example below.
-
-@example
-```
-import type {PickIndexSignature} from 'type-fest';
-
-declare const symbolKey: unique symbol;
-
-type Example = {
-	// These index signatures will remain.
-	[x: string]: unknown;
-	[x: number]: unknown;
-	[x: symbol]: unknown;
-	[x: `head-${string}`]: string;
-	[x: `${string}-tail`]: string;
-	[x: `head-${string}-tail`]: string;
-	[x: `${bigint}`]: string;
-	[x: `embedded-${number}`]: string;
-
-	// These explicitly defined keys will be removed.
-	['snake-case-key']: string;
-	[symbolKey]: string;
-	foo: 'bar';
-	qux?: 'baz';
-};
-
-type ExampleIndexSignature = PickIndexSignature<Example>;
-// {
-// 	[x: string]: unknown;
-// 	[x: number]: unknown;
-// 	[x: symbol]: unknown;
-// 	[x: `head-${string}`]: string;
-// 	[x: `${string}-tail`]: string;
-// 	[x: `head-${string}-tail`]: string;
-// 	[x: `${bigint}`]: string;
-// 	[x: `embedded-${number}`]: string;
-// }
-```
-
-@example
-```
-import type {OmitIndexSignature, PickIndexSignature, Simplify} from 'type-fest';
-
-type Foo = {
-	[x: string]: string;
-	foo: string;
-	bar: number;
-};
-
-// Imagine that you want a new type `Bar` that comes from `Foo`.
-// => {
-// 	[x: string]: string;
-// 	bar: number;
-// };
-
-type Bar = Omit<Foo, 'foo'>;
-// This is not working because `Omit` returns only indexed keys.
-// => {
-// 	[x: string]: string;
-// 	[x: number]: string;
-// }
-
-// One solution is to save the indexed signatures to new type.
-type FooIndexSignature = PickIndexSignature<Foo>;
-// => {
-// 	[x: string]: string;
-// }
-
-// Get a new type without index signatures.
-type FooWithoutIndexSignature = OmitIndexSignature<Foo>;
-// => {
-// 	foo: string;
-// 	bar: number;
-// }
-
-// At this point we can use Omit to get our new type.
-type BarWithoutIndexSignature = Omit<FooWithoutIndexSignature, 'foo'>;
-// => {
-// 	bar: number;
-// }
-
-// And finally we can merge back the indexed signatures.
-type BarWithIndexSignature = Simplify<BarWithoutIndexSignature & FooIndexSignature>;
-// => {
-// 	[x: string]: string;
-// 	bar: number;
-// }
-```
-
-@see OmitIndexSignature
-@category Object
-*/
-export type PickIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? KeyType
-		: never]: ObjectType[KeyType];
-};

package/node_modules/type-fest/source/primitive.d.ts

@@ -1,13 +0,0 @@
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-export type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;

package/node_modules/type-fest/source/promisable.d.ts

@@ -1,25 +0,0 @@
-/**
-Create a type that represents either the value or the value wrapped in `PromiseLike`.
-
-Use-cases:
-- A function accepts a callback that may either return a value synchronously or may return a promised value.
-- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-import type {Promisable} from 'type-fest';
-
-async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
-	const entry = await getLogEntry();
-	console.log(entry);
-}
-
-logger(() => 'foo');
-logger(() => Promise.resolve('bar'));
-```
-
-@category Async
-*/
-export type Promisable<T> = T | PromiseLike<T>;