npm install -D typescript@beta

• Preserved Narrowing in Closures Following Last Assignments
• The NoInfer Utility Type
• Object.groupBy and Map.groupBy
• Support for require() calls in --moduleResolution bundler and --module preserve
• Checked Import Attributes and Assertions
• Quick Fix for Adding Missing Parameters
• Upcoming 5.5 Deprecations
• Breaking Changes

Preserved Narrowing in Closures Following Last Assignments

function uppercaseStrings(x: string | number) {
    if (typeof x === "string") {
        // TypeScript knows 'x' is a 'string' here.
        return x.toUpperCase();
    }
}

function getUrls(url: string | URL, names: string[]) {
    if (typeof url === "string") {
        url = new URL(url);
    }

    return names.map(name => {
        url.searchParams.set("name", name)
        //  ~~~~~~~~~~~~
        // error!
        // Property 'searchParams' does not exist on type 'string | URL'.

        return url.toString();
    });
}

function printValueLater(value: string | undefined) {
    if (value === undefined) {
        value = "missing!";
    }

    setTimeout(() => {
        // Modifying 'value', even in a way that shouldn't affect
        // its type, will invalidate type refinements in closures.
        value = value;
    }, 500);

    setTimeout(() => {
        console.log(value.toUpperCase());
        //          ~~~~~
        // error! 'value' is possibly 'undefined'.
    }, 1000);
}

The NoInfer Utility Type

function doSomething<T>(arg: T) {
    // ...
}


// We can explicitly say that 'T' should be 'string'.
doSomething<string>("hello!");

// We can also just let the type of 'T' get inferred.
doSomething("hello!");

function createStreetLight<C extends string>(colors: C[], defaultColor?: C) {
    // ...
}

createStreetLight(["red", "yellow", "green"], "red");

// Oops! This undesirable, but is allowed!
createStreetLight(["red", "yellow", "green"], "blue");

function createStreetLight<C extends string, D extends C>(colors: C[], defaultColor?: D) {
}

createStreetLight(["red", "yellow", "green"], "blue");
//                                            ~~~~~~
// error!
// Argument of type '"blue"' is not assignable to parameter of type '"red" | "yellow" | "green" | undefined'.

function createStreetLight<C extends string>(colors: C[], defaultColor?: NoInfer<C>) {
    // ...
}

createStreetLight(["red", "yellow", "green"], "blue");
//                                            ~~~~~~
// error!
// Argument of type '"blue"' is not assignable to parameter of type '"red" | "yellow" | "green" | undefined'.

Object.groupBy and Map.groupBy

const array = [0, 1, 2, 3, 4, 5];

const myObj = Object.groupBy(array, (num, index) => {
    return num % 2 === 0 ? "even": "odd";
});

const myObj = {
    even: [0, 2, 4],
    odd: [1, 3, 5],
};

const myObj = Map.groupBy(array, (num, index) => {
    return num % 2 === 0 ? "even" : "odd";
});

const myObj = new Map();

myObj.set("even", [0, 2, 4]);
myObj.set("odd", [1, 3, 5]);

interface EvenOdds {
    even?: number[];
    odd?: number[];
}

const myObj: EvenOdds = Object.groupBy(...);

myObj.even;
//    ~~~~
// Error to access this under 'strictNullChecks'.

Support for require() calls in --moduleResolution bundler and --module preserve

// previously errored
import myModule = require("module/path");

{
    "compilerOptions": {
        "module": "preserve",
        // ^ also implies:
        // "moduleResolution": "bundler",
        // "esModuleInterop": true,
        // "resolveJsonModule": true,

        // ...
    }
}

import * as foo from "some-package/foo";
import bar = require("some-package/bar");

import * as foo from "some-package/foo";
var bar = require("some-package/bar");

{
  "name": "some-package",
  "version": "0.0.1",
  "exports": {
    "./foo": {
        "import": "./esm/foo-from-import.mjs",
        "require": "./cjs/foo-from-require.cjs"
    },
    "./bar": {
        "import": "./esm/bar-from-import.mjs",
        "require": "./cjs/bar-from-require.cjs"
    }
  }
}

Checked Import Attributes and Assertions

// In some global file.
interface ImportAttributes {
    type: "json";
}

// In some other module
import * as ns from "foo" with { type: "not-json" };
//                                     ~~~~~~~~~~
// error!
//
// Type '{ type: "not-json"; }' is not assignable to type 'ImportAttributes'.
//  Types of property 'type' are incompatible.
//    Type '"not-json"' is not assignable to type '"json"'.

Quick Fix for Adding Missing Parameters Upcoming Changes from TypeScript 5.0 Deprecations

• target: ES3
• noImplicitUseStrict
• keyofStringsOnly
• suppressExcessPropertyErrors
• suppressImplicitAnyIndexErrors
• noStrictGenericChecks
• charset
• out
• prepend in project references
• implicitly OS-specific newLine

Breaking Changes

lib.d.ts Changes

More Accurate Conditional Type Constraints

type IsArray<T> = T extends any[] ? true : false;

function foo<U extends object>(x: IsArray<U>) {
    let first: true = x;   // Error
    let second: false = x;  // Error, but previously wasn't
}

More Aggressive Reduction of Intersections Between Type Variables and Primitive Types

declare function intersect<T, U>(x: T, y: U): T & U;

function foo<T extends "abc" | "def">(x: T, str: string, num: number) {

    // Was 'T & string', now is just 'T'
    let a = intersect(x, str);

    // Was 'T & number', now is just 'never'
    let b = intersect(x, num)

    // Was '(T & "abc") | (T & "def")', now is just 'T'
    let c = Math.random() < 0.5 ?
        intersect(x, "abc") :
        intersect(x, "def");
}

function a<T extends {id: string}>() {
    let x: `-${keyof T & string}`;
    
    // Used to error, now doesn't.
    x = "-id";
}

Errors When Type-Only Imports Conflict with Local Values

import { Something } from "./some/path";

let Something = 123;

Import 'Something' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled.

import type { Something } from "./some/path";

// or

import { type Something } from "./some/path";

Emit Changes

• Preserve type parameter names more often when shadowed
• Move complex parameter lists of async function into downlevel generator body
• Do not remove binding alias in function declarations
• ImportAttributes should go through the same emit phases when in an ImportTypeNode

What’s Next?