content(learn): update resources about typescript

apps/site/i18n/locales/en.json

@@ -42,6 +42,15 @@
             "securityBestPractices": "Security Best Practices"
           }
         },
+        "typescript": {
+          "links": {
+            "typescript": "TypeScript",
+            "introduction": "Introduction to TypeScript",
+            "transpile": "Running TypeScript code using transpilation",
+            "run": "Running TypeScript with a runner",
+            "runNatively": "Running TypeScript with a Node.js Itself"
+          }
+        },
         "asynchronousWork": {
           "links": {
             "asynchronousWork": "Asynchronous Work",

apps/site/navigation.json

@@ -185,6 +185,27 @@
             }
           }
         },
+        "typescript": {
+          "label": "components.navigation.learn.typescript.links.typescript",
+          "items": {
+            "introduction": {
+              "link": "/learn/typescript/introduction",
+              "label": "components.navigation.learn.typescript.links.introduction"
+            },
+            "transpile": {
+              "link": "/learn/typescript/transpile",
+              "label": "components.navigation.learn.typescript.links.transpile"
+            },
+            "run": {
+              "link": "/learn/typescript/run",
+              "label": "components.navigation.learn.typescript.links.run"
+            },
+            "runNatively": {
+              "link": "/learn/typescript/run-natively",
+              "label": "components.navigation.learn.typescript.links.runNatively"
+            }
+          }
+        },
         "asynchronousWork": {
           "label": "components.navigation.learn.asynchronousWork.links.asynchronousWork",
           "items": {

apps/site/pages/en/learn/typescript/introduction.md

@@ -0,0 +1,50 @@
+---
+title: Introduction to TypeScript
+layout: learn
+authors: sbielenica, ovflowd, vaishnav-mk, AugustinMauroy
+---
+
+# Introduction to TypeScript
+
+## What is TypeScript
+
+**[TypeScript](https://www.typescriptlang.org)** is an open-source language maintained and developed by Microsoft. It's loved and used by a lot of software developers around the world.
+
+Basically, it's a superset of JavaScript that adds new capabilities to the language. The most notable addition is static type definitions, something that is not present in plain JavaScript. Thanks to types, it's possible, for example, to declare what kind of arguments we are expecting and what is returned exactly in our functions or what's the exact shape of the object that we are creating. TypeScript is a really powerful tool and opens a new world of possibilities in JavaScript projects. It makes our code more secure and robust by preventing many bugs before the code is even shipped - it catches problems during code development and integrates wonderfully with code editors like Visual Studio Code.
+
+We can talk about other TypeScript benefits later, let's see some examples now!
+
+## First TypeScript code
+
+Take a look at this code snippet and then we can unpack it together:
+
+<!--
+  Maintainers note: this code is duplicated in the next article, please keep them in sync
+-->
+
+```ts
+type User = {
+  name: string;
+  age: number;
+};
+
+function isAdult(user: User): boolean {
+  return user.age >= 18;
+}
+
+const justine: User = {
+  name: 'Justine',
+  age: 23,
+};
+
+const isJustineAnAdult: boolean = isAdult(justine);
+```
+
+The first part (with the `type` keyword) is responsible for declaring our custom object type representing users. Later we utilize this newly created type to create function `isAdult` that accepts one argument of type `User` and returns `boolean`. After this, we create `justine`, our example data that can be used for calling the previously defined function. Finally, we create a new variable with information on whether `justine` is an adult.
+
+There are additional things about this example that you should know. Firstly, if we would not comply with declared types, TypeScript would alarm us that something is wrong and prevent misuse. Secondly, not everything must be typed explicitly - TypeScript is very smart and can deduce types for us. For example, variable `isJustineAnAdult` would be of type `boolean` even if we didn't type it explicitly or `justine` would be valid argument for our function even if we didn't declare this variable as of `User` type.
+
+## How to run TypeScript code
+
+Okay, so we have some TypeScript code. Now how do we run it?
+There are few possible ways to run TypeScript code, we will cover all of them in the next articles.

apps/site/pages/en/learn/typescript/run-natively.md

@@ -0,0 +1,60 @@
+---
+title: Running TypeScript with a Node.js Itself
+layout: learn
+authors: AugustinMauroy
+---
+
+> **⚠️WARNING:** All content in this article uses Node.js experimental features. Please make sure you are using a version of Node.js that supports the features mentioned in this article. And remember that experimental features can change on future versions of Node.js.
+
+# Running TypeScript with a Node.js Itself
+
+In the previous articles, we learned how to run TypeScript code using transpilation and with a runner. In this article, we will learn how to run TypeScript code using Node.js itself.
+
+## Running TypeScript code with Node.js
+
+Node.js has experimental support for TypeScript. You can run TypeScript code directly in Node.js without the need to compile it first.
+
+So how do you run TypeScript code with Node.js?
+
+First, you need to install a nightly version of Node.js. You can download it from the [official Node.js website](https://nodejs.org/download/nightly/).
+
+Then, you can run your TypeScript code like this:
+
+```bash
+node --experimental-strip-types example.ts
+```
+
+The `--experimental-strip-types` flag tells Node.js to strip the type annotations from the TypeScript code before running it.
+
+And that's it! You can now run TypeScript code directly in Node.js without the need to compile it first.
+In the future we all hope that this feature will be stable and available in the LTS version of Node.js, so that we can all enjoy it without any additional steps.
+
+## Limitations
+
+At the time of writing, the experimental support for TypeScript in Node.js has some limitations. To allow typescript to run in node.js, our collaborators have chosen to only strip types from the code.
+
+<!--
+  Maintainers note: this content is copy from docs (unreleased) and should be updated when the docs are released with a link to the official documentation
+-->
+
+Since Node.js is only removing inline types, any TypeScript features that
+involve _replacing_ TypeScript syntax with new JavaScript syntax will error.
+This is by design. To run TypeScript with such features, see
+[Full TypeScript support][].
+
+The most prominent unsupported features that require transformation are:
+
+- `Enum`
+- `experimentalDecorators`
+- `namespaces`
+- parameter properties
+
+In addition, Node.js does not read `tsconfig.json` files and does not support
+features that depend on settings within `tsconfig.json`, such as paths or
+converting newer JavaScript syntax into older standards.
+
+## Important notes
+
+Thanks to all the contributors who have made this feature possible. We hope that this feature will be stable and available in the LTS version of Node.js soon.
+
+We can understand that this feature is experimental and has some limitations, and this may disappoint you. So please be patient and wait for the stable version of this feature. And **NEVER** spam us. If you are happy, you can share these articles on social media and tell your friends about this feature.

apps/site/pages/en/learn/typescript/run.md

@@ -0,0 +1,49 @@
+---
+title: Running TypeScript with a runner
+layout: learn
+authors: AugustinMauroy
+---
+
+# Running TypeScript with a runner
+
+In the previous article, we learned how to run TypeScript code using transpilation. In this article, we will learn how to run TypeScript code using a runner.
+
+## Running TypeScript code with `ts-node`
+
+[ts-node](https://typestrong.org/ts-node/) is a TypeScript execution environment for node.js. It allows you to run TypeScript code directly in node.js without the need to compile it first. But it's not typechecking your code. So we recommend to type check your code first with `tsc` and then run it with `ts-node` before shipping it.
+
+To use `ts-node`, you need to install it first:
+
+```bash
+npm i -D ts-node
+```
+
+Then you can run your TypeScript code like this:
+
+```bash
+npx ts-node example.ts
+```
+
+## Running TypeScript code with `tsx`
+
+[tsx](https://tsx.is/) is another TypeScript execution environment for node.js. It allows you to run TypeScript code directly in node.js without the need to compile it first. But it's not typechecking your code. So we recommend to type check your code first with `tsc` and then run it with `tsx` before shipping it.
+
+To use `tsx`, you need to install it first:
+
+```bash
+npm i -D tsx
+```
+
+Then you can run your TypeScript code like this:
+
+```bash
+npx tsx example.ts
+```
+
+### Registering `tsx` via `node`
+
+If you want to use `tsx` via `node`, you can register `tsx` via `--import`:
+
+```bash
+node --import=tsx example.ts
+```