Node FINALLY Supports TypeScript

Summary

The script discusses the long-awaited support for TypeScript in Node.js, a feature that has been absent since Node's inception in 2009. It highlights the emergence of alternatives like Dino and Bun, which embraced TypeScript early on. The speaker delves into the complexities of integrating TypeScript, emphasizing the distinction between type checking and transpilation. The introduction of a new Node.js flag that enables type stripping—removing TypeScript syntax without type checking—is explored. The script also touches on the TC39 proposal for type annotations in vanilla JavaScript and the use of SWC (a Rust-based tool) for implementing this feature, aiming to streamline the JavaScript ecosystem and reduce the need for external dependencies.

Takeaways

• 🕰️ Node.js was released in 2009, but it still doesn't natively support TypeScript, which has become the language of choice for the JavaScript ecosystem.
• 🏆 TypeScript has won the debate over other type systems like Flow, solidifying its position as the preferred choice for JavaScript projects.
• 🔄 Supporting TypeScript is complex because it can mean different things to different people, ranging from type checking to running TypeScript code directly.
• 📝 The TC39 proposal for type annotations aims to integrate TypeScript-like syntax into vanilla JavaScript without the need for transpilation.
• 🛠️ The goal of the TC39 proposal is to allow developers to run TypeScript, Flow, and other static typing supersets of JavaScript in the browser without modification.
• 🚫 Previous attempts to enforce types in JavaScript, like the V8 team's 'strong mode' experiment, resulted in performance issues and were eventually abandoned.
• 🛑 The new Node.js flag for TypeScript is not about type checking but about stripping types and running the resulting JavaScript code.
• 🔧 Node.js will use the 'swc' (Scalable Web Compiler) package for type stripping, leveraging its efficiency and small footprint compared to other solutions.
• 🌐 The use of WebAssembly for 'swc' allows it to run across all platforms without the need for platform-specific binaries, reducing the size and complexity of Node.js.
• 📜 The 'Amaro' package, a wrapper around 'swc', will handle the type stripping process in Node.js, making it easier to execute TypeScript files without external dependencies.
• 📝 Node.js will enforce the use of file extensions and module syntax, requiring developers to explicitly use either CommonJS or ES module formats.

Q & A

Why is the support for TypeScript in Node.js significant?

Support for TypeScript in Node.js is significant because TypeScript has become the language of choice for the JavaScript ecosystem, especially for building tools and projects. Node's support for TypeScript without the need for external dependencies or loaders can streamline development and move the ecosystem forward.

What are the two main functions of the TypeScript compiler?

The TypeScript compiler has two main functions: type checking, which verifies the correctness of the types used in the code, and transpilation, which converts TypeScript code into JavaScript code.

Why was the TC39 proposal for type annotations introduced?

The TC39 proposal for type annotations was introduced to add type annotations to the vanilla JavaScript specification in a way that allows developers to run programs written in TypeScript, Flow, and other static typing supersets of JavaScript without the need for transpilation.

What is the main goal of the TC39 proposal regarding type annotations?

The main goal of the TC39 proposal is to enable developers to run TypeScript, Flow, and other statically typed code in the browser without any need for transpilation, by treating type annotations as a comment syntax rather than a type-checked strict language.

What is the difference between type checking and transpilation in the context of TypeScript?

Type checking is the process of verifying the correctness of the types used in the code, ensuring there are no type errors. Transpilation is the process of converting TypeScript code, which may include type annotations, into plain JavaScript code that can be executed in a JavaScript runtime environment.

Why did the V8 team experiment with a 'strong mode' for JavaScript?

The V8 team experimented with a 'strong mode' for JavaScript to enforce types and improve site performance. However, the experiment was canceled due to the non-negligible slowdown it caused, indicating that enforcing types can sometimes lead to more performance problems than it resolves.

What is the role of the 'swc' package in the context of Node.js and TypeScript?

The 'swc' package, specifically the 'swc-wasm-typescript' package, is used by Node.js for type stripping. It is a Rust-based platform for the web that provides a set of compilation tools to convert TypeScript code into JavaScript code without performing type checking.

What is the advantage of using WebAssembly (WASM) for the 'swc-wasm-typescript' package?

Using WebAssembly for the 'swc-wasm-typescript' package allows it to run in any environment supported by Node.js without the need for shipping multiple native binaries for different platforms, thus reducing the overall size and complexity of the package.

Why is the 'Amaro' package used in Node.js for type stripping?

The 'Amaro' package is a wrapper around 'swc-wasm-typescript' and is used for type stripping in Node.js. It allows for the easy integration of the 'swc' transpiler within Node.js, providing a more streamlined and efficient way to handle TypeScript files.

What is the significance of file extensions in the new Node.js TypeScript support?

File extensions are mandatory for TypeScript files in Node.js to ensure proper module resolution and to avoid conflicts with existing JavaScript files. This is part of Node.js's commitment to maintaining backward compatibility and clarity in module systems.

How does Node.js differentiate between CommonJS and ES module syntax when dealing with TypeScript files?

Node.js will not automatically convert between CommonJS and ES module syntax. Developers must explicitly use the appropriate import and export syntax for ES modules or require and module.exports for CommonJS modules within their TypeScript files.