pull-request-split-advisor 3.1.2

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

@@ -0,0 +1,63 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
+
+/**
+Convert object properties to snake case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see SnakeCase
+@see SnakeCasedProperties
+
+@example
+```
+import type {SnakeCasedPropertiesDeep} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
+	user_info: {
+		user_id: 1,
+		user_name: 'Tom',
+	},
+	user_friends: [
+		{
+			user_id: 2,
+			user_name: 'Jerry',
+		},
+		{
+			user_id: 3,
+			user_name: 'Spike',
+		},
+	],
+};
+
+const splitOnNumbers: SnakeCasedPropertiesDeep<{line1: { line2: [{ line3: string }] }}, {splitOnNumbers: true}> = {
+	line_1: {
+		line_2: [
+			{
+				line_3: 'string',
+			},
+		],
+	},
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type SnakeCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

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

@@ -0,0 +1,40 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
+import type {DelimiterCasedProperties} from './delimiter-cased-properties';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
+
+/**
+Convert object properties to snake case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see SnakeCase
+@see SnakeCasedPropertiesDeep
+
+@example
+```
+import type {SnakeCasedProperties} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+const result: SnakeCasedProperties<User> = {
+	user_id: 1,
+	user_name: 'Tom',
+};
+
+const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
+	'line_1': 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type SnakeCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

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

@@ -0,0 +1,88 @@
+import type {And} from './and';
+import type {ApplyDefaultOptions, Not} from './internal';
+import type {IsStringLiteral} from './is-literal';
+import type {Or} from './or';
+
+/**
+Split options.
+
+@see {@link Split}
+*/
+type SplitOptions = {
+	/**
+	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
+
+	Note: In the future, this option might be enabled by default, so if you currently rely on this being disabled, you should consider explicitly enabling it.
+
+	@default false
+
+	@example
+	```ts
+	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
+	//=> ['foo', string, 'bar']
+
+	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
+	//=> string[]
+
+	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
+	//=> ['foo', 'r', 'z']
+
+	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
+	//=> string[]
+	```
+	*/
+	strictLiteralChecks?: boolean;
+};
+
+type DefaultSplitOptions = {
+	strictLiteralChecks: false;
+};
+
+/**
+Represents an array of strings split using a given character or character set.
+
+Use-case: Defining the return type of a method like `String.prototype.split`.
+
+@example
+```
+import type {Split} from 'type-fest';
+
+declare function split<S extends string, D extends string>(string: S, separator: D): Split<S, D>;
+
+type Item = 'foo' | 'bar' | 'baz' | 'waldo';
+const items = 'foo,bar,baz,waldo';
+let array: Item[];
+
+array = split(items, ',');
+```
+
+@see {@link SplitOptions}
+
+@category String
+@category Template literal
+*/
+export type Split<
+	S extends string,
+	Delimiter extends string,
+	Options extends SplitOptions = {},
+> =
+	SplitHelper<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
+
+type SplitHelper<
+	S extends string,
+	Delimiter extends string,
+	Options extends Required<SplitOptions>,
+	Accumulator extends string[] = [],
+> = S extends string // For distributing `S`
+	? Delimiter extends string // For distributing `Delimeter`
+		// If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
+		? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true
+			? S extends `${infer Head}${Delimiter}${infer Tail}`
+				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
+				: Delimiter extends ''
+					? Accumulator
+					: [...Accumulator, S]
+			// Otherwise, return `string[]`
+			: string[]
+		: never // Should never happen
+	: never; // Should never happen

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

@@ -0,0 +1,84 @@
+import type {RequiredKeysOf} from './required-keys-of';
+import type {Simplify} from './simplify';
+
+type SpreadObject<FirstType extends object, SecondType extends object> = {
+	[Key in keyof FirstType]: Key extends keyof SecondType
+		? FirstType[Key] | Required<SecondType>[Key]
+		: FirstType[Key];
+} & Pick<
+SecondType,
+RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
+>;
+
+type TupleOrArray = readonly [...unknown[]];
+
+type SpreadTupleOrArray<
+	FirstType extends TupleOrArray,
+	SecondType extends TupleOrArray,
+> = Array<FirstType[number] | SecondType[number]>;
+
+type Spreadable = object | TupleOrArray;
+
+/**
+Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
+
+@example
+```
+import type {Spread} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+};
+
+type Bar = {
+	b?: number;
+	c: boolean;
+};
+
+const foo = {a: 1, b: '2'};
+const bar = {c: false};
+const fooBar = {...foo, ...bar};
+
+type FooBar = Spread<Foo, Bar>;
+// type FooBar = {
+// 	a: number;
+// 	b?: string | number | undefined;
+// 	c: boolean;
+// }
+
+const baz = (argument: FooBar) => {
+	// Do something
+}
+
+baz(fooBar);
+```
+
+@example
+```
+import type {Spread} from 'type-fest';
+
+const foo = [1, 2, 3];
+const bar = ['4', '5', '6'];
+
+const fooBar = [...foo, ...bar];
+type FooBar = Spread<typeof foo, typeof bar>;
+// FooBar = (string | number)[]
+
+const baz = (argument: FooBar) => {
+	// Do something
+};
+
+baz(fooBar);
+```
+
+@category Object
+*/
+export type Spread<
+	FirstType extends Spreadable,
+	SecondType extends Spreadable,
+> = FirstType extends TupleOrArray
+	? SecondType extends TupleOrArray
+		? SpreadTupleOrArray<FirstType, SecondType>
+		: Simplify<SpreadObject<FirstType, SecondType>>
+	: Simplify<SpreadObject<FirstType, SecondType>>;

package/node_modules/type-fest/source/string-key-of.d.ts

@@ -0,0 +1,25 @@
+/**
+Get keys of the given type as strings.
+
+Number keys are converted to strings.
+
+Use-cases:
+- Get string keys from a type which may have number keys.
+- Makes it possible to index using strings retrieved from template types.
+
+@example
+```
+import type {StringKeyOf} from 'type-fest';
+
+type Foo = {
+	1: number,
+	stringKey: string,
+};
+
+type StringKeysOfFoo = StringKeyOf<Foo>;
+//=> '1' | 'stringKey'
+```
+
+@category Object
+*/
+export type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;

package/node_modules/type-fest/source/string-repeat.d.ts

@@ -0,0 +1,47 @@
+import type {IsNumericLiteral} from './is-literal';
+import type {IsNegative} from './numeric';
+
+/**
+Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
+
+@example
+```
+import {StringRepeat} from 'type-fest';
+
+declare function stringRepeat<
+	Input extends string,
+	Count extends number
+>(input: Input, count: Count): StringRepeat<Input, Count>;
+
+// The return type is the exact string literal, not just `string`.
+
+stringRepeat('foo', 2);
+//=> 'foofoo'
+
+stringRepeat('=', 3);
+//=> '==='
+```
+
+@category String
+@category Template literal
+*/
+export type StringRepeat<
+	Input extends string,
+	Count extends number,
+> = StringRepeatHelper<Input, Count>;
+
+type StringRepeatHelper<
+	Input extends string,
+	Count extends number,
+	Counter extends never[] = [],
+	Accumulator extends string = '',
+> =
+	IsNegative<Count> extends true
+		? never
+		: Input extends ''
+			? ''
+			: Count extends Counter['length']
+				? Accumulator
+				: IsNumericLiteral<Count> extends false
+					? string
+					: StringRepeatHelper<Input, Count, [...Counter, never], `${Accumulator}${Input}`>;

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

@@ -0,0 +1,37 @@
+import type {Join} from './join';
+import type {ArraySlice} from './array-slice';
+import type {StringToArray} from './internal';
+
+/**
+Returns a string slice of a given range, just like `String#slice()`.
+
+@see {ArraySlice}
+
+@example
+```
+import type {StringSlice} from 'type-fest';
+
+StringSlice<'abcde', 0, 2>;
+//=> 'ab'
+
+StringSlice<'abcde', 1>;
+//=> 'bcde'
+
+StringSlice<'abcde', 0, -1>;
+//=> 'abcd'
+
+StringSlice<'abcde', -2, -1>;
+//=> 'd'
+```
+
+@category String
+*/
+export type StringSlice<
+	S extends string,
+	Start extends number = 0,
+	End extends number = StringToArray<S>['length'],
+> = string extends S
+	? string
+	: ArraySlice<StringToArray<S>, Start, End> extends infer R extends readonly string[]
+		? Join<R, ''>
+		: never;

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

@@ -0,0 +1,23 @@
+/**
+Create a type with the keys of the given type changed to `string` type.
+
+Use-case: Changing interface values to strings in order to use them in a form model.
+
+@example
+```
+import type {Stringified} from 'type-fest';
+
+type Car = {
+	model: string;
+	speed: number;
+}
+
+const carForm: Stringified<Car> = {
+	model: 'Foo',
+	speed: '101'
+};
+```
+
+@category Object
+*/
+export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};

package/node_modules/type-fest/source/structured-cloneable.d.ts

@@ -0,0 +1,92 @@
+import type {TypedArray} from './typed-array';
+import type {FindGlobalInstanceType} from './find-global-type';
+
+type StructuredCloneablePrimitive =
+	| string
+	| number
+	| bigint
+	| boolean
+	| null
+	| undefined
+	| Boolean
+	| Number
+	| String;
+
+type StructuredCloneableData =
+	| ArrayBuffer
+	| DataView
+	| Date
+	| Error
+	| RegExp
+	| TypedArray
+	| FindGlobalInstanceType<
+	// DOM or Node types
+	| 'Blob'
+	| 'File'
+	// DOM exclusive types
+	| 'AudioData'
+	| 'CropTarget'
+	| 'CryptoKey'
+	| 'DOMException'
+	| 'DOMMatrix'
+	| 'DOMMatrixReadOnly'
+	| 'DOMPoint'
+	| 'DOMPointReadOnly'
+	| 'DOMQuad'
+	| 'DOMRect'
+	| 'DOMRectReadOnly'
+	| 'FileList'
+	| 'FileSystemDirectoryHandle'
+	| 'FileSystemFileHandle'
+	| 'FileSystemHandle'
+	| 'GPUCompilationInfo'
+	| 'GPUCompilationMessage'
+	| 'ImageBitmap'
+	| 'ImageData'
+	| 'RTCCertificate'
+	| 'VideoFrame'
+	>;
+
+type StructuredCloneableCollection =
+	| readonly StructuredCloneable[]
+	| {readonly [key: string]: StructuredCloneable; readonly [key: number]: StructuredCloneable}
+	| ReadonlyMap<StructuredCloneable, StructuredCloneable>
+	| ReadonlySet<StructuredCloneable>;
+
+/**
+Matches a value that can be losslessly cloned using `structuredClone`.
+
+Note:
+- Custom error types will be cloned as the base `Error` type
+
+@see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+
+@example
+```
+import type {StructuredCloneable} from 'type-fest';
+
+class CustomClass {}
+
+// @ts-expect-error
+const error: StructuredCloneable = {
+    custom: new CustomClass(),
+};
+
+structuredClone(error);
+//=> {custom: {}}
+
+const good: StructuredCloneable = {
+    number: 3,
+    date: new Date(),
+    map: new Map<string, number>(),
+}
+
+good.map.set('key', 1);
+
+structuredClone(good);
+//=> {number: 3, date: Date(2022-10-17 22:22:35.920), map: Map {'key' -> 1}}
+```
+
+@category Structured clone
+*/
+export type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;

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

@@ -0,0 +1,83 @@
+import type {NumberAbsolute, BuildTuple, ReverseSign} from './internal';
+import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
+import type {LessThan} from './less-than';
+
+/**
+Returns the difference between two numbers.
+
+Note:
+- A or B can only support `-999` ~ `999`.
+
+@example
+```
+import type {Subtract} from 'type-fest';
+
+Subtract<333, 222>;
+//=> 111
+
+Subtract<111, -222>;
+//=> 333
+
+Subtract<-111, 222>;
+//=> -333
+
+Subtract<18, 96>;
+//=> -78
+
+Subtract<PositiveInfinity, 9999>;
+//=> PositiveInfinity
+
+Subtract<PositiveInfinity, PositiveInfinity>;
+//=> number
+```
+
+@category Numeric
+*/
+// TODO: Support big integer.
+export type Subtract<A extends number, B extends number> =
+	// Handle cases when A or B is the actual "number" type
+	number extends A | B ? number
+		// Handle cases when A and B are both +/- infinity
+		: A extends B & (PositiveInfinity | NegativeInfinity) ? number
+			// Handle cases when A is - infinity or B is + infinity
+			: A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity
+				// Handle cases when A is + infinity or B is - infinity
+				: A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity
+					// Handle case when numbers are equal to each other
+					: A extends B ? 0
+						// Handle cases when A or B is 0
+						: A extends 0 ? ReverseSign<B> : B extends 0 ? A
+							// Handle remaining regular cases
+							: SubtractPostChecks<A, B>;
+
+/**
+Subtracts two numbers A and B, such that they are not equal and neither of them are 0, +/- infinity or the `number` type
+*/
+type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
+	AreNegative extends [false, false]
+		? SubtractPositives<A, B>
+		: AreNegative extends [true, true]
+			// When both numbers are negative we subtract the absolute values and then reverse the sign
+			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			// When the signs are different we can add the absolute values and then reverse the sign if A < B
+			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
+				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
+				: never;
+
+/**
+Subtracts two positive numbers.
+*/
+type SubtractPositives<A extends number, B extends number> =
+	LessThan<A, B> extends true
+		// When A < B we can reverse the result of B - A
+		? ReverseSign<SubtractIfAGreaterThanB<B, A>>
+		: SubtractIfAGreaterThanB<A, B>;
+
+/**
+Subtracts two positive numbers A and B such that A > B.
+*/
+type SubtractIfAGreaterThanB<A extends number, B extends number> =
+	// This is where we always want to end up and do the actual subtraction
+	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
+		? R['length']
+		: never;

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

@@ -0,0 +1,78 @@
+import type {NumberAbsolute, BuildTuple, TupleMax, ReverseSign} from './internal';
+import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
+import type {Subtract} from './subtract';
+
+/**
+Returns the sum of two numbers.
+
+Note:
+- A or B can only support `-999` ~ `999`.
+
+@example
+```
+import type {Sum} from 'type-fest';
+
+Sum<111, 222>;
+//=> 333
+
+Sum<-111, 222>;
+//=> 111
+
+Sum<111, -222>;
+//=> -111
+
+Sum<PositiveInfinity, -9999>;
+//=> PositiveInfinity
+
+Sum<PositiveInfinity, NegativeInfinity>;
+//=> number
+```
+
+@category Numeric
+*/
+// TODO: Support big integer.
+export type Sum<A extends number, B extends number> =
+	// Handle cases when A or B is the actual "number" type
+	number extends A | B ? number
+		// Handle cases when A and B are both +/- infinity
+		: A extends B & (PositiveInfinity | NegativeInfinity) ? A // A or B could be used here as they are equal
+			// Handle cases when A and B are opposite infinities
+			: A | B extends PositiveInfinity | NegativeInfinity ? number
+				// Handle cases when A is +/- infinity
+				: A extends PositiveInfinity | NegativeInfinity ? A
+					// Handle cases when B is +/- infinity
+					: B extends PositiveInfinity | NegativeInfinity ? B
+						// Handle cases when A or B is 0 or it's the same number with different signs
+						: A extends 0 ? B : B extends 0 ? A : A extends ReverseSign<B> ? 0
+							// Handle remaining regular cases
+							: SumPostChecks<A, B>;
+
+/**
+Adds two numbers A and B, such that they are not equal with different signs and neither of them are 0, +/- infinity or the `number` type
+*/
+type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
+	AreNegative extends [false, false]
+		// When both numbers are positive we can add them together
+		? SumPositives<A, B>
+		: AreNegative extends [true, true]
+			// When both numbers are negative we add the absolute values and then reverse the sign
+			? ReverseSign<SumPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			// When the signs are different we can subtract the absolute values, remove the sign
+			// and then reverse the sign if the larger absolute value is negative
+			: NumberAbsolute<Subtract<NumberAbsolute<A>, NumberAbsolute<B>>> extends infer Result extends number
+				? TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_ extends number
+					? Max_ extends A | B
+						// The larger absolute value is positive, so the result is positive
+						? Result
+						// The larger absolute value is negative, so the result is negative
+						: ReverseSign<Result>
+					: never
+				: never;
+
+/**
+Adds two positive numbers.
+*/
+type SumPositives<A extends number, B extends number> =
+	[...BuildTuple<A>, ...BuildTuple<B>]['length'] extends infer Result extends number
+		? Result
+		: never;