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 (plus précis que le Omit natif).
 */
type OmitStrict<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

/**
 * Récupère la version promisifiée d'une fonction.
 */
type Promisified<F extends Function> = F extends (...args: any[]) => infer R
	? (...a: Parameters<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>>

/**
 * 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>>

/**
 * Récupère le nom des clés qui ne sont pas en lecture seule.
 * https://stackoverflow.com/questions/52443276/how-to-exclude-getter-only-properties-from-type-in-typescript
 */
type NonReadonlyKeys<T> = { [P in keyof T]: 'readonly' extends keyof T[P] ? never : P }[keyof T]

/**
 * Requiert une seule des propriétés.
 */
type EitherOne<T, K = keyof T> = K extends keyof T
	? { [P in K]?: T[K] } & Partial<{ [P in Exclude<keyof T, K>]: never }>
	: never

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

/**
 * Force un tableau d'avoir au minimum un élément.
 */
type ArrayOneOrMore<T> = { 0: T } & Array<T>

/**
 * https://effectivetypescript.com/2020/04/09/jsonify/
 */
type Jsonify<T> = T extends { toJSON(): infer U } ? U : T extends object ? { [K in keyof T]: Jsonify<T[K]> } : T

/**
 * Récupère le premier type d'un tuple.
 * https://medium.com/free-code-camp/typescript-curry-ramda-types-f747e99744ab
 */
type Head<T extends any[]> = T extends [any, ...any[]] ? T[0] : never
type TestHead = Head<[1, 2, string]> // 1

/**
 * Récupère les types d'un tuple à partir du deuxième type.
 */
type Tail<T extends any[]> = ((...t: T) => any) extends (_: any, ...tail: infer U) => any ? U : []
type TestTail = Head<[1, 2, string]> // [2, string]

/**
 * https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
 */
type IsAny<T> = 0 extends 1 & T ? true : false

/**
 * https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
 */
type IsNever<T> = [T] extends [never] ? true : false

/**
 * https://stackoverflow.com/questions/56687668/a-way-to-disable-type-argument-inference-in-generics
 */
type NoInfer<T> = [T][T extends any ? 0 : never]