pull-request-split-advisor 3.1.2

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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,50 @@
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@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.
+	['kebab-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;
+// }
+```
+
+@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

@@ -0,0 +1,13 @@
+/**
+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

@@ -0,0 +1,25 @@
+/**
+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>;

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

@@ -0,0 +1,81 @@
+import type {BuiltIns, HasMultipleCallSignatures} from './internal';
+
+/**
+Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+
+This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	"foo": ["bar"]
+}
+
+// main.ts
+import type {ReadonlyDeep} from 'type-fest';
+import dataJson = require('./data.json');
+
+const data: ReadonlyDeep<typeof dataJson> = dataJson;
+
+export default data;
+
+// test.ts
+import data from './main';
+
+data.foo.push('bar');
+//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
+```
+
+Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type ReadonlyDeep<T> = T extends BuiltIns
+	? T
+	: T extends new (...arguments_: any[]) => unknown
+		? T // Skip class constructors
+		: T extends (...arguments_: any[]) => unknown
+			? {} extends ReadonlyObjectDeep<T>
+				? T
+				: HasMultipleCallSignatures<T> extends true
+					? T
+					: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
+			: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
+				? ReadonlyMapDeep<KeyType, ValueType>
+				: T extends Readonly<ReadonlySet<infer ItemType>>
+					? ReadonlySetDeep<ItemType>
+					: // Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
+					T extends readonly [] | readonly [...never[]]
+						? readonly []
+						: T extends readonly [infer U, ...infer V]
+							? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>]
+							: T extends readonly [...infer U, infer V]
+								? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>]
+								: T extends ReadonlyArray<infer ItemType>
+									? ReadonlyArray<ReadonlyDeep<ItemType>>
+									: T extends object
+										? ReadonlyObjectDeep<T>
+										: unknown;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyMapDeep<KeyType, ValueType> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>>;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlySetDeep<ItemType> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType>>>;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyObjectDeep<ObjectType extends object> = {
+	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
+};

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

@@ -0,0 +1,30 @@
+import type {WritableKeysOf} from './writable-keys-of';
+
+/**
+Extract all readonly keys from the given type.
+
+This is useful when you want to create a new type that contains readonly keys only.
+
+@example
+```
+import type {ReadonlyKeysOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+	readonly id: number;
+}
+
+type UpdateResponse<Entity extends object> = Pick<Entity, ReadonlyKeysOf<Entity>>;
+
+const update1: UpdateResponse<User> = {
+    id: 123,
+};
+```
+
+@category Utilities
+*/
+export type ReadonlyKeysOf<T> =
+	T extends unknown // For distributing `T`
+		? Exclude<keyof T, WritableKeysOf<T>>
+		: never; // Should never happen

package/node_modules/type-fest/source/readonly-tuple.d.ts

@@ -0,0 +1,41 @@
+/**
+Creates a read-only tuple of type `Element` and with the length of `Length`.
+
+@private
+@see `ReadonlyTuple` which is safer because it tests if `Length` is a specific finite number.
+*/
+type BuildTupleHelper<Element, Length extends number, Rest extends Element[]> =
+	Rest['length'] extends Length ?
+		readonly [...Rest] : // Terminate with readonly array (aka tuple)
+		BuildTupleHelper<Element, Length, [Element, ...Rest]>;
+
+/**
+Create a type that represents a read-only tuple of the given type and length.
+
+Use-cases:
+- Declaring fixed-length tuples with a large number of items.
+- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types.
+- Creating a tuple of coordinates with a static length, for example, length of 3 for a 3D vector.
+
+@example
+```
+import {ReadonlyTuple} from 'type-fest';
+
+type FencingTeam = ReadonlyTuple<string, 3>;
+
+const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
+
+const homeFencingTeam: FencingTeam = ['George', 'John'];
+//=> error TS2322: Type string[] is not assignable to type 'FencingTeam'
+
+guestFencingTeam.push('Sam');
+//=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
+```
+
+@category Utilities
+*/
+export type ReadonlyTuple<Element, Length extends number> =
+	number extends Length
+		// Because `Length extends number` and `number extends Length`, then `Length` is not a specific finite number.
+		? readonly Element[] // It's not fixed length.
+		: BuildTupleHelper<Element, Length, []>; // Otherwise it is a fixed length tuple.

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

@@ -0,0 +1,85 @@
+import type {ApplyDefaultOptions} from './internal';
+
+type ReplaceOptions = {
+	all?: boolean;
+};
+
+type DefaultReplaceOptions = {
+	all: false;
+};
+
+/**
+Represents a string with some or all matches replaced by a replacement.
+
+Use-case:
+- `kebab-case-path` to `dotted.path.notation`
+- Changing date/time format: `01-08-2042` → `01/08/2042`
+- Manipulation of type properties, for example, removal of prefixes
+
+@example
+```
+import {Replace} from 'type-fest';
+
+declare function replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string
+>(
+	input: Input,
+	search: Search,
+	replacement: Replacement
+): Replace<Input, Search, Replacement>;
+
+declare function replaceAll<
+	Input extends string,
+	Search extends string,
+	Replacement extends string
+>(
+	input: Input,
+	search: Search,
+	replacement: Replacement
+): Replace<Input, Search, Replacement, {all: true}>;
+
+// The return type is the exact string literal, not just `string`.
+
+replace('hello ?', '?', '🦄');
+//=> 'hello 🦄'
+
+replace('hello ??', '?', '❓');
+//=> 'hello ❓?'
+
+replaceAll('10:42:00', ':', '-');
+//=> '10-42-00'
+
+replaceAll('__userName__', '__', '');
+//=> 'userName'
+
+replaceAll('My Cool Title', ' ', '');
+//=> 'MyCoolTitle'
+```
+
+@category String
+@category Template literal
+*/
+export type Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends ReplaceOptions = {},
+> = _Replace<Input, Search, Replacement, ApplyDefaultOptions<ReplaceOptions, DefaultReplaceOptions, Options>>;
+
+type _Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends Required<ReplaceOptions>,
+	Accumulator extends string = '',
+> = Search extends string // For distributing `Search`
+	? Replacement extends string // For distributing `Replacement`
+		? Input extends `${infer Head}${Search}${infer Tail}`
+			? Options['all'] extends true
+				? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`>
+				: `${Head}${Replacement}${Tail}`
+			: `${Accumulator}${Input}`
+		: never
+	: never;

package/node_modules/type-fest/source/require-all-or-none.d.ts

@@ -0,0 +1,51 @@
+import type {IfAny} from './if-any';
+import type {IfNever} from './if-never';
+import type {IfNotAnyOrNever, RequireNone} from './internal';
+
+/**
+Requires all of the keys in the given object.
+*/
+type RequireAll<ObjectType, KeysType extends keyof ObjectType> = Required<Pick<ObjectType, KeysType>>;
+
+/**
+Create a type that requires all of the given keys or none of the given keys. The remaining keys are kept as is.
+
+Use-cases:
+- Creating interfaces for components with mutually-inclusive keys.
+
+The caveat with `RequireAllOrNone` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireAllOrNone` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import type {RequireAllOrNone} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+	secure: boolean;
+};
+
+const responder1: RequireAllOrNone<Responder, 'text' | 'json'> = {
+	secure: true
+};
+
+const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
+	text: () => '{"message": "hi"}',
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+
+@category Object
+*/
+export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType,
+	IfNever<KeysType,
+	ObjectType,
+	_RequireAllOrNone<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
+	>>;
+
+type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
+	| RequireAll<ObjectType, KeysType>
+	| RequireNone<KeysType>
+) & Omit<ObjectType, KeysType>; // The rest of the keys.

package/node_modules/type-fest/source/require-at-least-one.d.ts

@@ -0,0 +1,47 @@
+import type {Except} from './except';
+import type {IfAny} from './if-any';
+import type {IfNever} from './if-never';
+import type {IfNotAnyOrNever} from './internal';
+
+/**
+Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+
+@example
+```
+import type {RequireAtLeastOne} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+	secure?: boolean;
+};
+
+const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+
+@category Object
+*/
+export type RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType = keyof ObjectType,
+> =
+	IfNotAnyOrNever<ObjectType,
+	IfNever<KeysType,
+	never,
+	_RequireAtLeastOne<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
+	>>;
+
+type _RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType,
+> = {
+	// For each `Key` in `KeysType` make a mapped type:
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
+	// 2. Make all other keys in `KeysType` optional
+	Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+}[KeysType] &
+// 3. Add the remaining keys not in `KeysType`
+Except<ObjectType, KeysType>;

package/node_modules/type-fest/source/require-exactly-one.d.ts

@@ -0,0 +1,45 @@
+import type {IfAny} from './if-any';
+import type {IfNever} from './if-never';
+import type {IfNotAnyOrNever} from './internal';
+
+/**
+Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
+
+Use-cases:
+- Creating interfaces for components that only need one of the keys to display properly.
+- Declaring generic keys in a single place for a single use-case that gets narrowed down via `RequireExactlyOne`.
+
+The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireExactlyOne` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import type {RequireExactlyOne} from 'type-fest';
+
+type Responder = {
+	text: () => string;
+	json: () => string;
+	secure: boolean;
+};
+
+const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
+	// Adding a `text` key here would cause a compile error.
+
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+
+@category Object
+*/
+export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType,
+	IfNever<KeysType,
+	never,
+	_RequireExactlyOne<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
+	>>;
+
+type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
+	{[Key in KeysType]: (
+		Required<Pick<ObjectType, Key>> &
+		Partial<Record<Exclude<KeysType, Key>, never>>
+	)}[KeysType] & Omit<ObjectType, KeysType>;

package/node_modules/type-fest/source/require-one-or-none.d.ts

@@ -0,0 +1,46 @@
+import type {RequireExactlyOne} from './require-exactly-one';
+import type {IfNotAnyOrNever, RequireNone} from './internal';
+import type {IfNever} from './if-never';
+import type {IfAny} from './if-any';
+
+/**
+Create a type that requires exactly one of the given keys and disallows more, or none of the given keys. The remaining keys are kept as is.
+
+@example
+```
+import type {RequireOneOrNone} from 'type-fest';
+
+type Responder = RequireOneOrNone<{
+	text: () => string;
+	json: () => string;
+	secure: boolean;
+}, 'text' | 'json'>;
+
+const responder1: Responder = {
+	secure: true
+};
+
+const responder2: Responder = {
+	text: () => '{"message": "hi"}',
+	secure: true
+};
+
+const responder3: Responder = {
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+
+@category Object
+*/
+export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType,
+	IfNever<KeysType,
+	ObjectType,
+	_RequireOneOrNone<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
+	>>;
+
+type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (
+	| RequireExactlyOne<ObjectType, KeysType>
+	| RequireNone<KeysType>
+) & Omit<ObjectType, KeysType>; // Ignore unspecified keys.