type-fest 2.17.0 → 2.18.0

package/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, PartialDeepOptions} from './source/partial-deep';
+export {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep';
 export {ReadonlyDeep} from './source/readonly-deep';
 export {LiteralUnion} from './source/literal-union';
 export {Promisable} from './source/promisable';
@@ -61,6 +62,7 @@ export {OptionalKeysOf} from './source/optional-keys-of';
 export {HasOptionalKeys} from './source/has-optional-keys';
 export {RequiredKeysOf} from './source/required-keys-of';
 export {HasRequiredKeys} from './source/has-required-keys';
+export {Spread} from './source/spread';
 
 // Template literal types
 export {CamelCase} from './source/camel-case';

package/package.json

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

package/readme.md

@@ -40,41 +40,6 @@
 			<br>
 			<br>
 			<br>
-			<a href="https://neverinstall.com/spaces/devtools?utm_source=github&utm_medium=sponsor&utm_campaign=sindre#gh-light-mode-only">
-				<div>
-					<img src="https://sindresorhus.com/assets/thanks/neverinstall-logo-light.svg" width="200" alt="neverinstall">
-				</div>
-				<br>
-				<b>All your favourite IDE's now available on the cloud</b>
-				<div>
-					<sub>
-					Neverinstall gives you an uninterrupted development experience and improved accessibility,
-					<br>
-					allowing you to code faster, better and on-the-go on your favourite IDEs like
-					<br>
-					Android Studio, VS Code, Jupyter and PyCharm using your browser.
-					</sub>
-				</div>
-			</a>
-			<a href="https://neverinstall.com/spaces/devtools?utm_source=github&utm_medium=sponsor&utm_campaign=sindre#gh-dark-mode-only">
-				<div>
-					<img src="https://sindresorhus.com/assets/thanks/neverinstall-logo-dark.svg" width="200" alt="neverinstall">
-				</div>
-				<br>
-				<b>All your favourite IDE's now available on the cloud</b>
-				<div>
-					<sub>
-					Neverinstall gives you an uninterrupted development experience and improved accessibility,
-					<br>
-					allowing you to code faster, better and on-the-go on your favourite IDEs like
-					<br>
-					Android Studio, VS Code, Jupyter and PyCharm using your browser.
-					</sub>
-				</div>
-			</a>
-			<br>
-			<br>
-			<br>
 			<a href="https://www.useanvil.com/?utm_source=sindresorhus#gh-light-mode-only">
 				<div>
 					<img src="https://sindresorhus.com/assets/thanks/anvil-logo-light.svg" width="200" alt="Anvil">
@@ -169,6 +134,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/).
@@ -196,6 +162,7 @@ Click the type names for complete docs.
 - [`HasOptionalKeys`](source/has-optional-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any optional fields.
 - [`RequiredKeysOf`](source/required-keys-of.d.ts) - Extract all required keys from the given type.
 - [`HasRequiredKeys`](source/has-required-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any required fields.
+- [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects using the spread operator.
 
 ### JSON
 

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

@@ -0,0 +1,70 @@
+import type {BuiltIns} from './internal';
+import type {Merge} from './merge';
+
+/**
+@see PartialOnUndefinedDeep
+*/
+export interface PartialOnUndefinedDeepOptions {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+	readonly recurseIntoArrays?: boolean;
+}
+
+/**
+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. By default, it does not affect arrays and tuples items unless you explicitly pass `{recurseIntoArrays: true}` as the second type argument.
+
+Use-cases:
+- Make all properties of a type that can be undefined optional to not have to specify keys with undefined value.
+
+@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, Options extends PartialOnUndefinedDeepOptions = {}> = T extends Record<any, any> | undefined
+	? {[KeyType in keyof T as undefined extends T[KeyType] ? KeyType : never]?: PartialOnUndefinedDeepValue<T[KeyType], Options>} 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], Options>}, 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, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments: any[]) => unknown)
+	? T
+	: T extends ReadonlyArray<infer U> // Test if type is array or tuple
+	? Options['recurseIntoArrays'] extends true // Check if option is activated
+		? U[] extends T // Check if array not tuple
+		? readonly U[] extends T
+			? ReadonlyArray<PartialOnUndefinedDeep<U, Options>> // Readonly array treatment
+			: Array<PartialOnUndefinedDeep<U, Options>> // Mutable array treatment
+		: PartialOnUndefinedDeep<{[Key in keyof T]: PartialOnUndefinedDeep<T[Key], Options>}, Options> // Tuple treatment
+		: T
+	: T extends Record<any, any> | undefined
+	? PartialOnUndefinedDeep<T, Options>
+	: unknown;

package/source/spread.d.ts

@@ -0,0 +1,54 @@
+import type {Except} from './except';
+import type {RequiredKeysOf} from './required-keys-of';
+import type {Simplify} from './simplify';
+
+type Spread_<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>
+>;
+
+/**
+Mimic the type inferred by TypeScript when merging two objects using the spread operator.
+
+@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);
+```
+
+@category Object
+*/
+export type Spread<
+    FirstType extends object,
+    SecondType extends object,
+> = Simplify<Spread_<FirstType, SecondType>>;