Novedades de TypeScript 5.7 y 5.8

TypeScript 5.7: principales novedades

Comprobación de variables posiblemente no inicializadas

TypeScript 5.7 mejoró el análisis de flujo para detectar variables que podrían usarse antes de ser inicializadas en rutas de código complejas. Esta mejora reduce los errores en tiempo de ejecución causados por acceso a variables no definidas.

function procesarDatos(condicion: boolean): string {
    let resultado: string;

    if (condicion) {
        resultado = "con condición";
    }
    // TypeScript 5.7 detecta que resultado puede no estar inicializado aquí
    return resultado; // ✗ Variable 'resultado' is used before being assigned.
}

// Corrección:
function procesarDatosCorrecto(condicion: boolean): string {
    let resultado: string = "valor por defecto";

    if (condicion) {
        resultado = "con condición";
    }

    return resultado; // ✓
}

Comprobaciones mejoradas para paths relativos en tsconfig

TypeScript 5.7 introdujo búsqueda de tsconfig.json más inteligente al usar rutas relativas. Cuando ejecutas tsc --project ./subcarpeta, TypeScript ahora busca el tsconfig en la ruta relativa correcta desde el directorio de trabajo actual, facilitando los setups con múltiples proyectos.

Soporte mejorado para import attributes

Los import attributes (anteriormente llamados import assertions) permiten proporcionar metadatos sobre los módulos importados. TypeScript 5.7 mejoró el soporte para esta característica, que es especialmente relevante para módulos JSON:

// Importar JSON con type attribute (estándar ECMAScript)
import configuracion from "./config.json" with { type: "json" };

// TypeScript infiere los tipos del JSON automáticamente
console.log(configuracion.version); // Tipado según el contenido del archivo

Para habilitar esta funcionalidad en tsconfig.json:

{
  "compilerOptions": {
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "resolveJsonModule": true
  }
}

Transformaciones de path para JavaScript output

TypeScript 5.7 permite reescribir automáticamente las rutas de importación en el output JavaScript al usar paths aliases, eliminando la necesidad de herramientas adicionales de post-procesado para la resolución de alias en el código compilado.

{
  "compilerOptions": {
    "paths": {
      "@utils/*": ["./src/utils/*"]
    },
    "rewriteRelativeImportExtensions": true
  }
}

TypeScript 5.8: principales novedades

Comprobación de tipos granular en expresiones condicionales

TypeScript 5.8 introdujo mejoras en cómo se comprueban los tipos en expresiones condicionales complejas. Ahora el compilador es más preciso al analizar el tipo de retorno de funciones que devuelven valores condicionales con ramificaciones múltiples.

// TypeScript 5.8 infiere mejor el tipo de retorno en estos casos
function obtenerValor(tipo: "numero" | "texto" | "fecha"): number | string | Date {
    return tipo === "numero" ? 42
         : tipo === "texto" ? "hola"
         : new Date();
}

// El tipo de retorno se infiere correctamente como number | string | Date

Soporte mejorado para require() en módulos ES

TypeScript 5.8 mejoró la compatibilidad entre módulos CommonJS y ES Modules, permitiendo usar require() en archivos con module: NodeNext cuando el target es CommonJS. Esto facilita la migración gradual de proyectos legacy.

// Con TypeScript 5.8 y module: "CommonJS"
// En archivos .cts o cuando moduleResolution permite CJS
const modulo = require("./mi-modulo");

--erasableSyntaxOnly

TypeScript 5.8 introdujo la opción --erasableSyntaxOnly que restringe el código TypeScript a solo incluir sintaxis que puede eliminarse (tipos, interfaces, anotaciones) sin afectar el comportamiento del programa. Esto facilita el uso de TypeScript en entornos donde se usa strip-types (Node.js 23+, Deno, Bun) sin necesidad de compilación.

{
  "compilerOptions": {
    "erasableSyntaxOnly": true
  }
}

Con esta opción, características como enums no constantes y namespaces generan errores, ya que producen código JavaScript en tiempo de ejecución:

// ✗ Con erasableSyntaxOnly: true
enum Color { Rojo, Verde, Azul }  // Error: genera código en runtime

namespace Utilidades {}  // Error: genera código en runtime

// ✓ Con erasableSyntaxOnly: true
const enum Color { Rojo, Verde, Azul }  // Solo en tipos (se inlinea)
type Color = "rojo" | "verde" | "azul"; // Solo tipos

TypeScript sin compilación: Node.js strip-types

Desde Node.js 22.6.0 (experimental) y Node.js 23+, es posible ejecutar archivos TypeScript directamente con Node.js usando strip-types, que elimina las anotaciones de tipo sin compilar. --erasableSyntaxOnly complementa este flujo de trabajo asegurando que el código TypeScript sea compatible con este modo.

# Ejecutar TypeScript directamente en Node.js 23+
node --experimental-strip-types mi-archivo.ts

# O con --input-type=module-typescript
echo 'const x: number = 42; console.log(x)' | node --input-type=module-typescript

Versiones anteriores relevantes: TypeScript 5.0-5.6

Para completar el panorama de las versiones 5.x más importantes:

TypeScript 5.0 (marzo 2023):

• Decoradores estándar TC39 (ver lección dedicada)
• const type parameters para inferencia más estricta
• Múltiples archivos de configuración con extends como array

TypeScript 5.2 (agosto 2023):

• using declarations: gestión de recursos con Symbol.dispose
• Mejoras en tipos de tuplas

// using declaration (TypeScript 5.2)
class ConexionBD {
    [Symbol.dispose]() {
        console.log("Cerrando conexión");
    }
}

function procesarDatos() {
    using conexion = new ConexionBD(); // Se cierra automáticamente al salir del scope
    // Trabaja con la conexión
}

TypeScript 5.4 (marzo 2024):

• NoInfer<T>: evita que TypeScript infiera desde ciertos argumentos
• Mejoras en el narrowing de variables capturadas en closures

// NoInfer evita que un parámetro "contamine" la inferencia
function crearComponente<T>(valor: T, defecto: NoInfer<T>): T {
    return valor ?? defecto;
}

// TypeScript infiere T desde 'valor', no desde 'defecto'
crearComponente("texto", 42); // ✗ Error: 42 no es string
crearComponente("texto", "alternativa"); // ✓

TypeScript 5.5 (junio 2024):

• Inferencia de type guards en funciones de predicado
• Soporte mejorado para Regular Expressión syntax checking

// TypeScript 5.5 puede inferir el type guard sin anotación explícita
function esCadena(valor: unknown) {
    return typeof valor === "string";
}

// TypeScript infiere automáticamente: (valor: unknown) => valor is string
const valores = [1, "hola", null, "mundo", 42];
const soloCadenas = valores.filter(esCadena); // string[]

TypeScript 5.6 (septiembre 2024):

• Comprobación de iteradores y generadores mejorada
• --noUncheckedSideEffectImports para importaciones de solo efectos secundarios