TypeScript 5.x: Novedades que Deberías Usar Hoy

TypeScript 5.x trajo mejoras significativas que hacen que escribir código type-safe sea más fácil y performante. En Binary Core, ya adoptamos estas features en nuestros proyectos. Aquí te mostramos las que más valoramos.

Decorators Estables

Después de años en stage experimental, los decorators finalmente son estables en TypeScript 5.x. La sintaxis es más limpia y el soporte de runtime es mejor:

typescriptCopiar
// Decorador de clase
@sealed
class UserService {
  @log
  getUser(id: string): User {
    return this.repository.findById(id);
  }
}

// Decorador de método
function log(
  target: any,
  propertyKey: string,
  descriptor: PropertyDescriptor
) {
  const originalMethod = descriptor.value;
  
  descriptor.value = function (...args: any[]) {
    console.log(`Calling ${propertyKey} with`, args);
    return originalMethod.apply(this, args);
  };
}

// Decorador de clase
function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

Los decorators ahora soportan:

• Decoradores de clase, método, campo, getter y setter
• Metadata estándar con reflect-metadata
• Mejor integración con el runtime de JavaScript

Const Type Parameters

Esta feature permite inferir tipos más específicos cuando usas genéricos con const:

typescriptCopiar
// Antes: infería string[]
function createArray<T>(values: T[]): T[] {
  return values;
}

const arr = createArray(['a', 'b', 'c']);
// arr: string[] (se pierde la información de los valores específicos)

// Ahora: con const type parameters
function createConstArray<const T>(values: T[]): T[] {
  return values;
}

const arr2 = createConstArray(['a', 'b', 'c']);
// arr2: readonly ['a', 'b', 'c'] (se mantiene la información exacta)

// Útil para configuraciones
const config = createConstArray({
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  retries: 3
} as const);
// config se mantiene como readonly con tipos literales

Esto es especialmente útil para:

• Configuraciones inmutables
• Definición de constantes tipadas
• APIs que requieren valores literales específicos

Satisfies Operator

El operador satisfies te permite validar que un valor cumple un tipo sin cambiar el tipo inferido:

typescriptCopiar
type Theme = {
  primary: string;
  secondary: string;
  background: string;
};

// Con satisfies: validamos el tipo pero mantenemos el tipo específico
const theme = {
  primary: '#007bff',
  secondary: '#6c757d',
  background: '#ffffff',
  // TypeScript valida que esto cumpla Theme
  // pero theme sigue teniendo los tipos literales exactos
} satisfies Theme;

// Podemos usar propiedades específicas que Theme no conoce
const primaryColor = theme.primary.toUpperCase(); // OK

// Sin satisfies: el tipo sería Theme, perdiendo literales
const themeOld: Theme = {
  primary: '#007bff',
  secondary: '#6c757d',
  background: '#ffffff',
};
// themeOld.primary es string, no '#007bff'

Mejoras de Performance

TypeScript 5.x tiene mejoras significativas de performance:

• Compilación más rápida: hasta 20% más rápido en proyectos grandes
• Menor uso de memoria: optimización del checker de tipos
• Mejor watch mode: rebuilds incrementales más eficientes

bashCopiar
# Comparativa de tiempos en un proyecto mediano
# TypeScript 4.x: ~12s
# TypeScript 5.x: ~9s (25% más rápido)

Otras Mejoras Notables

Enums más seguros

typescriptCopiar
// Ahora puedes usar union types en lugar de enums
type Status = 'pending' | 'approved' | 'rejected';

// TypeScript 5.x tiene mejor soporte para pattern matching
function handleStatus(status: Status) {
  switch (status) {
    case 'pending':
      return 'Procesando...';
    case 'approved':
      return 'Aprobado';
    case 'rejected':
      return 'Rechazado';
  }
}

Mejor inferencia en funciones

typescriptCopiar
// Inferencia mejorada en funciones genéricas
function mapValues<T extends object, U>(
  obj: T,
  fn: (value: T[keyof T]) => U
): { [K in keyof T]: U } {
  const result = {} as { [K in keyof T]: U };
  for (const key in obj) {
    result[key] = fn(obj[key]);
  }
  return result;
}

const obj = { a: 1, b: 2, c: 3 };
const mapped = mapValues(obj, x => x.toString());
// mapped: { a: string; b: string; c: string }

Migración desde TypeScript 4.x

Migrar es generalmente sencillo:

bashCopiar
# Actualizar TypeScript
npm install typescript@latest

# Actualizar @types
npm install @types/node@latest @types/react@latest

Cambios a tener en cuenta:

• Algunos tipos obsoletos fueron removidos
• La configuración de tsconfig.json puede necesitar ajustes menores
• Los decorators ahora requieren experimentalDecorators: false (son estándar)

Conclusión

TypeScript 5.x no es solo una actualización incremental — trae features que mejoran significativamente la experiencia de desarrollo. En Binary Core, el satisfies operator y los const type parameters se han convertido en herramientas esenciales para escribir código más type-safe y mantenible.

Si aún no has migrado, te recomendamos hacerlo. Las mejoras de performance por sí solas valen la pena, y las nuevas features te permitirán escribir mejor código.