The final release of TypeScript 3.8 is here

TypeScript 3.8 adds support for ECMAScript private fields and top-level await

February 21, 2020 Maika Möbus

#typescript

TypeScript 3.8 has arrived two days after the planned release date. It adds some new features including support for ECMAScript private fields, which are currently in the third stage of development, type-only imports and exports, and top-level await. Minor breaking changes have been added in the final release as well.

Microsoft has released TypeScript 3.8, as Daniel Rosenwasser, Program Manager of TypeScript, announced in a blog post. TypeScript is a popular superset of JavaScript that adds syntax for types which can be analyzed through static type-checking before running the code.

Top-level await

TypeScript users on Twitter are especially excited about the new feature top-level await:

TypeScript 3.8 has arrived! 🎉

Now with

– type-only imports/exports
– private fields
– ‘export * as ns’ syntax
– top-level ‘await’
– convert to template string
– call hierarchy

and more! Try it today!https://t.co/PMcmnsr5OB

— TypeScript (@typescript) February 20, 2020

Top-level await is an upcoming ECMAScript feature that allows await to be used at the top level of a module. Previously, this was only possible within the body of an async function.

The new feature can be used as seen here:

const response = await fetch("...");
const greeting = await response.text();
console.log(greeting);

// Make sure we're a module
export {};

Type-only imports and exports

TypeScript 3.8 also adds type-only imports and exports:

import type { SomeThing } from "./some-module.js";

export type { SomeThing };

The new command import type imports declarations only to be used for type annotations and declarations, whereas the export provided by export type can be used only for type contexts.

Both are always fully erased from the TypeScript output and leave no remnant at runtime.

ECMAScript private fields

Support for ECMAScript private fields has been added as well.

The ECMAScript proposal is currently under development in stage 3. Private fields start with #, do not permit TypeScript accessiblity modifiers like public or private, and cannot be accessed or detected outside of the containing class, which is referred to as “hard privacy.”

Here’s how to use private fields, as shown in the blog post:

class Person {
    #name: string

    constructor(name: string) {
        this.#name = name;
    }

    greet() {
        console.log(`Hello, my name is ${this.#name}!`);
    }
}

let jeremy = new Person("Jeremy Bearimy");

jeremy.#name
//     ~~~~~
// Property '#name' is not accessible outside class 'Person'
// because it has a private identifier.

Breaking changes

Among other features, some breaking changes have made it into TypeScript 3.8–but according to Daniel Rosenwasser, they are minor breaking changes. For example, unions with index signatures have received stricter assignability checks. The use of Object and object has been clarified, in that lowercase object now “really refers to the non-primitive object type.”