What’s New in the TypeScript 5.6 Beta?

Install the TypeScript 5.6 beta with $ npm install typescript@beta or select the Nightly TypeScript version in VS Code (Cmd + Shift + P → “Select TypeScript Version”).

More Complete Nullish and Truthy Checks

TypeScript 4.8 and 4.9 added literal‑value equality for reference types and NaN equality checks. In 5.6 the compiler also flags expressions that always evaluate to true or false. Errors are reported for constant‑true regular‑expression literals, arrow functions that return a constant, and comparisons that can never succeed. A warning is emitted when the right‑hand side of the nullish‑coalescing operator ?? is unreachable because the left side can never be null or undefined.

const obj = {};
// Error: this condition always returns false because objects are compared by reference
if (obj === {}) {}

const func = () => {};
// Error: this condition always returns true – did you mean to call func?
if (func) {}

// Error: this condition always returns false – did you mean Number.isNaN(value)?
if (value === NaN) {}

if (/0x[0-9a-f]/) {
  // Error: this condition always returns true
}

if (x => 0) {
  // Error: this condition always returns true
}

// Warning: the right side of ?? is unreachable because the left side can never be null/undefined
const value = inital < input ?? 100;

Using literal true or false in a condition remains allowed when intentional, mirroring ESLint’s no‑constant‑binary‑expression rule.

Iterator Helper Methods

The TC39 proposal‑iterator‑helpers is now synchronized in TypeScript, adding a set of methods to the built‑in Iterator object. These methods reduce boilerplate and resemble array methods. iterator.take(limit: number) – stops iteration after limit values.

function* naturals() {
  let i = 0;
  while (true) {
    yield i;
    i += 1;
  }
}
const result = naturals().take(3);
result.next(); // {value: 0, done: false}
result.next(); // {value: 1, done: false}
result.next(); // {value: 2, done: false}
result.next(); // {value: undefined, done: true}

iterator.drop(limit: number)

– skips the first limit values.

const result = naturals().drop(3);
result.next(); // {value: 3, done: false}
result.next(); // {value: 4, done: false}
result.next(); // {value: 5, done: false}

iterator.flatMap(mapper)

– the mapper returns another iterator which is then flattened.

const result = naturals().flatMap(i => (function* () { yield i; yield i * 2; })());
result.next(); // {value: 0, done: false}
result.next(); // {value: 0, done: false}
result.next(); // {value: 1, done: false}
result.next(); // {value: 2, done: false}

iterator.toArray()

– converts a finite iterator into an array.

const result = naturals().take(5).toArray();
// result => [0, 1, 2, 3, 4]

Iterator.from()

– creates a standard iterator from any object that implements a next method.

class Iter {
  next() { return { done: false, value: 1 }; }
}
const iter = new Iter();
const wrapper = Iterator.from(iter);
wrapper.next(); // {value: 1, done: false}

These helpers are implemented under a new type BuiltinIterator to avoid naming conflicts with existing iterators.

Arbitrary Module Identifiers

Any string can be used as an export name, enabling statements such as:

// fruits.ts
const banana = "🍌";
export { banana as "🍌" };

// index.ts
import * as Fruits from "./fruits";
Fruits["🍌"]; // accesses the banana export

The feature is useful for scenarios like WebAssembly where module exports may have unconventional names:

import { "Foo::new" as Foo_new } from "./foo.wasm";
const foo = Foo_new();
export { Foo_new as "Foo::new" };

The implementation was contributed by the author of ESBuild (see issue #58640).

Checking Side‑Effect Imports with --noUncheckedSideEffectImports

When the --noUncheckedSideEffectImports flag is enabled, TypeScript validates side‑effect imports (e.g., polyfills or CSS files) and reports missing paths instead of silently ignoring them.

Disabling Type Checking with --noCheck

The --noCheck compiler option disables all type checking while still allowing declaration and code emission. It is often combined with --isolatedDeclarations to generate .d.ts files quickly. Related flags: noEmit – performs type checking but does not emit output. noCheck – skips type checking and emits both declarations and compiled code. declaration – generates declaration files (default false unless Project References are enabled). emitDeclarationOnly – emits only declaration files.

These options let developers separate the type‑checking phase from the build phase as needed.