TypeScripten AL2 023

TypeScript(TS) est un langage de programmation basé sur JavaScript (JS) qui offre toutes les fonctionnalités de JS et l'étend également avec un système de types. Dans un scénario typique, les programmes écrits en TS sont d'abord traduits dans le code JS, puis exécutés comme n'importe quel autre programme JS normal parNode.js. Dans la terminologie spécifique de TS, ce processus de traduction est appelé « compilation » et est effectué par un « compilateur », appelé tsc. Le compilateur tsc lui-même est écrit en JS, donc pour fonctionner, il a également besoin d'un environnement d'exécution JS, tel queNode.js. Contrairement à d'autres environnements d'exécution JS, il ne dispose Node.js actuellement que d'un support TS expérimental et léger. Un support TS complet, y compris la vérification de type, nécessite toujours l'utilisation de packages tiers, tels que le tapuscript. La méthode attendue pour obtenir tsc (le compilateur TS) pour l'environnement Node.js d'exécution consiste à installer le module de nœud typescript. Cela peut être fait à l'aide de l'un des gestionnaires de packages, généralement npm. Il existe deux manières d'installer le compilateur TS à l'aide de npm : globalement et dans un projet. La méthode officiellement recommandée consiste à installer le compilateur TS par projet, ce qui garantit la cohérence et la reproductibilité à long terme des projets. Cependant, l'installation globale du compilateur TS peut toujours être utile, car il fournit la même version pour l'ensemble de l'hôte et son environnement d'exécution JS, et donc pour les projets sur lesquels aucun compilateur TS n'est installé localement. C'est précisément ainsi que les packages RPM disponibles sur Amazon Linux, tels que nodejs20-typescript ou nodejs22-typescript installent un compilateur TS : globalement au niveau du système, et séparément pour chaque Node.js version prise en charge.

Le tsc ne dépend directement d'aucune Node.js version. Le compilateur attend un certain niveau de fonctionnalités d'exécution, qui sont définies dans un fichier spécial (tsconfig.json) via des options telles que target et lib. Les valeurs de ces options représentent une version de la norme ECMAScript(ES), qui peut (ou non) être prise en charge par l'environnement d'exécution JS. Différentes versions Node.js prennent en charge différentes versions de la norme ES. Plus la version de est récenteNode.js, plus la version standard ES prise en charge est performante et complète. Si tsconfig.json n'existe pas dans le répertoire racine d'un projet, l'ensemble d'options de configuration par défaut sera utilisé. Le tableau de compatibilité avec les différentes versions Node.js et les fonctionnalités prises en charge par les différentes versions standard ES est disponible sur node.green. Le tsc comporte plus de 100 options différentes, qui peuvent être définies dans le tsconfig.json. Le chaînage de configuration est également pris en charge lorsque certaines options de configuration sont définies dans un autre fichier puis incluses dans le fichier principal. Cette approche permet d'installer une base TS Config compatible avec une certaine version deNode.js, puis de l'étendre avec des options spécifiques au projet. Heureusement, les configurations de base TS pour Node.js sont disponibles sous forme de modules de nœuds qui peuvent être installés dans un dossier de projet à l'aide de npm. Voici le code source de la configuration pour les Node.js versions 18, 20 et 22.

La conception d'exécution Node.js basée sur un environnement d'exécution présente un certain point faible : elle ne prend en charge qu'une seule version de l'environnement d'exécution sur un hôte et exige la reproductibilité et la cohérence de toutes les dépendances au niveau du projet. Cela a conduit à l'approche commune suivante TypeScript : le compilateur TS, la configuration de base TS pour la Node.js version actuelle et toutes les dépendances logicielles sont installés localement, dans un projet. Bien que les modules de nœuds installés globalement soient censés être uniquement des outils CLI, tels que npm, tsc, qui est également un outil CLI, est rarement installé globalement. Heureusement, les installations globales (à l'échelle du système) et locales (au sein d'un projet) de tsc peuvent coexister sans problème et peuvent également être des versions différentes utilisées indépendamment. Notez qu'un tsc installé localement doit être exécuté à l'aide de l'outil npx, qui est installé avec npm. Ainsi, même avec un compilateur système TS, les utilisateurs ont la possibilité de choisir des versions des composants du moteur d'exécution, par exemple Node.js (en changeant la version active via des alternatives), un compilateur TS (en l'installant localement ou globalement et en changeant également la version active via des alternatives), et en le configurant pour les besoins spécifiques.

Amazon Linux empaquète un compilateur TS de la même manière que les autres modules de nœuds installés dans le monde entier, tels que npm, sur une base par Node.js version. Les packages et les fichiers binaires sont dotés d'un espace de noms et contiennent la version majeure de dans leur Node.js nom. Le nom exécutable par défaut du compilateur, tsc, est géré au moment de l'exécution par l'outil alternatives et indique la version actuellement active Node.js pour laquelle il a été installé et par laquelle il sera exécuté. Cette sélection ne dépend pas de la version Node.js d'exécution actuelle. Il est possible que l'exécutable du nœud pointe vers Node.js 20 et que tsc soit configuré pour être interprété par le Node.js 22. Il est également possible d'utiliser les noms avec espaces de noms d'un compilateur TS, par exemple tsc- {MAJOR_VERSION} indépendamment de ce pour quoi le nom tsc par défaut est configuré.

Exemple d'installation et d'utilisation de plusieurs versions de Node et d'un compilateur TS sur le même système :

# Check the AL2023 release
$ cat /etc/amazon-linux-release
Amazon Linux release 2023.9.20250929 (Amazon Linux)

# Install a TypeScript compiler for Node.js 20 and 22
# Node.js 20 and 22 will be installed automatically
$ sudo dnf install -qy nodejs20-typescript nodejs22-typescript

# Check what was installed
$ rpm -q nodejs20 nodejs20-typescript nodejs22 nodejs22-typescript
nodejs20-20.19.5-1.amzn2023.0.1.x86_64
nodejs20-typescript-5.9.2-1.amzn2023.0.1.noarch
nodejs22-22.19.0-1.amzn2023.0.1.x86_64
nodejs22-typescript-5.9.2-1.amzn2023.0.1.noarch

# Check the active version of Node.js - it is version 20
$ alternatives --display node
node - status is auto.
 link currently points to /usr/bin/node-20
/usr/bin/node-20 - priority 100
 slave npmrc: /usr/lib/nodejs20/lib/node_modules/npm/npmrc
 slave npm: /usr/bin/npm-20
 slave npx: /usr/bin/npx-20
 slave node_modules: /usr/lib/nodejs20/lib/node_modules
/usr/bin/node-22 - priority 100
 slave npmrc: /usr/lib/nodejs22/lib/node_modules/npm/npmrc
 slave npm: /usr/bin/npm-22
 slave npx: /usr/bin/npx-22
 slave node_modules: /usr/lib/nodejs22/lib/node_modules
Current 'best' version is /usr/bin/node-20.

# Check the active JS runtime version for TypeScript
# Currently, the tsc compiler will be executed by Node.js 22
$ alternatives --display tsc
tsc - status is auto.
 link currently points to /usr/bin/tsc-22
/usr/bin/tsc-22 - priority 100
 slave tsserver: /usr/bin/tsserver-22
/usr/bin/tsc-20 - priority 100
 slave tsserver: /usr/bin/tsserver-20
Current 'best' version is /usr/bin/tsc-22.

# Check versions printed by executables
$ node -v
v20.19.5

$ tsc -v
Version 5.9.2

# while the node is 20, tsc is executed by node 22 anyway
$ head -1 /usr/bin/tsc
#!/usr/bin/node-22

# However, instead of default executable names, e.g. node or tsc,
# we can use namespaced names to target any installed version
$ node-20 -v
v20.19.5

$ node-22 -v
v22.19.0

$ tsc-20 -v
Version 5.9.2

$ tsc-22 -v
Version 5.9.2

$ head -1 /usr/bin/tsc-20
#!/usr/bin/node-20

$ head -1 /usr/bin/tsc-22
#!/usr/bin/node-22