Microsoft annonce la disponibilité de la version candidate de TypeScript 5.4

Cette version corrige des bogues critiques et contient des changements notables de comportement

Le 23 février 2024 à 13:47, par Jade Emy

1PARTAGES

Après la version Beta de TypeScript 5.4, voici la présentation de la version candidate de TypeScript 5.4 (TypeScript 5.4 RC). Cette version se concentre sur les corrections de bogues. D'ici la sortie de la version stable de TypeScript 5.4, Microsoft ne prévoit pas d'autres changements, que des corrections de bogues critiques.

Voici une liste rapide des nouveautés de TypeScript 5.4 :

Préservation du rétrécissement dans les fermetures après les dernières affectations
Le type utilitaire NoInfer
Object.groupBy et Map.groupBy
Support des appels require() dans --moduleResolution bundler et --module preserve
Attributs et assertions d'importation vérifiés
Correction rapide pour l'ajout de paramètres manquants
Dépréciations à venir de la version 5.5

Ces nouveautés n'ont subit aucun changement dans cette version stable. Depuis la bêta, cette version met à jour les nouveaux changements notables de comportement, y compris les restrictions autour de la compatibilité des enums, les restrictions sur le nommage des membres des enums, et les améliorations dans le comportement des types mappés.

Changements à venir suite aux dépréciations de TypeScript 5.0

TypeScript 5.0 a rendu obsolètes les options et comportements suivants :

charset
target: ES3
importsNotUsedAsValues
noImplicitUseStrict
noStrictGenericChecks
keyofStringsOnly
suppressExcessPropertyErrors
suppressImplicitAnyIndexErrors
out
preserveValueImports
prepend pour les projets références
newLine inmplicitemet spécifique à l'OS

Pour continuer à les utiliser, les développeurs utilisant TypeScript 5.0 et d'autres versions plus récentes ont dû spécifier une nouvelle option appelée ignoreDeprecations avec la valeur "5.0".

Cependant, TypScript 5.4 sera la dernière version dans laquelle elles continueront à fonctionner normalement. D'ici TypeScript 5.5 (probablement juin 2024), elles deviendront des erreurs difficiles à corriger, et le code qui les utilise devra être migré.

Changements notables du comportement

Cette section présente un ensemble de changements notables qu'il convient de reconnaître et de comprendre dans le cadre d'une mise à jour. Elle met parfois en évidence des dépréciations, des suppressions et de nouvelles restrictions. Elle peut également contenir des corrections de bogues qui sont des améliorations fonctionnelles, mais qui peuvent également affecter une version existante en introduisant de nouvelles erreurs.

Changements dans lib.d.ts

Les types générés pour le DOM peuvent avoir un impact sur la vérification de type de votre base de code.

Contraintes de type conditionnelles plus précises

Le code suivant n'autorise plus la deuxième déclaration de variable dans la fonction foo.

Code :

Sélectionner tout

1
2
3
4
5
6
type IsArray<T> = T extends any[] ? true : false;

function foo<U extends object>(x: IsArray<U>) {
    let first: true = x;    // Error
    let second: false = x;  // Error, but previously wasn't
}

Auparavant, lorsque TypeScript vérifiait l'initialisateur pour second, il devait déterminer si IsArray<U> était assignable au type unitaire false. Bien que IsArray<U> ne soit pas compatible de manière évidente, TypeScript examine également la contrainte de ce type. Dans un type conditionnel comme T extends Foo ? TrueBranch : FalseBranch, où T est générique, le système de type regarderait la contrainte de T, la substituerait à T lui-même, et déciderait de la branche vraie ou fausse.

Mais ce comportement était inexact car il était trop enthousiaste. Même si la contrainte de T n'est pas assignable à Foo, cela ne signifie pas qu'elle ne sera pas instanciée avec quelque chose qui l'est. Le comportement le plus correct est donc de produire un type union pour la contrainte du type conditionnel dans les cas où il n'est pas possible de prouver que T n'étend jamais ou toujours Foo.

TypeScript 5.4 adopte ce comportement plus précis. Ce que cela signifie en pratique, c'est que vous pouvez commencer à trouver que certaines instances de type conditionnel ne sont plus compatibles avec leurs branches.

Réduction plus agressive des intersections entre les variables de type et les types primitifs

TypeScript réduit maintenant les intersections entre les variables de type et les primitives de manière plus agressive, en fonction de la façon dont la contrainte de la variable de type se superpose à ces primitives.

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
declare function intersect<T, U>(x: T, y: U): T & U;

function foo<T extends "abc" | "def">(x: T, str: string, num: number) {

    // Was 'T & string', now is just 'T'
    let a = intersect(x, str);

    // Was 'T & number', now is just 'never'
    let b = intersect(x, num)

    // Was '(T & "abc") | (T & "def")', now is just 'T'
    let c = Math.random() < 0.5 ?
        intersect(x, "abc") :
        intersect(x, "def");
}

Amélioration de la vérification des chaînes de caractères avec interpolations

TypeScript vérifie maintenant plus précisément si les chaînes de caractères sont assignables aux emplacements d'un modèle de chaîne de caractères.

Code :

Sélectionner tout

1
2
3
4
5
6
function a<T extends {id: string}>() {
    let x: `-${keyof T & string}`;
    
    // Used to error, now doesn't.
    x = "-id";
}

Ce comportement est plus souhaitable, mais peut causer des ruptures dans le code utilisant des constructions comme les types conditionnels, où ces changements de règles sont faciles à observer.

Erreurs lorsque les importations de type seulement entrent en conflit avec les valeurs locales

Auparavant, TypeScript autorisait le code suivant sous isolatedModules si l'importation vers Something ne faisait référence qu'à un type.

Code :

Sélectionner tout

1
2
3
import { Something } from "./some/path";

let Something = 123;

Cependant, il n'est pas sûr pour un compilateur à fichier unique de supposer qu'il est "sûr" d'abandonner l'importation, même si le code est garanti d'échouer à l'exécution. Dans TypeScript 5.4, ce code déclenchera une erreur comme la suivante :

Code :

Sélectionner tout

Import 'Something' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled.

La solution consiste soit à effectuer un renommage local, soit, comme l'indique l'erreur, à ajouter le modificateur de type à l'importation :

Code :

Sélectionner tout

1
2
3
4
5
import type { Something } from "./some/path";

// or

import { type Something } from "./some/path";

Nouvelles restrictions d'assignabilité des enums

Lorsque deux enums ont les mêmes noms déclarés et les mêmes noms de membres d'enum, ils étaient auparavant toujours considérés comme compatibles ; cependant, lorsque les valeurs étaient connues, TypeScript autorisait silencieusement qu'ils aient des valeurs différentes.

TypeScript 5.4 renforce cette restriction en exigeant que les valeurs soient identiques lorsqu'elles sont connues.

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
namespace First {
    export enum SomeEnum {
        A = 0,
        B = 1,
    }
}

namespace Second {
    export enum SomeEnum {
        A = 0,
        B = 2,
    }
}

function foo(x: First.SomeEnum, y: Second.SomeEnum) {
    // Both used to be compatible - no longer the case,
    // TypeScript errors with something like:
    //
    //  Each declaration of 'SomeEnum.B' differs in its value, where '1' was expected but '2' was given.
    x = y;
    y = x;
}

De plus, il existe de nouvelles restrictions pour les cas où l'un des membres de l'énumération n'a pas de valeur statiquement connue. Dans ce cas, l'autre enum doit au moins être implicitement numérique (par exemple, il n'a pas d'initialisateur résolu statiquement), ou il est explicitement numérique (ce qui signifie que TypeScript pourrait résoudre la valeur en quelque chose de numérique). En pratique, cela signifie que les membres d'une énumération de chaînes de caractères ne sont jamais compatibles qu'avec d'autres énumérations de chaînes de caractères de même valeur.

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
namespace First {
    export declare enum SomeEnum {
        A,
        B,
    }
}

namespace Second {
    export declare enum SomeEnum {
        A,
        B = "some known string",
    }
}

function foo(x: First.SomeEnum, y: Second.SomeEnum) {
    // Both used to be compatible - no longer the case,
    // TypeScript errors with something like:
    //
    //  One value of 'SomeEnum.B' is the string '"some known string"', and the other is assumed to be an unknown numeric value.
    x = y;
    y = x;
}

Restrictions sur les noms des membres des enums

TypeScript ne permet plus aux membres d'une énumération d'utiliser les noms Infinity, -Infinity ou NaN.

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
// Errors on all of these:
//
//  An enum member cannot have a numeric name.
enum E {
    Infinity = 0,
    "-Infinity" = 1,
    NaN = 2,
}

Meilleure préservation des types mappés sur les tuples avec n'importe quels éléments restants

Auparavant, l'application d'un type mappé avec any dans un tuple créait un type d'élément any. Ceci n'est pas souhaitable et est maintenant corrigé.

Code :

Sélectionner tout

1
2
3
4
5
Promise.all(["", ...([] as any)])
    .then((result) => {
        const head = result[0];       // 5.3: any, 5.4: string
        const tail = result.slice(1); // 5.3 any, 5.4: any[]
    });

Quelles sont les prochaines étapes ?

À ce stade, nous prévoyons très peu de changements pour TypeScript 5.4, hormis des corrections de bogues critiques pour le compilateur et des corrections de bogues mineurs pour le service de langage. Dans les prochaines semaines, nous publierons la première version stable de TypeScript 5.4. Gardez un œil sur notre plan d'itération pour connaître les dates de sortie et plus si vous avez besoin de planifier en fonction de cela.

Sinon, nous nous concentrons principalement sur le développement de TypeScript 5.5, et nous venons de rendre public le plan d'itération de TypeScript 5.5. De même, ce plan d'itération décrit les domaines d'intérêt et les éléments de travail prévus, ainsi que les dates de publication cibles que vous pouvez utiliser pour vos propres plans. De plus, nous facilitons l'utilisation des nightly builds de TypeScript sur npm, et il existe une extension pour utiliser ces nightly releases dans Visual Studio Code.

Source : Daniel Rosenwasser et l'équipe TypeScript

Et vous ?

Quel est votre avis sur cette version ?

Voir aussi :

Microsoft annonce la disponibilité de TypeScript 5.4 Beta, avec l'introduction du type utilitaire NoInfer, mais aussi les changements à venir suite aux dépréciations de TypeScript 5.0

TypeScript a 10 ans ! Joyeux anniversaire. À cette occasion, Microsoft fait le point. L'entreprise revient sur les doutes des premiers jours ainsi que sur l'évolution du langage

Cinq vérités inconfortables à propos de TypeScript selon Stefan Baumgartner, auteur de livres sur le langage de programmation

Une erreur dans cette actualité ? Signalez-nous-la !

Votre nom : Votre e-mail :

Décrivez l'erreur que vous souhaitez porter à notre connaissance :

Identifiez-vous

Créer un compte

Microsoft annonce la disponibilité de la version candidate de TypeScript 5.4

Cette version corrige des bogues critiques et contient des changements notables de comportement

Identifiant
Mot de passe

Mot de passe oublié ?

Identifiez-vous

Créer un compte

Microsoft annonce la disponibilité de la version candidate de TypeScript 5.4 Cette version corrige des bogues critiques et contient des changements notables de comportement

Microsoft annonce la disponibilité de la version candidate de TypeScript 5.4

Cette version corrige des bogues critiques et contient des changements notables de comportement