Estas son las herramientas de programación a nivel de tipos de TypeScript: computan nuevos tipos a partir de los existentes.
Un mapped type itera sobre las claves de un tipo y transforma cada una:
<T> = { [K keyof T]: T[K] };
<T> = { [K keyof T]?: T[K] };
{ : ; : ; }
= <>;
[K in keyof T] recorre cada clave K; T[K] es el tipo del valor de esa clave. Así es como se implementan Partial, Readonly y Required. También puedes remapear claves y añadir modificadores (-readonly, -? los eliminan).
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"
T extends U ? X : Y es un if/else a nivel de tipos. Con infer puedes extraer tipos dentro de la condición:
type ElementOf<T> = T extends (infer U)[] ? U : never;
type E = ElementOf<string[]>; // string
// Make only the function-valued properties optional
type PartialMethods<T> = {
[K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K];
};
Los mapped types también distribuyen sobre unions en los conditionals, lo que habilita transformaciones potentes.
Los mapped types y los conditional types permiten que las librerías expresen relaciones de tipos precisas: implementan los utility types, impulsan librerías de formularios/validación, query builders de ORM y clientes de API que infieren las formas de las respuestas.
Son avanzados, pero entenderlos explica cómo el sistema de tipos de TypeScript puede ser tan expresivo, y te permite construir transformaciones de tipos reutilizables en lugar de escribir variantes a mano.