TypeScript 4.8 for JavaScript users

Types cannot be imported or exported by name in .js files

An ES module import of a name that has no value fails at run time, and before 4.8 TypeScript let a checked .js file write one: import { Product } from "./models.js", where Product is a @typedef. Under checkJs or // @ts-check that is now an error (TS18042), and so is an export { MyType } of a type-only name.

Two spellings work instead: an import type inside the braces, {import("./models.js").Product}, or, from TypeScript 5.5, the @import tag. To re-export a type, declare another @typedef for it; a @typedef is exported from its module already.

import { Product } from "./models.js";error TS18042: 'Product' is a type and cannot be imported in JavaScript files. Use 'import("./models.js").Product' in a JSDoc type annotation.

/** @param {Product} product */
export function priceOf(product) {
  return product.price;
}

/** @import { Product } from "./models.js" */

/** @param {import("./models.js").Product} product */
export function priceOf(product) {
  return product.price;
}

/** @param {Product} product */
export function skuOf(product) {
  return product.sku;
}

Comparing with an object or array literal

JavaScript compares objects by reference, so tags === [] is false for every array, empty or not. TypeScript 4.8 reports the comparison (TS2839). Check tags.length === 0 instead.

/** @param {string[]} tags */
export function isUntaggedLoose(tags) {
  return tags === [];error TS2839: This condition will always return 'false' since JavaScript compares objects by reference, not value.
}

/** @param {string[]} tags */
export function isUntagged(tags) {
  return tags.length === 0;
}

unknown and unconstrained type parameters

Under strictNullChecks, unknown now behaves like {} | null | undefined: a truthiness check narrows it to {}. The other side of the same change is stricter: a @template type parameter with no constraint may be null or undefined, so passing it where {} or object is expected is an error (TS2345). Constrain it with @template {{}} T, or check for null first.

/** @param {{}} value */
function keysOf(value) {
  return Object.keys(value);
}

/**
 * @template T
 * @param {T} input
 */
export function describeLoose(input) {
  return keysOf(input);error TS2345: Argument of type 'T' is not assignable to parameter of type '{}'.
}

/**
 * @template {{}} T
 * @param {T} input
 */
export function describe(input) {
  return keysOf(input);
}

Faster --watch, --build and --incremental

The release notes report 10 to 25 percent faster common operations in watch and build mode, and no-change rebuilds about 40 percent faster. File watching also survives a git checkout that replaces files, which used to leave stale errors on screen until tsc or the editor restarted.