types-playground.ts

// https://www.typescriptlang.org/docs/handbook/advanced-types.html
// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html

/** Enlève les clés K de T (opposé de Pick) */
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

/** Récupère les types des arguments d'une fonction */
type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never

/** Récupère la version promisifiée d'une fonction */
type Promisified<F extends Function> = F extends (...args: any[]) => infer R ? (...a: ArgumentTypes<F>) => Promise<R> : never

/** Rend optionnel les clés K de T */
type PartialSome<T extends object, K extends keyof T> = { [k in K]?: T[k] } & Omit<T, K>

/** Récupère le nom des clés de T d'un certain type U */
type KeysOfType<T, U> = ({ [P in keyof T]: T[P] extends U ? P : never })[keyof T]

/** Récupère le nom des clés de T différentes d'un certain type U */
type KeysNotOfType<T, U> = ({ [P in keyof T]: T[P] extends U ? never : P })[keyof T]

/** Récupère une union des noms de méthode de T */
type MethodKeys<T> = KeysOfType<T, Function>

/** Garde uniquement les méthodes de T */
type Methods<T> = Pick<T, MethodKeys<T>>

/** Récupère une union des noms de propriétés (et non les méthodes) de T */
type PropertyKeys<T> = KeysNotOfType<T, Function>

/** Garde uniquement les propriétés (et non les méthodes) de T */
type Properties<T> = Pick<T, PropertyKeys<T>>

/** Garde uniquement les propriétés (et non les méthodes) de T et les rend toutes optionnels */
type PartialProperties<T> = Partial<Properties<T>>

/** Garde uniquement les propriétés (et non les méthodes) de T et les rend toutes requises */
type RequiredProperties<T> = Required<Properties<T>>

/** 
 * Récupère le nom des clés nullables de T 
 * https://github.com/Microsoft/TypeScript/issues/29627
 */
type NullableKeys<T> = { [P in keyof T]: null extends T[P] ? P : never }[keyof T]

/** Récupère le nom des clés non nullables de T */
type NonNullableKeys<T> = { [P in keyof T]: null extends T[P] ? never : P }[keyof T]

/** Garde uniquement les propriétés nullables de T */
type Nullables<T> = Pick<T, NullableKeys<T>>

/** Garde uniquement les propriétés non nullables de T */
type NonNullables<T> = Pick<T, NonNullableKeys<T>>

/** Etend correctement le tableau natif */
class CustomArray<T> extends Array<T> {
  constructor(items?: Array<T>) {
    super(...items)
    Object.setPrototypeOf(this, Object.create(CustomArray.prototype))
  }
}