From ff9a622f755e893337493fb3d8a13c6a7320621f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Tue, 3 Dec 2024 16:35:55 +1300
Subject: [PATCH 1/8] feat: create AllUnionFields type

---
 index.d.ts                      |   1 +
 readme.md                       |   1 +
 source/all-union-fields.d.ts    | 150 ++++++++++++++++
 source/shared-union-fields.d.ts |   1 +
 test-d/all-union-fields.ts      | 307 ++++++++++++++++++++++++++++++++
 5 files changed, 460 insertions(+)
 create mode 100644 source/all-union-fields.d.ts
 create mode 100644 test-d/all-union-fields.ts

diff --git a/index.d.ts b/index.d.ts
index ff20fbd95..627897589 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -128,6 +128,7 @@ export type {ArraySplice} from './source/array-splice';
 export type {ArrayTail} from './source/array-tail';
 export type {SetFieldType} from './source/set-field-type';
 export type {Paths} from './source/paths';
+export type {AllUnionFields} from './source/all-union-fields';
 export type {SharedUnionFields} from './source/shared-union-fields';
 export type {SharedUnionFieldsDeep} from './source/shared-union-fields-deep';
 export type {IsNull} from './source/is-null';
diff --git a/readme.md b/readme.md
index 7bc311371..a5e971368 100644
--- a/readme.md
+++ b/readme.md
@@ -202,6 +202,7 @@ Click the type names for complete docs.
 - [`Paths`](source/paths.d.ts) - Generate a union of all possible paths to properties in the given object.
 - [`SharedUnionFields`](source/shared-union-fields.d.ts) - Create a type with shared fields from a union of object types.
 - [`SharedUnionFieldsDeep`](source/shared-union-fields-deep.d.ts) - Create a type with shared fields from a union of object types, deeply traversing nested structures.
+- [`AllUnionFields`](source/all-union-fields.d.ts) - Create a type with all fields from a union of object types.
 - [`DistributedOmit`](source/distributed-omit.d.ts) - Omits keys from a type, distributing the operation over a union.
 - [`DistributedPick`](source/distributed-pick.d.ts) - Picks keys from a type, distributing the operation over a union.
 - [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both true.
diff --git a/source/all-union-fields.d.ts b/source/all-union-fields.d.ts
new file mode 100644
index 000000000..354685a8c
--- /dev/null
+++ b/source/all-union-fields.d.ts
@@ -0,0 +1,150 @@
+import type {IsUnion, NonRecursiveType} from './internal';
+import type {ReadonlyKeysOf} from './readonly-keys-of';
+import type {SharedUnionFields} from './shared-union-fields';
+import type {Simplify} from './simplify';
+import type {TupleToUnion} from './tuple-to-union';
+import type {UnionToTuple} from './union-to-tuple';
+import type {UnknownArray} from './unknown-array';
+
+/**
+AllUnionFields options.
+
+@see {@link AllUnionFields}
+*/
+export type AllUnionFieldsOptions = {
+	/**
+	When set to true, we assume no properties other than what is declared on each object in the union exist.
+
+	@default false
+ 	*/
+	exact?: boolean;
+};
+
+/**
+Create a type with all fields from a union of object types.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+
+@example
+```
+import type {AllUnionFields} from 'type-fest';
+
+type Cat = {
+	name: string;
+	type: 'cat';
+	catType: string;
+};
+
+type Dog = {
+	name: string;
+	type: 'dog';
+	dogType: string;
+};
+
+function displayPetInfo(petInfo: Cat | Dog) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat';
+	// 	catType: string;
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string;
+	// }
+
+	console.log('name: ', petInfo.name);
+	console.log('type: ', petInfo.type);
+
+	// TypeScript complains about `catType` and `dogType` not existing on type `Cat | Dog`.
+	console.log('animal type: ', petInfo.catType ?? petInfo.dogType);
+}
+
+function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	//  catType?: unknown;
+	//  dogType?: unknown;
+	// }
+
+	console.log('name: ', petInfo.name);
+	console.log('type: ', petInfo.type);
+
+	// No TypeScript error.
+	console.log('animal type: ', petInfo.catType ?? petInfo.dogType);
+}
+```
+
+@see SharedUnionFields
+
+@category Object
+@category Union
+*/
+export type AllUnionFields<
+	Union,
+	Options extends AllUnionFieldsOptions = {exact: false},
+> =
+	// 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]
+				? Simplify<
+				SharedUnionFields<Union> &
+				NonSharedUnionFields<UnionToTuple<Union>, keyof Union, Options>
+				>
+				: Union;
+
+type NonSharedUnionFields<
+	Tuple,
+	SharedKeys,
+	Options extends AllUnionFieldsOptions,
+> = NonSharedUnionFieldsHelper<
+Tuple,
+Exclude<KeysOfEach<Tuple>, ReadonlyKeysOfEach<Tuple> | SharedKeys>,
+Exclude<ReadonlyKeysOfEach<Tuple>, SharedKeys>,
+Options
+>;
+
+type NonSharedUnionFieldsHelper<
+	Tuple,
+	NonReadonlyKeys extends PropertyKey,
+	ReadonlyKeys extends PropertyKey,
+	Options extends AllUnionFieldsOptions,
+> = {
+	[Key in NonReadonlyKeys]?: ValueOfEach<Tuple, Key, Options>;
+} & {
+	readonly [Key in ReadonlyKeys]?: ValueOfEach<Tuple, Key, Options>;
+};
+
+type KeysOfEach<Tuple> = TupleToUnion<{
+	[Index in keyof Tuple]: keyof Tuple[Index];
+}>;
+
+type ReadonlyKeysOfEach<Tuple> = TupleToUnion<{
+	[Index in keyof Tuple]: ReadonlyKeysOf<Tuple[Index]>;
+}>;
+
+type ValueOfEach<
+	Tuple,
+	Key,
+	Options extends AllUnionFieldsOptions,
+> = Options['exact'] extends true
+	? TupleToUnion<{
+		[Index in keyof Tuple]: Key extends keyof Tuple[Index]
+			? Tuple[Index][Key]
+			: never;
+	}>
+	: unknown;
diff --git a/source/shared-union-fields.d.ts b/source/shared-union-fields.d.ts
index 506f3696a..339a39389 100644
--- a/source/shared-union-fields.d.ts
+++ b/source/shared-union-fields.d.ts
@@ -59,6 +59,7 @@ function displayPetInfo(petInfo: SharedUnionFields<Cat | Dog>) {
 ```
 
 @see SharedUnionFieldsDeep
+@see AllUnionFields
 
 @category Object
 @category Union
diff --git a/test-d/all-union-fields.ts b/test-d/all-union-fields.ts
new file mode 100644
index 000000000..fb2ee1722
--- /dev/null
+++ b/test-d/all-union-fields.ts
@@ -0,0 +1,307 @@
+import {expectType} from 'tsd';
+import {type AllUnionFields, type Simplify} from '../index';
+
+type TestingType = {
+	function: () => void;
+	record: Record<
+	string,
+	{
+		propertyA: string;
+	}
+	>;
+	object: {
+		subObject: {
+			subSubObject: {
+				propertyA: string;
+			};
+		};
+	};
+	string: string;
+	union: 'test1' | 'test2';
+	number: number;
+	boolean: boolean;
+	date: Date;
+	regexp: RegExp;
+	symbol: symbol;
+	null: null;
+	undefined: undefined;
+	optional?: boolean | undefined;
+	readonly propertyWithKeyword: boolean;
+	map: Map<string, {propertyA: string; propertyB: string}>;
+	set: Set<string>;
+	objectSet: Set<{propertyA: string; propertyB: string}>;
+};
+
+type AllUnionFieldsExact<T> = AllUnionFields<T, {exact: true}>;
+
+declare const normal: AllUnionFields<
+TestingType | {string: string; number: number; foo: any}
+>;
+expectType<Simplify<
+{
+	string: string;
+	number: number;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'string' | 'number'>
+>>(normal);
+
+declare const normalExact: AllUnionFieldsExact<
+TestingType | {string: string; number: number; foo: any}
+>;
+expectType<Simplify<
+{
+	string: string;
+	number: number;
+	foo?: any;
+} & Partial<Omit<TestingType, 'string' | 'number'>>
+>>(normalExact);
+
+declare const unMatched: AllUnionFields<TestingType | {foo: any}>;
+expectType<Simplify<
+{
+	foo?: unknown;
+} & {[Key in keyof TestingType]?: unknown;}
+>>(unMatched);
+
+declare const unMatchedExact: AllUnionFieldsExact<TestingType | {foo: any}>;
+expectType<Simplify<
+{
+	foo?: any;
+} & Partial<TestingType>
+>>(unMatchedExact);
+
+declare const number: AllUnionFields<TestingType | {number: number; foo: any}>;
+expectType<Simplify<{
+	number: number;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'number'>
+>>(number);
+
+declare const numberExact: AllUnionFieldsExact<TestingType | {number: number; foo: any}>;
+expectType<Simplify<{
+	number: number;
+	foo?: any;
+} & Partial<Omit<TestingType, 'number'>>
+>>(numberExact);
+
+declare const string: AllUnionFields<TestingType | {string: string; foo: any}>;
+expectType<Simplify<{
+	string: string;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'string'>
+>>(string);
+
+declare const stringExact: AllUnionFieldsExact<TestingType | {string: string; foo: any}>;
+expectType<Simplify<{
+	string: string;
+	foo?: any;
+} & Partial<Omit<TestingType, 'string'>>
+>>(stringExact);
+
+declare const boolean: AllUnionFields<TestingType | {boolean: boolean; foo: any}>;
+expectType<Simplify<{
+	boolean: boolean;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'boolean'>
+>>(boolean);
+
+declare const booleanExact: AllUnionFieldsExact<TestingType | {boolean: boolean; foo: any}>;
+expectType<Simplify<{
+	boolean: boolean;
+	foo?: any;
+} & Partial<Omit<TestingType, 'boolean'>>
+>>(booleanExact);
+
+declare const date: AllUnionFields<TestingType | {date: Date; foo: any}>;
+expectType<Simplify<{
+	date: Date;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'date'>
+>>(date);
+
+declare const dateExact: AllUnionFieldsExact<TestingType | {date: Date; foo: any}>;
+expectType<Simplify<{
+	date: Date;
+	foo?: any;
+} & Partial<Omit<TestingType, 'date'>>
+>>(dateExact);
+
+declare const regexp: AllUnionFields<TestingType | {regexp: RegExp; foo: any}>;
+expectType<Simplify<{
+	regexp: RegExp;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'regexp'>
+>>(regexp);
+
+declare const regexpExact: AllUnionFieldsExact<TestingType | {regexp: RegExp; foo: any}>;
+expectType<Simplify<{
+	regexp: RegExp;
+	foo?: any;
+} & Partial<Omit<TestingType, 'regexp'>>
+>>(regexpExact);
+
+declare const symbol: AllUnionFields<TestingType | {symbol: symbol; foo: any}>;
+expectType<Simplify<{
+	symbol: symbol;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'symbol'>
+>>(symbol);
+
+declare const symbolExact: AllUnionFieldsExact<TestingType | {symbol: symbol; foo: any}>;
+expectType<Simplify<{
+	symbol: symbol;
+	foo?: any;
+} & Partial<Omit<TestingType, 'symbol'>>
+>>(symbolExact);
+
+declare const null_: AllUnionFields<TestingType | {null: null; foo: any}>;
+expectType<Simplify<{
+	null: null;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'null'>
+>>(null_);
+
+declare const nullExact: AllUnionFieldsExact<TestingType | {null: null; foo: any}>;
+expectType<Simplify<{
+	null: null;
+	foo?: any;
+} & Partial<Omit<TestingType, 'null'>>
+>>(nullExact);
+
+declare const undefined_: AllUnionFields<TestingType | {undefined: undefined; foo: any}>;
+expectType<Simplify<{
+	undefined: undefined;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'undefined'>
+>>(undefined_);
+
+declare const undefinedExact: AllUnionFieldsExact<TestingType | {undefined: undefined; foo: any}>;
+expectType<Simplify<{
+	undefined: undefined;
+	foo?: any;
+} & Partial<Omit<TestingType, 'undefined'>>
+>>(undefinedExact);
+
+declare const optional: AllUnionFields<TestingType | {optional: string; foo: any}>;
+expectType<Simplify<{
+	optional?: string | boolean | undefined;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'optional'>
+>>(optional);
+
+declare const optionalExact: AllUnionFieldsExact<TestingType | {optional: string; foo: any}>;
+expectType<Simplify<{
+	optional?: string | boolean | undefined;
+	foo?: any;
+} & Partial<Omit<TestingType, 'optional'>>
+>>(optionalExact);
+
+declare const propertyWithKeyword: AllUnionFields<TestingType | {readonly propertyWithKeyword: string; foo: any}>;
+expectType<Simplify<{
+	readonly propertyWithKeyword: boolean | string;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'propertyWithKeyword'>
+>>(propertyWithKeyword);
+
+declare const propertyWithKeywordExact: AllUnionFieldsExact<TestingType | {readonly propertyWithKeyword: string; foo: any}>;
+expectType<Simplify<{
+	readonly propertyWithKeyword: boolean | string;
+	foo?: any;
+} & Partial<Omit<TestingType, 'propertyWithKeyword'>>
+>>(propertyWithKeywordExact);
+
+declare const map: AllUnionFields<TestingType | {map: Map<string, {propertyA: string}>; foo: any}>;
+expectType<Simplify<{
+	map: TestingType['map'] | Map<string, {propertyA: string}>;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'map'>
+>>(map);
+
+declare const mapExact: AllUnionFieldsExact<TestingType | {map: Map<string, {propertyA: string}>; foo: any}>;
+expectType<Simplify<{
+	map: TestingType['map'] | Map<string, {propertyA: string}>;
+	foo?: any;
+} & Partial<Omit<TestingType, 'map'>>
+>>(mapExact);
+
+declare const set: AllUnionFields<TestingType | {set: Set<number>; foo: any}>;
+expectType<Simplify<{
+	set: TestingType['set'] | Set<number>;
+	foo?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'set'>
+>>(set);
+
+declare const setExact: AllUnionFieldsExact<TestingType | {set: Set<number>; foo: any}>;
+expectType<Simplify<{
+	set: TestingType['set'] | Set<number>;
+	foo?: any;
+} & Partial<Omit<TestingType, 'set'>>
+>>(setExact);
+
+declare const moreUnion: AllUnionFields<TestingType | {string: string; number: number; foo: any} | {string: string; bar: any}>;
+expectType<Simplify<{
+	string: string;
+	foo?: unknown;
+	bar?: unknown;
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'string'>
+>>(moreUnion);
+
+declare const moreUnionExact: AllUnionFieldsExact<TestingType | {string: string; number: number; foo: any} | {string: string; bar: any}>;
+expectType<Simplify<{
+	string: string;
+	foo?: any;
+	bar?: any;
+} & Partial<Omit<TestingType, 'string'>>
+>>(moreUnionExact);
+
+declare const union: AllUnionFields<TestingType | {union: {a: number}}>;
+expectType<Simplify<{
+	union: 'test1' | 'test2' | {a: number};
+} & Omit<{[Key in keyof TestingType]?: unknown;}, 'union'>
+>>(union);
+
+declare const unionExact: AllUnionFieldsExact<TestingType | {union: {a: number}}>;
+expectType<Simplify<{
+	union: 'test1' | 'test2' | {a: number};
+} & Partial<Omit<TestingType, 'union'>>
+>>(unionExact);
+
+declare const unionWithOptional: AllUnionFields<{a?: string; foo: number} | {a: string; bar: string}>;
+expectType<{
+	a?: string;
+	foo?: unknown;
+	bar?: unknown;
+}>(unionWithOptional);
+
+declare const unionWithOptionalExact: AllUnionFieldsExact<{a?: string; foo: number} | {a: string; bar: string}>;
+expectType<{
+	a?: string;
+	foo?: number;
+	bar?: string;
+}>(unionWithOptionalExact);
+
+declare const mixedKeywords: AllUnionFields<{readonly a: string; b: number} | {a: string; readonly b: string}>;
+expectType<{
+	readonly a: string;
+	readonly b: string | number;
+}>(mixedKeywords);
+
+declare const mixedKeywordsExact: AllUnionFieldsExact<{readonly a: string; b: number} | {a: string; readonly b: string}>;
+expectType<{
+	readonly a: string;
+	readonly b: string | number;
+}>(mixedKeywordsExact);
+
+declare const mixedKeywords2: AllUnionFields<{readonly a: string; b: number} | {a: string; readonly b: string} | {readonly c: number}>;
+expectType<{
+	readonly a?: unknown;
+	readonly b?: unknown;
+	readonly c?: unknown;
+}>(mixedKeywords2);
+
+declare const mixedKeywords2Exact: AllUnionFieldsExact<{readonly a: string; b: number} | {a: string; readonly b: string} | {readonly c: number}>;
+expectType<{
+	readonly a?: string;
+	readonly b?: string | number;
+	readonly c?: number;
+}>(mixedKeywords2Exact);

From b7dda36bffa9ec82da75caf3e1a72d77f1369be3 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Wed, 4 Dec 2024 14:37:31 +1300
Subject: [PATCH 2/8] fix: remove `exact` option and just make that how it
 works

---
 source/all-union-fields.d.ts |  47 +++-------
 test-d/all-union-fields.ts   | 174 ++++-------------------------------
 2 files changed, 30 insertions(+), 191 deletions(-)

diff --git a/source/all-union-fields.d.ts b/source/all-union-fields.d.ts
index 354685a8c..6a854ca8a 100644
--- a/source/all-union-fields.d.ts
+++ b/source/all-union-fields.d.ts
@@ -6,20 +6,6 @@ import type {TupleToUnion} from './tuple-to-union';
 import type {UnionToTuple} from './union-to-tuple';
 import type {UnknownArray} from './unknown-array';
 
-/**
-AllUnionFields options.
-
-@see {@link AllUnionFields}
-*/
-export type AllUnionFieldsOptions = {
-	/**
-	When set to true, we assume no properties other than what is declared on each object in the union exist.
-
-	@default false
- 	*/
-	exact?: boolean;
-};
-
 /**
 Create a type with all fields from a union of object types.
 
@@ -66,8 +52,8 @@ function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
 	// {
 	// 	name: string;
 	// 	type: 'cat' | 'dog';
-	//  catType?: unknown;
-	//  dogType?: unknown;
+	//  catType?: string;
+	//  dogType?: string;
 	// }
 
 	console.log('name: ', petInfo.name);
@@ -83,10 +69,7 @@ function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
 @category Object
 @category Union
 */
-export type AllUnionFields<
-	Union,
-	Options extends AllUnionFieldsOptions = {exact: false},
-> =
+export type AllUnionFields<Union> =
 	// If `Union` is not a union type, return `Union` directly.
 	IsUnion<Union> extends false
 		? Union
@@ -103,30 +86,27 @@ export type AllUnionFields<
 			: [Union] extends [object]
 				? Simplify<
 				SharedUnionFields<Union> &
-				NonSharedUnionFields<UnionToTuple<Union>, keyof Union, Options>
+				NonSharedUnionFields<UnionToTuple<Union>, keyof Union>
 				>
 				: Union;
 
 type NonSharedUnionFields<
 	Tuple,
 	SharedKeys,
-	Options extends AllUnionFieldsOptions,
 > = NonSharedUnionFieldsHelper<
 Tuple,
 Exclude<KeysOfEach<Tuple>, ReadonlyKeysOfEach<Tuple> | SharedKeys>,
-Exclude<ReadonlyKeysOfEach<Tuple>, SharedKeys>,
-Options
+Exclude<ReadonlyKeysOfEach<Tuple>, SharedKeys>
 >;
 
 type NonSharedUnionFieldsHelper<
 	Tuple,
 	NonReadonlyKeys extends PropertyKey,
 	ReadonlyKeys extends PropertyKey,
-	Options extends AllUnionFieldsOptions,
 > = {
-	[Key in NonReadonlyKeys]?: ValueOfEach<Tuple, Key, Options>;
+	[Key in NonReadonlyKeys]?: ValueOfEach<Tuple, Key>;
 } & {
-	readonly [Key in ReadonlyKeys]?: ValueOfEach<Tuple, Key, Options>;
+	readonly [Key in ReadonlyKeys]?: ValueOfEach<Tuple, Key>;
 };
 
 type KeysOfEach<Tuple> = TupleToUnion<{
@@ -140,11 +120,8 @@ type ReadonlyKeysOfEach<Tuple> = TupleToUnion<{
 type ValueOfEach<
 	Tuple,
 	Key,
-	Options extends AllUnionFieldsOptions,
-> = Options['exact'] extends true
-	? TupleToUnion<{
-		[Index in keyof Tuple]: Key extends keyof Tuple[Index]
-			? Tuple[Index][Key]
-			: never;
-	}>
-	: unknown;
+> = TupleToUnion<{
+	[Index in keyof Tuple]: Key extends keyof Tuple[Index]
+		? Tuple[Index][Key]
+		: never;
+}>;
diff --git a/test-d/all-union-fields.ts b/test-d/all-union-fields.ts
index fb2ee1722..8d561db10 100644
--- a/test-d/all-union-fields.ts
+++ b/test-d/all-union-fields.ts
@@ -32,253 +32,128 @@ type TestingType = {
 	objectSet: Set<{propertyA: string; propertyB: string}>;
 };
 
-type AllUnionFieldsExact<T> = AllUnionFields<T, {exact: true}>;
-
 declare const normal: AllUnionFields<
 TestingType | {string: string; number: number; foo: any}
 >;
 expectType<Simplify<
-{
-	string: string;
-	number: number;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'string' | 'number'>
->>(normal);
-
-declare const normalExact: AllUnionFieldsExact<
-TestingType | {string: string; number: number; foo: any}
->;
-expectType<Simplify<
 {
 	string: string;
 	number: number;
 	foo?: any;
 } & Partial<Omit<TestingType, 'string' | 'number'>>
->>(normalExact);
+>>(normal);
 
 declare const unMatched: AllUnionFields<TestingType | {foo: any}>;
 expectType<Simplify<
-{
-	foo?: unknown;
-} & {[Key in keyof TestingType]?: unknown;}
->>(unMatched);
-
-declare const unMatchedExact: AllUnionFieldsExact<TestingType | {foo: any}>;
-expectType<Simplify<
 {
 	foo?: any;
 } & Partial<TestingType>
->>(unMatchedExact);
+>>(unMatched);
 
 declare const number: AllUnionFields<TestingType | {number: number; foo: any}>;
-expectType<Simplify<{
-	number: number;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'number'>
->>(number);
-
-declare const numberExact: AllUnionFieldsExact<TestingType | {number: number; foo: any}>;
 expectType<Simplify<{
 	number: number;
 	foo?: any;
 } & Partial<Omit<TestingType, 'number'>>
->>(numberExact);
+>>(number);
 
 declare const string: AllUnionFields<TestingType | {string: string; foo: any}>;
-expectType<Simplify<{
-	string: string;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'string'>
->>(string);
-
-declare const stringExact: AllUnionFieldsExact<TestingType | {string: string; foo: any}>;
 expectType<Simplify<{
 	string: string;
 	foo?: any;
 } & Partial<Omit<TestingType, 'string'>>
->>(stringExact);
+>>(string);
 
 declare const boolean: AllUnionFields<TestingType | {boolean: boolean; foo: any}>;
-expectType<Simplify<{
-	boolean: boolean;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'boolean'>
->>(boolean);
-
-declare const booleanExact: AllUnionFieldsExact<TestingType | {boolean: boolean; foo: any}>;
 expectType<Simplify<{
 	boolean: boolean;
 	foo?: any;
 } & Partial<Omit<TestingType, 'boolean'>>
->>(booleanExact);
+>>(boolean);
 
 declare const date: AllUnionFields<TestingType | {date: Date; foo: any}>;
-expectType<Simplify<{
-	date: Date;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'date'>
->>(date);
-
-declare const dateExact: AllUnionFieldsExact<TestingType | {date: Date; foo: any}>;
 expectType<Simplify<{
 	date: Date;
 	foo?: any;
 } & Partial<Omit<TestingType, 'date'>>
->>(dateExact);
+>>(date);
 
 declare const regexp: AllUnionFields<TestingType | {regexp: RegExp; foo: any}>;
-expectType<Simplify<{
-	regexp: RegExp;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'regexp'>
->>(regexp);
-
-declare const regexpExact: AllUnionFieldsExact<TestingType | {regexp: RegExp; foo: any}>;
 expectType<Simplify<{
 	regexp: RegExp;
 	foo?: any;
 } & Partial<Omit<TestingType, 'regexp'>>
->>(regexpExact);
+>>(regexp);
 
 declare const symbol: AllUnionFields<TestingType | {symbol: symbol; foo: any}>;
-expectType<Simplify<{
-	symbol: symbol;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'symbol'>
->>(symbol);
-
-declare const symbolExact: AllUnionFieldsExact<TestingType | {symbol: symbol; foo: any}>;
 expectType<Simplify<{
 	symbol: symbol;
 	foo?: any;
 } & Partial<Omit<TestingType, 'symbol'>>
->>(symbolExact);
+>>(symbol);
 
 declare const null_: AllUnionFields<TestingType | {null: null; foo: any}>;
-expectType<Simplify<{
-	null: null;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'null'>
->>(null_);
-
-declare const nullExact: AllUnionFieldsExact<TestingType | {null: null; foo: any}>;
 expectType<Simplify<{
 	null: null;
 	foo?: any;
 } & Partial<Omit<TestingType, 'null'>>
->>(nullExact);
+>>(null_);
 
 declare const undefined_: AllUnionFields<TestingType | {undefined: undefined; foo: any}>;
-expectType<Simplify<{
-	undefined: undefined;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'undefined'>
->>(undefined_);
-
-declare const undefinedExact: AllUnionFieldsExact<TestingType | {undefined: undefined; foo: any}>;
 expectType<Simplify<{
 	undefined: undefined;
 	foo?: any;
 } & Partial<Omit<TestingType, 'undefined'>>
->>(undefinedExact);
+>>(undefined_);
 
 declare const optional: AllUnionFields<TestingType | {optional: string; foo: any}>;
-expectType<Simplify<{
-	optional?: string | boolean | undefined;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'optional'>
->>(optional);
-
-declare const optionalExact: AllUnionFieldsExact<TestingType | {optional: string; foo: any}>;
 expectType<Simplify<{
 	optional?: string | boolean | undefined;
 	foo?: any;
 } & Partial<Omit<TestingType, 'optional'>>
->>(optionalExact);
+>>(optional);
 
 declare const propertyWithKeyword: AllUnionFields<TestingType | {readonly propertyWithKeyword: string; foo: any}>;
-expectType<Simplify<{
-	readonly propertyWithKeyword: boolean | string;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'propertyWithKeyword'>
->>(propertyWithKeyword);
-
-declare const propertyWithKeywordExact: AllUnionFieldsExact<TestingType | {readonly propertyWithKeyword: string; foo: any}>;
 expectType<Simplify<{
 	readonly propertyWithKeyword: boolean | string;
 	foo?: any;
 } & Partial<Omit<TestingType, 'propertyWithKeyword'>>
->>(propertyWithKeywordExact);
+>>(propertyWithKeyword);
 
 declare const map: AllUnionFields<TestingType | {map: Map<string, {propertyA: string}>; foo: any}>;
-expectType<Simplify<{
-	map: TestingType['map'] | Map<string, {propertyA: string}>;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'map'>
->>(map);
-
-declare const mapExact: AllUnionFieldsExact<TestingType | {map: Map<string, {propertyA: string}>; foo: any}>;
 expectType<Simplify<{
 	map: TestingType['map'] | Map<string, {propertyA: string}>;
 	foo?: any;
 } & Partial<Omit<TestingType, 'map'>>
->>(mapExact);
+>>(map);
 
 declare const set: AllUnionFields<TestingType | {set: Set<number>; foo: any}>;
-expectType<Simplify<{
-	set: TestingType['set'] | Set<number>;
-	foo?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'set'>
->>(set);
-
-declare const setExact: AllUnionFieldsExact<TestingType | {set: Set<number>; foo: any}>;
 expectType<Simplify<{
 	set: TestingType['set'] | Set<number>;
 	foo?: any;
 } & Partial<Omit<TestingType, 'set'>>
->>(setExact);
+>>(set);
 
 declare const moreUnion: AllUnionFields<TestingType | {string: string; number: number; foo: any} | {string: string; bar: any}>;
-expectType<Simplify<{
-	string: string;
-	foo?: unknown;
-	bar?: unknown;
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'string'>
->>(moreUnion);
-
-declare const moreUnionExact: AllUnionFieldsExact<TestingType | {string: string; number: number; foo: any} | {string: string; bar: any}>;
 expectType<Simplify<{
 	string: string;
 	foo?: any;
 	bar?: any;
 } & Partial<Omit<TestingType, 'string'>>
->>(moreUnionExact);
+>>(moreUnion);
 
 declare const union: AllUnionFields<TestingType | {union: {a: number}}>;
-expectType<Simplify<{
-	union: 'test1' | 'test2' | {a: number};
-} & Omit<{[Key in keyof TestingType]?: unknown;}, 'union'>
->>(union);
-
-declare const unionExact: AllUnionFieldsExact<TestingType | {union: {a: number}}>;
 expectType<Simplify<{
 	union: 'test1' | 'test2' | {a: number};
 } & Partial<Omit<TestingType, 'union'>>
->>(unionExact);
+>>(union);
 
 declare const unionWithOptional: AllUnionFields<{a?: string; foo: number} | {a: string; bar: string}>;
-expectType<{
-	a?: string;
-	foo?: unknown;
-	bar?: unknown;
-}>(unionWithOptional);
-
-declare const unionWithOptionalExact: AllUnionFieldsExact<{a?: string; foo: number} | {a: string; bar: string}>;
 expectType<{
 	a?: string;
 	foo?: number;
 	bar?: string;
-}>(unionWithOptionalExact);
+}>(unionWithOptional);
 
 declare const mixedKeywords: AllUnionFields<{readonly a: string; b: number} | {a: string; readonly b: string}>;
 expectType<{
@@ -286,22 +161,9 @@ expectType<{
 	readonly b: string | number;
 }>(mixedKeywords);
 
-declare const mixedKeywordsExact: AllUnionFieldsExact<{readonly a: string; b: number} | {a: string; readonly b: string}>;
-expectType<{
-	readonly a: string;
-	readonly b: string | number;
-}>(mixedKeywordsExact);
-
 declare const mixedKeywords2: AllUnionFields<{readonly a: string; b: number} | {a: string; readonly b: string} | {readonly c: number}>;
-expectType<{
-	readonly a?: unknown;
-	readonly b?: unknown;
-	readonly c?: unknown;
-}>(mixedKeywords2);
-
-declare const mixedKeywords2Exact: AllUnionFieldsExact<{readonly a: string; b: number} | {a: string; readonly b: string} | {readonly c: number}>;
 expectType<{
 	readonly a?: string;
 	readonly b?: string | number;
 	readonly c?: number;
-}>(mixedKeywords2Exact);
+}>(mixedKeywords2);

From a157e8b32799730773a6010282edaf178adebb3d Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Sun, 15 Dec 2024 16:19:42 +1300
Subject: [PATCH 3/8] refactor: AllUnionFields

---
 source/all-union-fields.d.ts | 79 +++++++++---------------------------
 1 file changed, 19 insertions(+), 60 deletions(-)

diff --git a/source/all-union-fields.d.ts b/source/all-union-fields.d.ts
index 6a854ca8a..9415d6b60 100644
--- a/source/all-union-fields.d.ts
+++ b/source/all-union-fields.d.ts
@@ -1,9 +1,8 @@
-import type {IsUnion, NonRecursiveType} from './internal';
-import type {ReadonlyKeysOf} from './readonly-keys-of';
+import type {NonRecursiveType} from './internal';
+import type {IsEqual} from './is-equal';
+import type {KeysOfUnion} from './keys-of-union';
 import type {SharedUnionFields} from './shared-union-fields';
 import type {Simplify} from './simplify';
-import type {TupleToUnion} from './tuple-to-union';
-import type {UnionToTuple} from './union-to-tuple';
 import type {UnknownArray} from './unknown-array';
 
 /**
@@ -69,59 +68,19 @@ function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
 @category Object
 @category Union
 */
-export type AllUnionFields<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]
-				? Simplify<
-				SharedUnionFields<Union> &
-				NonSharedUnionFields<UnionToTuple<Union>, keyof Union>
-				>
-				: Union;
-
-type NonSharedUnionFields<
-	Tuple,
-	SharedKeys,
-> = NonSharedUnionFieldsHelper<
-Tuple,
-Exclude<KeysOfEach<Tuple>, ReadonlyKeysOfEach<Tuple> | SharedKeys>,
-Exclude<ReadonlyKeysOfEach<Tuple>, SharedKeys>
->;
-
-type NonSharedUnionFieldsHelper<
-	Tuple,
-	NonReadonlyKeys extends PropertyKey,
-	ReadonlyKeys extends PropertyKey,
-> = {
-	[Key in NonReadonlyKeys]?: ValueOfEach<Tuple, Key>;
-} & {
-	readonly [Key in ReadonlyKeys]?: ValueOfEach<Tuple, Key>;
-};
-
-type KeysOfEach<Tuple> = TupleToUnion<{
-	[Index in keyof Tuple]: keyof Tuple[Index];
-}>;
-
-type ReadonlyKeysOfEach<Tuple> = TupleToUnion<{
-	[Index in keyof Tuple]: ReadonlyKeysOf<Tuple[Index]>;
-}>;
-
-type ValueOfEach<
-	Tuple,
-	Key,
-> = TupleToUnion<{
-	[Index in keyof Tuple]: Key extends keyof Tuple[Index]
-		? Tuple[Index][Key]
-		: never;
-}>;
+export type AllUnionFields<Union> = [Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray]
+	? Union
+	: Simplify<
+	SharedUnionFields<Union> &
+	{
+		readonly [P in ReadonlyKeysOfUnion<Union>]?: ValueOfUnion<Union, P>;
+	} & {
+		[P in Exclude<KeysOfUnion<Union>, ReadonlyKeysOfUnion<Union> | keyof Union>]?: ValueOfUnion<Union, P>;
+	}
+	>;
+
+type ValueOfUnion<Union, Key> = Union extends unknown ? Key extends keyof Union ? Union[Key] : never : never;
+
+type ReadonlyKeysOfUnion<T> = T extends unknown ? keyof {
+	[P in keyof T as IsEqual<{[Q in P]: T[P]}, {readonly [Q in P]: T[P]}> extends true ? P : never]: never
+} : never;

From b3b010b2c35ab70abc88d94f7089e3a99c04ccc2 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Sun, 15 Dec 2024 17:01:45 +1300
Subject: [PATCH 4/8] style: linting fix

---
 test-d/all-union-fields.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/all-union-fields.ts b/test-d/all-union-fields.ts
index 8d561db10..fee71bdd1 100644
--- a/test-d/all-union-fields.ts
+++ b/test-d/all-union-fields.ts
@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import {type AllUnionFields, type Simplify} from '../index';
+import type {AllUnionFields, Simplify} from '../index';
 
 type TestingType = {
 	function: () => void;

From 0a57aa21f3ad942683e87418a0d0a6d5d81f41e1 Mon Sep 17 00:00:00 2001
From: Som Shekhar Mukherjee <iamssmkhrj@gmail.com>
Date: Sat, 28 Dec 2024 12:54:43 +0530
Subject: [PATCH 5/8] doc: move types to internal and add doc

---
 source/all-union-fields.d.ts |  9 +--------
 source/internal/object.d.ts  | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/source/all-union-fields.d.ts b/source/all-union-fields.d.ts
index 9415d6b60..d366c79c7 100644
--- a/source/all-union-fields.d.ts
+++ b/source/all-union-fields.d.ts
@@ -1,5 +1,4 @@
-import type {NonRecursiveType} from './internal';
-import type {IsEqual} from './is-equal';
+import type {NonRecursiveType, ReadonlyKeysOfUnion, ValueOfUnion} from './internal';
 import type {KeysOfUnion} from './keys-of-union';
 import type {SharedUnionFields} from './shared-union-fields';
 import type {Simplify} from './simplify';
@@ -78,9 +77,3 @@ export type AllUnionFields<Union> = [Union] extends [NonRecursiveType | Readonly
 		[P in Exclude<KeysOfUnion<Union>, ReadonlyKeysOfUnion<Union> | keyof Union>]?: ValueOfUnion<Union, P>;
 	}
 	>;
-
-type ValueOfUnion<Union, Key> = Union extends unknown ? Key extends keyof Union ? Union[Key] : never : never;
-
-type ReadonlyKeysOfUnion<T> = T extends unknown ? keyof {
-	[P in keyof T as IsEqual<{[Q in P]: T[P]}, {readonly [Q in P]: T[P]}> extends true ? P : never]: never
-} : never;
diff --git a/source/internal/object.d.ts b/source/internal/object.d.ts
index bbd63a411..8f99a79d6 100644
--- a/source/internal/object.d.ts
+++ b/source/internal/object.d.ts
@@ -1,5 +1,6 @@
 import type {Simplify} from '../simplify';
 import type {UnknownArray} from '../unknown-array';
+import type {IsEqual} from '../is-equal';
 import type {KeysOfUnion} from '../keys-of-union';
 import type {FilterDefinedKeys, FilterOptionalKeys} from './keys';
 import type {NonRecursiveType} from './type';
@@ -122,3 +123,36 @@ type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 export type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
 	[P in keyof T as Extract<P, Keys>]: T[P]
 };
+
+/**
+Extract all possible values for a given key from a union of object types.
+
+@example
+
+type Statuses = ValueOfUnion<{ id: 1, status: "open" } | { id: 2, status: "closed" }, "status">;
+//=> "open" | "closed"
+*/
+export type ValueOfUnion<Union, Key extends KeysOfUnion<Union>> =
+	Union extends unknown ? Key extends keyof Union ? Union[Key] : never : never;
+
+/**
+Extract all readonly keys from a union of object types.
+
+@example
+type User = {
+		readonly id: string;
+		name: string;
+};
+
+type Post = {
+		readonly id: string;
+		readonly author: string;
+		body: string;
+};
+
+type ReadonlyKeys = ReadonlyKeysOfUnion<User | Post>;
+//=> "id" | "author"
+*/
+export type ReadonlyKeysOfUnion<Union> = Union extends unknown ? keyof {
+	[Key in keyof Union as IsEqual<{[K in Key]: Union[Key]}, {readonly [K in Key]: Union[Key]}> extends true ? Key : never]: never
+} : never;

From 5537126da5c05420e0aff94680997245a97c4a50 Mon Sep 17 00:00:00 2001
From: Som Shekhar Mukherjee <iamssmkhrj@gmail.com>
Date: Sat, 28 Dec 2024 13:19:23 +0530
Subject: [PATCH 6/8] refactor: improve handling of recursive types

---
 source/all-union-fields.d.ts | 27 +++++++++++++++++----------
 test-d/all-union-fields.ts   | 15 +++++++++++++++
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/source/all-union-fields.d.ts b/source/all-union-fields.d.ts
index d366c79c7..4e166b576 100644
--- a/source/all-union-fields.d.ts
+++ b/source/all-union-fields.d.ts
@@ -67,13 +67,20 @@ function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
 @category Object
 @category Union
 */
-export type AllUnionFields<Union> = [Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray]
-	? Union
-	: Simplify<
-	SharedUnionFields<Union> &
-	{
-		readonly [P in ReadonlyKeysOfUnion<Union>]?: ValueOfUnion<Union, P>;
-	} & {
-		[P in Exclude<KeysOfUnion<Union>, ReadonlyKeysOfUnion<Union> | keyof Union>]?: ValueOfUnion<Union, P>;
-	}
-	>;
+export type AllUnionFields<Union> =
+Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+		?
+		| SkippedMembers
+		| Simplify<
+		SharedUnionFields<RelevantMembers> &
+		{
+			readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>;
+		} & {
+			[
+			P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>
+			]?: ValueOfUnion<RelevantMembers, P>;
+		}
+		>
+		: never
+	: never;
diff --git a/test-d/all-union-fields.ts b/test-d/all-union-fields.ts
index fee71bdd1..3089f61c6 100644
--- a/test-d/all-union-fields.ts
+++ b/test-d/all-union-fields.ts
@@ -1,5 +1,6 @@
 import {expectType} from 'tsd';
 import type {AllUnionFields, Simplify} from '../index';
+import type {NonRecursiveType} from '../source/internal';
 
 type TestingType = {
 	function: () => void;
@@ -167,3 +168,17 @@ expectType<{
 	readonly b?: string | number;
 	readonly c?: number;
 }>(mixedKeywords2);
+
+// Non-recursive types
+expectType<Set<string> | Map<string, string>>({} as AllUnionFields<Set<string> | Map<string, string>>);
+expectType<string[] | Set<string>>({} as AllUnionFields<string[] | Set<string>>);
+expectType<NonRecursiveType>({} as AllUnionFields<NonRecursiveType>);
+
+// Mix of non-recursive and recursive types
+expectType<{a: string | number; b?: true} | undefined>({} as AllUnionFields<{a: string} | {a: number; b: true} | undefined>);
+expectType<RegExp | {test: string}>({} as AllUnionFields<RegExp | {test: string}>);
+expectType<RegExp | null | {test: string | number; foo?: any}>({} as AllUnionFields<RegExp | null | {test: string} | {test: number; foo: any}>);
+
+// Boundary types
+expectType<any>({} as AllUnionFields<any>);
+expectType<never>({} as AllUnionFields<never>);

From ec1dfb33f3cc4f6b91595043b4bc5b5a809373e4 Mon Sep 17 00:00:00 2001
From: Som Shekhar Mukherjee <iamssmkhrj@gmail.com>
Date: Sat, 28 Dec 2024 12:56:58 +0530
Subject: [PATCH 7/8] test: add cases for value-of-union and
 readonly-keys-of-union

---
 test-d/internal/readonly-keys-of-union.ts | 27 ++++++++++++++
 test-d/internal/value-of-union.ts         | 44 +++++++++++++++++++++++
 2 files changed, 71 insertions(+)
 create mode 100644 test-d/internal/readonly-keys-of-union.ts
 create mode 100644 test-d/internal/value-of-union.ts

diff --git a/test-d/internal/readonly-keys-of-union.ts b/test-d/internal/readonly-keys-of-union.ts
new file mode 100644
index 000000000..b3edc161e
--- /dev/null
+++ b/test-d/internal/readonly-keys-of-union.ts
@@ -0,0 +1,27 @@
+import {expectType} from 'tsd';
+import type {ReadonlyKeysOfUnion} from '../../source/internal';
+
+declare const test1: ReadonlyKeysOfUnion<{readonly a: 1; b: 2}>;
+expectType<'a'>(test1);
+
+declare const test2: ReadonlyKeysOfUnion<{readonly a: 1; b?: 2} | {readonly c?: 3; d: 4}>;
+expectType<'a' | 'c'>(test2);
+
+declare const test3: ReadonlyKeysOfUnion<{readonly a: 1; b?: 2} | {readonly c?: 3; d: 4} | {readonly c: 5} | {d: 6}>;
+expectType<'a' | 'c'>(test3);
+
+// Returns `never` if there's no readonly key
+declare const test4: ReadonlyKeysOfUnion<{a: 1; b?: 2} | {c?: 3; d: 4}>;
+expectType<never>(test4);
+
+// Works with index signatures
+declare const test5: ReadonlyKeysOfUnion<{readonly [x: string]: number; a: 1} | {readonly [x: symbol]: number; a: 2}>;
+expectType<string | number | symbol>(test5);
+
+// Works with arrays
+declare const test7: ReadonlyKeysOfUnion<readonly string[] | readonly [number, number]>;
+expectType<number | typeof Symbol.unscopables | '0' | '1' | 'length'>(test7);
+
+// Works with functions
+declare const test8: ReadonlyKeysOfUnion<(() => void) | {(): void; readonly a: 1}>;
+expectType<'a'>(test8);
diff --git a/test-d/internal/value-of-union.ts b/test-d/internal/value-of-union.ts
new file mode 100644
index 000000000..204fc0b2b
--- /dev/null
+++ b/test-d/internal/value-of-union.ts
@@ -0,0 +1,44 @@
+import {expectType} from 'tsd';
+import type {ValueOfUnion} from '../../source/internal';
+
+// Works with objects
+declare const test1: ValueOfUnion<{a: 1; b: 2} | {a: 3; c: 4}, 'a'>;
+expectType<1 | 3>(test1);
+
+// Works with arrays
+declare const test2: ValueOfUnion<string[] | [number, boolean], number>;
+expectType<string | number | boolean>(test2);
+
+// Works with index signatures
+declare const test3: ValueOfUnion<{[x: string]: string; a: 'a'} | {[x: number]: number; a: 'a'}, string>;
+expectType<string>(test3);
+
+declare const test4: ValueOfUnion<{[x: string]: string; a: 'a'} | {[x: number]: number; a: 'a'}, number>;
+expectType<string | number>(test4);
+
+// Works with functions
+declare const test5: ValueOfUnion<(() => void) | {(): void; a: 1} | {(): void; a: 2}, 'a'>;
+expectType<1 | 2>(test5);
+
+// Ignores objects where `Key` is missing
+declare const test6: ValueOfUnion<{a: 1; b: 2} | {a: 3; c: 4} | {a: 5; d: 6} | {e: 7}, 'a'>;
+expectType<1 | 3 | 5>(test6);
+
+// Adds `undefined` when the key is optional
+declare const test7: ValueOfUnion<{readonly a?: 1; b: 2} | {a: 3; c: 4}, 'a'>;
+expectType<1 | 3 | undefined>(test7);
+
+// Works when `Key` is a union
+declare const test8: ValueOfUnion<{a: 1; b: 2} | {a: 3; c: 4} | {a: 5; b: 6} | {e: 7}, 'a' | 'b'>;
+expectType<1 | 2 | 3 | 5 | 6>(test8);
+
+// @ts-expect-error - Errors if `Key` is missing from all of the objects
+declare const test9: ValueOfUnion<{a: 1; b: 2} | {a: 3; c: 4}, 'd'>;
+
+// Returns `any` when `Key` is `any`
+declare const test10: ValueOfUnion<{a: 1; b: 2} | {a: 3; c: 4}, any>;
+expectType<any>(test10);
+
+// Returns `never` when `Key` is `never`
+declare const test11: ValueOfUnion<{a: 1; b: 2} | {a: 3; c: 4}, never>;
+expectType<never>(test11);

From 2d1de301b500b91468af8e68d2e6ba2fe5a921e2 Mon Sep 17 00:00:00 2001
From: Som Shekhar Mukherjee <iamssmkhrj@gmail.com>
Date: Sat, 28 Dec 2024 14:10:45 +0530
Subject: [PATCH 8/8] fix: satisfy constraint for value-of-union

---
 source/all-union-fields.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/all-union-fields.d.ts b/source/all-union-fields.d.ts
index 4e166b576..7619809cb 100644
--- a/source/all-union-fields.d.ts
+++ b/source/all-union-fields.d.ts
@@ -75,7 +75,7 @@ Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<un
 		| Simplify<
 		SharedUnionFields<RelevantMembers> &
 		{
-			readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>;
+			readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>;
 		} & {
 			[
 			P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>