@epic-web/workshop-app 5.1.0 → 5.1.2

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

@@ -1,68 +0,0 @@
-// The builtin `join` method supports all these natively in the same way that typescript handles them so we can safely accept all of them.
-type JoinableItem = string | number | bigint | boolean | undefined | null;
-
-// `null` and `undefined` are treated uniquely in the built-in join method, in a way that differs from the default `toString` that would result in the type `${undefined}`. That's why we need to handle it specifically with this helper.
-// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join#description
-type NullishCoalesce<
-	Value extends JoinableItem,
-	Fallback extends string,
-> = Value extends undefined | null ? NonNullable<Value> | Fallback : Value;
-
-/**
-Join an array of strings and/or numbers using the given string as a delimiter.
-
-Use-case: Defining key paths in a nested object. For example, for dot-notation fields in MongoDB queries.
-
-@example
-```
-import type {Join} from 'type-fest';
-
-// Mixed (strings & numbers) items; result is: 'foo.0.baz'
-const path: Join<['foo', 0, 'baz'], '.'> = ['foo', 0, 'baz'].join('.');
-
-// Only string items; result is: 'foo.bar.baz'
-const path: Join<['foo', 'bar', 'baz'], '.'> = ['foo', 'bar', 'baz'].join('.');
-
-// Only number items; result is: '1.2.3'
-const path: Join<[1, 2, 3], '.'> = [1, 2, 3].join('.');
-
-// Only bigint items; result is '1.2.3'
-const path: Join<[1n, 2n, 3n], '.'> = [1n, 2n, 3n].join('.');
-
-// Only boolean items; result is: 'true.false.true'
-const path: Join<[true, false, true], '.'> = [true, false, true].join('.');
-
-// Contains nullish items; result is: 'foo..baz..xyz'
-const path: Join<['foo', undefined, 'baz', null, 'xyz'], '.'> = ['foo', undefined, 'baz', null, 'xyz'].join('.');
-
-// Partial tuple shapes (rest param last); result is: `prefix.${string}`
-const path: Join<['prefix', ...string[]], '.'> = ['prefix'].join('.');
-
-// Partial tuple shapes (rest param first); result is: `${string}.suffix`
-const path: Join<[...string[], 'suffix'], '.'> = ['suffix'].join('.');
-
-// Tuples items with nullish unions; result is '.' | 'hello.' | '.world' | 'hello.world'
-const path: Join<['hello' | undefined, 'world' | null], '.'> = ['hello', 'world'].join('.');
-```
-
-@category Array
-@category Template literal
-*/
-export type Join<
-	Items extends readonly JoinableItem[],
-	Delimiter extends string,
-> = Items extends readonly []
-	? ''
-	: Items extends readonly [JoinableItem?]
-		? `${NullishCoalesce<Items[0], ''>}`
-		: Items extends readonly [
-			infer First extends JoinableItem,
-			...infer Tail extends readonly JoinableItem[],
-		]
-			? `${NullishCoalesce<First, ''>}${Delimiter}${Join<Tail, Delimiter>}`
-			: Items extends readonly [
-				...infer Head extends readonly JoinableItem[],
-				infer Last extends JoinableItem,
-			]
-				? `${Join<Head, Delimiter>}${Delimiter}${NullishCoalesce<Last, ''>}`
-				: string;

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

@@ -1,37 +0,0 @@
-import type {JsonPrimitive} from './basic';
-
-type JsonifiableObject = {[Key in string]?: Jsonifiable} | {toJSON: () => Jsonifiable};
-type JsonifiableArray = readonly Jsonifiable[];
-
-/**
-Matches a value that can be losslessly converted to JSON.
-
-Can be used to type values that you expect to pass to `JSON.stringify`.
-
-`undefined` is allowed in object fields (for example, `{a?: number}`) as a special case even though `JSON.stringify({a: undefined})` is `{}` because it makes this class more widely useful and checking for undefined-but-present values is likely an anti-pattern.
-
-@example
-```
-import type {Jsonifiable} from 'type-fest';
-
-// @ts-expect-error
-const error: Jsonifiable = {
-    map: new Map([['a', 1]]),
-};
-
-JSON.stringify(error);
-//=> {"map": {}}
-
-const good: Jsonifiable = {
-    number: 3,
-    date: new Date(),
-    missing: undefined,
-}
-
-JSON.stringify(good);
-//=> {"number": 3, "date": "2022-10-17T22:22:35.920Z"}
-```
-
-@category JSON
-*/
-export type Jsonifiable = JsonPrimitive | JsonifiableObject | JsonifiableArray;

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

@@ -1,121 +0,0 @@
-import type {JsonPrimitive, JsonValue} from './basic';
-import type {EmptyObject} from './empty-object';
-import type {UndefinedToOptional} from './internal';
-import type {IsAny} from './is-any';
-import type {IsNever} from './is-never';
-import type {IsUnknown} from './is-unknown';
-import type {NegativeInfinity, PositiveInfinity} from './numeric';
-import type {TypedArray} from './typed-array';
-import type {UnknownArray} from './unknown-array';
-
-// Note: The return value has to be `any` and not `unknown` so it can match `void`.
-type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
-
-type NeverToNull<T> = IsNever<T> extends true ? null : T;
-
-// Handles tuples and arrays
-type JsonifyList<T extends UnknownArray> = T extends readonly []
-	? []
-	: T extends readonly [infer F, ...infer R]
-		? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
-		: IsUnknown<T[number]> extends true
-			? []
-			: Array<T[number] extends NotJsonable ? null : Jsonify<T[number]>>;
-
-type FilterJsonableKeys<T extends object> = {
-	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
-}[keyof T];
-
-/**
-JSON serialize objects (not including arrays) and classes.
-*/
-type JsonifyObject<T extends object> = {
-	[Key in keyof Pick<T, FilterJsonableKeys<T>>]: Jsonify<T[Key]>;
-};
-
-/**
-Transform a type to one that is assignable to the `JsonValue` type.
-
-This includes:
-1. Transforming JSON `interface` to a `type` that is assignable to `JsonValue`.
-2. Transforming non-JSON value that is *jsonable* to a type that is assignable to `JsonValue`, where *jsonable* means the non-JSON value implements the `.toJSON()` method that returns a value that is assignable to `JsonValue`.
-
-@remarks
-
-An interface cannot be structurally compared to `JsonValue` because an interface can be re-opened to add properties that may not be satisfy `JsonValue`.
-
-@example
-```
-import type {Jsonify, JsonValue} from 'type-fest';
-
-interface Geometry {
-	type: 'Point' | 'Polygon';
-	coordinates: [number, number];
-}
-
-const point: Geometry = {
-	type: 'Point',
-	coordinates: [1, 1]
-};
-
-const problemFn = (data: JsonValue) => {
-	// Does something with data
-};
-
-problemFn(point); // Error: type Geometry is not assignable to parameter of type JsonValue because it is an interface
-
-const fixedFn = <T>(data: Jsonify<T>) => {
-	// Does something with data
-};
-
-fixedFn(point); // Good: point is assignable. Jsonify<T> transforms Geometry into value assignable to JsonValue
-fixedFn(new Date()); // Error: As expected, Date is not assignable. Jsonify<T> cannot transforms Date into value assignable to JsonValue
-```
-
-Non-JSON values such as `Date` implement `.toJSON()`, so they can be transformed to a value assignable to `JsonValue`:
-
-@example
-```
-import type {Jsonify} from 'type-fest';
-
-const time = {
-	timeValue: new Date()
-};
-
-// `Jsonify<typeof time>` is equivalent to `{timeValue: string}`
-const timeJson = JSON.parse(JSON.stringify(time)) as Jsonify<typeof time>;
-```
-
-@link https://github.com/Microsoft/TypeScript/issues/1897#issuecomment-710744173
-
-@category JSON
-*/
-export type Jsonify<T> = IsAny<T> extends true
-	? any
-	: T extends PositiveInfinity | NegativeInfinity
-		? null
-		: T extends JsonPrimitive
-			? T
-			: // Any object with toJSON is special case
-			T extends {toJSON(): infer J}
-				? (() => J) extends () => JsonValue // Is J assignable to JsonValue?
-					? J // Then T is Jsonable and its Jsonable value is J
-					: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
-				: // Instanced primitives are objects
-				T extends Number
-					? number
-					: T extends String
-						? string
-						: T extends Boolean
-							? boolean
-							: T extends Map<any, any> | Set<any>
-								? EmptyObject
-								: T extends TypedArray
-									? Record<string, number>
-									: T extends NotJsonable
-										? never // Non-JSONable type union was found not empty
-										: T extends UnknownArray
-											? JsonifyList<T>
-											: T extends object
-												? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
-												: never; // Otherwise any other non-object is removed

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

@@ -1,38 +0,0 @@
-import type {DelimiterCase} from './delimiter-case';
-
-/**
-Convert a string literal to kebab-case.
-
-This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
-
-@example
-```
-import type {KebabCase} from 'type-fest';
-
-// Simple
-
-const someVariable: KebabCase<'fooBar'> = 'foo-bar';
-
-// Advanced
-
-type KebabCasedProperties<T> = {
-	[K in keyof T as KebabCase<K>]: T[K]
-};
-
-interface CliOptions {
-	dryRun: boolean;
-	includeFile: string;
-	foo: number;
-}
-
-const rawCliOptions: KebabCasedProperties<CliOptions> = {
-	'dry-run': true,
-	'include-file': 'bar.js',
-	foo: 123
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type KebabCase<Value> = DelimiterCase<Value, '-'>;

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

@@ -1,47 +0,0 @@
-import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
-
-/**
-Convert object properties to kebab case recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see KebabCase
-@see KebabCasedProperties
-
-@example
-```
-import type [KebabCasedPropertiesDeep] from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-interface UserWithFriends {
-	userInfo: User;
-	userFriends: User[];
-}
-
-const result: KebabCasedPropertiesDeep<UserWithFriends> = {
-	'user-info': {
-		'user-id': 1,
-		'user-name': 'Tom',
-	},
-	'user-friends': [
-		{
-			'user-id': 2,
-			'user-name': 'Jerry',
-		},
-		{
-			'user-id': 3,
-			'user-name': 'Spike',
-		},
-	],
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type KebabCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '-'>;

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

@@ -1,30 +0,0 @@
-import type {DelimiterCasedProperties} from './delimiter-cased-properties';
-
-/**
-Convert object properties to kebab case but not recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see KebabCase
-@see KebabCasedPropertiesDeep
-
-@example
-```
-import type {KebabCasedProperties} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-const result: KebabCasedProperties<User> = {
-	'user-id': 1,
-	'user-name': 'Tom',
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type KebabCasedProperties<Value> = DelimiterCasedProperties<Value, '-'>;

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

@@ -1,40 +0,0 @@
-/**
-Create a union of all keys from a given type, even those exclusive to specific union members.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-	common: string;
-	a: number;
-};
-
-type B = {
-	common: string;
-	b: string;
-};
-
-type C = {
-	common: string;
-	c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@category Object
-*/
-export type KeysOfUnion<ObjectType> = ObjectType extends unknown
-	? keyof ObjectType
-	: never;

package/node_modules/type-fest/source/last-array-element.d.ts

@@ -1,38 +0,0 @@
-/**
-Extracts the type of the last element of an array.
-
-Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
-
-@example
-```
-import type {LastArrayElement} from 'type-fest';
-
-declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
-
-const array = ['foo', 2];
-
-typeof lastOf(array);
-//=> number
-
-const array = ['foo', 2] as const;
-
-typeof lastOf(array);
-//=> 2
-```
-
-@category Array
-@category Template literal
-*/
-export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> =
-	// If the last element of an array is a spread element, the `LastArrayElement` result should be `'the type of the element before the spread element' | 'the type of the spread element'`.
-	Elements extends readonly []
-		? ElementBeforeTailingSpreadElement
-		: Elements extends readonly [...infer U, infer V]
-			? V
-			: Elements extends readonly [infer U, ...infer V]
-				// If we return `V[number] | U` directly, it would be wrong for `[[string, boolean, object, ...number[]]`.
-				// So we need to recurse type `V` and carry over the type of the element before the spread element.
-				? LastArrayElement<V, U>
-				: Elements extends ReadonlyArray<infer U>
-					? U | ElementBeforeTailingSpreadElement
-					: never;

package/node_modules/type-fest/source/less-than-or-equal.d.ts

@@ -1,22 +0,0 @@
-import type {GreaterThan} from './greater-than';
-
-/**
- Returns a boolean for whether a given number is less than or equal to another number.
-
-@example
-```
-import type {LessThanOrEqual} from 'type-fest';
-
-LessThanOrEqual<1, -5>;
-//=> false
-
-LessThanOrEqual<1, 1>;
-//=> true
-
-LessThanOrEqual<1, 5>;
-//=> true
-```
-*/
-export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThan<A, B> extends true ? false : true;

package/node_modules/type-fest/source/less-than.d.ts

@@ -1,22 +0,0 @@
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-
-/**
-Returns a boolean for whether a given number is less than another number.
-
-@example
-```
-import type {LessThan} from 'type-fest';
-
-LessThan<1, -5>;
-//=> false
-
-LessThan<1, 1>;
-//=> false
-
-LessThan<1, 5>;
-//=> true
-```
-*/
-export type LessThan<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThanOrEqual<A, B> extends true ? false : true;

package/node_modules/type-fest/source/literal-to-primitive-deep.d.ts

@@ -1,36 +0,0 @@
-import type {LiteralToPrimitive} from './literal-to-primitive';
-import type {OmitIndexSignature} from './omit-index-signature';
-
-/**
-Like `LiteralToPrimitive` except it converts literal types inside an object or array deeply.
-
-For example, given a constant object, it returns a new object type with the same keys but with all the values converted to primitives.
-
-@see LiteralToPrimitive
-
-Use-case: Deal with data that is imported from a JSON file.
-
-@example
-```
-import type {LiteralToPrimitiveDeep, TsConfigJson} from 'type-fest';
-import tsconfig from 'path/to/tsconfig.json';
-
-function doSomethingWithTSConfig(config: LiteralToPrimitiveDeep<TsConfigJson>) { ... }
-
-// No casting is needed to pass the type check
-doSomethingWithTSConfig(tsconfig);
-
-// If LiteralToPrimitiveDeep is not used, you need to cast the imported data like this:
-doSomethingWithTSConfig(tsconfig as TsConfigJson);
-```
-
-@category Type
-@category Object
-*/
-export type LiteralToPrimitiveDeep<T> = T extends object
-	? T extends Array<infer U>
-		? Array<LiteralToPrimitiveDeep<U>>
-		: {
-			[K in keyof OmitIndexSignature<T>]: LiteralToPrimitiveDeep<T[K]>;
-		}
-	: LiteralToPrimitive<T>;

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

@@ -1,36 +0,0 @@
-/**
-Given a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) return the {@link Primitive | primitive type} it belongs to, or `never` if it's not a primitive.
-
-Use-case: Working with generic types that may be literal types.
-
-@example
-```
-import type {LiteralToPrimitive} from 'type-fest';
-
-// No overloads needed to get the correct return type
-function plus<T extends number | bigint | string>(x: T, y: T): LiteralToPrimitive<T> {
-	return x + (y as any);
-}
-
-plus('a', 'b'); // string
-plus(1, 2); // number
-plus(1n, 2n); // bigint
-```
-
-@category Type
-*/
-export type LiteralToPrimitive<T> = T extends number
-	? number
-	: T extends bigint
-		? bigint
-		: T extends string
-			? string
-			: T extends boolean
-				? boolean
-				: T extends symbol
-					? symbol
-					: T extends null
-						? null
-						: T extends undefined
-							? undefined
-							: never;

package/node_modules/type-fest/source/literal-union.d.ts

@@ -1,35 +0,0 @@
-import type {Primitive} from './primitive';
-
-/**
-Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
-
-Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
-
-This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
-
-@example
-```
-import type {LiteralUnion} from 'type-fest';
-
-// Before
-
-type Pet = 'dog' | 'cat' | string;
-
-const pet: Pet = '';
-// Start typing in your TypeScript-enabled IDE.
-// You **will not** get auto-completion for `dog` and `cat` literals.
-
-// After
-
-type Pet2 = LiteralUnion<'dog' | 'cat', string>;
-
-const pet: Pet2 = '';
-// You **will** get auto-completion for `dog` and `cat` literals.
-```
-
-@category Type
-*/
-export type LiteralUnion<
-	LiteralType,
-	BaseType extends Primitive,
-> = LiteralType | (BaseType & Record<never, never>);