TypeScript 4.1 RC 版本发布：带来了令人兴奋的新特性

npm install typescript@rc

function setVerticalAlignment(color: "top" | "middle" | "bottom") {
    // ...
}
setVerticalAlignment("middel");
// ~~~~~~~~
// error: Argument of type '"middel"' is not assignable to
// parameter of type '"top" | "middle" | "bottom"'.

type Options = {
    [K in "noImplicitAny" | "strictNullChecks" | "strictFunctionTypes"]?: boolean
};
// same as
// type Options = {
// noImplicitAny?: boolean,
// strictNullChecks?: boolean,
// strictFunctionTypes?: boolean
// };

type World = "world";
type Greeting = `hello ${World}`;
// same as
// type Greeting = "hello world";

type Color = "red" | "blue";
type Quantity = "one" | "two";
type SeussFish = `${Quantity | Color} fish`;
// same as
// type SeussFish = "one fish" | "two fish"
// | "red fish" | "blue fish";5

type VerticalAlignment = "top" | "middle" | "bottom";
type HorizontalAlignment = "left" | "center" | "right";
// Takes
// | "top-left"    | "top-center"    | "top-right"
// | "middle-left" | "middle-center" | "middle-right"
// | "bottom-left" | "bottom-center" | "bottom-right"
declare function setAlignment(value: `${VerticalAlignment}-${HorizontalAlignment}`): void;
setAlignment("top-left"); // works!
setAlignment("top-middel"); // error!
setAlignment("top-pot"); // error! but good doughnuts if you're ever in Seattle

let person = makeWatchedObject({
    firstName: "Homer",
    age: 42, // give-or-take
    location: "Springfield",
});
person.on("firstNameChanged", () => {
    console.log(`firstName was changed!`);
});

type PropEventSource<T> = {
    on(eventName: `${string & keyof T}Changed`, callback: () => void): void;
};
/// Create a "watched object" with an 'on' method
/// so that you can watch for changes to properties.
declare function makeWatchedObject<T>(obj: T): T & PropEventSource<T>;

// error!
person.on("firstName", () => {
});
// error!
person.on("frstNameChanged", () => {
});

type PropEventSource<T> = {
    on<K extends string & keyof T>
        (eventName: `${K}Changed`, callback: (newValue: T[K]) => void ): void;
};
declare function makeWatchedObject<T>(obj: T): T & PropEventSource<T>;
let person = makeWatchedObject({
    firstName: "Homer",
    age: 42,
    location: "Springfield",
});
// works! 'newName' is typed as 'string'
person.on("firstNameChanged", newName => {
    // 'newName' has the type of 'firstName'
    console.log(`new name is ${newName.toUpperCase()}`);
});
// works! 'newAge' is typed as 'number'
person.on("ageChanged", newAge => {
    if (newAge < 0) {
        console.log("warning! negative age");
    }
})

type EnthusiasticGreeting<T extends string> = `${Uppercase<T>}`
type HELLO = EnthusiasticGreeting<"hello">;
// same as
// type HELLO = "HELLO";

type Options = {
    [K in "noImplicitAny" | "strictNullChecks" | "strictFunctionTypes"]?: boolean
};
// same as
// type Options = {
// noImplicitAny?: boolean,
// strictNullChecks?: boolean,
// strictFunctionTypes?: boolean
// };

/// 'Partial<T>' is the same as 'T', but with each property marked optional.
type Partial<T> = {
    [K in keyof T]?: T[K]
};

type MappedTypeWithNewKeys<T> = {
    [K in keyof T as NewKeyType]: T[K]
    // ^^^^^^^^^^^^^
    // This is the new syntax!
}

type Getters<T> = {
    [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
interface Person {
    name: string;
    age: number;
    location: string;
}
type LazyPerson = Getters<Person>;

// Remove the 'kind' property
type RemoveKindField<T> = {
    [K in keyof T as Exclude<K, "kind">]: T[K]
};
interface Circle {
    kind: "circle";
    radius: number;
}
type KindlessCircle = RemoveKindField<Circle>;
// same as
// type KindlessCircle = {
// radius: number;
// };

type ElementType<T> =
    T extends ReadonlyArray<infer U> ? ElementType<U> : T;
function deepFlatten<T extends readonly unknown[]>(x: T): ElementType<T>[] {
    throw "not implemented";
}
// All of these return the type 'number[]':
deepFlatten([1, 2, 3]);
deepFlatten([[1], [2, 3]]);
deepFlatten([[1], [[2]], [[[3]]]]);

type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;
/// Like `promise.then(...)`, but more accurate in types.
declare function customThen<T, U>(
    p: Promise<T>,
    onFulfilled: (value: Awaited<T>) => U
): Promise<Awaited<U>>;

interface Options {
    path: string;
    permissions: number;
    // Extra properties are caught by this index signature.
    [propName: string]: string | number;
}
function checkOptions(opts: Options) {
    opts.path // string
    opts.permissions // number
    // These are all allowed too!
    // They have the type 'string | number'.
    opts.yadda.toString();
    opts["foo bar baz"].toString();
    opts[Math.random()].toString();
}

// Checking if it's really there first.
if (opts.yadda) {
    console.log(opts.yadda.toString());
}

// Basically saying "trust me I know what I'm doing"
// with the '!' non-null assertion operator.
opts.yadda!.toString();

function screamLines(strs: string[]) {
    // this will have issues
    for (let i = 0; i < strs.length; i++) {
        console.log(strs[i].toUpperCase());
        // ~~~~~~~
        // error! Object is possibly 'undefined'.
    }
}

function screamLines(strs: string[]) {
    // this works fine
    for (const str of strs) {
        console.log(str.toUpperCase());
    }
    // this works fine
    strs.forEach(str => {
        console.log(str.toUpperCase());
    });
}

// ./src/tsconfig.json
{
    "compilerOptions": {
        "module": "esnext",
        "target": "es2015",
        "jsx": "react-jsx",
        "strict": true
    },
    "include": [
        "./**/*"
    ]
}

// ./src/tsconfig.dev.json
{
    "extends": "./tsconfig.json",
    "compilerOptions": {
        "jsx": "react-jsxdev"
    }
}

// @filename: first.ts
export class C { }
// @filename: main.ts
import * as first from './first';
/**
 * @see first.C
 */
function related() { }

declare let foo: unknown;
declare let somethingElse: { someProp: string };
let x = foo && somethingElse;

function isThing(x: any): boolean {
    return x && typeof x === 'object' && x.blah === 'foo';
}

interface Person {
    name: string;
    age: number;
    location: string;
}
interface Animal {
    name: string;
    owner: Person;
}
function copyOwner(pet?: Animal) {
    return {
        ...(pet && pet.owner),
        otherStuff: 123
    }
}
// We could also use optional chaining here:
function copyOwner(pet?: Animal) {
    return {
        ...(pet?.owner),
        otherStuff: 123
    }
}

{ x: number } | { x: number, name: string, age: number, location: string }

{
    x: number;
    name?: string;
    age?: number;
    location?: string;
}

// @filename: projectRoot/index.ts
export * from "./nested/base";
// @filename: projectRoot/nested/base.ts
export const a = "123"

declare module "nested/base" {
    export const a = "123";
}
declare module "index" {
    export * from "nested/base";
}

declare module "hello/nested/base" {
    export const a = "123";
}
declare module "hello" {
    export * from "hello/nested/base";
}

The `bundledPackageName` option must be provided when using outFile and node module resolution with declaration emit.

new Promise(resolve => {
    doSomethingAsync(() => {
        doSomething();
        resolve();
    })
})

resolve()
  ~~~~~~~~~
error TS2554: Expected 1 arguments, but got 0.
  An argument for 'value' was not provided.

new Promise<number>(resolve => {
    // ^^^^^^^^
    doSomethingAsync(value => {
        doSomething();
        resolve(value);
        // ^^^^^
    })
})

new Promise<void>(resolve => {
    // ^^^^^^
    doSomethingAsync(() => {
        doSomething();
        resolve();
    })
})