SharedUnionFields: Simplify implementation (#1000)

source/shared-union-fields.d.ts

@@ -1,5 +1,6 @@
 import type {NonRecursiveType, IsUnion} from './internal';
 import type {IsNever} from './is-never';
+import type {Simplify} from './simplify';
 import type {UnknownArray} from './unknown-array';
 
 /**
@@ -62,22 +63,13 @@ function displayPetInfo(petInfo: SharedUnionFields<Cat | Dog>) {
 @category Object
 @category Union
 */
-export type SharedUnionFields<Union> =
-// If `Union` is not a union type, return `Union` directly.
-IsUnion<Union> extends false
-	? Union
-	// `Union extends` will convert `Union`
-	// to a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	// But this is not what we want, so we need to wrap `Union` with `[]` to prevent it.
-	: [Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray]
-		? Union
-		: [Union] extends [object]
-			// `keyof Union` can extract the same key in union type, if there is no same key, return never.
-			? keyof Union extends infer Keys
-				? IsNever<Keys> extends false
-					? {
-						[Key in keyof Union]: Union[Key]
-					}
-					: {}
-				: Union
-			: Union;
+type SharedUnionFields<Union> =
+Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+		?
+		| SkippedMembers
+		| (IsNever<RelevantMembers> extends true
+			? never
+			: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
+		: never
+	: never;

test-d/shared-union-fields.ts

@@ -1,5 +1,6 @@
 import {expectType} from 'tsd';
 import type {SharedUnionFields} from '../index';
+import type {NonRecursiveType} from '../source/internal';
 
 type TestingType = {
 	function: (() => void);
@@ -82,3 +83,17 @@ expectType<{union: 'test1' | 'test2' | {a: number}}>(union);
 
 declare const unionWithOptional: SharedUnionFields<{a?: string; foo: number} | {a: string; bar: string}>;
 expectType<{a?: string}>(unionWithOptional);
+
+// Non-recursive types
+expectType<Set<string> | Map<string, string>>({} as Set<string> | Map<string, string>);
+expectType<string[] | Set<string>>({} as string[] | Set<string>);
+expectType<NonRecursiveType>({} as NonRecursiveType);
+
+// Mix of non-recursive and recursive types
+expectType<{a: string | number} | undefined>({} as SharedUnionFields<{a: string} | {a: number; b: true} | undefined>);
+expectType<RegExp | {test: string}>({} as SharedUnionFields<RegExp | {test: string}>);
+expectType<RegExp | null | {test: string | number}>({} as SharedUnionFields<RegExp | null | {test: string} | {test: number; foo: any}>);
+
+// Boundary types
+expectType<any>({} as SharedUnionFields<any>);
+expectType<never>({} as SharedUnionFields<never>);