Typeseedcordv0.10.6

Merge

Merge two types into a new type. Keys of the second type overrides keys of the first type.

This is different from the TypeScript && (intersection) operator. With &&, conflicting property types are intersected, which often results in nevernever. For example, {a: string} & {a: number}{a: string} & {a: number} makes aa become string & numberstring & number, which resolves to nevernever. With MergeMerge, the second type's keys cleanly override the first, so Merge<{a: string}, {a: number}>Merge<{a: string}, {a: number}> gives {a: number}{a: number} as expected. MergeMerge also produces a flattened type (via SimplifySimplify), making it more readable in IDE tooltips compared to A & BA & B.

See also:ObjectMerge Object

type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination` ? Source extends unknown // For distributing `Source` ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen : never

type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination` ? Source extends unknown // For distributing `Source` ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen : never

import type {Merge} from 'type-fest';

type Foo = {
	a: string;
	b: number;
};

type Bar = {
	a: number; // Conflicts with Foo['a']
	c: boolean;
};

// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
type WithIntersection = (Foo & Bar)['a'];
//=> never

// With `Merge`, `a` is cleanly overridden to `number`.
type WithMerge = Merge<Foo, Bar>['a'];
//=> number

import type {Merge} from 'type-fest';

type Foo = {
	a: string;
	b: number;
};

type Bar = {
	a: number; // Conflicts with Foo['a']
	c: boolean;
};

// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
type WithIntersection = (Foo & Bar)['a'];
//=> never

// With `Merge`, `a` is cleanly overridden to `number`.
type WithMerge = Merge<Foo, Bar>['a'];
//=> number

import type {Merge} from 'type-fest';

type Foo = {
	[x: string]: unknown;
	[x: number]: unknown;
	foo: string;
	bar: symbol;
};

type Bar = {
	[x: number]: number;
	[x: symbol]: unknown;
	bar: Date;
	baz: boolean;
};

export type FooBar = Merge<Foo, Bar>;
//=> {
// 	[x: string]: unknown;
// 	[x: number]: number;
// 	[x: symbol]: unknown;
// 	foo: string;
// 	bar: Date;
// 	baz: boolean;
// }

Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or Object.assign, refer to the ObjectMerge type.

import type {Merge} from 'type-fest';

type Foo = {
	[x: string]: unknown;
	[x: number]: unknown;
	foo: string;
	bar: symbol;
};

type Bar = {
	[x: number]: number;
	[x: symbol]: unknown;
	bar: Date;
	baz: boolean;
};

export type FooBar = Merge<Foo, Bar>;
//=> {
// 	[x: string]: unknown;
// 	[x: number]: number;
// 	[x: symbol]: unknown;
// 	foo: string;
// 	bar: Date;
// 	baz: boolean;
// }

Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or Object.assign, refer to the ObjectMerge type.

Destination

Destination

Destination

Source

Source

Source

Merge

Merge two types into a new type. Keys of the second type overrides keys of the first type.

type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination` ? Source extends unknown // For distributing `Source` ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen : never

import type {Merge} from 'type-fest'; type Foo = { a: string; b: number; }; type Bar = { a: number; // Conflicts with Foo['a'] c: boolean; }; // With `&`, `a` becomes `string & number` which is `never`. Not what you want. type WithIntersection = (Foo & Bar)['a']; //=> never // With `Merge`, `a` is cleanly overridden to `number`. type WithMerge = Merge<Foo, Bar>['a']; //=> number

import type {Merge} from 'type-fest'; type Foo = { [x: string]: unknown; [x: number]: unknown; foo: string; bar: symbol; }; type Bar = { [x: number]: number; [x: symbol]: unknown; bar: Date; baz: boolean; }; export type FooBar = Merge<Foo, Bar>; //=> { // [x: string]: unknown; // [x: number]: number; // [x: symbol]: unknown; // foo: string; // bar: Date; // baz: boolean; // } Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or Object.assign, refer to the ObjectMerge type.