@epic-web/workshop-app 5.0.3 → 5.1.1

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

@@ -1,25 +0,0 @@
-import type {IsEqual} from './is-equal';
-
-/**
-Returns a boolean for whether two given types are both true.
-
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
-
-@example
-```
-import type {And} from 'type-fest';
-
-And<true, true>;
-//=> true
-
-And<true, false>;
-//=> false
-```
-
-@see {@link Or}
-*/
-export type And<A extends boolean, B extends boolean> = [A, B][number] extends true
-	? true
-	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
-		? false
-		: never;

package/node_modules/type-fest/source/array-indices.d.ts

@@ -1,23 +0,0 @@
-/**
-Provides valid indices for a constant array or tuple.
-
-Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
-
-@example
-```
-import type {ArrayIndices, ArrayValues} from 'type-fest';
-
-const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
-
-type Weekday = ArrayIndices<typeof weekdays>;
-type WeekdayName = ArrayValues<typeof weekdays>;
-
-const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
-```
-
-@see {@link ArrayValues}
-
-@category Array
-*/
-export type ArrayIndices<Element extends readonly unknown[]> =
-	Exclude<Partial<Element>['length'], Element['length']>;

package/node_modules/type-fest/source/array-slice.d.ts

@@ -1,107 +0,0 @@
-import type {Sum} from './sum';
-import type {LessThanOrEqual} from './less-than-or-equal';
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-import type {GreaterThan} from './greater-than';
-import type {IsNegative} from './numeric';
-import type {Not, ArrayMin} from './internal';
-import type {IsEqual} from './is-equal';
-import type {And} from './and';
-import type {ArraySplice} from './array-splice';
-
-/**
-Returns an array slice of a given range, just like `Array#slice()`.
-
-@example
-```
-import type {ArraySlice} from 'type-fest';
-
-type T0 = ArraySlice<[0, 1, 2, 3, 4]>;
-//=> [0, 1, 2, 3, 4]
-
-type T1 = ArraySlice<[0, 1, 2, 3, 4], 0, -1>;
-//=> [0, 1, 2, 3]
-
-type T2 = ArraySlice<[0, 1, 2, 3, 4], 1, -2>;
-//=> [1, 2]
-
-type T3 = ArraySlice<[0, 1, 2, 3, 4], -2, 4>;
-//=> [3]
-
-type T4 = ArraySlice<[0, 1, 2, 3, 4], -2, -1>;
-//=> [3]
-
-type T5 = ArraySlice<[0, 1, 2, 3, 4], 0, -999>;
-//=> []
-
-function arraySlice<
-	const Array_ extends readonly unknown[],
-	Start extends number = 0,
-	End extends number = Array_['length'],
->(array: Array_, start?: Start, end?: End) {
-	return array.slice(start, end) as ArraySlice<Array_, Start, End>;
-}
-
-const slice = arraySlice([1, '2', {a: 3}, [4, 5]], 0, -1);
-
-typeof slice;
-//=> [1, '2', { readonly a: 3; }]
-
-slice[2].a;
-//=> 3
-
-// @ts-expect-error -- TS2493: Tuple type '[1, "2", {readonly a: 3}]' of length '3' has no element at index '3'.
-slice[3];
-```
-
-@category Array
-*/
-export type ArraySlice<
-	Array_ extends readonly unknown[],
-	Start extends number = never,
-	End extends number = never,
-> = And<IsEqual<Start, never>, IsEqual<End, never>> extends true
-	? Array_
-	: number extends Array_['length']
-		? VariableLengthArraySliceHelper<Array_, Start, End>
-		: ArraySliceHelper<Array_, IsEqual<Start, never> extends true ? 0 : Start, IsEqual<End, never> extends true ? Array_['length'] : End>;
-
-type VariableLengthArraySliceHelper<
-	Array_ extends readonly unknown[],
-	Start extends number,
-	End extends number,
-> = And<Not<IsNegative<Start>>, IsEqual<End, never>> extends true
-	? ArraySplice<Array_, 0, Start>
-	: And<
-	And<Not<IsNegative<Start>>, Not<IsNegative<End>>>,
-	IsEqual<GreaterThan<End, Start>, true>
-	> extends true
-		? ArraySliceByPositiveIndex<Array_, Start, End>
-		: [];
-
-type ArraySliceHelper<
-	Array_ extends readonly unknown[],
-	Start extends number = 0,
-	End extends number = Array_['length'],
-	TraversedElement extends Array<Array_[number]> = [],
-	Result extends Array<Array_[number]> = [],
-	ArrayLength extends number = Array_['length'],
-	PositiveS extends number = IsNegative<Start> extends true
-		? Sum<ArrayLength, Start> extends infer AddResult extends number
-			? number extends AddResult // (ArrayLength + Start) < 0
-				? 0
-				: AddResult
-			: never
-		: Start,
-	PositiveE extends number = IsNegative<End> extends true ? Sum<ArrayLength, End> : End,
-> = true extends [IsNegative<PositiveS>, LessThanOrEqual<PositiveE, PositiveS>, GreaterThanOrEqual<PositiveS, ArrayLength>][number]
-	? []
-	: ArraySliceByPositiveIndex<Array_, ArrayMin<[PositiveS, ArrayLength]>, ArrayMin<[PositiveE, ArrayLength]>>;
-
-type ArraySliceByPositiveIndex<
-	Array_ extends readonly unknown[],
-	Start extends number,
-	End extends number,
-	Result extends Array<Array_[number]> = [],
-> = Start extends End
-	? Result
-	: ArraySliceByPositiveIndex<Array_, Sum<Start, 1>, End, [...Result, Array_[Start]]>;

package/node_modules/type-fest/source/array-splice.d.ts

@@ -1,97 +0,0 @@
-import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal';
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-import type {Subtract} from './subtract';
-import type {UnknownArray} from './unknown-array';
-
-/**
-The implementation of `SplitArrayByIndex` for fixed length arrays.
-*/
-type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-SplitIndex extends 0
-	? [[], T]
-	: T extends readonly [...BuildTuple<SplitIndex>, ...infer V]
-		? T extends readonly [...infer U, ...V]
-			? [U, V]
-			: [never, never]
-		: [never, never];
-
-/**
-The implementation of `SplitArrayByIndex` for variable length arrays.
-*/
-type SplitVariableArrayByIndex<T extends UnknownArray,
-	SplitIndex extends number,
-	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
-	T2 = T1 extends number ? BuildTuple<T1, VariablePartOfArray<T>[number]> : [],
-> =
-SplitIndex extends 0
-	? [[], T]
-	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
-		? [
-			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
-			[
-				...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
-				...VariablePartOfArray<T>,
-			],
-		]
-		: [
-			[
-				...StaticPartOfArray<T>,
-				...(T2 extends UnknownArray ? T2 : []),
-			],
-			VariablePartOfArray<T>,
-		];
-
-/**
-Split the given array `T` by the given `SplitIndex`.
-
-@example
-```
-type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
-// type A = [[1, 2], [3, 4]];
-
-type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
-// type B = [[], [1, 2, 3, 4]];
-```
-*/
-type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-	SplitIndex extends 0
-		? [[], T]
-		: number extends T['length']
-			? SplitVariableArrayByIndex<T, SplitIndex>
-			: SplitFixedArrayByIndex<T, SplitIndex>;
-
-/**
-Creates a new array type by adding or removing elements at a specified index range in the original array.
-
-Use-case: Replace or insert items in an array type.
-
-Like [`Array#splice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) but for types.
-
-@example
-```
-type SomeMonths0 = ['January', 'April', 'June'];
-type Mouths0 = ArraySplice<SomeMonths0, 1, 0, ['Feb', 'March']>;
-//=> type Mouths0 = ['January', 'Feb', 'March', 'April', 'June'];
-
-type SomeMonths1 = ['January', 'April', 'June'];
-type Mouths1 = ArraySplice<SomeMonths1, 1, 1>;
-//=> type Mouths1 = ['January', 'June'];
-
-type SomeMonths2 = ['January', 'Foo', 'April'];
-type Mouths2 = ArraySplice<SomeMonths2, 1, 1, ['Feb', 'March']>;
-//=> type Mouths2 = ['January', 'Feb', 'March', 'April'];
-```
-
-@category Array
-*/
-export type ArraySplice<
-	T extends UnknownArray,
-	Start extends number,
-	DeleteCount extends number,
-	Items extends UnknownArray = [],
-> =
-	SplitArrayByIndex<T, Start> extends [infer U extends UnknownArray, infer V extends UnknownArray]
-		? SplitArrayByIndex<V, DeleteCount> extends [infer _Deleted extends UnknownArray, infer X extends UnknownArray]
-			? [...U, ...Items, ...X]
-			: never // Should never happen
-		: never; // Should never happen

package/node_modules/type-fest/source/array-values.d.ts

@@ -1,22 +0,0 @@
-/**
-Provides all values for a constant array or tuple.
-
-Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
-
-@example
-```
-import type {ArrayValues, ArrayIndices} from 'type-fest';
-
-const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
-
-type WeekdayName = ArrayValues<typeof weekdays>;
-type Weekday = ArrayIndices<typeof weekdays>;
-
-const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
-```
-
-@see {@link ArrayIndices}
-
-@category Array
-*/
-export type ArrayValues<T extends readonly unknown[]> = T[number];

package/node_modules/type-fest/source/async-return-type.d.ts

@@ -1,23 +0,0 @@
-type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
-
-/**
-Unwrap the return type of a function that returns a `Promise`.
-
-There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
-
-@example
-```ts
-import type {AsyncReturnType} from 'type-fest';
-import {asyncFunction} from 'api';
-
-// This type resolves to the unwrapped return type of `asyncFunction`.
-type Value = AsyncReturnType<typeof asyncFunction>;
-
-async function doSomething(value: Value) {}
-
-asyncFunction().then(value => doSomething(value));
-```
-
-@category Async
-*/
-export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;

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

@@ -1,32 +0,0 @@
-import type {SetReturnType} from './set-return-type';
-
-/**
-Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
-
-Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
-
-@example
-```
-import type {Asyncify} from 'type-fest';
-
-// Synchronous function.
-function getFooSync(someArg: SomeType): Foo {
-	// …
-}
-
-type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
-//=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
-
-// Same as `getFooSync` but asynchronous.
-const getFooAsync: AsyncifiedFooGetter = (someArg) => {
-	// TypeScript now knows that `someArg` is `SomeType` automatically.
-	// It also knows that this function must return `Promise<Foo>`.
-	// If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
-
-	// …
-}
-```
-
-@category Async
-*/
-export type Asyncify<Function_ extends (...arguments_: any[]) => any> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;

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

@@ -1,68 +0,0 @@
-/**
-Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-
-@category Class
-*/
-export type Class<T, Arguments extends unknown[] = any[]> = {
-	prototype: Pick<T, keyof T>;
-	new(...arguments_: Arguments): T;
-};
-
-/**
-Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-
-@category Class
-*/
-export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
-
-/**
-Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
-
-@category Class
-
-@privateRemarks
-We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
-*/
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
-	prototype: Pick<T, keyof T>;
-}
-
-/**
-Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
-
-@category Class
-*/
-export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;
-
-/**
-Matches a JSON object.
-
-This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
-
-@category JSON
-*/
-export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
-
-/**
-Matches a JSON array.
-
-@category JSON
-*/
-export type JsonArray = JsonValue[] | readonly JsonValue[];
-
-/**
-Matches any valid JSON primitive value.
-
-@category JSON
-*/
-export type JsonPrimitive = string | number | boolean | null;
-
-/**
-Matches any valid JSON value.
-
-@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
-
-@category JSON
-*/
-export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

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

@@ -1,80 +0,0 @@
-import type {SplitWords} from './split-words';
-
-/**
-CamelCase options.
-
-@see {@link CamelCase}
-*/
-export type CamelCaseOptions = {
-	/**
-	Whether to preserved consecutive uppercase letter.
-
-	@default true
-	*/
-	preserveConsecutiveUppercase?: boolean;
-};
-
-/**
-Convert an array of words to camel-case.
-*/
-type CamelCaseFromArray<
-	Words extends string[],
-	Options extends CamelCaseOptions,
-	OutputString extends string = '',
-> = Words extends [
-	infer FirstWord extends string,
-	...infer RemainingWords extends string[],
-]
-	? Options['preserveConsecutiveUppercase'] extends true
-		? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}`
-		: `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}`
-	: OutputString;
-
-/**
-Convert a string literal to camel-case.
-
-This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
-
-By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
-
-@example
-```
-import type {CamelCase} from 'type-fest';
-
-// Simple
-
-const someVariable: CamelCase<'foo-bar'> = 'fooBar';
-
-// Advanced
-
-type CamelCasedProperties<T> = {
-	[K in keyof T as CamelCase<K>]: T[K]
-};
-
-interface RawOptions {
-	'dry-run': boolean;
-	'full_family_name': string;
-	foo: number;
-	BAR: string;
-	QUZ_QUX: number;
-	'OTHER-FIELD': boolean;
-}
-
-const dbResult: CamelCasedProperties<RawOptions> = {
-	dryRun: true,
-	fullFamilyName: 'bar.js',
-	foo: 123,
-	bar: 'foo',
-	quzQux: 6,
-	otherField: false
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type CamelCase<Type, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Type extends string
-	? string extends Type
-		? Type
-		: Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>>
-	: Type;

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

@@ -1,87 +0,0 @@
-import type {CamelCase, CamelCaseOptions} from './camel-case';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Convert object properties to camel case recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see CamelCasedProperties
-@see CamelCase
-
-@example
-```
-import type {CamelCasedPropertiesDeep} from 'type-fest';
-
-interface User {
-	UserId: number;
-	UserName: string;
-}
-
-interface UserWithFriends {
-	UserInfo: User;
-	UserFriends: User[];
-}
-
-const result: CamelCasedPropertiesDeep<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 CamelCasedPropertiesDeep<
-	Value,
-	Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true},
-> = Value extends Function
-	? Value
-	: Value extends UnknownArray
-		? CamelCasedPropertiesArrayDeep<Value>
-		: Value extends Set<infer U>
-			? Set<CamelCasedPropertiesDeep<U, Options>>
-			: {
-				[K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<
-				Value[K],
-				Options
-				>;
-			};
-
-// This is a copy of DelimiterCasedPropertiesArrayDeep (see: delimiter-cased-properties-deep.d.ts).
-// These types should be kept in sync.
-type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> =
-	Value extends []
-		? []
-		: // Tailing spread array
-		Value extends [infer U, ...infer V]
-			? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>]
-			: Value extends readonly [infer U, ...infer V]
-				? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>]
-				: // Leading spread array
-				Value extends readonly [...infer U, infer V]
-					? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>]
-					: Value extends readonly [...infer U, infer V]
-						? readonly [
-							...CamelCasedPropertiesDeep<U>,
-							CamelCasedPropertiesDeep<V>,
-						]
-						: // Array
-						Value extends Array<infer U>
-							? Array<CamelCasedPropertiesDeep<U>>
-							: Value extends ReadonlyArray<infer U>
-								? ReadonlyArray<CamelCasedPropertiesDeep<U>>
-								: never;

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

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

package/node_modules/type-fest/source/conditional-except.d.ts

@@ -1,45 +0,0 @@
-import type {Except} from './except';
-import type {ConditionalKeys} from './conditional-keys';
-
-/**
-Exclude keys from a shape that matches the given `Condition`.
-
-This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
-
-@example
-```
-import type {Primitive, ConditionalExcept} from 'type-fest';
-
-class Awesome {
-	name: string;
-	successes: number;
-	failures: bigint;
-
-	run() {}
-}
-
-type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
-//=> {run: () => void}
-```
-
-@example
-```
-import type {ConditionalExcept} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c: () => void;
-	d: {};
-}
-
-type NonStringKeysOnly = ConditionalExcept<Example, string>;
-//=> {b: string | number; c: () => void; d: {}}
-```
-
-@category Object
-*/
-export type ConditionalExcept<Base, Condition> = Except<
-Base,
-ConditionalKeys<Base, Condition>
->;