TypeScript 5.7 Unveils a Flood of New Features

TypeScript 5.7 RC adds numerous language and compiler enhancements.

Uninitialized Variable Checks

The compiler now errors when a variable may be used before assignment, even if the previous analysis was optimistic (e.g., the variable is accessed inside a nested function whose call time cannot be determined).

let result: number;
if (someCondition()) {
    result = doSomeWork();
} else {
    let temporaryWork = doSomeWork();
    temporaryWork *= 2;
    // Forgot to assign result
}
console.log(result); // error: Variable 'result' is used before being assigned.

When the access occurs inside a separate function, the older compiler assumed the variable was initialized; the new version correctly flags the usage.

Relative Import Rewrites

Tools that run TypeScript directly ( ts-node, tsx, Deno, Bun) allow importing .ts files without a build step. Node.js experiments with --experimental-transform-types and --experimental-strip-types to support this pattern.

The new compiler option --rewriteRelativeImportExtensions rewrites relative import paths that end with a TypeScript extension ( .ts, .tsx, .mts, .cts) to the corresponding JavaScript extension ( .js, .jsx, .mjs, .cjs) when the imported file is not a declaration file.

// Paths that will be rewritten
import * as foo from "./foo.ts";
import * as bar from "../someFolder/bar.mts";

// Paths that will NOT be rewritten
import * as a from "./foo";
import * as b from "some-package/file.ts";
import * as c from "@some-scope/some-package/file.ts";
import * as d from "#/file.ts";
import * as e from "./file.js";

Only relative paths ( ./ or ../) are rewritten; paths resolved via baseUrl, paths, or package exports / imports are left unchanged.

Support for --target es2024 and --lib es2024

The --target es2024 flag lets developers compile to the upcoming ECMAScript 2024 runtime. Paired with --lib es2024, it adds built‑in declarations for new features such as SharedArrayBuffer, Object.groupBy, Map.groupBy, Promise.withResolvers, and moves Atomics.waitAsync from the ES2022 lib to the ES2024 lib.

Typed array constructors become generic, preserving the underlying buffer type:

interface Uint8Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> {
    // ...
}

Each typed array now has a TArrayBuffer type parameter with a default, allowing usage like Int32Array without explicitly writing Int32Array<ArrayBufferLike>.

Upper Config File Search

When a TypeScript file is opened in an editor, the language service walks up the directory tree to locate additional tsconfig.json files, improving flexibility for projects that use multiple configuration files (e.g., a main config and a test config).

Faster Editor Checks for Complex Projects

In large monorepos, opening an unrelated script previously caused the entire workspace to be loaded. With the new behavior, only projects marked with the composite flag are fully scanned, preventing the worst‑case slowdown.

--module nodenext JSON Import Validation

When using --module nodenext, importing a .json file now requires an explicit type: "json" attribute, and JSON modules provide only a default export.

// ❌ error – missing type attribute
import myConfig from "./myConfig.json";

// ✅ correct usage
import myConfig from "./myConfig.json" with { type: "json" };
let version = myConfig.version;

// ❌ named import not allowed
import * as myConfigB from "./myConfig.json" with { type: "json" };
let version = myConfig.version; // error

// ✅ access via default export
import * as myConfigC from "./myConfig.json" with { type: "json" };
let version = myConfigC.default.version;

Support for Node.js V8 Compile Cache

Node.js 22 adds module.enableCompileCache(). TypeScript 5.7 leverages this API, yielding roughly a 2.5× speedup when running tsc --version in the authors' benchmarks.

Benchmark 1 (no cache): 122.2 ms ± 1.5 ms
Benchmark 2 (with cache): 48.4 ms ± 1.0 ms
=> 2.52× faster with caching

TypedArrays Now Generic Over ArrayBufferLike

All typed arrays are generic over ArrayBufferLike, preserving the underlying buffer type while remaining backward compatible (see the generic constructor example above).

Index Signatures from Non‑Literal Method Names

Methods declared with computed property names (e.g., a symbol) now contribute an index signature to the class type, making the method part of the structural type system.

declare const symbolMethodName: symbol;
export class A {
    [symbolMethodName]() { return 1; }
}
// Interpreted as having an index signature:
// { [x: symbol]: () => number }

Implicit any Errors for null / undefined Returns

If a function expression returns null or undefined without an explicit return‑type annotation, the compiler emits a noImplicitAny error.

declare var p: Promise<number>;
const p2 = p.catch(() => null); // error TS7011: Function expression implicitly has an 'any' return type.

Reference

Full list of changes: https://devblogs.microsoft.com/typescript/announcing-typescript-5-7-rc/