mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/type-fest/source/set-optional.d.ts

@@ -0,0 +1,42 @@
+import type {Except} from './except.d.ts';
+import type {HomomorphicPick} from './internal/index.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Create a type that makes the given keys optional, while keeping the remaining keys as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
+
+@example
+```
+import type {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+};
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+//=> {a: number; b?: string; c?: boolean}
+```
+
+@category Object
+*/
+export type SetOptional<BaseType, Keys extends keyof BaseType> =
+	(BaseType extends (...arguments_: never) => any
+		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
+		: unknown)
+	& _SetOptional<BaseType, Keys>;
+
+type _SetOptional<BaseType, Keys extends keyof BaseType> =
+	BaseType extends unknown // To distribute `BaseType` when it's a union type.
+		? Simplify<
+			// Pick just the keys that are readonly from the base type.
+			Except<BaseType, Keys>
+			// Pick the keys that should be mutable from the base type and make them mutable.
+			& Partial<HomomorphicPick<BaseType, Keys>>
+		>
+		: never;
+
+export {};

package/node_modules/type-fest/source/set-parameter-type.d.ts

@@ -0,0 +1,125 @@
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {StaticPartOfArray, VariablePartOfArray} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Create an array that replaces the given `TArray`'s elements with the given `TObject`'s values at the given indices.
+
+`TArray` and `TObject` supports tailing spread array like `[string, ...boolean[]]`, but does not support `[string, ...boolean[], number]`.
+
+@example:
+```ts
+// object
+type A = MergeObjectToArray<[string, number], {0: boolean}>;
+//=> [boolean, number]
+
+// array
+type B = MergeObjectToArray<[string, number], [boolean]>;
+//=> [boolean, number]
+
+// tailing spread array
+type C = MergeObjectToArray<[string, ...boolean[]], {1: number}>;
+//=> [string, ...number[]]
+
+type D = MergeObjectToArray<[string, ...boolean[]], [number, ...string[]]>;
+//=> [number, ...string[]]
+```
+*/
+type MergeObjectToArray<TArray extends UnknownArray, TObject, TArrayCopy extends UnknownArray = TArray> =
+	// If `TObject` is an array like `[0, 1, 2]`
+	TObject extends UnknownArray
+		// If `TObject` is a variable length array, we should use `TObject`'s type as the result type.
+		? number extends TObject['length']
+			? TObject
+			: {
+				[K in keyof TArray]:
+				number extends K
+					? VariablePartOfArray<TArray>[number]
+					: K extends keyof TObject ? TObject[K] : TArray[K]
+			}
+		: TObject extends object
+			// If `TObject` is an object with number keys like `{0: string, 1: number}`
+			? {
+				[K in keyof TArray]:
+				K extends `${infer NumberK extends number}`
+					? NumberK extends keyof TObject ? TObject[NumberK] : TArray[K]
+					: number extends K
+					// If array key `K` is `number`, means it's a rest parameter, we should set the rest parameter type to corresponding type in `TObject`.
+					// example: `MergeObjectToArray<[string, ...boolean[]], {1: number}>` => `[string, ...number[]]`
+						? StaticPartOfArray<TArrayCopy>['length'] extends keyof TObject
+							? TObject[StaticPartOfArray<TArrayCopy>['length']]
+							: TArray[K]
+						: never
+			} : never;
+
+/**
+Create a function that replaces some parameters with the given parameters.
+
+The parameters that are not specified will be kept as-is.
+
+Note:
+- This type will ignore the given function's generic type.
+- If you change the parameter type that return type depends on, the return type will not change:
+	```
+	import type {SetParameterType} from 'type-fest';
+
+	const fn = (a: number) => a;
+	//=> (a: number) => number
+
+ 	// We change type of `a` to `string`, but return type is still `number`.
+	type Fn = SetParameterType<typeof fn, {0: string}>;
+ 	//=> (a: string) => number
+	```
+
+Use-case:
+- Define a wrapped function that receives something different while returning the same type.
+- Mocking and testing.
+- Overload function type. (See example)
+
+@example
+```
+import type {SetParameterType} from 'type-fest';
+
+type SuccessData = {success: true; value: number};
+type ErrorData = {success: false; error: string};
+type Data = SuccessData | ErrorData;
+
+type HandleMessage = (data: Data, message: string, ...arguments_: any[]) => void;
+
+type HandleOk = SetParameterType<HandleMessage, {0: SuccessData; 1: 'ok'}>;
+//=> (data: SuccessData, message: 'ok', ...arguments_: any[]) => void
+
+// Another way to define the parameters to replace.
+type HandleError = SetParameterType<HandleMessage, [data: ErrorData, message: 'error']>;
+//=> (data: ErrorData, message: 'error', ...arguments_: any[]) => void
+
+// Change single parameter type.
+type HandleWarn = SetParameterType<HandleMessage, {1: 'warn'}>;
+//=> (data: Data, message: 'warn', ...arguments_: any[]) => void
+
+// Change rest parameter type.
+
+// Way 1: Input full parameter type.
+type HandleLog = SetParameterType<HandleMessage, [data: Data, message: 'log', ...arguments_: string[]]>;
+//=> (data: Data, message: 'log', ...arguments_: string[]) => void
+
+// Way 2: Input rest parameter type by Object index.
+type HandleLog2 = SetParameterType<HandleMessage, {2: string}>;
+//=> (data: Data, message: string, ...arguments_: string[]) => void
+```
+
+@category Function
+*/
+export type SetParameterType<Function_ extends (...arguments_: any[]) => unknown, P extends Record<number, unknown>> =
+	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
+	Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => unknown
+		? (
+			// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
+			// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
+			IsUnknown<ThisArgument> extends true
+				? (...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
+				: (this: ThisArgument, ...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
+		)
+		: Function_;	// This part should be unreachable
+
+export {};

package/node_modules/type-fest/source/set-readonly.d.ts

@@ -0,0 +1,40 @@
+import type {Except} from './except.d.ts';
+import type {HomomorphicPick} from './internal/index.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Create a type that makes the given keys readonly, while keeping the remaining keys as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are readonly.
+
+@example
+```
+import type {SetReadonly} from 'type-fest';
+
+type Foo = {
+	a: number;
+	readonly b: string;
+	c: boolean;
+};
+
+type SomeReadonly = SetReadonly<Foo, 'b' | 'c'>;
+//=> {a: number; readonly b: string; readonly c: boolean}
+```
+
+@category Object
+*/
+export type SetReadonly<BaseType, Keys extends keyof BaseType> =
+	(BaseType extends (...arguments_: never) => any
+		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
+		: unknown)
+	& _SetReadonly<BaseType, Keys>;
+
+export type _SetReadonly<BaseType, Keys extends keyof BaseType> =
+	BaseType extends unknown // To distribute `BaseType` when it's a union type.
+		? Simplify<
+			Except<BaseType, Keys>
+			& Readonly<HomomorphicPick<BaseType, Keys>>
+		>
+		: never;
+
+export {};

package/node_modules/type-fest/source/set-required-deep.d.ts

@@ -0,0 +1,64 @@
+import type {IsAny} from './is-any.d.ts';
+import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {Paths} from './paths.d.ts';
+import type {SetRequired} from './set-required.d.ts';
+import type {SimplifyDeep} from './simplify-deep.d.ts';
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+import type {RequiredDeep} from './required-deep.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Create a type that makes the given keys required, with support for deeply nested key paths, while keeping the remaining keys as is.
+
+Use-case: Selectively make nested properties required in complex types like models.
+
+@example
+```
+import type {SetRequiredDeep} from 'type-fest';
+
+type Foo = {
+	a?: number;
+	b?: string;
+	c?: Array<{
+		d?: number;
+	}>;
+};
+
+type SomeRequiredDeep = SetRequiredDeep<Foo, 'a' | `c.${number}.d`>;
+//=> {b?: string; c?: {d: number}[]; a: number}
+
+// Set specific indices in an array to be required.
+type ArrayExample = SetRequiredDeep<{a: [number?, number?, number?]}, 'a.0' | 'a.1'>;
+//=> {a: [number, number, number?]}
+```
+
+@category Object
+*/
+export type SetRequiredDeep<BaseType, KeyPaths extends Paths<BaseType>> = IsAny<KeyPaths> extends true
+	? SimplifyDeep<RequiredDeep<BaseType>>
+	: SetRequiredDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
+
+/**
+Internal helper for {@link SetRequiredDeep}.
+
+Recursively transforms the `BaseType` by applying {@link SetRequiredDeepSinglePath} for each path in `KeyPathsTuple`.
+*/
+type SetRequiredDeepHelper<BaseType, KeyPathsTuple extends UnknownArray> =
+	KeyPathsTuple extends [infer KeyPath, ...infer RestPaths]
+		? SetRequiredDeepHelper<SetRequiredDeepSinglePath<BaseType, KeyPath>, RestPaths>
+		: BaseType;
+
+/**
+Makes a single path required in `BaseType`.
+*/
+type SetRequiredDeepSinglePath<BaseType, KeyPath> = BaseType extends NonRecursiveType
+	? BaseType
+	: KeyPath extends `${infer Property}.${infer RestPath}`
+		? {
+			[Key in keyof BaseType]: Property extends `${Key & (string | number)}`
+				? SetRequiredDeepSinglePath<BaseType[Key], RestPath>
+				: BaseType[Key];
+		}
+		: SetRequired<BaseType, (KeyPath | StringToNumber<KeyPath & string>) & keyof BaseType>;
+
+export {};

package/node_modules/type-fest/source/set-required.d.ts

@@ -0,0 +1,75 @@
+import type {Except} from './except.d.ts';
+import type {If} from './if.d.ts';
+import type {HomomorphicPick, IsArrayReadonly} from './internal/index.d.ts';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Create a type that makes the given keys required, while keeping the remaining keys as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
+
+@example
+```
+import type {SetRequired} from 'type-fest';
+
+type Foo = {
+	a?: number;
+	b: string;
+	c?: boolean;
+};
+
+type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
+//=> {a?: number; b: string; c: boolean}
+
+// Set specific indices in an array to be required.
+type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
+//=> [number, number, number?]
+```
+
+@category Object
+*/
+export type SetRequired<BaseType, Keys extends keyof BaseType> =
+	(BaseType extends (...arguments_: never) => any
+		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
+		: unknown)
+	& _SetRequired<BaseType, Keys>;
+
+type _SetRequired<BaseType, Keys extends keyof BaseType> =
+	BaseType extends UnknownArray
+		? SetArrayRequired<BaseType, Keys> extends infer ResultantArray
+			? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray>
+			: never
+		: Simplify<
+		// Pick just the keys that are optional from the base type.
+			Except<BaseType, Keys>
+		// Pick the keys that should be required from the base type and make them required.
+			& Required<HomomorphicPick<BaseType, Keys>>
+		>;
+
+/**
+Remove the optional modifier from the specified keys in an array.
+*/
+type SetArrayRequired<
+	TArray extends UnknownArray,
+	Keys,
+	Counter extends any[] = [],
+	Accumulator extends UnknownArray = [],
+> = TArray extends unknown // For distributing `TArray` when it's a union
+	? keyof TArray & `${number}` extends never
+		// Exit if `TArray` is empty (e.g., []), or
+		// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		? [...Accumulator, ...TArray]
+		: TArray extends readonly [(infer First)?, ...infer Rest]
+			? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
+				? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
+					? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
+					// If the current element is optional, but it doesn't need to be required,
+					// then we can exit early, since no further elements can now be made required.
+					: [...Accumulator, ...TArray]
+				: SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]>
+			: never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+	: never; // Should never happen
+
+export {};

package/node_modules/type-fest/source/set-return-type.d.ts

@@ -0,0 +1,31 @@
+import type {IsUnknown} from './is-unknown.d.ts';
+
+/**
+Create a function type with a return type of your choice and the same parameters as the given function type.
+
+Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+
+@example
+```
+import type {SetReturnType} from 'type-fest';
+
+type MyFunctionThatCanThrow = (foo: string, bar: number) => boolean;
+
+type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, ReturnType<MyFunctionThatCanThrow> | undefined>;
+//=> (foo: string, bar: number) => boolean | undefined
+```
+
+@category Function
+*/
+export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeToReturn> =
+	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
+	Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => any ? (
+		// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
+		// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
+		IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn
+	) : (
+		// This part should be unreachable, but we make it meaningful just in case…
+		(...arguments_: Parameters<Function_>) => TypeToReturn
+	);
+
+export {};

package/node_modules/type-fest/source/shared-union-fields-deep.d.ts

@@ -0,0 +1,180 @@
+import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+SharedUnionFieldsDeep options.
+
+@see {@link SharedUnionFieldsDeep}
+*/
+export type SharedUnionFieldsDeepOptions = {
+	/**
+	When set to true, this option impacts each element within arrays or tuples. If all union values are arrays or tuples, it constructs an array of the shortest possible length, ensuring every element exists in the union array.
+
+	@default false
+ 	*/
+	recurseIntoArrays?: boolean;
+};
+
+type DefaultSharedUnionFieldsDeepOptions = {
+	recurseIntoArrays: false;
+};
+
+/**
+Create a type with shared fields from a union of object types, deeply traversing nested structures.
+
+Use the {@link SharedUnionFieldsDeepOptions `Options`} to specify the behavior for arrays.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
+
+@example
+```
+import type {SharedUnionFieldsDeep} from 'type-fest';
+
+type Cat = {
+	info: {
+		name: string;
+		type: 'cat';
+		catType: string;
+	};
+};
+
+type Dog = {
+	info: {
+		name: string;
+		type: 'dog';
+		dogType: string;
+	};
+};
+
+function displayPetInfo(petInfo: (Cat | Dog)['info']) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat';
+	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
+	// }
+
+	// petInfo type is complex and have some needless fields
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+
+function displayPetInfoWithSharedUnionFieldsDeep(petInfo: SharedUnionFieldsDeep<Cat | Dog>['info']) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	// }
+
+	// petInfo type is simple and clear
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+```
+
+@see {@link SharedUnionFields}
+
+@category Object
+@category Union
+*/
+export type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOptions = {}> =
+	ApplyDefaultOptions<SharedUnionFieldsDeepOptions, DefaultSharedUnionFieldsDeepOptions, Options> extends infer OptionsWithDefaults extends Required<SharedUnionFieldsDeepOptions>
+	// `Union extends` will convert `Union`
+	// to a [distributive conditional type](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>]
+			? Union
+			: [Union] extends [UnknownArray]
+				? OptionsWithDefaults['recurseIntoArrays'] extends true
+					? SetArrayAccess<SharedArrayUnionFieldsDeep<Union, OptionsWithDefaults>, IsArrayReadonly<Union>>
+					: Union
+				: [Union] extends [object]
+					? SharedObjectUnionFieldsDeep<Union, OptionsWithDefaults>
+					: Union
+		: never;
+
+/**
+Same as `SharedUnionFieldsDeep`, but accepts only `object`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
+*/
+type SharedObjectUnionFieldsDeep<Union, Options extends Required<SharedUnionFieldsDeepOptions>> =
+	// `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] extends NonRecursiveType
+					? Union[Key]
+					// Remove `undefined` from the union to support optional
+					// fields, then recover `undefined` if union was already undefined.
+					: SharedUnionFieldsDeep<Exclude<Union[Key], undefined>, Options> | (
+						undefined extends Required<Union>[Key] ? undefined : never
+					)
+			}
+			: {}
+		: Union;
+
+/**
+Same as `SharedUnionFieldsDeep`, but accepts only `UnknownArray`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
+*/
+type SharedArrayUnionFieldsDeep<Union extends UnknownArray, Options extends Required<SharedUnionFieldsDeepOptions>> =
+	// Restore the readonly modifier of the array.
+	SetArrayAccess<
+		InternalSharedArrayUnionFieldsDeep<Union, Options>,
+		IsArrayReadonly<Union>
+	>;
+
+/**
+Internal helper for `SharedArrayUnionFieldsDeep`. Needn't care the `readonly` modifier of arrays.
+*/
+type InternalSharedArrayUnionFieldsDeep<
+	Union extends UnknownArray,
+	Options extends Required<SharedUnionFieldsDeepOptions>,
+	ResultTuple extends UnknownArray = [],
+> =
+	// We should build a minimum possible length tuple where each element in the tuple exists in the union tuple.
+	IsNever<TupleLength<Union>> extends true
+		// Rule 1: If all the arrays in the union have non-fixed lengths,
+		// like `Array<string> | [number, ...string[]]`
+		// we should build a tuple that is [the_fixed_parts_of_union, ...the_rest_of_union[]].
+		// For example: `InternalSharedArrayUnionFieldsDeep<Array<string> | [number, ...string[]]>`
+		// => `[string | number, ...string[]]`.
+		? ResultTuple['length'] extends UnionMax<StaticPartOfArray<Union>['length']>
+			? [
+				// The fixed-length part of the tuple.
+				...ResultTuple,
+				// The rest of the union.
+				// Due to `ResultTuple` is the maximum possible fixed-length part of the tuple,
+				// so we can use `StaticPartOfArray` to get the rest of the union.
+				...Array<
+					SharedUnionFieldsDeep<VariablePartOfArray<Union>[number], Options>
+				>,
+			]
+			// Build the fixed-length tuple recursively.
+			: InternalSharedArrayUnionFieldsDeep<
+				Union, Options,
+				[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
+			>
+		// Rule 2: If at least one of the arrays in the union have fixed lengths,
+		// like `Array<string> | [number, string]`,
+		// we should build a tuple of the smallest possible length to ensure any
+		// item in the result tuple exists in the union tuple.
+		// For example: `InternalSharedArrayUnionFieldsDeep<Array<string> | [number, string]>`
+		// => `[string | number, string]`.
+		: ResultTuple['length'] extends UnionMin<TupleLength<Union>>
+			? ResultTuple
+			// As above, build tuple recursively.
+			: InternalSharedArrayUnionFieldsDeep<
+				Union, Options,
+				[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
+			>;
+
+export {};

package/node_modules/type-fest/source/shared-union-fields.d.ts

@@ -0,0 +1,79 @@
+import type {NonRecursiveType} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {IsUnion} from './is-union.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Create a type with shared fields from a union of object types.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
+
+@example
+```
+import type {SharedUnionFields} 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; // Needn't care about this field, because it's not a common pet info field.
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
+	// }
+
+	// petInfo type is complex and have some needless fields
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+
+function displayPetInfoWithSharedUnionFields(petInfo: SharedUnionFields<Cat | Dog>) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	// }
+
+	// petInfo type is simple and clear
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+```
+
+@see {@link SharedUnionFieldsDeep}
+@see {@link AllUnionFields}
+
+@category Object
+@category Union
+*/
+export type SharedUnionFields<Union> =
+	Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+		? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+			? // eslint-disable-line @stylistic/operator-linebreak
+			| SkippedMembers
+			| (IsNever<RelevantMembers> extends true
+				? never
+				: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
+			: never
+		: never;
+
+export {};