Add PartialOnUndefinedDeep type

index.d.ts

@@ -15,6 +15,7 @@ export {RequireExactlyOne} from './source/require-exactly-one';
 export {RequireAllOrNone} from './source/require-all-or-none';
 export {RemoveIndexSignature} from './source/remove-index-signature';
 export {PartialDeep} from './source/partial-deep';
+export {PartialOnUndefinedDeep} from './source/partial-on-undefined-deep';
 export {ReadonlyDeep} from './source/readonly-deep';
 export {LiteralUnion} from './source/literal-union';
 export {Promisable} from './source/promisable';

readme.md

@@ -169,6 +169,7 @@ Click the type names for complete docs.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys.
 - [`RemoveIndexSignature`](source/remove-index-signature.d.ts) - Create a type that only has explicitly defined properties, absent of any index signatures.
 - [`PartialDeep`](source/partial-deep.d.ts) - Create a deeply optional version of another type. Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
+- [`PartialOnUndefinedDeep`](source/partial-on-undefined-deep.d.ts) - Create a deep version of another type where all keys accepting `undefined` type are set to optional.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
 - [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
 - [`Opaque`](source/opaque.d.ts) - Create an [opaque type](https://codemix.com/opaque-types-in-javascript/).

source/partial-on-undefined-deep.d.ts

@@ -0,0 +1,51 @@
+import type {BuiltIns} from './internal';
+import type {Merge} from './merge';
+
+/**
+Create a deep version of another type where all keys accepting `undefined` type are set to optional.
+
+This utility type is recursive, transforming at any level deep, and recurses into arrays too.
+
+Use-cases:
+- Make all properties of a type that can be undefined optional to not have to specify keys with undefined value
+
+https://github.com/sindresorhus/type-fest/issues/399
+@example
+```
+import type {PartialOnUndefinedDeep} from 'type-fest';
+
+interface Settings {
+	optionA: string;
+	optionB: number | undefined;
+	subOption: {
+		subOptionA: boolean;
+		subOptionB: boolean | undefined;
+	}
+};
+
+const testSettings: PartialOnUndefinedDeep<Settings> = {
+	optionA: 'foo',
+	// 👉 optionB is now optional and can be omitted
+	subOption: {
+		subOptionA: true,
+		// 👉 subOptionB is now optional as well and can be omitted
+	},
+};
+```
+
+@category Object
+*/
+export type PartialOnUndefinedDeep<T> = T extends Record<any, any> | undefined
+	? {[KeyType in keyof T as undefined extends T[KeyType] ? KeyType : never]?: PartialOnUndefinedDeepValue<T[KeyType]>} extends infer U // Make a partial type with all value types accepting undefined (and set them optional)
+		? Merge<{[KeyType in keyof T as KeyType extends keyof U ? never : KeyType]: PartialOnUndefinedDeepValue<T[KeyType]>}, U> // Join all remaining keys not treated in U
+		: never // Should not happen
+	: T;
+
+/**
+Utility type to get the value type by key and recursively call `PartialOnUndefinedDeep` to transform sub-objects.
+*/
+type PartialOnUndefinedDeepValue<T> = T extends BuiltIns | ((...arguments: any[]) => unknown)
+	? T
+	: T extends Record<any, any> | undefined
+	? PartialOnUndefinedDeep<T>
+	: unknown;

test-d/partial-on-undefined-deep.ts

@@ -0,0 +1,46 @@
+import {expectType} from 'tsd';
+import type {PartialOnUndefinedDeep} from '../index';
+
+declare const foo: PartialOnUndefinedDeep<{
+	function: (() => void) | undefined;
+	object: {objectKey: 1} | undefined;
+	objectDeep: {
+		subObject: string | undefined;
+	};
+	string: string | undefined;
+	union: 'test1' | 'test2' | undefined;
+	number: number | undefined;
+	boolean: boolean | undefined;
+	date: Date | undefined;
+	regexp: RegExp | undefined;
+	symbol: Symbol | undefined;
+	null: null | undefined;
+	record: Record<string, any> | undefined;
+	map: Map<string, string> | undefined;
+	set: Set<string> | undefined;
+	array: any[] | undefined;
+	tuple: ['test1'] | undefined;
+	readonly: readonly string[] | undefined;
+}>;
+
+expectType<{
+	function?: typeof foo['function'];
+	object?: typeof foo['object'];
+	objectDeep: {
+		subObject?: typeof foo['objectDeep']['subObject'];
+	};
+	string?: typeof foo['string'];
+	union?: typeof foo['union'];
+	number?: typeof foo['number'];
+	boolean?: typeof foo['boolean'];
+	date?: typeof foo['date'];
+	regexp?: typeof foo['regexp'];
+	symbol?: typeof foo['symbol'];
+	null?: typeof foo['null'];
+	record?: typeof foo['record'];
+	map?: typeof foo['map'];
+	set?: typeof foo['set'];
+	array?: typeof foo['array'];
+	tuple?: typeof foo['tuple'];
+	readonly?: typeof foo['readonly'];
+}>(foo);