Helper type to merge conflicting interfaces

01-merge-types.ts

/**
 * Simple merge of two types where first `T1` will override second `T2`
 */
export type MergeSimple<T1, T2> = T1 & Omit<T2, keyof T1>;

/**
 * Recursive merge of array of types where first types take over the last ones
 */
export type Merge<T extends any[]> = MergeRecursive<Head<T>, Tail<T>>;

type Head<T extends any[]> = T extends [infer X, ...any[]] ? X : never;

type Tail<T extends any[]> = ((...x: T) => void) extends (
  x: any,
  ...xs: infer XS
) => void
  ? XS
  : never;

type MergeRecursive<
  T1,
  TRest extends any[],
  FirstAndSecond = MergeSimple<T1, Head<TRest>>
> = {
  0: FirstAndSecond;
  1: FirstAndSecond & MergeRecursive<FirstAndSecond, Tail<TRest>>;
}[TRest extends [] ? 0 : TRest extends [any] ? 0 : 1];

02-example.ts

import { Merge, MergeSimple } from './merge-types';

interface A {
  readonly lol: string;
  prop1: string;
}

interface B {
  lol: boolean;
  prop2?: boolean;
}

interface B2 {
  lol: string[];
  prop2: string;
  prop3: number;
}

type CSimple = MergeSimple<A, B>;

let cSimple: CSimple;
cSimple.lol; // readonly (property) A.lol: string
cSimple.prop1; // (property) A.prop1: string
cSimple.prop2; // (property) prop2?: boolean

type C = Merge<[A, B, B2]>;

let c: C;
c.lol; // readonly (property) A.lol: string
c.prop1; // (property) A.prop1: string
c.prop2; // (property) prop2?: boolean
c.prop3; // (property) prop3: number