TypeScript 5.5 : Decorators Standardisés et Type System Amélioré

Microsoft a publié le 24 octobre 2025 TypeScript 5.5, une version majeure qui finalise les decorators conformes à ES2024, améliore considérablement le système de types et accélère les performances de compilation de 25%.

Decorators ES2024 : Enfin Standards

Transition de Experimental à Standard

Les decorators expérimentaux de TypeScript sont remplacés par la spécification officielle ES2024 :

Anciennes decorators (legacy) :

// tsconfig.json
{
  "experimentalDecorators": true
}

// Syntaxe legacy
function log(target: any, key: string) {
  // ...
}

class User {
  @log
  login() {}
}

Nouveaux decorators (ES2024) :

// Plus besoin de flag expérimental !

// Decorator de méthode
function log(target: Function, context: ClassMethodDecoratorContext) {
  return function (this: any, ...args: any[]) {
    console.log(`Calling ${context.name as string}`);
    return target.apply(this, args);
  };
}

class User {
  @log
  login() {
    console.log('Logged in');
  }
}

Différences clés :

• Context object fourni en second paramètre
• Type-safe par défaut
• Performance améliorée (30% plus rapide)
• Compatible avec tous les runtimes ES2024

Tous les Types de Decorators

Class Decorators :

function sealed(constructor: Function, context: ClassDecoratorContext) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class BugReport {
  type = "report";
  title: string;

  constructor(t: string) {
    this.title = t;
  }
}

Field Decorators :

function uppercase(target: undefined, context: ClassFieldDecoratorContext) {
  return function (this: any, value: string) {
    return value.toUpperCase();
  };
}

class User {
  @uppercase
  name: string = "john";

  // name sera automatiquement "JOHN"
}

Accessor Decorators :

function logged(target: Function, context: ClassAccessorDecoratorContext) {
  return {
    get(this: any) {
      console.log(`Getting ${context.name as string}`);
      return target.get.call(this);
    },
    set(this: any, value: any) {
      console.log(`Setting ${context.name as string} to ${value}`);
      return target.set.call(this, value);
    }
  };
}

class Person {
  @logged
  accessor age: number = 0;
}

Type System : Inférences Améliorées

Conditional Types Plus Intelligents

TypeScript 5.5 améliore l'inférence des types conditionnels complexes :

Avant (TS 5.4) :

type Result<T> = T extends Promise<infer U> ? U : T;

async function fetchData() {
  return { id: 1, name: "test" };
}

type Data = Result<ReturnType<typeof fetchData>>;
// Type = Promise<{ id: number; name: string; }>
// ❌ N'infère pas automatiquement le type déballé

Maintenant (TS 5.5) :

type Data = Result<ReturnType<typeof fetchData>>;
// Type = { id: number; name: string; }
// ✅ Infère correctement le type déballé !

Template Literal Types Améliorés

Nouveau : Pattern Matching dans Template Literals

type Route = "/users/:id" | "/posts/:id/comments/:commentId";

// Extraire les paramètres automatiquement
type ExtractParams<T extends string> =
  T extends `${infer Start}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractParams<`/${Rest}`>]: string }
    : T extends `${infer Start}:${infer Param}`
    ? { [K in Param]: string }
    : {};

type UserParams = ExtractParams<"/users/:id">;
// Type = { id: string }

type CommentParams = ExtractParams<"/posts/:id/comments/:commentId">;
// Type = { id: string; commentId: string }
// ✅ Parfait pour typer les routes Express/Next.js !

Narrowing Amélioré

typeof guards plus précis :

function process(value: string | number | boolean) {
  if (typeof value === "string") {
    // TS 5.4 : type = string
    // TS 5.5 : détecte aussi les string literals
    return value.toUpperCase();
  }

  if (typeof value === "number") {
    // TS 5.5 infère maintenant les constantes numériques
    return value.toFixed(2);
  }

  // type = boolean (narrowing complet)
  return value ? "yes" : "no";
}

Performance : 25% Plus Rapide

Optimisations Compilation

Benchmarks sur grands projets :

Optimisations clés :

• Cache de résolution de modules amélioré
• Parallélisation accrue (utilise tous les cores CPU)
• Mémoire : -15% de consommation RAM

Watch Mode Ultra-Rapide

# Recompilation incrémentale
tsc --watch

# TS 5.4 : 2-3s par modification
# TS 5.5 : 0.5-1s par modification
# Amélioration : 3x plus rapide !

Nouveaux Utility Types

Awaited Amélioré

// Déballe récursivement les Promises
type DeepAwaited<T> = T extends Promise<infer U>
  ? DeepAwaited<U>
  : T;

type Nested = Promise<Promise<Promise<number>>>;
type Result = DeepAwaited<Nested>;
// Type = number ✅

NoInfer

Empêche l'inférence de type dans certains contextes :

function createConfig<T extends string>(
  values: T[],
  defaultValue: NoInfer<T>
) {
  // defaultValue doit être dans values, mais TS ne l'infère pas
}

// ✅ OK
createConfig(["light", "dark"], "light");

// ❌ Erreur : "auto" n'est pas dans ["light", "dark"]
createConfig(["light", "dark"], "auto");

Intégration IDE

VSCode : Intellisense Amélioré

Nouvelles features :

• Auto-completion decorators : suggestions contextuelles
• Quick fixes : migration legacy → ES2024 decorators
• Refactoring : extraire decorators automatiquement
• Inlay hints : affiche les types inférés inline

Exemple Inlay Hints :

const data = fetchUser();
//    ^^^^^: Promise<User>  <- affiché automatiquement

Migration depuis 5.4

Guide Étape par Étape

1. Mise à jour ** :

npm install typescript@5.5

2. Decorators legacy ** :

Si vous utilisez experimentalDecorators: true, deux options :

Option A : Garder legacy (temporaire)

{
  "compilerOptions": {
    "experimentalDecorators": true  // Garde l'ancien comportement
  }
}

Option B : Migrer vers ES2024 (recommandé)

# Outil de migration automatique
npx ts-migrate decorators ./src

3. Vérifier les breaking changes ** :

# Mode strict pour identifier les problèmes
tsc --strict

Breaking changes mineurs :

• const enums : comportement changé (inlining plus agressif)
• preserveValueImports : déprécié, utiliser verbatimModuleSyntax

Écosystème

Support Framework

Angular 18 :

• Migration complète vers decorators ES2024
• Decorators de composants optimisés

NestJS 11 :

• Decorators de contrôleurs mis à jour
• Performance améliórée de 20%

TypeORM 0.4 :

• Entity decorators ES2024
• Backward compatible avec legacy

Outils

ESLint :

• @typescript-eslint/parser 8.0 avec support TS 5.5
• Règles pour decorators standardisés

Prettier :

• Formatting decorators ES2024
• Compatible depuis Prettier 3.1

Futur : TypeScript 5.6 Preview

Roadmap annoncée (Q1 2026) :

• Explicit Resource Management : using keyword pour cleanup automatique
• Type-only imports améliorés : résolution plus rapide
• Control Flow Analysis : détection bugs encore meilleure

Articles connexes

Pour approfondir le sujet, consultez également ces articles :

• TypeScript 5.6 : Nullish Narrowing et Iterator Helpers Natifs
• Deno 2.0 : Compatibilité Totale avec npm et l'Écosystème Node.js en 2025
• React 19 Stable : Actions, use() Hook et Optimistic UI Natives

Conclusion

TypeScript 5.5 marque une étape majeure avec les decorators ES2024 standardisés, un type system encore plus intelligent et des performances de compilation supérieures. Pour tout développeur TypeScript, cette mise à jour est incontournable.

Avantages clés :

• Decorators enfin standards (exit le flag experimental)
• Compilation 25% plus rapide
• Inférences de types améliorées
• Meilleure expérience IDE

Recommandation : Migrer dès maintenant pour bénéficier des améliorations.

TypeScript 5.5 = le meilleur TypeScript à ce jour.