conditional union/intersection types

merge-type.ts

// type utils
type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
  x: infer R
) => any
  ? R
  : never;

type UnionOf<T extends object> = T[keyof T];

type IntersectionOf<T extends object> = UnionToIntersection<UnionOf<T>>;

type TypeMap = {
  '|': object;
  '&': object;
};

type TypeConfig<T extends TypeMap> = {
  [key in keyof T['|'] | keyof T['&']]?: boolean;
};

type UnionTypeOf<T extends TypeMap, U extends TypeConfig<T>> = UnionOf<
  {
    [key in keyof T['|']]: key extends keyof U
      ? U[key] extends true
        ? T['|'][key]
        : never
      : never;
  }
>;

type IntersectionTypeOf<
  T extends TypeMap,
  U extends TypeConfig<T>
> = IntersectionOf<
  {
    [key in keyof T['&']]: key extends keyof U
      ? U[key] extends true
        ? T['&'][key]
        : never
      : never;
  }
>;

type MergeType<T extends TypeMap, U extends TypeConfig<T>> = IntersectionTypeOf<
  T,
  U
> &
  {
    [key in keyof T['|']]: key extends keyof U
      ? U[key] extends true
        ? T['|'][key]
        : never
      : never;
  }[keyof T['|']];

// response type

type DefaultValueResponse<T> = {
  kind: 'Response.defaultValue';
  defaultValue: T;
};

type PendingResponse = {
  kind: 'Response.pending';
};

type ErrorResponse = {
  kind: 'Response.error';
  error: Error;
};

type DataResponse<T> = {
  kind: 'Response.data';
  data: T;
};

type SnapshotResponse<T> = {
  snapshot?: T;
};

type ParamsResponse<T> = {
  params?: T;
};

type ResponseUnions<T> = {
  defaultValue: DefaultValueResponse<T>;
  pending: PendingResponse;
  error: ErrorResponse;
  data: DataResponse<T>;
};

type ResponseIntersections<T> = {
  snapshot: SnapshotResponse<T>;
  params: ParamsResponse<T>;
};

type ResponseMap<T> = {
  '|': ResponseUnions<T>;
  '&': ResponseIntersections<T>;
};

type ResOptions<T> = {
  defaultValue?: T;
  throwError?: boolean;
  snapshot?: boolean;
};

type ResType<T, U extends ResOptions<T> = {}> = MergeType<
  ResponseMap<T>,
  {
    data: true;
    params: true;
    defaultValue: U extends { defaultValue: T } ? true : false;
    pending: U extends { defaultValue: T } ? false : true;
    error: U extends { throwError: false } ? false : true;
    snapshot: U extends { snapshot: true } ? true : false;
  }
>;

type T1 = ResType<number>;

type T2 = ResType<number, { defaultValue: number }>;

type T3 = ResType<number, { defaultValue: number; snapshot: true }>;

type T4 = ResType<
  number,
  { defaultValue: number; snapshot: true; throwError: false }
>;