pull-request-split-advisor 3.1.2

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

@@ -0,0 +1,39 @@
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+export type OptionalKeysOf<BaseType extends object> =
+	BaseType extends unknown // For distributing `BaseType`
+		? (keyof {
+			[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never
+		}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+		: never; // Should never happen

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

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

package/node_modules/type-fest/source/override-properties.d.ts

@@ -0,0 +1,36 @@
+import type {Merge} from './merge';
+
+/**
+Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
+
+This is useful when you want to override existing properties with a different type and make sure that these properties really exist in the original.
+
+@example
+```
+type Foo = {
+	a: string
+	b: string
+}
+type Bar = OverrideProperties<Foo, {b: number}>
+//=> {a: string, b: number}
+
+type Baz = OverrideProperties<Foo, {c: number}>
+// Error, type '{ c: number; }' does not satisfy the constraint '{ c: never; }'
+
+type Fizz = OverrideProperties<Foo, {b: number; c: number}>
+// Error, type '{ b: number; c: number; }' does not satisfy the constraint '{ b: number; c: never; }'
+```
+
+@category Object
+*/
+export type OverrideProperties<
+	TOriginal,
+	// This first bit where we use `Partial` is to enable autocomplete
+	// and the second bit with the mapped type is what enforces that we don't try
+	// to override properties that doesn't exist in the original type.
+	TOverride extends Partial<Record<keyof TOriginal, unknown>> & {
+		[Key in keyof TOverride]: Key extends keyof TOriginal
+			? TOverride[Key]
+			: never;
+	},
+> = Merge<TOriginal, TOverride>;