type-fest 4.40.0 → 4.41.0

package/index.d.ts

@@ -47,6 +47,7 @@ export type {SetReadonly} from './source/set-readonly';
 export type {SetRequired} from './source/set-required';
 export type {SetRequiredDeep} from './source/set-required-deep';
 export type {SetNonNullable} from './source/set-non-nullable';
+export type {SetNonNullableDeep} from './source/set-non-nullable-deep';
 export type {ValueOf} from './source/value-of';
 export type {AsyncReturnType} from './source/async-return-type';
 export type {ConditionalExcept} from './source/conditional-except';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.40.0",
+	"version": "4.41.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -151,6 +151,7 @@ Click the type names for complete docs.
 - [`SetRequired`](source/set-required.d.ts) - Create a type that makes the given keys required.
 - [`SetRequiredDeep`](source/set-required-deep.d.ts) - Like `SetRequired` except it selects the keys deeply.
 - [`SetNonNullable`](source/set-non-nullable.d.ts) - Create a type that makes the given keys non-nullable.
+- [`SetNonNullableDeep`](source/set-non-nullable-deep.d.ts) - Create a type that makes the specified keys non-nullable (removes `null` and `undefined`), supports deeply nested key paths, and leaves all other keys unchanged.
 - [`ValueOf`](source/value-of.d.ts) - Create a union of the given object's values, and optionally specify which keys to get the values from.
 - [`ConditionalKeys`](source/conditional-keys.d.ts) - Extract keys from a shape where values extend the given `Condition` type.
 - [`ConditionalPick`](source/conditional-pick.d.ts) - Like `Pick` except it selects properties from a shape where the values extend the given `Condition` type.

package/source/camel-cased-properties-deep.d.ts

@@ -68,12 +68,11 @@ type _CamelCasedPropertiesDeep<
 		? CamelCasedPropertiesArrayDeep<Value, Options>
 		: Value extends Set<infer U>
 			? Set<_CamelCasedPropertiesDeep<U, Options>>
-			: {
-				[K in keyof Value as CamelCase<K, Options>]: _CamelCasedPropertiesDeep<
-				Value[K],
-				Options
-				>;
-			};
+			: Value extends object
+				? {
+					[K in keyof Value as CamelCase<K, Options>]: _CamelCasedPropertiesDeep<Value[K], Options>;
+				}
+				: Value;
 
 // This is a copy of DelimiterCasedPropertiesArrayDeep (see: delimiter-cased-properties-deep.d.ts).
 // These types should be kept in sync.

package/source/delimiter-cased-properties-deep.d.ts

@@ -72,13 +72,13 @@ type _DelimiterCasedPropertiesDeep<
 	: Value extends UnknownArray
 		? DelimiterCasedPropertiesArrayDeep<Value, Delimiter, Options>
 		: Value extends Set<infer U>
-			? Set<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>> : {
-				[K in keyof Value as DelimiterCase<
-				K,
-				Delimiter,
-				Options
-				>]: _DelimiterCasedPropertiesDeep<Value[K], Delimiter, Options>;
-			};
+			? Set<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>>
+			: Value extends object
+				? {
+					[K in keyof Value as DelimiterCase<K, Delimiter, Options>]:
+					_DelimiterCasedPropertiesDeep<Value[K], Delimiter, Options>
+				}
+				: Value;
 
 // This is a copy of CamelCasedPropertiesArrayDeep (see: camel-cased-properties-deep.d.ts).
 // These types should be kept in sync.

package/source/greater-than.d.ts

@@ -21,31 +21,36 @@ GreaterThan<1, 5>;
 //=> false
 ```
 */
-export type GreaterThan<A extends number, B extends number> = number extends A | B
-	? never
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-		And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-		> extends true
-			? true
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-			> extends true
-				? false
-				: true extends R[number]
-					? false
-					: [IsNegative<A>, IsNegative<B>] extends infer R extends [boolean, boolean]
-						? [true, false] extends R
+export type GreaterThan<A extends number, B extends number> =
+	A extends number // For distributing `A`
+		? B extends number // For distributing `B`
+			? number extends A | B
+				? never
+				: [
+					IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
+					IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
+				] extends infer R extends [boolean, boolean, boolean, boolean]
+					? Or<
+					And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
+					And<IsEqual<R[3], true>, IsEqual<R[1], false>>
+					> extends true
+						? true
+						: Or<
+						And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
+						And<IsEqual<R[2], true>, IsEqual<R[0], false>>
+						> extends true
 							? false
-							: [false, true] extends R
-								? true
-								: [false, false] extends R
-									? PositiveNumericStringGt<`${A}`, `${B}`>
-									: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
-						: never
-		: never;
+							: true extends R[number]
+								? false
+								: [IsNegative<A>, IsNegative<B>] extends infer R extends [boolean, boolean]
+									? [true, false] extends R
+										? false
+										: [false, true] extends R
+											? true
+											: [false, false] extends R
+												? PositiveNumericStringGt<`${A}`, `${B}`>
+												: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
+									: never
+					: never
+			: never // Should never happen
+		: never; // Should never happen

package/source/internal/type.d.ts

@@ -1,3 +1,4 @@
+import type {IsAny} from '../is-any';
 import type {IsNever} from '../is-never';
 import type {Primitive} from '../primitive';
 
@@ -111,3 +112,28 @@ type InternalIsUnion<T, U = T> =
 	? boolean extends Result ? true
 		: Result
 	: never; // Should never happen
+
+/**
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
+
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
+
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
+*/
+export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
+	IsAny<T> extends true
+		? IfAny
+		: IsNever<T> extends true
+			? IfNever
+			: IfNotAnyOrNever;

package/source/is-float.d.ts

@@ -1,5 +1,3 @@
-import type {Zero} from './numeric';
-
 /**
 Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
 

package/source/less-than.d.ts

@@ -19,4 +19,8 @@ LessThan<1, 5>;
 */
 export type LessThan<A extends number, B extends number> = number extends A | B
 	? never
-	: GreaterThanOrEqual<A, B> extends true ? false : true;
+	: GreaterThanOrEqual<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen

package/source/partial-deep.d.ts

@@ -1,4 +1,5 @@
 import type {ApplyDefaultOptions, BuiltIns} from './internal';
+import type {IsNever} from './is-never';
 
 /**
 @see {@link PartialDeep}
@@ -95,27 +96,29 @@ const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 export type PartialDeep<T, Options extends PartialDeepOptions = {}> =
 	_PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
 
-type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown))
 	? T
-	: T extends Map<infer KeyType, infer ValueType>
-		? PartialMapDeep<KeyType, ValueType, Options>
-		: T extends Set<infer ItemType>
-			? PartialSetDeep<ItemType, Options>
-			: T extends ReadonlyMap<infer KeyType, infer ValueType>
-				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-				: T extends ReadonlySet<infer ItemType>
-					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends object
-						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-							? Options['recurseIntoArrays'] extends true
-								? ItemType[] extends T // Test for arrays (non-tuples) specifically
-									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-										? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
-										: Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
-									: PartialObjectDeep<T, Options> // Tuples behave properly
-								: T // If they don't opt into array testing, just use the original type
-							: PartialObjectDeep<T, Options>
-						: unknown;
+	: IsNever<keyof T> extends true // For functions with no properties
+		? T
+		: T extends Map<infer KeyType, infer ValueType>
+			? PartialMapDeep<KeyType, ValueType, Options>
+			: T extends Set<infer ItemType>
+				? PartialSetDeep<ItemType, Options>
+				: T extends ReadonlyMap<infer KeyType, infer ValueType>
+					? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+					: T extends ReadonlySet<infer ItemType>
+						? PartialReadonlySetDeep<ItemType, Options>
+						: T extends object
+							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+								? Options['recurseIntoArrays'] extends true
+									? ItemType[] extends T // Test for arrays (non-tuples) specifically
+										? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+											? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
+											: Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
+										: PartialObjectDeep<T, Options> // Tuples behave properly
+									: T // If they don't opt into array testing, just use the original type
+								: PartialObjectDeep<T, Options>
+							: unknown;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
@@ -140,6 +143,9 @@ type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
-	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
-};
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> =
+	(ObjectType extends (...arguments_: any) => unknown
+		? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType>
+		: {}) & ({
+		[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
+	});

package/source/pascal-cased-properties-deep.d.ts

@@ -54,6 +54,9 @@ type _PascalCasedPropertiesDeep<Value, Options extends Required<CamelCaseOptions
 	: Value extends Array<infer U>
 		? Array<_PascalCasedPropertiesDeep<U, Options>>
 		: Value extends Set<infer U>
-			? Set<_PascalCasedPropertiesDeep<U, Options>> : {
-				[K in keyof Value as PascalCase<K, Options>]: _PascalCasedPropertiesDeep<Value[K], Options>;
-			};
+			? Set<_PascalCasedPropertiesDeep<U, Options>>
+			: Value extends object
+				? {
+					[K in keyof Value as PascalCase<K, Options>]: _PascalCasedPropertiesDeep<Value[K], Options>;
+				}
+				: Value;

package/source/require-all-or-none.d.ts

@@ -1,4 +1,6 @@
-import type {RequireNone} from './internal';
+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.
@@ -36,7 +38,14 @@ const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
 
 @category Object
 */
-export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = (
+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/source/require-at-least-one.d.ts

@@ -1,4 +1,7 @@
 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.
@@ -24,6 +27,16 @@ const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 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

package/source/require-exactly-one.d.ts

@@ -1,3 +1,7 @@
+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.
 
@@ -28,6 +32,13 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 @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>>

package/source/require-one-or-none.d.ts

@@ -1,5 +1,7 @@
 import type {RequireExactlyOne} from './require-exactly-one';
-import type {RequireNone} from './internal';
+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.
@@ -31,7 +33,14 @@ const responder3: Responder = {
 
 @category Object
 */
-export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = (
+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.

package/source/set-non-nullable-deep.d.ts

@@ -0,0 +1,83 @@
+import type {NonRecursiveType, StringToNumber} from './internal';
+import type {Paths} from './paths';
+import type {SetNonNullable} from './set-non-nullable';
+import type {Simplify} from './simplify';
+import type {UnionToTuple} from './union-to-tuple';
+import type {UnknownArray} from './unknown-array';
+
+/**
+Create a type that makes the specified keys non-nullable (removes `null` and `undefined`), supports deeply nested key paths, and leaves all other keys unchanged.
+
+NOTE: Optional modifiers (`?`) are not removed from properties. For example, `SetNonNullableDeep<{foo?: string | null | undefined}, 'foo'>` will result in `{foo?: string}`.
+
+@example
+```
+import type {SetNonNullableDeep} from 'type-fest';
+
+type User = {
+	name: string;
+	address: {
+		city: string | undefined;
+		street?: string | null;
+	};
+	contact: {
+		email?: string | null | undefined;
+		phone: string | undefined;
+	};
+};
+
+type UpdatedUser = SetNonNullableDeep<User, 'address.street' | 'contact.email' | 'contact.phone'>;
+//=> {
+// 	name: string;
+// 	address: {
+// 		city: string | undefined;
+// 		street?: string;
+// 	};
+// 	contact: {
+// 		email?: string;
+// 		phone: string;
+// 	};
+// };
+```
+
+@example
+```
+import type {SetNonNullableDeep} from 'type-fest';
+
+// Set specific indices in an array to be non-nullable.
+type ArrayExample1 = SetNonNullableDeep<{a: [number | null, number | null, number | undefined]}, 'a.1' | 'a.2'>;
+//=> {a: [number | null, number, number]}
+
+// Optional modifier (`?`) is not removed.
+type ArrayExample2 = SetNonNullableDeep<{a: [(number | null)?, (number | null)?]}, 'a.1'>;
+//=> {a: [(number | null)?, number?]}
+```
+
+@category Object
+*/
+export type SetNonNullableDeep<BaseType, KeyPaths extends Paths<BaseType>> =
+	SetNonNullableDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
+
+/**
+Internal helper for {@link SetNonNullableDeep}.
+
+Recursively transforms the `BaseType` by applying {@link SetNonNullableDeepSinglePath} for each path in `KeyPathsTuple`.
+*/
+type SetNonNullableDeepHelper<BaseType, KeyPathsTuple extends UnknownArray> =
+	KeyPathsTuple extends [infer KeyPath, ...infer RestPaths]
+		? SetNonNullableDeepHelper<SetNonNullableDeepSinglePath<BaseType, KeyPath>, RestPaths>
+		: BaseType;
+
+/**
+Makes a single path non-nullable in `BaseType`.
+*/
+type SetNonNullableDeepSinglePath<BaseType, KeyPath> =
+	BaseType extends NonRecursiveType | ReadonlySet<unknown> | ReadonlyMap<unknown, unknown> // Also distributes `BaseType`
+		? BaseType
+		: KeyPath extends `${infer Property}.${infer RestPath}`
+			? {
+				[Key in keyof BaseType]: Property extends `${Key & (string | number)}`
+					? SetNonNullableDeepSinglePath<BaseType[Key], RestPath>
+					: BaseType[Key];
+			}
+			: Simplify<SetNonNullable<BaseType, (KeyPath | StringToNumber<KeyPath & string>) & keyof BaseType>>;

package/source/set-optional.d.ts

@@ -1,6 +1,5 @@
 import type {Except} from './except';
 import type {HomomorphicPick} from './internal';
-import type {KeysOfUnion} from './keys-of-union';
 import type {Simplify} from './simplify';
 
 /**

package/source/set-readonly.d.ts

@@ -1,6 +1,5 @@
 import type {Except} from './except';
 import type {HomomorphicPick} from './internal';
-import type {KeysOfUnion} from './keys-of-union';
 import type {Simplify} from './simplify';
 
 /**

package/source/set-required.d.ts

@@ -1,6 +1,5 @@
 import type {Except} from './except';
 import type {HomomorphicPick, IfArrayReadonly} from './internal';
-import type {KeysOfUnion} from './keys-of-union';
 import type {OptionalKeysOf} from './optional-keys-of';
 import type {Simplify} from './simplify';
 import type {UnknownArray} from './unknown-array';

package/source/shared-union-fields-deep.d.ts

@@ -1,4 +1,4 @@
-import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsUnion, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal';
+import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal';
 import type {IsNever} from './is-never';
 import type {UnknownArray} from './unknown-array';