TypeScript en AL2023

TypeScript (TS) es un lenguaje de programación basado en JavaScript (JS) que ofrece todas las funciones de JS y, además, lo amplía con un sistema de tipos. En un escenario típico, los programas escritos en TS se traducen primero al código JS y luego se ejecutan como cualquier otro programa JS normalNode.js. En la terminología específica de TS, este proceso de traducción se denomina “compilación” y lo realiza un “compilador”, llamado tsc. El propio compilador tsc está escrito en JS, por lo que, para ejecutarse, también necesita un entorno de ejecución de JS, como Node.js. A diferencia de otros entornos de ejecución de JS, Node.js actualmente solo tiene soporte TS experimental y ligero. La compatibilidad total con TS, incluida la verificación de tipos, aún requiere el uso de paquetes de terceros, como TypeScript. La forma esperada de obtener tsc (el compilador de TS) para el entorno de ejecución de Node.js es instalar el módulo de nodo Typescript. Esto se puede hacer usando uno de los administradores de paquetes, normalmente npm. Hay dos formas de instalar el compilador de TS usando npm: globalmente y en un proyecto. El método recomendado oficialmente es instalar el compilador de TS por proyecto, lo que garantiza la coherencia y la reproducibilidad de los proyectos a largo plazo. Sin embargo, instalar el compilador de TS de forma global puede seguir siendo útil, ya que proporciona la misma versión para todo el host y su entorno de ejecución de JS y, por lo tanto, para los proyectos que no tienen un compilador de TS instalado localmente. Así es precisamente como los paquetes RPM disponibles en Amazon Linux, como nodejs20-typescript o nodejs22-typescript, instalan un compilador de TS: globalmente en el nivel del sistema y por separado para cada versión de Node.js compatible.

El tsc no depende directamente de ninguna versión de Node.js. El compilador espera un cierto nivel de características de tiempo de ejecución, que se definen en un archivo especial (tsconfig.json) a través de opciones tales como target y lib. Los valores de estas opciones representan una versión del estándar ECMAScript (ES), que puede (o no) ser compatible con el entorno de ejecución JS. Las distintas versiones de Node.js admiten diferentes versiones de ES. Cuanto más reciente sea la versión de Node.js, más alta y completa será la compatible con la versión estándar de ES. Si tsconfig.json no existe en el directorio raíz de un proyecto, se utilizará el conjunto predeterminado de opciones de configuración. La tabla de compatibilidad con las distintas versiones de Node.js y las funciones compatibles de las distintas versiones estándar de ES está disponible en node.green. El tsc tiene más de 100 opciones diferentes, que se pueden definir en tsconfig.json. También se admite el encadenamiento de configuraciones cuando algunas opciones de configuración se definen en otro archivo y luego se incluyen en el archivo principal. Este enfoque permite instalar una configuración TS base compatible con una versión determinada de y, a continuación, ampliarla con opciones específicas del proyecto. Afortunadamente, las configuraciones TS base de Node.js están disponibles como módulos de nodo que se pueden instalar en una carpeta de proyecto mediante npm. Este es el código fuente de la configuración para las versiones de Node.js 18, 20 y 22.

El diseño del tiempo de ejecución de Node.js basado tiene una cierta debilidad: solo admite una versión del tiempo de ejecución en un host y requiere la reproducibilidad y la coherencia de todas las dependencias en el nivel del proyecto. Esto llevó al siguiente enfoque común de usar TypeScript: el compilador de TS, la configuración base de TS para la versión actual de Node.js y todas las dependencias de software se instalan localmente, dentro de un proyecto. Aunque se espera que los módulos de nodo instalados globalmente sean solo herramientas CLI, como npm y tsc, que también es una herramienta CLI, rara vez se instala globalmente. Afortunadamente, las instalaciones globales (en todo el sistema) y locales (dentro de un proyecto) de tsc pueden coexistir sin problemas y también pueden ser versiones diferentes que se utilizan de forma independiente. Tenga en cuenta que un tsc instalado localmente debe ejecutarse con la herramienta npx, que se instala junto con npm. Por lo tanto, incluso con un compilador TS de sistema, los usuarios tienen la oportunidad de elegir versiones de los componentes del motor de ejecución, por ejemplo Node.js (cambiando la versión activa por alternativas), un compilador de TS (instalándolo local o globalmente y también cambiando la versión activa a través de alternativas) y configurándolo según las necesidades específicas.

Amazon Linux empaqueta un compilador de TS de la misma forma que otros módulos de nodos instalados globalmente, como npm, en una versión básica por versión de Node.js. Los paquetes y los binarios tienen espacios de nombres y contienen la versión principal de Node.js como parte de sus nombres. El nombre ejecutable predeterminado del compilador, tsc, lo administra en tiempo de ejecución la herramienta de alternativas y apunta a la versión actualmente activa de Node.js para la que se instaló y con la que se ejecutará. Esta selección no depende de la versión de tiempo de ejecución actual de Node.js. Es posible tener un ejecutable de nodo que apunte a Node.js 20 y que tsc esté configurado para ser interpretado por Node.js 22. También es posible utilizar los nombres con espacios de nombres de un compilador de TS, por ejemplo, tsc- {MAJOR_VERSION} independientemente de para qué esté configurado el nombre de tsc predeterminado.

Un ejemplo de instalación y uso de varias versiones de Node y un compilador de TS en el mismo sistema:

# 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