Typescript how to create type with common properties of two types?

Question

There are 2 types

type A = {
  x: number
  y: number
}

type B = {
  y: number
  z: number
}

How to get type with common properties of that types?

type C = Something<T1, T2> // { y: number }

Answer 1

Common Properties

Use static keyof operator:

type Ka = keyof A // 'x' | 'y'
type Kb = keyof B // 'y' | 'z'
type Kc = Ka & Kb // 'y'

And define a Mapped Type with properties in Kc:

type C = {
  [K in keyof A & keyof B]: A[K] | B[K]
}

This defines a new type where each key will be present both in A and B.

Each value associated to this key will have type A[K] | B[K], in case A[K] and B[K] are different.

---

Common Properties with Same Types only

Use Conditional Type to map key to value only if type same in A and B:

type MappedC = {
  [K in keyof A & keyof B]:
    A[K] extends B[K] // Basic check for simplicity here.
    ? K // Value becomes same as key
    : never // Or `never` if check did not pass
}

From this object, get union of all values, by accessing all keys:

// `never` will not appear in the union
type Kc = MappedC[keyof A & keyof B]

Finally:

type C = {
  [K in Kc]: A[K]
}

Answer 2

Based on @kube's answer, you could use generics to create a reusable type:

type Common<A, B> = {
    [P in keyof A & keyof B]: A[P] | B[P];
}

This allows you to create intersections on the fly:

const c: Common<T1, T2> = { y: 123 };

Answer 3

Shortcomings of a naive approach

While the below type is commonly suggested in the other answers:

type Common<A, B> = {
    [P in keyof A & keyof B]: A[P] | B[P];
}

It fails to check whether the property values are assignable to one another. This implies that it is possible for Common<A, B> to have properties that are not really shared by A and B.

type A = { a: number; x: string; z: number }
type B = { b: number; x: number; z: number}
Common<A, B> // => { x: string | number; z: number}
// above should just be { z: number }, since the type of property x is not
// assignable to the type of property x in both A and B.

The reason this sucks is because destructuring an object of type Common<A, B> into an object of either type A or type B can fail for either A or B. For example,

const sharedProps: Common<A, B> = { x: 'asdf', z: 9 }
const a: A = { ...sharedProps, a: 1 }

// below throws type error; string not assignable to number
const b: B = { ...sharedProps, b: 1 }

This is confusing, and puts an arbitrary limit on what we can do with the generic type.

In-depth approach that covers the above use-case

I suggest the below type (available for TS4.1+):

/**
 * Omits properties that have type `never`. Utilizes key-remapping introduced in
 * TS4.1.
 *
 * @example
 * ```ts
 * type A = { x: never; y: string; }
 * OmitNever<A> // => { y: string; }
 * ```
 */
type OmitNever<T extends Record<string, unknown>> = {
  [K in keyof T as T[K] extends never ? never : K]: T[K];
};

/**
 * Constructs a Record type that only includes shared properties between `A` and
 * `B`. If the value of a key is different in `A` and `B`, `SharedProperties<A,
 * B>` attempts to choose a type that is assignable to the types of both values.
 *
 * Note that this is NOT equivalent to `A & B`.
 *
 * @example
 * ```ts
 * type A = { x: string; y: string; }
 * type B = { y: string; z: string }
 * type C = { y: string | number; }
 *
 * A & B                  // => { x: string; y: string; z: string; }
 * SharedProperties<A, B> // => { y: string; }
 * SharedProperties<B, C> // => { y: string | number; }
 * ```
 */
type SharedProperties<A, B> = OmitNever<Pick<A & B, keyof A & keyof B>>;

This type correctly returns shared properties that are guaranteed to be subtypes of both A and B, since A & B is guaranteed to be a subtype of A and B so long as A & B is not never.

type A = { a: number; x: string; z: number }
type B = { b: number; x: number; z: number}
SharedProperties<A, B> // => { z: number }

Answer 4

Extract common props with same types only

Based on @kube's answer,

type Common<A, B> = Pick<
  A,
  {
    [K in keyof A & keyof B]: A[K] extends B[K]
      ? B[K] extends A[K]
        ? K
        : never
      : never;
  }[keyof A & keyof B]
>;

Answer 5

This common type will be used to create a type that has all the keys of both types, but with the type of the value being the intersection of the two types.

type Common<A, B> = {
  [K in keyof A & keyof B]: A[K] extends B[K]
    ? B[K] extends A[K]
      ? A[K] // A[K] and B[K] are the same type
      : B[K] // A[K] is a subtype of B[K]
    : Common<A[K], B[K]> // A[K] and B[K] are not the same type, recurse
}

Here is an example of usage:

type A = {
  x: {
    i: string
    j: string
  }
  y: {
    l: string
    m: string
  }
  z: string
}

type B = {
  x: {
    j: string
    k: string
  }
  y: {
    m: string
    n: string
  }
}

type AB = Common<A, B> // { x: { j: string }, y: { m: string } }