Guide Complet TypeScript 6.0 : Nouvelles Fonctionnalités, Changements Majeurs et Migration

TypeScript 6.0 est sorti le 20 mars 2026, et c'est la version la plus importante en plusieurs années. Non pas à cause d'un opérateur de type fantaisiste — mais parce que c'est la dernière version du compilateur TypeScript écrite en JavaScript. TypeScript 7 livrera un compilateur basé sur Go promettant des compilations 10 fois plus rapides. TypeScript 6.0 existe pour faire le pont : il renforce les valeurs par défaut, supprime le code hérité obsolète et introduit de vraies nouvelles fonctionnalités comme les types intégrés pour l'API Temporal.

Si vous effectuez la mise à niveau sans lire les notes de version, votre CI sera cassé. Ce guide vous explique tout ce qui a changé, avec des exemples de code et une liste de vérification de migration détaillée.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Node.js 18 ou supérieur installé
• Un projet TypeScript actuellement en version 5.x
• Une connaissance de base de tsconfig.json
• Un éditeur de code (VS Code est recommandé)

Ce que vous allez accomplir

À la fin de ce guide, vous aurez :

1. Un tsconfig.json entièrement migré compatible avec TypeScript 6.0
2. Des exemples pratiques de chaque nouvelle fonctionnalité significative
3. Une compréhension opérationnelle des types de l'API Temporal
4. Une vision claire de ce que TypeScript 7 (compilateur Go) signifie pour votre workflow

Étape 1 : Installer TypeScript 6.0

Commencez par mettre à niveau votre projet :

npm install typescript@6 --save-dev
# ou
pnpm add typescript@6 --save-dev

Après l'installation, exécutez le compilateur immédiatement pour voir ce qui se casse :

npx tsc --noEmit 2>&1 | head -50

Vous verrez probablement des erreurs liées aux options de configuration dépréciées ou aux violations du mode strict. Ne paniquez pas — chaque erreur correspond à une section de ce guide.

Étape 2 : Comprendre les Nouvelles Valeurs par Défaut

TypeScript 6.0 a changé neuf valeurs par défaut dans tsconfig.json. Si votre configuration repose sur des valeurs par défaut implicites, le comportement de votre build changera silencieusement. Voici une comparaison complète :

Action : Rendre Toutes les Valeurs par Défaut Explicites

L'approche de migration la plus sûre consiste à fixer explicitement chaque valeur par défaut dans tsconfig.json, pour que les futures mises à niveau de TypeScript ne puissent pas modifier silencieusement le comportement :

{
  "compilerOptions": {
    "target": "es2022",
    "module": "esnext",
    "moduleResolution": "bundler",
    "strict": true,
    "esModuleInterop": true,
    "types": [],
    "rootDir": "./src",
    "outDir": "./dist"
  }
}

Si vous avez besoin de l'ancien comportement pendant une migration incrémentale, ajoutez :

{
  "compilerOptions": {
    "ignoreDeprecations": "6.0"
  }
}

Cela supprime temporairement les avertissements de dépréciation. Cela ne fonctionnera pas dans TypeScript 7.0, alors traitez-le comme une béquille temporaire, pas comme un correctif permanent.

Étape 3 : Gérer les Changements Majeurs

3.1 — Le Mode Strict Est Activé par Défaut

strict: true active un ensemble de drapeaux de rigueur :

• strictNullChecks
• strictFunctionTypes
• strictBindCallApply
• strictPropertyInitialization
• noImplicitAny
• noImplicitThis
• useUnknownInCatchVariables

Si votre projet n'avait pas strict: true auparavant, vous verrez maintenant des erreurs comme :

// Erreur TypeScript 6.0 : L'objet est peut-être 'undefined'
function saluer(nom: string | undefined) {
  return "Bonjour " + nom.toUpperCase(); // ❌
}
 
// Correction : ajoutez une vérification null
function saluer(nom: string | undefined) {
  return "Bonjour " + (nom ?? "visiteur").toUpperCase(); // ✅
}

Pour les grandes bases de code, activez les drapeaux strict individuellement et corrigez-les un par un :

{
  "compilerOptions": {
    "strict": false,
    "strictNullChecks": true,
    "noImplicitAny": true
  }
}

3.2 — La Cible ES5 Est Supprimée

Si vous aviez "target": "es5" dans votre configuration, TypeScript 6.0 génèrera une erreur. Mettez à jour votre cible :

{
  "compilerOptions": {
    "target": "es2022"
  }
}

Si vous avez vraiment besoin d'une sortie ES5 pour la prise en charge des anciens navigateurs, utilisez Babel ou SWC comme étape de transpilation après la vérification des types TypeScript.

3.3 — Les Formats de Modules AMD et UMD Sont Dépréciés

// ❌ Déprécié dans TypeScript 6.0
{
  "compilerOptions": {
    "module": "amd"
  }
}
 
// ✅ Utilisez plutôt
{
  "compilerOptions": {
    "module": "esnext"
  }
}

3.4 — L'Option outFile Est Supprimée

L'option outFile concaténait toute la sortie dans un seul fichier — un modèle hérité de l'ère pré-bundler de TypeScript. Elle est maintenant entièrement supprimée. Remplacez-la par un bundler approprié : Vite, Rollup, tsdown ou esbuild.

3.5 — baseUrl Seul Est Déprécié

baseUrl sans paths est déprécié. Utilisez des mappings de chemins explicites :

// ❌ Déprécié
{
  "compilerOptions": {
    "baseUrl": "./src"
  }
}
 
// ✅ Utilisez paths à la place
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  }
}

Étape 4 : Utiliser l'Outil de Migration Automatisé

Pour les deux changements les plus perturbateurs (suppression de baseUrl et inférence de rootDir), utilisez l'outil officiel ts5to6 :

npx ts5to6

Cet outil analyse votre tsconfig.json et effectue automatiquement :

• La conversion de baseUrl seul en paths explicites
• L'ajout de rootDir explicite là où il était précédemment inféré
• Le signalement des options nécessitant une révision manuelle

Exécutez-le en premier, puis traitez les erreurs restantes manuellement.

Étape 5 : Explorer les Nouvelles Fonctionnalités du Langage

5.1 — Types Intégrés pour l'API Temporal

La proposition Temporal API a atteint le Stage 4 et TypeScript 6.0 inclut des déclarations de types intégrées pour elle. Pas besoin de polyfill ni de paquet @types.

Activez-la dans votre configuration :

{
  "compilerOptions": {
    "target": "esnext",
    "lib": ["esnext", "esnext.temporal", "dom"]
  }
}

Puis utilisez-la avec une sécurité de types complète :

// Obtenir la date et l'heure actuelles
const maintenant = Temporal.Now.plainDateTimeISO();
console.log(maintenant.toString()); // "2026-06-03T12:00:00"
 
// Ajouter une durée
const semainePro = maintenant.add({ days: 7 });
console.log(semainePro.toString()); // "2026-06-10T12:00:00"
 
// Calculer la différence entre deux dates
const echeance = Temporal.PlainDateTime.from("2026-12-31T23:59:00");
const diff = maintenant.until(echeance);
console.log(`${diff.days} jours avant la fin de l'année`);
 
// Avec prise en charge des fuseaux horaires
const reunionAParis = Temporal.ZonedDateTime.from({
  timeZone: "Europe/Paris",
  year: 2026,
  month: 6,
  day: 15,
  hour: 14,
  minute: 30,
});
console.log(reunionAParis.toString());

Classes Temporal principales et leurs types TypeScript :

Remarque : Si votre projet utilise temporal-polyfill ou @js-temporal/polyfill, ces types de paquets ne sont pas interassignables avec les nouvelles déclarations intégrées. Supprimez le polyfill une fois que votre environnement d'exécution supporte Temporal nativement (Node.js 22 et supérieur).

5.2 — Inférence de Type Améliorée pour les Méthodes

TypeScript 6.0 corrige une limitation ancienne concernant l'inférence des signatures de méthodes dans les types génériques :

class QueryBuilder<T> {
  filtrer(predicat: (item: T) => boolean): this {
    return this;
  }
 
  trier(comparateur: (a: T, b: T) => number): this {
    return this;
  }
}
 
// TypeScript 6.0 infère maintenant correctement la chaîne de types
const resultat = new QueryBuilder<Utilisateur>()
  .filtrer(u => u.actif)                     // correctement typé comme QueryBuilder<Utilisateur>
  .trier((a, b) => a.age - b.age);           // toujours QueryBuilder<Utilisateur>

5.3 — Imports de Sous-chemins avec le Préfixe #/

TypeScript 6.0 ajoute une prise en charge de première classe pour les imports de sous-chemins Node.js. Définissez-les dans package.json :

{
  "imports": {
    "#/utils": "./src/utils/index.ts",
    "#/config": "./src/config.ts",
    "#/*": "./src/*.ts"
  }
}

Puis utilisez-les dans TypeScript avec une résolution de types complète :

import { formaterDate } from "#/utils";
import { configApp } from "#/config";

TypeScript 6.0 résout ces imports vers les fichiers sources corrects sans configuration supplémentaire.

5.4 — Cible et Bibliothèque ES2025

La nouvelle cible "target": "es2025" émet les fonctionnalités JavaScript modernes nativement :

// Avec target: "es2025", TypeScript n'abaissera pas le niveau de ces expressions
const resultat = await Promise.try(() => operationRisquee());
 
import donnees from "./data.json" with { type: "json" };
 
const echappe = RegExp.escape("hello.world"); // "hello\\.world"

Étape 6 : Améliorations de Performance en Pratique

TypeScript 6.0 apporte des gains de performance mesurables :

• 40-60% plus rapide en compilation incrémentale — le compilateur met en cache les résultats de résolution de types plus agressivement
• 25% de réduction de la consommation mémoire — la consommation de mémoire de pointe diminue significativement pour les grandes bases de code
• 30% plus rapide pour les opérations d'éditeur — les astuces de type, le survol et la navigation vers la définition sont nettement plus réactifs

Vous n'avez pas besoin de modifier de code pour bénéficier de ces améliorations. Elles s'appliquent automatiquement après la mise à niveau.

Pour mesurer vos temps de compilation :

# Avant la mise à niveau
time npx tsc --noEmit
 
# Après la mise à niveau vers 6.0
time npx tsc --noEmit

Étape 7 : Vérifier Votre Migration

Après avoir appliqué tous les changements, exécutez une vérification de types complète :

npx tsc --noEmit

Vérifiez également que les tests passent toujours :

npm test

Une migration réussie produit :

• Zéro erreur TypeScript sur tsc --noEmit
• Tous les tests passent
• Sortie de build dans le format de module correct

Étape 8 : Se Préparer pour TypeScript 7

TypeScript 7.0 livrera le compilateur basé sur Go (tsc-go). Vous n'aurez pas besoin de modifier votre code TypeScript — seulement la façon dont vous invoquez le compilateur. Le compilateur Go offre :

• Compilations initiales 10 fois plus rapides par rapport à TypeScript 6.0
• Traitement parallèle des fichiers grâce aux goroutines Go
• Remplacement direct de la CLI tsc actuelle

Pour vous préparer dès maintenant :

1. Supprimez tous les usages de ignoreDeprecations: "6.0" — ils généreront des erreurs dans TypeScript 7
2. Assurez-vous que votre tsconfig.json ne contient pas d'options dépréciées
3. Testez avec la version nightly de TypeScript 7 si vous souhaitez un retour anticipé :

npm install typescript@next --save-dev

Résolution des Problèmes

"strict est activé mais je veux migrer de façon incrémentale"

Activez les drapeaux strict individuels plutôt que le parapluie strict: true :

{
  "compilerOptions": {
    "strict": false,
    "strictNullChecks": true,
    "noImplicitAny": true,
    "strictFunctionTypes": true
  }
}

"Module introuvable après avoir changé moduleResolution en bundler"

Le mode bundler autorise les imports sans extension mais nécessite que votre bundler (Vite, webpack, etc.) résolve également les extensions. Si vous utilisez tsc directement pour émettre, utilisez plutôt "moduleResolution": "node16".

"Conflit de types Temporal avec le polyfill"

Supprimez votre paquet polyfill et son entrée @types. Avec TypeScript 6.0, les types Temporal sont intégrés :

npm uninstall temporal-polyfill @types/temporal-polyfill

"outFile était ma stratégie de bundling"

Remplacez outFile par un bundler approprié. Pour la publication de bibliothèques, tsdown est l'option recommandée actuellement :

npm install tsdown --save-dev
npx tsdown --entry src/index.ts --format esm,cjs --dts

Prochaines Étapes

• Lisez les notes de version officielles de TypeScript 6.0
• Explorez la documentation de l'API Temporal
• Suivez la feuille de route TypeScript 7 pour les mises à jour du compilateur Go
• Consultez notre tutoriel sur la validation de schéma avec Zod v4
• Explorez Effect-TS pour des pipelines avancés avec sécurité de types

Conclusion

TypeScript 6.0 est une version de transition. Elle modernise l'outillage du langage en supprimant les héritages vieux d'une décennie, renforce les valeurs par défaut pour refléter la façon dont les développeurs configurent réellement leurs projets aujourd'hui, et introduit l'API Temporal comme la première primitive JavaScript genuinement nouvelle que TypeScript a typée en plusieurs années.

Le chemin de migration est simple : exécutez npx ts5to6, rendez explicites vos valeurs par défaut de configuration, traitez les violations du mode strict de façon incrémentale, et c'est fait. Votre base de code — et votre futur vous attendant des compilations 10 fois plus rapides — vous remercieront.