update: remove SimpleIsEqual, move LastOfUnion to internal, delete unused tests

Author: taiyakihitotsu

index.d.ts

@@ -167,7 +167,6 @@ export type {IsNullable} from './source/is-nullable.d.ts';
 export type {TupleOf} from './source/tuple-of.d.ts';
 export type {ExclusifyUnion} from './source/exclusify-union.d.ts';
 export type {ArrayReverse} from './source/array-reverse.d.ts';
-export type {LastOfUnion} from './source/last-of-union.d.ts';
 
 // Template literal types
 export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';

readme.md

@@ -191,7 +191,6 @@ Click the type names for complete docs.
 - [`ConditionalSimplify`](source/conditional-simplify.d.ts) - Simplifies a type while including and/or excluding certain types from being simplified.
 - [`ConditionalSimplifyDeep`](source/conditional-simplify-deep.d.ts) - Recursively simplifies a type while including and/or excluding certain types from being simplified.
 - [`ExclusifyUnion`](source/exclusify-union.d.ts) - Ensure mutual exclusivity in object unions by adding other members’ keys as `?: never`.
-- [`LastOfUnion`](source/last-of-union.d.ts) - Return a member of a union type. Order is not guaranteed.
 
 ### Type Guard
 

source/exclude-exactly.d.ts

@@ -1,45 +1,30 @@
 import type {IsNever} from './is-never.d.ts';
 import type {IsAny} from './is-any.d.ts';
 import type {If} from './if.d.ts';
-import type {IfNotAnyOrNever, SimpleIsEqual} from './internal/type.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
 
 /**
-A stricter version of `Exclude<T, U>` that ensures objects with different key modifiers are not considered identical.
-
-TypeScript's built-in `Exclude` and `ExcludeStrict` in `type-fest` don't distinguish key modifiers of objects.
-
-@example
-```
-import type {ExcludeStrict} from 'type-fest';
-
-type NeverReturned_0 = Exclude<{a: 0} | {readonly a: 0}, {readonly a: 0}>;
-//=> never
-type NeverReturned_1 = ExcludeStrict<{a: 0} | {readonly a: 0}, {readonly a: 0}>;
-//=> never
-```
+A stricter version of `Exclude<T, U>` that excludes types only when they are exactly identical.
 
 `ExcludeExactly` keeps the union members element if the members are not identical.
 
 @example
 ```
 import type {ExcludeExactly} from 'type-fest';
 
-type ExcludeNever = ExcludeExactly<{a: 0} | {a: 0} | {readonly a: 0}, never>;
-//=> {a: 0} | {a: 0} | {readonly a: 0}
-type ExcludeReadonlyKey = ExcludeExactly<{a: 0} | {readonly a: 0}, {readonly a: 0}>;
-//=> {a: 0}
-type ExcludeKey = ExcludeExactly<{readonly a: 0}, {a: 0}>;
-//=> {readonly a: 0}
-type ExcludeReadonly = ExcludeExactly<{readonly a: 0}, {readonly a: 0}>;
+type TestExclude1 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 1 | 2 | 3
+type TestExcludeExactly1 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+type TestExclude2 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
 //=> never
-type ExcludeSubType = ExcludeExactly<0 | 1 | number, 1>;
-//=> number
-type ExcludeAllSet = ExcludeExactly<0 | 1 | number, number>;
+type TestExcludeExactly2 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+type TestExclude3 = Exclude<{a: string} | {a: string; b: string}, {a: string}>;
 //=> never
-type ExcludeFromUnknown = ExcludeExactly<unknown, string>;
-//=> unknown
-type ExcludeFromUnknownArray = ExcludeExactly<number[] | unknown[], number[]>;
-//=> unknown[]
+type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string; b: string}
 ```
 
 @category Improved Built-in
@@ -58,7 +43,7 @@ type _ExcludeExactly<Union, Delete> =
 	IfNotAnyOrNever<Delete,
 		Union extends unknown // For distributing `Union`
 			? [Delete extends unknown // For distributing `Delete`
-				? If<SimpleIsEqual<Union, Delete>, true, never>
+				? If<IsEqual<Union, Delete>, true, never>
 				: never] extends [never] ? Union : never
 			: never,
 		// If `Delete` is `any` or `never`, then return `Union`,

source/internal/type.d.ts

@@ -3,6 +3,7 @@ import type {IsAny} from '../is-any.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
+import type {UnionToIntersection} from '../union-to-intersection.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -162,27 +163,45 @@ export type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extend
 	: true;
 
 /**
-A simple version of `IsEqual`.
+Return a member of a union type. Order is not guaranteed.
+Returns `never` when the input is `never`.
 
-`SimpleIsEqual<never, unknown>` and `SimpleIsEqual<unknown, never>` return `true`, whereas `IsEqual` returns `false` correctly.
+@see https://github.com/microsoft/TypeScript/issues/13298#issuecomment-468375328
 
-`SimpleIsEqual` doesn't return `false` correctly for identical union/intersection arguments.
+Use-cases:
+- Implementing recursive type functions that accept a union type.
+- Reducing a union one member at a time, for example when building tuples.
+
+It can detect a termination case using {@link IsNever `IsNever`}.
 
 @example
 ```
-type UnionCase = SimpleIsEqual<{a: {b: 0} | {b: 0}}, {a: {b: 0}}>;
-//=> false
+import type {LastOfUnion, ExcludeExactly, IsNever} from 'type-fest';
 
-type IntersectionCase = SimpleIsEqual<{a: {b: 0} & {b: 0}}, {a: {b: 0}}>;
-//=> false
+export type UnionToTuple<T, L = LastOfUnion<T>> =
+	IsNever<T> extends false
+		? [...UnionToTuple<ExcludeExactly<T, L>>, L]
+		: [];
+```
+
+@example
 ```
+import type {LastOfUnion} from 'type-fest';
 
-`SimpleIsEqual` fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/internal/simple-is-equal.ts`.
+type Last = LastOfUnion<1 | 2 | 3>;
+//=> 3
+
+type LastNever = LastOfUnion<never>;
+//=> never
+```
+
+@category Type
 */
-export type SimpleIsEqual<A, B> =
-	(<G>() => G extends A & G | G ? 1 : 2) extends
-	(<G>() => G extends B & G | G ? 1 : 2)
-		? true
-		: false;
+export type LastOfUnion<T> =
+	true extends IsNever<T>
+		? never
+		: UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
+			? R
+			: never;
 
 export {};

source/is-equal.d.ts

@@ -1,5 +1,3 @@
-import type {SimpleIsEqual} from './internal/type.d.ts';
-
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -29,8 +27,14 @@ type Includes<Value extends readonly any[], Item> =
 export type IsEqual<A, B> =
 	[A] extends [B]
 		? [B] extends [A]
-			? SimpleIsEqual<A, B>
+			? _IsEqual<A, B>
 			: false
 		: false;
 
+type _IsEqual<A, B> =
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
+		? true
+		: false;
+
 export {};

source/last-of-union.d.ts

@@ -1,6 +1,6 @@
 import type {IsNever} from './is-never.d.ts';
 import type {ExcludeExactly} from './exclude-exactly.d.ts';
-import type {LastOfUnion} from './last-of-union.d.ts';
+import type {LastOfUnion} from './internal/index.d.ts';
 
 /**
 Convert a union type into an unordered tuple type of its elements.

source/union-to-tuple.d.ts

@@ -1,11 +1,12 @@
 import {expectType} from 'tsd';
-import type {ExcludeExactly} from '../index.d.ts';
+import type {LastOfUnion} from '../source/internal/index.d.ts';
+import type {ExcludeExactly, IsNever} from '../index.d.ts';
 
-expectType<number>({} as ExcludeExactly<0 | 1 | number, '1'>);
-expectType<never>({} as ExcludeExactly<0 | 1 | number, number>);
+expectType<number>({} as ExcludeExactly<number, '1'>);
+expectType<never>({} as ExcludeExactly<number, number>);
 expectType<0>({} as ExcludeExactly<0, number>);
-expectType<string>({} as ExcludeExactly<'0' | '1' | string, '1'>);
-expectType<never>({} as ExcludeExactly<'0' | '1' | string, string>);
+expectType<string>({} as ExcludeExactly<string, '1'>);
+expectType<never>({} as ExcludeExactly<string, string>);
 
 // `{readonly a: t}` should not be equal to `{a: t}` because of assignability.
 expectType<{a: 0}>({} as ExcludeExactly<{a: 0} | {readonly a: 0}, {readonly a: 0}>);

test-d/exclude-exactly.ts

@@ -0,0 +1,22 @@
+import {expectType} from 'tsd';
+import type {LastOfUnion} from '../../source/internal/index.d.ts';
+import type {IsAny, IsUnknown, UnionToTuple} from '../../index.d.ts';
+
+// `LastOfUnion` distinguishes between different modifiers.
+type UnionType = {a: 0} | {b: 0} | {a?: 0} | {readonly a?: 0} | {readonly a: 0};
+expectType<true>({} as LastOfUnion<UnionType> extends UnionType ? true : false);
+expectType<false>({} as UnionType extends LastOfUnion<UnionType> ? true : false);
+
+// `never` acts as a termination condition with `IsNever`.
+expectType<never>({} as LastOfUnion<never>);
+
+expectType<true>({} as IsUnknown<LastOfUnion<unknown>>);
+expectType<true>({} as IsAny<LastOfUnion<any>>);
+
+type DifferentModifierUnion = {readonly a: 0} | {a: 0};
+expectType<DifferentModifierUnion>({} as UnionToTuple<DifferentModifierUnion>[number]);
+expectType<2>({} as UnionToTuple<DifferentModifierUnion>['length']);
+
+type ReversedDifferentModifierUnion = {a: 0} | {readonly a: 0};
+expectType<ReversedDifferentModifierUnion>({} as UnionToTuple<ReversedDifferentModifierUnion>[number]);
+expectType<2>({} as UnionToTuple<ReversedDifferentModifierUnion>['length']);