Types avancés

interface Produit {
  reference: string;
  libelle: string;
  prix: number;
}

// K extends keyof T : K ne peut etre qu'une cle de T. T[K] designe alors le
// type de la valeur rangee sous cette cle, et il suit K d'un appel a l'autre.
function parCle<T, K extends keyof T>(elements: readonly T[], cle: K): Map<T[K], T> {
  const index = new Map<T[K], T>();
  for (const element of elements) {
    index.set(element[cle], element);
  }
  return index;
}

const produits: Produit[] = [
  { reference: 'USB-64', libelle: 'Cle USB 64 Go', prix: 12 },
  { reference: 'SSD-1T', libelle: 'Disque SSD 1 To', prix: 89 },
];

// Rien entre chevrons : T est deduit du tableau, K du litteral passe en
// second argument.
const parReference = parCle(produits, 'reference'); // Map<string, Produit>
const parPrix = parCle(produits, 'prix'); // Map<number, Produit>

console.log(parReference.get('SSD-1T')?.prix); // 89
console.log(parPrix.get(12)?.libelle); // Cle USB 64 Go

// parCle(produits, 'poids');
// error TS2345: Argument of type '"poids"' is not assignable to parameter of type 'keyof Produit'.

// Les arguments de type se donnent tous ou aucun.
// parCle<Produit>(produits, 'prix');
// error TS2558: Expected 2 type arguments, but got 1.

// Un parametre par defaut sert quand aucun argument ne permet de deduire le
// type. Sans lui, lister() rendrait unknown[].
function lister<T = string>(...elements: T[]): T[] {
  return elements;
}

const vide = lister(); // string[]
const nombres = lister(1, 2); // number[] : l'inference passe avant le defaut

// Un ternaire evalue par le compilateur : si T est assignable au type teste,
// le resultat est la premiere branche, sinon la seconde.
type NomDuType<T> = T extends string
  ? 'chaine'
  : T extends number
    ? 'nombre'
    : T extends undefined
      ? 'indefini'
      : 'objet';

type A = NomDuType<'bonjour'>; // 'chaine' : un litteral est assignable a string
type B = NomDuType<Date>; // 'objet'

// T est ici un parametre nu, pose seul a gauche d'extends. Recu sous forme
// d'union, il est evalue membre par membre, et les resultats sont reunis.
type C = NomDuType<string | number | undefined>; // 'chaine' | 'nombre' | 'indefini'

// C'est ce qui permet de filtrer une union : never, l'union vide, disparait
// de toute union ou il apparait.
type SansNull<T> = T extends null | undefined ? never : T;
type D = SansNull<string | null | undefined>; // string

// Exclude et Extract sont ecrits exactement ainsi dans lib.es5.d.ts.
type Statut = 'brouillon' | 'publie' | 'archive';
type Visible = Exclude<Statut, 'archive'>; // 'brouillon' | 'publie'
type EnLigne = Extract<Statut, 'publie' | 'supprime'>; // 'publie'

// Normaliser une valeur qui arrive seule ou deja en tableau.
type EnListe<T> = T extends readonly unknown[] ? T : T[];

// Distribue sur l'union, le resultat est un tableau de chaines OU un tableau
// de nombres, jamais un tableau qui melange les deux.
type Ids = EnListe<string | number>; // string[] | number[]

// const ids: Ids = ['USB-64', 42];
// error TS2322: Type '(string | number)[]' is not assignable to type 'Ids'.
//   Type '(string | number)[]' is not assignable to type 'string[]'.

// Meme mecanisme sur never : une union vide n'a aucun membre a evaluer, et le
// resultat n'est ni true ni false.
type EstNever<T> = T extends never ? true : false;
type N = EstNever<never>; // never

// Enveloppe dans un tuple a un element, T n'est plus nu : l'union est testee
// d'un bloc.
type EnListe<T> = [T] extends [readonly unknown[]] ? T : T[];

type Ids = EnListe<string | number>; // (string | number)[]
const ids: Ids = ['USB-64', 42];

type EstNever<T> = [T] extends [never] ? true : false;
type N = EstNever<never>; // true
type S = EstNever<string>; // false

interface Produit {
  reference: string;
  prix: number;
}

// infer U declare une variable de type dans le motif teste. Si T a la forme
// Promise<quelque chose>, ce quelque chose est capture dans U.
type DeballeUnNiveau<T> = T extends Promise<infer U> ? U : T;

type A = DeballeUnNiveau<Promise<Produit>>; // Produit
type B = DeballeUnNiveau<string>; // string : pas de Promise, T revient tel quel
type C = DeballeUnNiveau<Promise<Promise<number>>>; // Promise<number>

// Un type conditionnel peut se rappeler lui-meme : il deballe tant qu'il reste
// une Promise, comme await le fait a l'execution.
type Deballe<T> = T extends Promise<infer U> ? Deballe<U> : T;

type D = Deballe<Promise<Promise<number>>>; // number
type E = Deballe<Promise<string> | number>; // string | number : T est nu, il distribue

// L'usage courant : nommer ce que rend une fonction sans le recopier.
async function chargerProduit(reference: string): Promise<Produit> {
  return { reference, prix: 12 };
}

type Charge = Deballe<ReturnType<typeof chargerProduit>>; // Produit

// infer se pose partout ou un type peut apparaitre, et accepte une contrainte.
type Element<T> = T extends readonly (infer E)[] ? E : never;
type CodeHttp<T> = T extends `${infer N extends number}` ? N : never;

type F = Element<string[]>; // string
type G = CodeHttp<'404'>; // 404 : le nombre, et non plus la chaine

interface Client {
  readonly id: number;
  nom: string;
  email?: string;
}

// [K in keyof T] parcourt les cles de T. A droite des deux-points, T[K] est le
// type d'origine de chaque propriete, transforme a volonte.
type Nullable<T> = { [K in keyof T]: T[K] | null };

type ClientNullable = Nullable<Client>;
// { readonly id: number | null; nom: string | null; email?: string | null | undefined }

// Mappe directement sur keyof T, le type est homomorphe : il recopie readonly
// et ? depuis l'original.
const saisie: ClientNullable = { id: null, nom: null };

// saisie.id = 3;
// error TS2540: Cannot assign to 'id' because it is a read-only property.

// Les modificateurs s'ajoutent par + (sous-entendu quand on l'omet) et se
// retirent par -.
type Modifiable<T> = { -readonly [K in keyof T]: T[K] };
type Complet<T> = { [K in keyof T]-?: T[K] };
type Brouillon<T> = { -readonly [K in keyof T]?: T[K] | null };

type M = Modifiable<Client>; // { id: number; nom: string; email?: string | undefined }
type R = Complet<Client>; // { readonly id: number; nom: string; email: string }

const brouillon: Brouillon<Client> = {};
brouillon.id = 7; // accepte : readonly a ete retire

// Sur un tuple, le mapped type transforme les elements et rend un tuple.
type Paire = Nullable<[number, string]>; // [number | null, string | null]

interface EvenementsPanier {
  ajout: { reference: string; quantite: number };
  retrait: { reference: string };
  vidage: undefined;
}

// as renomme chaque cle au passage. keyof T & string ecarte les cles number et
// symbol, que Capitalize refuse : il n'opere que sur des chaines.
type Gestionnaires<T> = {
  [K in keyof T & string as `on${Capitalize<K>}`]: (charge: T[K]) => void;
};

// Le type obtenu :
// { onAjout: (charge: { reference: string; quantite: number }) => void;
//   onRetrait: (charge: { reference: string }) => void;
//   onVidage: (charge: undefined) => void }
const gestionnaires: Gestionnaires<EvenementsPanier> = {
  onAjout: (charge) => console.log(`+${charge.quantite} ${charge.reference}`),
  onRetrait: (charge) => console.log(`-${charge.reference}`),
  onVidage: () => console.log('panier vide'),
};

gestionnaires.onAjout({ reference: 'USB-64', quantite: 2 }); // +2 USB-64

// Un evenement ajoute a l'interface est un gestionnaire exige partout.
// const partiel: Gestionnaires<EvenementsPanier> = { onAjout() {}, onRetrait() {} };
// error TS2741: Property 'onVidage' is missing in type '{ onAjout(): void; onRetrait(): void; }' but required in type 'Gestionnaires<EvenementsPanier>'.

// Le chemin inverse : infer dans un template literal decoupe la chaine.
type NomEvenement<C> = C extends `on${infer N}` ? Uncapitalize<N> : never;
type Noms = NomEvenement<keyof typeof gestionnaires>; // 'ajout' | 'retrait' | 'vidage'

// Une union dans un template literal se developpe en produit cartesien.
type Coin = `${'haut' | 'bas'}-${'gauche' | 'droite'}`;
// 'haut-gauche' | 'haut-droite' | 'bas-gauche' | 'bas-droite'

interface Client {
  readonly id: number;
  nom: string;
  email?: string;
  motDePasse: string;
}

// Pick : un mapped type sur une partie des cles. K etant contraint a keyof T,
// P in K recopie readonly et ? comme un mapped type homomorphe.
type Choisir<T, K extends keyof T> = { [P in K]: T[P] };

// Omit : Pick sur les cles restantes, obtenues par un conditionnel distribue
// sur l'union keyof T.
type Exclure<T, U> = T extends U ? never : T;
type Retirer<T, K extends keyof T> = Choisir<T, Exclure<keyof T, K>>;

type Apercu = Choisir<Client, 'id' | 'nom'>; // { readonly id: number; nom: string }
type ClientPublic = Retirer<Client, 'motDePasse'>;
// { readonly id: number; nom: string; email?: string | undefined }

function publier(client: Client): ClientPublic {
  const { motDePasse, ...reste } = client;
  return reste;
}

console.log(publier({ id: 1, nom: 'Durand', motDePasse: 'secret' })); // { id: 1, nom: 'Durand' }

// Le Omit de la bibliotheque contraint K a keyof any, pas a keyof T : une
// faute de frappe ne retire rien, et ne le signale pas.
type Fuite = Omit<Client, 'motDePase'>; // motDePasse est toujours la

// type Refus = Retirer<Client, 'motDePase'>;
// error TS2344: Type '"motDePase"' does not satisfy the constraint 'keyof Client'.

// Les definitions de lib.es5.d.ts, renommees pour ne pas masquer les originales.
type Partiel<T> = { [P in keyof T]?: T[P] };
type Requis<T> = { [P in keyof T]-?: T[P] };
type Dictionnaire<K extends keyof any, T> = { [P in K]: T };
type Retour<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

interface Options {
  delaiMs?: number;
  tentatives?: number;
}

const defauts: Requis<Options> = { delaiMs: 500, tentatives: 3 };

function configurer(options: Partiel<Options>): Requis<Options> {
  return { ...defauts, ...options };
}

console.log(configurer({ tentatives: 5 })); // { delaiMs: 500, tentatives: 5 }

// Mappe sur une union de litteraux, Record exige chacune des cles.
type Langue = 'fr' | 'en' | 'de';
const libelles: Dictionnaire<Langue, string> = { fr: 'Panier', en: 'Cart', de: 'Warenkorb' };

type Config = Retour<typeof configurer>; // Requis<Options>

// Un seul type pour trois moyens de paiement : chaque champ propre a l'un
// d'eux devient optionnel, et le compilateur ne sait plus lequel est la.
interface Paiement {
  type: 'carte' | 'virement' | 'especes';
  numeroMasque?: string;
  iban?: string;
  rendu?: number;
}

function libelle(p: Paiement): string {
  switch (p.type) {
    case 'carte':
      return `Carte ${p.numeroMasque}`; // 'Carte undefined' si le champ manque
    case 'virement':
      return `Virement depuis ${p.iban}`;
    case 'especes':
      // return `Especes, rendu ${p.rendu.toFixed(2)} EUR`;
      // error TS18048: 'p.rendu' is possibly 'undefined'.
      return `Especes, rendu ${p.rendu?.toFixed(2)} EUR`;
  }
}

// Et rien n'interdit une combinaison absurde.
const incoherent: Paiement = { type: 'especes', iban: 'FR76 3000 6000 0112 3456 7890 189' };

console.log(libelle(incoherent)); // Especes, rendu undefined EUR

// Une variante par moyen de paiement, chacune avec ses seuls champs, toutes
// marquees par un litteral sous la meme cle : c'est le discriminant.
type Paiement =
  | { type: 'carte'; numeroMasque: string }
  | { type: 'virement'; iban: string }
  | { type: 'especes'; rendu: number };

function libelle(p: Paiement): string {
  switch (p.type) {
    case 'carte':
      // Le test sur p.type a restreint p a la seule variante carte.
      return `Carte ${p.numeroMasque}`;
    case 'virement':
      return `Virement depuis ${p.iban}`;
    case 'especes':
      return `Especes, rendu ${p.rendu.toFixed(2)} EUR`;
  }
  // Pas de return final, et pas d'erreur : les trois cas couvrent l'union, et
  // le compilateur sait que cette ligne est inatteignable.
}

console.log(libelle({ type: 'especes', rendu: 3.5 })); // Especes, rendu 3.50 EUR

// const incoherent: Paiement = { type: 'especes', iban: 'FR76 3000 6000 0112 3456 7890 189' };
// error TS2353: Object literal may only specify known properties, and 'iban' does not exist in type '{ type: "especes"; rendu: number; }'.

type Paiement =
  | { type: 'carte'; numeroMasque: string }
  | { type: 'virement'; iban: string }
  | { type: 'especes'; rendu: number };

// La variante qui arrivera plus tard. L'ajouter a l'union ci-dessus, sans
// toucher a frais, fait echouer la compilation dans le default :
//   | { type: 'cheque'; numero: string }

// Seul never est assignable a never : cet appel ne compile que si le
// compilateur a prouve que la valeur ne peut pas exister.
function nonTraite(valeur: never): never {
  throw new Error(`Variante non traitee : ${JSON.stringify(valeur)}`);
}

function frais(p: Paiement): number {
  switch (p.type) {
    case 'carte':
      return 0.25;
    case 'virement':
    case 'especes':
      return 0;
    default:
      // Chaque case a retire une variante ; il n'en reste aucune, p est de type
      // never. Avec la variante cheque, il en reste une, et l'erreur tombe ici :
      // error TS2345: Argument of type '{ type: "cheque"; numero: string; }' is not assignable to parameter of type 'never'.
      return nonTraite(p);
  }
}

console.log(frais({ type: 'carte', numeroMasque: '**** 4242' })); // 0.25

// Le default sert aussi a l'execution : une valeur venue d'un JSON n'a pas lu
// les types, et une variante inconnue leve au lieu de passer en silence.