fix(Exact): support array union

source/exact.d.ts

@@ -1,6 +1,26 @@
-import type {Primitive} from './primitive';
 import type {KeysOfUnion} from './internal';
 
+/**
+Extract the element of an array that also works for array union.
+Return `never` if T is not an array.
+It creates a type-safe way to access the element type of `unknown` type.
+*/
+type ArrayElement<T> = T extends unknown[] ? T[0] : never;
+
+/**
+Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
+It creates a type-safe way to access the member type of `unknown` type.
+*/
+type ObjectValue<T, K> = K extends keyof T ? T[K] : never;
+
+/**
+Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
+- Generate a list of keys that exists in `InputType` but not in `ParameterType`.
+- Mark these excess keys as `never`.
+*/
+type ExactObject<ParameterType, InputType> = {[Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>}
+	& Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+
 /**
 Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.
 
@@ -41,11 +61,8 @@ onlyAcceptNameImproved(invalidInput); // Compilation error
 
 @category Utilities
 */
-export type Exact<ParameterType, InputType extends ParameterType> = ParameterType extends Primitive
-	? ParameterType
-	/*
-	Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
-	- Generate a list of keys that exists in `InputType` but not in `ParameterType`.
-	- Mark these excess keys as `never`.
-	*/
-	: {[Key in keyof ParameterType]: Exact<ParameterType[Key], InputType[Key]>} & Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+export type Exact<ParameterType, InputType> =
+	// Converting union of array to array of union. i.e. A[] & B[] => (A & B)[]
+	ParameterType extends unknown[] ? Array<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+	: ParameterType extends object ? ExactObject<ParameterType, InputType>
+	: ParameterType;

test-d/exact.ts

@@ -143,3 +143,69 @@ import type {Exact} from '../index';
 		fn(input);
 	}
 }
+
+{ // Spec - union of array
+	type Type = Array<{x: string}> & Array<{z: number}>;
+	const fn = <T extends Exact<Type, T>>(args: T) => args;
+
+	{ // It should accept valid input
+		const input = [{
+			x: '',
+			z: 1,
+		}];
+		fn(input);
+	}
+
+	{ // It should reject missing field
+		const input = [{
+			z: 1,
+		}];
+		// @ts-expect-error
+		fn(input);
+	}
+
+	{ // It should reject missing field
+		const input = [{
+			x: '',
+		}];
+		// @ts-expect-error
+		fn(input);
+	}
+
+	{ // It should reject incorrect type
+		const input = [{
+			x: 1,
+			z: 1,
+		}];
+		// @ts-expect-error
+		fn(input);
+	}
+
+	{ // It should reject excess field
+		const input = [{
+			x: '',
+			y: '',
+			z: 1,
+		}];
+		// @ts-expect-error
+		fn(input);
+	}
+}
+
+{ // Spec - union of array with nested fields
+	type Type = Array<{x: string}> & Array<{z: number; d: {e: string}}>;
+	const fn = <T extends Exact<Type, T>>(args: T) => args;
+
+	{ // It should reject excess field
+		const input = [{
+			x: '',
+			z: 1,
+			d: {
+				e: 'test',
+				f: true, // Excess field
+			},
+		}];
+		// @ts-expect-error
+		fn(input);
+	}
+}