TypeScript

TypeScript 4.8

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de la version 4.8 de son langage TypeScript. Cette mouture apporte de nombreuses nouveautés depuis TypeScript 4.8 bêta. Toutes ces nouveautés sont récapitulées dans ce billet de Microsoft.

Nous y remarquons plus particulièrement l’introduction de plusieurs optimisations qui devraient accélérer les scénarios autour de –watch et --incremental, ainsi que les constructions de références de projet à l'aide de --build. Par exemple, TypeScript est désormais en mesure d'éviter de passer du temps à mettre à jour les horodatages pendant les changements de mode sans opération, ce qui accélère les reconstructions et évite de déranger les autres outils de construction qui pourraient surveiller la sortie de TypeScript.

De nombreuses autres optimisations permettant de réutiliser les informations dans --build, --watch et --incremental ont également été introduites.

Microsoft dit avoir constaté, sur une base de code interne assez importante, des réductions de temps de construction de l'ordre de 10 % à 25 % sur de nombreuses opérations courantes simples, avec des réductions de temps d'environ 40 % dans des scénarios sans changement. Ces améliorations des temps de construction sont décrites plus en détail dans ce billet publié sur GitHub. 

TypeScript 4.8 bêta

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 4.8 bêta. Principalement TypeScript 4.8 apporte une série d'améliorations d'exactitude et de cohérence sous --strictNullChecks. Ces changements affectent le fonctionnement des types d'intersection et d'union et sont exploités dans la façon dont TypeScript restreint les types.

Par exemple, unknown est proche dans l'esprit du type union car il accepte {} | null | undefined, et tout autre type. TypeScript le reconnaît désormais et autorise les affectations de unknown à {} | null | undefined.

function f(x: unknown, y: {} | null | undefined) {
    x = y; // always worked
    y = x; // used to error, now works
}

On peut encore remarquer les améliorations de performances pour -- build, --watch et --incremental. Ainsi TypeScript 4.8 introduit plusieurs optimisations qui devraient accélérer les scénarios autour de --watch et --incremental, ainsi que les constructions de références de projet à l'aide de --build. Par exemple, TypeScript est désormais en mesure d'éviter de passer du temps à mettre à jour les horodatages pendant les changements de mode sans opération, ce qui accélère les reconstructions et évite de déranger les autres outils de construction qui pourraient surveiller la sortie de TypeScript. De nombreuses autres optimisations permettant de réutiliser les informations dans --build, --watch et --incremental ont également été introduites.

En ce qui concerne la portée de ces améliorations, Microsoft dit avoir constaté, sur une base de code interne assez importante, des réductions de temps de l'ordre de 10 % à 25 % sur de nombreuses opérations courantes simples, avec des réductions de temps d'environ 40 % dans des scénarios sans changement.

Microsoft avertir aussi sur quelques changements de rupture introduits par TypeScript 4.8 bêta.

Plus d'informations

TypeScript 4.7

Soumis par fredericmazue le

Microsoft annoncé la disponibilité de TypeScript 4.7 bêta. L'apport majeur de cette nouvelle version est la prise en charge du module ECMScript dans node.js.

Depuis quelques années, Node.js travaille pour supporter les modules ECMAScript (ESM). Cela est un sujet très difficile, car l'écosystème Node.js est construit sur un système de modules différent appelé CommonJS (CJS). L'interopérabilité entre les deux apporte de grands défis, avec de nombreuses nouvelles fonctionnalités à jongler ; cependant, la prise en charge d'ESM dans Node.js a été largement implémentée dans Node.js 12 et versions ultérieures. Depuis TypeScript 4.5, Microsoft a déployé une prise en charge nocturne uniquement pour ESM dans Node.js afin d'obtenir des commentaires des utilisateurs et de permettre aux auteurs de bibliothèques de se préparer à une prise en charge plus large.

Dans TypeScript 4.7 bêta la prise en charge d'ESM dans Node.js était node12. Toutefois, conscient que node.js 12 n'est plus maintenu, Microsoft a commencé à cibler node.js 16

TypeScript 4.7 ajoute donc cette fonctionnalité avec deux nouveaux paramètres de module : node12 et nodenext.

{
    "compilerOptions": {
        "module": "node16",
    }
}

Une autre nouvelle fonctionnalité à remarquer est le contrôle de la détection de module. Un problème avec l'introduction des modules dans JavaScript était l'ambiguïté entre le code "script" existant et le nouveau code de module. Le code JavaScript dans un module s'exécute légèrement différemment et a des règles de portée différentes, de sorte que les outils doivent prendre des décisions sur la façon dont chaque fichier s'exécute. Par exemple, Node.js nécessite que les points d'entrée du module soient écrits dans un .mjs, ou aient package.json à proximité avec le "type": "module". TypeScript traite un fichier comme un module chaque fois qu'il trouve une instruction import ou export dans un fichier, mais sinon, il supposera qu'un fichier .ts ou .js est un fichier de script agissant sur la portée globale

Cela ne correspond pas tout à fait au comportement de Node.js où le package.json peut modifier le format d'un fichier, ou le paramètre --jsxreact-jsx, là où un fichier JSX contient une importation implicite vers une factory JSX. Cela ne correspond pas non plus aux attentes modernes où la plupart des nouveaux codes TypeScript sont écrits en pensant aux modules.

C'est pourquoi TypeScript 4.7 introduit une nouvelle option appelée moduleDetection. moduleDetection peut prendre 3 valeurs : "auto"(la valeur par défaut), "legacy"(le même comportement que la version 4.6 et antérieure), et "force".

TypeScript 4.7 bêta

Soumis par fredericmazue le

Microsoft annoncé la disponibilité de TypeScript 4.7 bêta. L'apport majeur de cette nouvelle version est la prise en charge du module ECMScript dans node.js.

Depuis quelques années, Node.js travaille pour supporter les modules ECMAScript (ESM). Cela est un sujet très difficile, car l'écosystème Node.js est construit sur un système de modules différent appelé CommonJS (CJS). L'interopérabilité entre les deux apporte de grands défis, avec de nombreuses nouvelles fonctionnalités à jongler ; cependant, la prise en charge d'ESM dans Node.js a été largement implémentée dans Node.js 12 et versions ultérieures. Depuis TypeScript 4.5, Microsoft a déployé une prise en charge nocturne uniquement pour ESM dans Node.js afin d'obtenir des commentaires des utilisateurs et de permettre aux auteurs de bibliothèques de se préparer à une prise en charge plus large.

TypeScript 4.7 ajoute cette fonctionnalité avec deux nouveaux paramètres de module : node12 et nodenext.

{
    "compilerOptions": {
        "module": "nodenext",
    }
} 

Une autre nouvelle fonctionnalité à remarquer est le contrôle de la détection de module. Un problème avec l'introduction des modules dans JavaScript était l'ambiguïté entre le code "script" existant et le nouveau code de module. Le code JavaScript dans un module s'exécute légèrement différemment et a des règles de portée différentes, de sorte que les outils doivent prendre des décisions sur la façon dont chaque fichier s'exécute. Par exemple, Node.js nécessite que les points d'entrée du module soient écrits dans un .mjs, ou aient package.json à proximité avec le "type": "module". TypeScript traite un fichier comme un module chaque fois qu'il trouve une instruction import ou export dans un fichier, mais sinon, il supposera qu'un fichier .ts ou .js est un fichier de script agissant sur la portée globale

Cela ne correspond pas tout à fait au comportement de Node.js où le package.json peut modifier le format d'un fichier, ou le paramètre --jsxreact-jsx, là où un fichier JSX contient une importation implicite vers une factory JSX. Cela ne correspond pas non plus aux attentes modernes où la plupart des nouveaux codes TypeScript sont écrits en pensant aux modules.

C'est pourquoi TypeScript 4.7 introduit une nouvelle option appelée moduleDetection. moduleDetection peut prendre 3 valeurs : "auto"(la valeur par défaut), "legacy"(le même comportement que la version 4.6 et antérieure), et "force".

TypeScript 4.6 Bêta

Soumis par fredericmazue le

Microsoft vient de publier TypeScript 4.6 Bêta. Parmi les nouveautés, nous remarquons la possibilité de placer du code dans les constructeurs de classe avant l'appel à super().

Dans les classes JavaScript, il est obligatoire d'appeler super() avant de faire référence à this. TypeScript applique également cela, mais il était un peu trop strict dans la façon dont il le garantissait. Dans TypeScript, c'était auparavant une erreur de placer du code au début d'un constructeur si la classe avait des initialiseurs de propriété. Par exemple :

class Base {
    // ...
}

class Derived extends Base {
    someProperty = true;

    constructor() {
        // error!
        // have to call 'super()' first because it needs to initialize 'someProperty'.
        doSomeStuff();
        super();
    }
}

C'était un moyen facile de vérifier que super() était appelé avant que this soit référencé, mais cela pouvait aboutir à rejeter beaucoup de code valide, explique Microsoft. Pour remédier à cela, TypeScript est plus indulgent et permet à du code d'être exécuté avant l'appel à super() tout en s'assurant que cet appel est fait avant toute référence à this.

Quelques-unes des autres nouveautés apportées par TypeScript 4.6 :

  • Vérifications améliorées de la profondeur de récursivité
  • Améliorations de l'inférence d'accès indexé
  • Analyse de flux de contrôle pour les paramètres dépendants
  • Plus d'erreurs de syntaxe et de liaison dans JavaScript

En ce qui concerne le dernier point, TypeScript a élargi son ensemble d'erreurs de syntaxe et de liaison dans les fichiers JavaScript.

Par exemple, si vous avez deux déclarations d'une même constante dans la même portée d'un fichier JavaScript, TypeScript émettra désormais une erreur sur ces déclarations.

const foo = 1234;
//    ~~~
// error: Cannot redeclare block-scoped variable 'foo'.

// ...
const foo = 5678;
//    ~~~
// error: Cannot redeclare block-scoped variable 'foo'.

Autre exemple, TypeScript vous indiquera si un modificateur est utilisé de manière incorrecte.

function container() {
    export function foo() {
//  ~~~~~~
// error: Modifiers cannot appear here.
    }
}

TypeScript 4.5

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de son langage TypeScript en version 4.5. Il est à remarquer tout d'abord que la prise en charge du module ECMAScript pour Node.js 12, annoncée lors de la sortie de TypeScript 4.5 bêta, a été reportée. Ce support n'est disponible qu'à titre expérimental dans les nightly builds du langage. Microsoft ne donne pas de date pour l'arrivée de ce support en version finale.

La nouveauté la plus marquante de TypeScript 4.5 est l'arrivée du type Awaited et les améliorations que cela apporte aux Promise. Awaited est un type utilitaire. Ce type est destiné à modéliser des opérations comme await dans les fonctions async, ou la méthode .then sur les Promise.

// A = string
type A = Awaited<Promise<string>>;

// B = number
type B = Awaited<Promise<Promise<number>>>;

// C = boolean | number
type C = Awaited<boolean | Promise<number>>;

Microsoft souligne que le type Awaited peut être utile pour modéliser les API existantes, y compris les fonctionnalitées JavaScript intégrées comme Promise.all et Promise.race, Microsoft précise que ce sont certains des problèmes liés à l'inférence avec Promise.all qui ont motivé la création du type Awaited. Microsoft donne cet exemple qui échoue dans TypeScript 4.4 ainsi que dans les versions antérieures :

declare function MaybePromise<T>(value: T): T | Promise<T> | PromiseLike<T>;

async function doSomething(): Promise<[number, number]> {
    const result = await Promise.all([
        MaybePromise(100),
        MaybePromise(200)
    ]);

    // Error!
    //
    //    [number | Promise<100>, number | Promise<200>]
    //
    // is not assignable to type
    //
    //    [number, number]
    return result;
}

Maintenant, Promise.all combine certaines fonctionnalités avec le type Awaited, ce qui donne de bien meilleurs résultats d'inférence, et l'exemple ci-dessus fonctionne.

TypeScript 4.5 Bêta

Soumis par fredericmazue le

Microsoft a annoncé la sortie de TypeScript 4.5 Bêta. Il s'agit d'une version riche qui apporte une douzaine de nouveautés, parmi lesquelles Microsoft souligne particulièrement l'arrivée de deux nouveaux paramètres de modules pour profiter du support de modules ECMAScript arrivé dans node.js depuis la version 12 de celui-ci.

Microsoft explique qu'au cours des dernières années, Node.js a travaillé pour prendre en charge l'exécution de modules ECMAScript (ESM). Cela a été une fonctionnalité très difficile à prendre en charge, car la fondation de l'écosystème Node.js repose sur un système de modules différent appelé CommonJS (CJS). L'interopérabilité entre les deux apporte de grands défis, avec de nombreuses nouvelles fonctionnalités à gérer. Cependant, la prise en charge d'ESM dans Node.js est désormais largement implémentée dans Node.js 12 et versions ultérieures, et la poussière a commencé à retomber.

C'est pourquoi TypeScript 4.5 apporte deux nouveaux paramètres de modules : node12 et nodenext. Voici un exemple d'utilisation de nodenext :

{
    "compilerOptions": {
        "module": "nodenext",
    }
}

Ces nouveaux paramètres apportent quelques fonctionnalités de haut niveau que Microsoft détaille dans ce billet.

Si vous souhaitez essayer TypeSccript 4.5 bêta, vous pouvez l'obtenir via NuGet ou utiliser npm avec la commande suivante :

npm installer typescript@beta

TypeScript 4.4

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 4.4. Outre les nouveautés décrites lors de la sortie de TypeScript en version release candidate, nous remarquons l'arrivée des blocs de code 'static' dans les classes. Il s'agit d'une fonctionnalité qui fera bientôt partir du standard ECMAScript, et qui permet d'écrire un code d'initialisation plus complexe pour les membres statiques.

Par exemple :

class Foo {
    static count = 0;

    // ceci est un bloc static
    static {
        if (someCondition()) {
            Foo.count++;
        }
    }
}

Ces blocs statiques vous permettent d'écrire une séquence d'instructions avec leur propre portée pouvant accéder aux champs privés de la classe conteneur. Cela signifie qu'il est possible d'écrire du code d'initialisation avec toutes les capacités d'écriture d'instructions, aucune fuite de variables et un accès complet aux composants internes de notre classe.

Par exemple :

class Foo {
    static #count = 0;

    get count() {
        return Foo.#count;
    }

    static {
        try {
            const lastInstances = loadLastInstances();
            Foo.#count += lastInstances.length;
        }
        catch {}
    }
}

Sans les blocs stiatic, il n'aurait pas été possible d'écrire le code ci-dessus.

A remarquer encore, avec TypeScript 4.4, des améliorations de performances lors de l'utilisation de types complexes, grâce à un nouveau mécanisme de cache des symboles internes et des améliorations de performances concernant la normalisation des noms de fichiers, qui apportent une réduction de 5 à 10% du temps de chargement des gros projets.

Pour utiliser typescript 4.4 vous pouvez l'obtenir via NuGet ou utiliser npm avec la commande suivante :

npm install typescript

TypeScript 4.4 est disponible en version Release Candidate

Soumis par fredericmazue le

Le 12 août dernier, Microsoft a annoncé la disponibilité de Typescript 4.4 en Release Candidate. Cette nouvelle mouture du langage apporte principalement une meilleure analyse du flux de contrôle des conditions d'alias et l'introduction du drapeau --useUnknownInCatchVariables

Analyse du flux de contrôle des conditions d'alias

En JavaScript, nous devons souvent sonder une variable de différentes manières pour voir si elle a un type plus spécifique que nous pouvons utiliser. TypeScript comprend ces vérifications et les appelle des gardes de type. Au lieu d'avoir à convaincre TypeScript du type d'une variable chaque fois que nous l'utilisons, le vérificateur de type exploite ce qu'on appelle l'analyse de flux de contrôle pour déduire le type dans chaque construction de langage.

Par exemple :

function foo(arg: unknown) {
    if (typeof arg === "string") {
        // We know this is a string now.
        console.log(arg.toUpperCase());
    }
}

Mais que se passe-t-il dans le cas suivant qui déplace la condition vers une constante :

function foo(arg: unknown) {
    const argIsString = typeof arg === "string";
    if (argIsString) {
        console.log(arg.toUpperCase());
        //              ~~~~~~~~~~~
        // Error! Property 'toUpperCase' does not exist on type 'unknown'.
    }
}

TypeScript a perdu l'information de type et remonte une erreur.

TypeScript 4.4 est doté d'une meilleure analyse et le code ci-dessous fontionne maintenant sans erreur.

L'indicateur --useUnknownInCatchVariables

En JavaScript, n'importe quel type de valeur peut être lancé avec throw et capturé dans une clause catch. Pour cette raison, TypeScript a historiquement typé les variables de clause catch en tant que any, et n'autorisait aucune autre annotation de type :

try {
    // Who knows what this might throw...
    executeSomeThirdPartyCode();
}
catch (err) { // err: any
    console.error(err.message); // Allowed, because 'any'
    err.thisWillProbablyFail(); // Allowed, because 'any' :(
}

Toutefois, lorsque TypeScript a ajouté le type unknown , il est devenu clair que celui-ci c'était un meilleur choix que any dans les variables de clause catch pour les utilisateurs qui souhaitent le plus haut degré d'exactitude et de sécurité de type.

Finalement, TypeScript 4.0 a permis aux utilisateurs de spécifier une annotation de type explicite unknown (ou any) sur chaque variable de clause catch. Cependant spécifier manuellement chaque clause peut vite devenir une corvée.

C'est pourquoi TypeScript 4.4 introduit un nouveau drapeau appelé --useUnknownInCatchVariables. Cet indicateur modifie le type par défaut des variables de clause de any a unknown

Ce drapeau est activé sous la famille d'options --strict. Cela signifie que si vous vérifiez votre code à l'aide de --strict, cette option sera automatiquement activée.

Pour utiliser typescript 4.4 RC, vous pouvez l'obtenir via NuGet ou utiliser npm avec la commande suivante :

npm installer typescript@rc

TypeScript 4.4 bêta

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 4.4 en version bêta. Dans cette version, nous remarquons principalement une meilleure analyse du flux de contrôle des conditions d'alias et l'introduction du drapeau --useUnknownInCatchVariables

Analyse du flux de contrôle des conditions d'alias

En JavaScript, nous devons souvent sonder une variable de différentes manières pour voir si elle a un type plus spécifique que nous pouvons utiliser. TypeScript comprend ces vérifications et les appelle des gardes de type. Au lieu d'avoir à convaincre TypeScript du type d'une variable chaque fois que nous l'utilisons, le vérificateur de type exploite ce qu'on appelle l'analyse de flux de contrôle pour déduire le type dans chaque construction de langage.

Par exemple :

function foo(arg: unknown) {
    if (typeof arg === "string") {
        // We know this is a string now.
        console.log(arg.toUpperCase());
    }
}

Mais que se passe-t-il dans le cas suivant qui déplace la condition vers une constante :

function foo(arg: unknown) {
    const argIsString = typeof arg === "string";
    if (argIsString) {
        console.log(arg.toUpperCase());
        //              ~~~~~~~~~~~
        // Error! Property 'toUpperCase' does not exist on type 'unknown'.
    }
}

TypeScript a perdu l'information de type et remonte une erreur.

TypeScript 4.4 est doté d'une meilleure analyse et le code ci-dessous fontionne maintenant sans erreur.

L'indicateur --useUnknownInCatchVariables

En JavaScript, n'importe quel type de valeur peut être lancé avec throw et capturé dans une clause catch. Pour cette raison, TypeScript a historiquement typé les variables de clause catch en tant que any, et n'autorisait aucune autre annotation de type :

try {
    // Who knows what this might throw...
    executeSomeThirdPartyCode();
}
catch (err) { // err: any
    console.error(err.message); // Allowed, because 'any'
    err.thisWillProbablyFail(); // Allowed, because 'any' :(
}

Toutefois, lorsque TypeScript a ajouté le type unknown , il est devenu clair que celui-ci c'était un meilleur choix que any dans les variables de clause catch pour les utilisateurs qui souhaitent le plus haut degré d'exactitude et de sécurité de type.

Finalement, TypeScript 4.0 a permis aux utilisateurs de spécifier une annotation de type explicite unknown (ou any) sur chaque variable de clause catch. Cependant spécifier manuellement chaque clause peut vite devenir une corvée.

C'est pourquoi TypeScript 4.4 introduit un nouveau drapeau appelé --useUnknownInCatchVariables. Cet indicateur modifie le type par défaut des variables de clause de any a unknown

Ce drapeau est activé sous la famille d'options --strict. Cela signifie que si vous vérifiez votre code à l'aide de --strict, cette option sera automatiquement activée.

Pour utiliser typescript 4.4 bêta, vous pouvez l'obtenir via NuGet ou utiliser npm avec la commande suivante :

npm installer typescript@beta