type-fest 4.18.3 → 4.20.0

package/index.d.ts

@@ -61,6 +61,7 @@ export type {SetReturnType} from './source/set-return-type';
 export type {SetParameterType} from './source/set-parameter-type';
 export type {Asyncify} from './source/asyncify';
 export type {Simplify} from './source/simplify';
+export type {SimplifyDeep} from './source/simplify-deep';
 export type {Jsonify} from './source/jsonify';
 export type {Jsonifiable} from './source/jsonifiable';
 export type {Schema} from './source/schema';

package/package.json

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

package/readme.md

@@ -173,6 +173,7 @@ Click the type names for complete docs.
 - [`SetReturnType`](source/set-return-type.d.ts) - Create a function type with a return type of your choice and the same parameters as the given function type.
 - [`SetParameterType`](source/set-parameter-type.d.ts) - Create a function that replaces some parameters with the given parameters.
 - [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+- [`SimplifyDeep`](source/simplify-deep.d.ts) - Deeply simplifies an object type.
 - [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 - [`StringKeyOf`](source/string-key-of.d.ts) - Get keys of the given type as strings.
 - [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type.

package/source/is-literal.d.ts

@@ -22,10 +22,12 @@ LiteralCheck<1, string>
 */
 type LiteralCheck<T, LiteralType extends Primitive> = (
 	IsNever<T> extends false // Must be wider than `never`
-		? [T] extends [LiteralType] // Must be narrower than `LiteralType`
-			? [LiteralType] extends [T] // Cannot be wider than `LiteralType`
-				? false
-				: true
+		? [T] extends [LiteralType & infer U] // Remove any branding
+			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
+				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
+					? false
+					: true
+				: false
 			: false
 		: false
 );

package/source/merge-deep.d.ts

@@ -11,11 +11,10 @@ import type {
 } from './internal';
 import type {UnknownRecord} from './unknown-record';
 import type {EnforceOptional} from './enforce-optional';
+import type {SimplifyDeep} from './simplify-deep';
+import type {UnknownArray} from './unknown-array';
 
-/**
-Deeply simplifies an object excluding iterables and functions. Used internally to improve the UX and accept both interfaces and type aliases as inputs.
-*/
-export type SimplifyDeep<Type> = ConditionalSimplifyDeep<Type, Function | Iterable<unknown>, object>;
+type SimplifyDeepExcludeArray<T> = SimplifyDeep<T, UnknownArray>;
 
 /**
 Try to merge two record properties or return the source property value, preserving `undefined` properties values in both cases.
@@ -251,7 +250,7 @@ type MergeDeepArrayRecursive<
 		: DoMergeArrayOrTuple<Destination, Source, Options>
 	: Destination[number] extends UnknownRecord
 		? Source[number] extends UnknownRecord
-			? Array<SimplifyDeep<MergeDeepRecord<Destination[number], Source[number], Options>>>
+			? Array<SimplifyDeepExcludeArray<MergeDeepRecord<Destination[number], Source[number], Options>>>
 			: DoMergeArrayOrTuple<Destination, Source, Options>
 		: DoMergeArrayOrTuple<Destination, Source, Options>;
 
@@ -294,7 +293,7 @@ type MergeDeepOrReturn<
 	Destination,
 	Source,
 	Options extends MergeDeepInternalOptions,
-> = SimplifyDeep<[undefined] extends [Destination | Source]
+> = SimplifyDeepExcludeArray<[undefined] extends [Destination | Source]
 	? DefaultType
 	: Destination extends UnknownRecord
 		? Source extends UnknownRecord
@@ -357,7 +356,7 @@ type DefaultMergeDeepOptions<Options extends MergeDeepOptions> = Merge<{
 /**
 This utility selects the correct entry point with the corresponding default options. This avoids re-merging the options at each iteration.
 */
-type MergeDeepWithDefaultOptions<Destination, Source, Options extends MergeDeepOptions> = SimplifyDeep<
+type MergeDeepWithDefaultOptions<Destination, Source, Options extends MergeDeepOptions> = SimplifyDeepExcludeArray<
 [undefined] extends [Destination | Source]
 	? never
 	: Destination extends UnknownRecord
@@ -481,7 +480,7 @@ function mergeDeep<Destination, Source, Options extends MergeDeepOptions = {}>(
 @category Utilities
 */
 export type MergeDeep<Destination, Source, Options extends MergeDeepOptions = {}> = MergeDeepWithDefaultOptions<
-SimplifyDeep<Destination>,
-SimplifyDeep<Source>,
+SimplifyDeepExcludeArray<Destination>,
+SimplifyDeepExcludeArray<Source>,
 Options
 >;

package/source/omit-deep.d.ts

@@ -3,9 +3,9 @@ import type {ExactKey, IsArrayReadonly, NonRecursiveType, SetArrayAccess, ToStri
 import type {IsEqual} from './is-equal';
 import type {IsNever} from './is-never';
 import type {LiteralUnion} from './literal-union';
-import type {SimplifyDeep} from './merge-deep';
 import type {Paths} from './paths';
 import type {SharedUnionFieldsDeep} from './shared-union-fields-deep';
+import type {SimplifyDeep} from './simplify-deep';
 import type {UnknownArray} from './unknown-array';
 
 /**
@@ -75,8 +75,8 @@ export type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> =
 	SimplifyDeep<
 	SharedUnionFieldsDeep<
 	{[P in PathUnion]: OmitDeepWithOnePath<T, P>}[PathUnion]
-	>
-	>;
+	>,
+	UnknownArray>;
 
 /**
 Omit one path from the given object/array.

package/source/simplify-deep.d.ts

@@ -0,0 +1,115 @@
+import type {ConditionalSimplifyDeep} from './conditional-simplify';
+import type {NonRecursiveType} from './internal';
+
+/**
+Deeply simplifies an object type.
+
+You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.
+
+Useful to flatten the type output to improve type hints shown in editors.
+
+@example
+```
+import type {SimplifyDeep} from 'type-fest';
+
+type PositionX = {
+	left: number;
+	right: number;
+};
+
+type PositionY = {
+	top: number;
+	bottom: number;
+};
+
+type Properties1 = {
+	height: number;
+	position: PositionY;
+};
+
+type Properties2 = {
+	width: number;
+	position: PositionX;
+};
+
+type Properties = Properties1 & Properties2;
+// In your editor, hovering over `Props` will show the following:
+//
+// type Properties = Properties1 & Properties2;
+
+type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
+// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
+//
+// SimplifyDeepProperties = {
+// 	height: number;
+// 	width: number;
+// 	position: {
+// 		top: number;
+// 		bottom: number;
+// 		left: number;
+// 		right: number;
+// 	};
+// };
+```
+
+@example
+```
+import type {SimplifyDeep} from 'type-fest';
+
+// A complex type that you don't want or need to simplify
+type ComplexType = {
+	a: string;
+	b: 'b';
+	c: number;
+	...
+};
+
+type PositionX = {
+	left: number;
+	right: number;
+};
+
+type PositionY = {
+	top: number;
+	bottom: number;
+};
+
+// You want to simplify all other types
+type Properties1 = {
+	height: number;
+	position: PositionY;
+	foo: ComplexType;
+};
+
+type Properties2 = {
+	width: number;
+	position: PositionX;
+	foo: ComplexType;
+};
+
+type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
+// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
+// show a flattened object with all the properties except `ComplexType`:
+//
+// SimplifyDeepProperties = {
+// 	height: number;
+// 	width: number;
+// 	position: {
+// 		top: number;
+// 		bottom: number;
+// 		left: number;
+// 		right: number;
+// 	};
+//	foo: ComplexType;
+// };
+```
+
+@see Simplify
+@category Object
+*/
+export type SimplifyDeep<Type, ExcludeType = never> =
+	ConditionalSimplifyDeep<
+	Type,
+	ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>,
+	object
+	>;

package/source/simplify.d.ts

@@ -52,7 +52,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 ```
 
 @link https://github.com/microsoft/TypeScript/issues/15300
-
+@see SimplifyDeep
 @category Object
 */
 export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};