TypeScript 实用技巧（中）

interface InputStream {
 getNextLine(): string;
}

type StreamValue = null | string;
interface InputStream {
 getNextLine(): StreamValue;
}

function countComments(is: InputStream) {
 let commentCount = 0;
 while (true) {
 const line = is.getNextLine();
 // @ts-expect-error: Object is possibly 'null'.(2531)
 if (line.startsWith('#')) { // (A)
 commentCount++;
 }
 if (line === null) break;
 }
 return commentCount;
}

function countComments(is: InputStream) {
 let commentCount = 0;
 while (true) {
 const line = is.getNextLine();
 if (line === null) break;
 if (line.startsWith('#')) { // (A)
 commentCount++;
 }
 }
 return commentCount;
}

const EOF = Symbol('EOF');
type StreamValue = typeof EOF | string;

interface InputStream<T> {
 getNextValue(): T;
}

interface NormalValue<T> {
 type: 'normal'; // string literal type
 data: T;
}
interface Eof {
 type: 'eof'; // string literal type
}
type InputStreamValue<T> = Eof | NormalValue<T>;
interface InputStream<T> {
 getNextValue(): InputStreamValue<T>;
}

function countValues<T>(is: InputStream<T>, data: T) {
 let valueCount = 0;
 while (true) {
 // %inferred-type: Eof | NormalValue<T>
 const value = is.getNextValue(); // (A)
 if (value.type === 'eof') break;
 // %inferred-type: NormalValue<T>
 value; // (B)
 if (value.data === data) { // (C)
 valueCount++;
 }
 }
 return valueCount;
}

interface IteratorYieldResult<TYield> {
 done?: false; // boolean literal type
 value: TYield;
}
interface IteratorReturnResult<TReturn> {
 done: true; // boolean literal type
 value: TReturn;
}
type IteratorResult<T, TReturn = any> =
 | IteratorYieldResult<T>
 | IteratorReturnResult<TReturn>;

interface A {
 one: number;
 two: number;
}
interface B {
 three: number;
 four: number;
}
type Union = A | B;
function func(x: Union) {
 // @ts-expect-error: Property 'two' does not exist on type 'Union'.
 // Property 'two' does not exist on type 'B'.(2339)
 console.log(x.two); // error
 if ('one' in x) { // discriminating check
 console.log(x.two); // OK
 }
}

type Union = [string] | number;
function logHexValue(x: Union) {
 if (Array.isArray(x)) { // discriminating check
 console.log(x[0]); // OK
 } else {
 console.log(x.toString(16)); // OK
 }
}

let obj1: Object;

let obj2: object;

// Object type literal
let obj3: {prop: boolean};
// Interface
interface ObjectType {
 prop: boolean;
}
let obj4: ObjectType;

> const obj1 = {};
> obj1 instanceof Object
true

> Object.prototype.isPrototypeOf(obj1)
true

> obj1.toString === Object.prototype.toString
true

> const obj2 = Object.create(null);
> Object.getPrototypeOf(obj2)
null

> typeof obj2
'object'
> obj2 instanceof Object
false

interface Object { // (A)
 constructor: Function;
 toString(): string;
 toLocaleString(): string;
 valueOf(): Object;
 hasOwnProperty(v: PropertyKey): boolean;
 isPrototypeOf(v: Object): boolean;
 propertyIsEnumerable(v: PropertyKey): boolean;
}
interface ObjectConstructor {
 /** Invocation via `new` */
 new(value?: any): Object;
 /** Invocation via function calls */
 (value?: any): any;
 readonly prototype: Object; // (B)
 getPrototypeOf(o: any): any;
 // ···
}
declare var Object: ObjectConstructor; // (C)

function func1(x: Object) { }
func1('abc'); // OK

> 'abc'.hasOwnProperty === Object.prototype.hasOwnProperty
true

function func2(x: object) { }
// @ts-expect-error: Argument of type '"abc"' is not assignable to
// parameter of type 'object'. (2345)
func2('abc');

// @ts-expect-error: Type '() => number' is not assignable to
// type '() => string'.
//   Type 'number' is not assignable to type 'string'. (2322)
const obj1: Object = { toString() { return 123 } };

const obj2: object = { toString() { return 123 } };

// Object type literal
type ObjType1 = {
 a: boolean,
 b: number;
 c: string,
};
// Interface
interface ObjType2 {
 a: boolean,
 b: number;
 c: string,
}

// Inlined object type literal:
function f1(x: {prop: number}) {}
// Referenced interface:
function f2(x: ObjectInterface) {} 
interface ObjectInterface {
 prop: number;
}

// @ts-expect-error: Duplicate identifier 'PersonAlias'. (2300)
type PersonAlias = {first: string};
// @ts-expect-error: Duplicate identifier 'PersonAlias'. (2300)
type PersonAlias = {last: string};

interface PersonInterface {
 first: string;
}
interface PersonInterface {
 last: string;
}
const jane: PersonInterface = {
 first: 'Jane',
 last: 'Doe',
};

interface Point {
 x: number;
 y: number;
}
type PointCopy1 = {
 [Key in keyof Point]: Point[Key]; // (A)
};
// Syntax error:
// interface PointCopy2 {
//   [Key in keyof Point]: Point[Key];
// };

interface AddsStrings {
 add(str: string): this;
};
class StringBuilder implements AddsStrings {
 result = '';
 add(str: string) {
 this.result += str;
 return this;
 }
}

interface Point {
 x: number;
 y: number;
}
const point: Point = {x: 1, y: 2}; // OK

interface ExampleInterface {
 // Property signature
 myProperty: boolean;
 // Method signature
 myMethod(str: string): number;
 // Index signature
 [key: string]: any;
 // Call signature
 (num: number): string;
 // Construct signature
 new(str: string): ExampleInstance; 
}
interface ExampleInstance {}

myProperty: boolean;

myMethod(str: string): number;

[key: string]: any;

(num: number): string;

new(str: string): ExampleInstance;

interface HasMethodDef {
 simpleMethod(flag: boolean): void;
}
interface HasFuncProp {
 simpleMethod: (flag: boolean) => void;
}
const objWithMethod: HasMethodDef = {
 simpleMethod(flag: boolean): void {},
};
const objWithMethod2: HasFuncProp = objWithMethod;
const objWithOrdinaryFunction: HasMethodDef = {
 simpleMethod: function (flag: boolean): void {},
};
const objWithOrdinaryFunction2: HasFuncProp = objWithOrdinaryFunction;
const objWithArrowFunction: HasMethodDef = {
 simpleMethod: (flag: boolean): void => {},
};
const objWithArrowFunction2: HasFuncProp = objWithArrowFunction;

function translate(dict: TranslationDict, english: string): string {
 return dict[english];
}

interface TranslationDict {
 [key:string]: string; // (A)
}
const dict = {
 'yes': 'sí',
 'no': 'no',
 'maybe': 'tal vez',
};
assert.equal(
 translate(dict, 'maybe'),
 'tal vez');

interface StringAndNumberKeys {
 [key: string]: Object;
 [key: number]: RegExp;
}
// %inferred-type: (x: StringAndNumberKeys) =>
// { str: Object; num: RegExp; }
function f(x: StringAndNumberKeys) {
 return { str: x['abc'], num: x[123] };
}

interface I1 {
 [key: string]: boolean;
 // @ts-expect-error: Property 'myProp' of type 'number' is not assignable
 // to string index type 'boolean'. (2411)
 myProp: number;
 // @ts-expect-error: Property 'myMethod' of type '() => string' is not
 // assignable to string index type 'boolean'. (2411)
 myMethod(): string;
}

interface I2 {
 [key: string]: number;
 myProp: number;
}
interface I3 {
 [key: string]: () => string;
 myMethod(): string;
}

function f1(x: {}): Object {
 return x;
}

function f2(x: {}): { toString(): string } {
 return x;
}

interface Point {
 x: number;
 y: number;
}

function computeDistance(point: Point) { /*...*/ }

const obj = { x: 1, y: 2, z: 3 };
computeDistance(obj); // OK

// @ts-expect-error: Argument of type '{ x: number; y: number; z: number; }'
// is not assignable to parameter of type 'Point'.
//   Object literal may only specify known properties, and 'z' does not
//   exist in type 'Point'. (2345)
computeDistance({ x: 1, y: 2, z: 3 }); // error
computeDistance({x: 1, y: 2}); // OK

interface Person {
 first: string;
 middle?: string;
 last: string;
}
function computeFullName(person: Person) { /*...*/ }

// @ts-expect-error: Argument of type '{ first: string; mdidle: string;
// last: string; }' is not assignable to parameter of type 'Person'.
//   Object literal may only specify known properties, but 'mdidle'
//   does not exist in type 'Person'. Did you mean to write 'middle'?
computeFullName({first: 'Jane', mdidle: 'Cecily', last: 'Doe'});

interface HasYear {
 year: number;
}
function getAge(obj: HasYear) {
 const yearNow = new Date().getFullYear();
 return yearNow - obj.year;
}

interface Empty { }
interface OneProp {
 myProp: number;
}
// @ts-expect-error: Type '{ myProp: number; anotherProp: number; }' is not
// assignable to type 'OneProp'.
//   Object literal may only specify known properties, and
//   'anotherProp' does not exist in type 'OneProp'. (2322)
const a: OneProp = { myProp: 1, anotherProp: 2 };
const b: Empty = {myProp: 1, anotherProp: 2}; // OK

interface WithoutProperties {
 [key: string]: never;
}
// @ts-expect-error: Type 'number' is not assignable to type 'never'. (2322)
const a: WithoutProperties = { prop: 1 };
const b: WithoutProperties = {}; // OK

interface Point {
 x: number;
 y: number;
}
function computeDistance1(point: Point) { /*...*/ }
// @ts-expect-error: Argument of type '{ x: number; y: number; z: number; }'
// is not assignable to parameter of type 'Point'.
//   Object literal may only specify known properties, and 'z' does not
//   exist in type 'Point'. (2345)
computeDistance1({ x: 1, y: 2, z: 3 });

const obj = { x: 1, y: 2, z: 3 };
computeDistance1(obj);

computeDistance1({ x: 1, y: 2, z: 3 } as Point); // OK

function computeDistance2<P extends Point>(point: P) { /*...*/ }
computeDistance2({ x: 1, y: 2, z: 3 }); // OK

interface PointEtc extends Point {
 [key: string]: any;
}
function computeDistance3(point: PointEtc) { /*...*/ }
computeDistance3({ x: 1, y: 2, z: 3 }); // OK

interface Incrementor {
 inc(): void
}
function createIncrementor(start = 0): Incrementor {
 return {
 // @ts-expect-error: Type '{ counter: number; inc(): void; }' is not
 // assignable to type 'Incrementor'.
 //   Object literal may only specify known properties, and
 //   'counter' does not exist in type 'Incrementor'. (2322)
 counter: start,
 inc() {
 // @ts-expect-error: Property 'counter' does not exist on type
 // 'Incrementor'. (2339)
 this.counter++;
 },
 };
}

function createIncrementor2(start = 0): Incrementor {
 return {
 counter: start,
 inc() {
 // @ts-expect-error: Property 'counter' does not exist on type
 // 'Incrementor'. (2339)
 this.counter++;
 },
 } as Incrementor;
}

function createIncrementor3(start = 0): Incrementor {
 const incrementor = {
 counter: start,
 inc() {
 this.counter++;
 },
 };
 return incrementor;
}

function compareDateStrings(
 a: {dateStr: string}, b: {dateStr: string}) {
 if (a.dateStr < b.dateStr) {
 return +1;
 } else if (a.dateStr > b.dateStr) {
 return -1;
 } else {
 return 0;
 }
 }

// %inferred-type: Object
const obj1 = new Object();
// %inferred-type: any
const obj2 = Object.create(null);
// %inferred-type: {}
const obj3 = {};
// %inferred-type: { prop: number; }
const obj4 = {prop: 123};
// %inferred-type: object
const obj5 = Reflect.getPrototypeOf({});

interface Name {
 first: string;
 middle?: string;
 last: string;
}

const john: Name = {first: 'Doe', last: 'Doe'}; // (A)
const jane: Name = {first: 'Jane', middle: 'Cecily', last: 'Doe'};

interface Interf {
 prop1?: string;
 prop2: undefined | string; 
}

const obj1: Interf = { prop1: undefined, prop2: undefined };

const obj2: Interf = { prop2: undefined };
// @ts-expect-error: Property 'prop2' is missing in type '{}' but required
// in type 'Interf'. (2741)
const obj3: Interf = { };

interface MyInterface {
 readonly prop: number;
}

const obj: MyInterface = {
 prop: 1,
};
console.log(obj.prop); // OK
// @ts-expect-error: Cannot assign to 'prop' because it is a read-only
// property. (2540)
obj.prop = 2;

interface MyInterface {
 toString(): string; // inherited property
 prop: number; // own property
}
const obj: MyInterface = { // OK
 prop: 123,
};

class OtherClass {}
class MyClass1 extends OtherClass {
 publicInstanceField = 1;
 constructor() {
 super();
 }
 publicPrototypeMethod() {
 return 2;
 }
}
const inst1 = new MyClass1();
assert.equal(inst1.publicInstanceField, 1);
assert.equal(inst1.publicPrototypeMethod(), 2);

class MyClass2 {
 static staticPublicField = 1;
 static staticPublicMethod() {
 return 2;
 }
}
assert.equal(MyClass2.staticPublicField, 1);
assert.equal(MyClass2.staticPublicMethod(), 2);

class MyClass3 {
 #privateField = 1;
 #privateMethod() {
 return 2;
 }
 static accessPrivateMembers() {
 // Private members can only be accessed from inside class definitions
 const inst3 = new MyClass3();
 assert.equal(inst3.#privateField, 1);
 assert.equal(inst3.#privateMethod(), 2);
 }
}
MyClass3.accessPrivateMembers();

class MyClass5 {
 #name = 'Rumpelstiltskin';
 /** Prototype getter */
 get name() {
 return this.#name;
 }
 /** Prototype setter */
 set name(value) {
 this.#name = value;
 }
}
const inst5 = new MyClass5();
assert.equal(inst5.name, 'Rumpelstiltskin'); // getter
inst5.name = 'Queen'; // setter
assert.equal(inst5.name, 'Queen'); // getter

class MyClass6 {
 * publicPrototypeGeneratorMethod() {
 yield 'hello';
 yield 'world';
 }
}
const inst6 = new MyClass6();
assert.deepEqual(
 [...inst6.publicPrototypeGeneratorMethod()],
 ['hello', 'world']);

class MyClass7 {
 async publicPrototypeAsyncMethod() {
 const result = await Promise.resolve('abc');
 return result + result;
 }
}
const inst7 = new MyClass7();
inst7.publicPrototypeAsyncMethod()
 .then(result => assert.equal(result, 'abcabc'));

const publicInstanceFieldKey = Symbol('publicInstanceFieldKey');
const publicPrototypeMethodKey = Symbol('publicPrototypeMethodKey');
class MyClass8 {
 [publicInstanceFieldKey] = 1;
 [publicPrototypeMethodKey]() {
 return 2;
 }
}
const inst8 = new MyClass8();
assert.equal(inst8[publicInstanceFieldKey], 1);
assert.equal(inst8[publicPrototypeMethodKey](), 2);

class ClassA {
 static staticMthdA() {}
 constructor(instPropA) {
 this.instPropA = instPropA;
 }
 prototypeMthdA() {}
}
class ClassB extends ClassA {
 static staticMthdB() {}
 constructor(instPropA, instPropB) {
 super(instPropA);
 this.instPropB = instPropB;
 }
 prototypeMthdB() {}
}
const instB = new ClassB(0, 1);

class PersonPrivateProperty {
 private name: string; // (A)
 constructor(name: string) {
 this.name = name;
 }
 sayHello() {
 return `Hello ${this.name}!`;
 }
}

const john = new PersonPrivateProperty('John');
assert.equal(
 john.sayHello(), 'Hello John!');
// @ts-expect-error: Property 'name' is private and only accessible
// within class 'PersonPrivateProperty'. (2341)
john.name; // (A)

assert.deepEqual(
 Object.keys(john),
 ['name']);

class PersonPrivateProperty {
 constructor(name) {
 this.name = name;
 }
 sayHello() {
 return `Hello ${this.name}!`;
 }
}

class PersonPrivateField {
 #name: string;
 constructor(name: string) {
 this.#name = name;
 }
 sayHello() {
 return `Hello ${this.#name}!`;
 }
}

const john = new PersonPrivateField('John');
assert.equal(
 john.sayHello(), 'Hello John!');

assert.throws(
 () => eval('john.#name'), // (A)
 {
 name: 'SyntaxError',
 message: "Private field '#name' must be declared in "
 + "an enclosing class",
 });
assert.deepEqual(
 Object.keys(john),
 []);

var __classPrivateFieldSet = function (receiver, privateMap, value) {
 if (!privateMap.has(receiver)) {
 throw new TypeError(
 'attempted to set private field on non-instance');
 }
 privateMap.set(receiver, value);
 return value;
};
// Omitted: __classPrivateFieldGet
var _name = new WeakMap();
class Person {
 constructor(name) {
 // Add an entry for this instance to _name
 _name.set(this, void 0);
 // Now we can use the helper function:
 __classPrivateFieldSet(this, _name, name);
 }
 // ···
}

class PrivatePerson {
 private name: string;
 constructor(name: string) {
 this.name = name;
 }
 sayHello() {
 return `Hello ${this.name}!`;
 }
}
class PrivateEmployee extends PrivatePerson {
 private company: string;
 constructor(name: string, company: string) {
 super(name);
 this.company = company;
 }
 sayHello() {
 // @ts-expect-error: Property 'name' is private and only
 // accessible within class 'PrivatePerson'. (2341)
 return `Hello ${this.name} from ${this.company}!`; // (A)
 } 
}

class ProtectedPerson {
 protected name: string; // (A)
 constructor(name: string) {
 this.name = name;
 }
 sayHello() {
 return `Hello ${this.name}!`;
 }
}
class ProtectedEmployee extends ProtectedPerson {
 protected company: string; // (B)
 constructor(name: string, company: string) {
 super(name);
 this.company = company;
 }
 sayHello() {
 return `Hello ${this.name} from ${this.company}!`; // OK
 } 
}

class DataContainer {
 #data: string;
 static async create() {
 const data = await Promise.resolve('downloaded'); // (A)
 return new this(data);
 }
 private constructor(data: string) {
 this.#data = data;
 }
 getData() {
 return 'DATA: '+this.#data;
 }
}
DataContainer.create()
 .then(dc => assert.equal(
 dc.getData(), 'DATA: downloaded'));

class Point {
 x: number;
 y: number;
 constructor(x: number, y: number) {
 this.x = x;
 this.y = y;
 }
}

class Point {
 x = 0;
 y = 0;
 // No constructor needed
}

class Point {
 x!: number; // (A)
 y!: number; // (B)
 constructor() {
 this.initProperties();
 }
 initProperties() {
 this.x = 0;
 this.y = 0;
 }
}

class CompilerError implements CompilerErrorProps { // (A)
 line!: number;
 description!: string;
 constructor(props: CompilerErrorProps) {
 Object.assign(this, props); // (B)
 }
}
// Helper interface for the parameter properties
interface CompilerErrorProps {
 line: number,
 description: string,
}
// Using the class:
const err = new CompilerError({
 line: 123,
 description: 'Unexpected token',
});

class Point1 {
 constructor(public x: number, public y: number) {
 }
}
class Point2 {
 x: number;
 y: number;
 constructor(x: number, y: number) {
 this.x = x;
 this.y = y;
 }
}

class StringBuilder {
 string = '';
 add(str: string) {
 this.string += str;
 }
}
abstract class Printable {
 toString() {
 const out = new StringBuilder();
 this.print(out);
 return out.string;
 }
 abstract print(out: StringBuilder): void;
}

class Entries extends Printable {
 entries: Entry[];
 constructor(entries: Entry[]) {
 super();
 this.entries = entries;
 }
 print(out: StringBuilder): void {
 for (const entry of this.entries) {
 entry.print(out);
 }
 }
}
class Entry extends Printable {
 key: string;
 value: string;
 constructor(key: string, value: string) {
 super();
 this.key = key;
 this.value = value;
 }
 print(out: StringBuilder): void {
 out.add(this.key);
 out.add(': ');
 out.add(this.value);
 out.add('\n');
 }
}

const entries = new Entries([
 new Entry('accept-ranges', 'bytes'),
 new Entry('content-length', '6518'),
]);
assert.equal(
 entries.toString(),
 'accept-ranges: bytes\ncontent-length: 6518\n');

class Counter extends Object {
 static createZero() {
 return new Counter(0);
 }
 value: number;
 constructor(value: number) {
 super();
 this.value = value;
 }
 increment() {
 this.value++;
 }
}
// Static method
const myCounter = Counter.createZero();
assert.ok(myCounter instanceof Counter);
assert.equal(myCounter.value, 0);
// Instance method
myCounter.increment();
assert.equal(myCounter.value, 1);

interface CountingService {
 value: number;
 increment(): void;
}

const myCounter2: CountingService = new Counter(3);

class Counter implements CountingService {
 // ···
};

// Converting JSON to instances
interface JsonStatic {
 fromJson(json: any): JsonInstance;
}
// Converting instances to JSON
interface JsonInstance {
 toJson(): any;
}

class Person implements JsonInstance {
 static fromJson(json: any): Person {
 if (typeof json !== 'string') {
 throw new TypeError(json);
 }
 return new Person(json);
 }
 name: string;
 constructor(name: string) {
 this.name = name;
 }
 toJson(): any {
 return this.name;
 }
}

// Assign the class to a type-annotated variable
const personImplementsJsonStatic: JsonStatic = Person;

const Person: JsonStatic = class implements JsonInstance {
 // ···
};

/**
 * Provides functionality common to all JavaScript objects.
 */
declare var Object: ObjectConstructor;
interface ObjectConstructor {
 new(value?: any): Object;
 (): any;
 (value: any): any;
 /** A reference to the prototype for a class of objects. */
 readonly prototype: Object;
 /**
 * Returns the prototype of an object.
 * @param  o The object that references the prototype.
 */
 getPrototypeOf(o: any): any;
}

interface Object {
 /** The initial value of Object.prototype.constructor is the standard built-in Object constructor. */
 constructor: Function;
 /** Returns a string representation of an object. */
 toString(): string;
}

class Color {
 name: string;
 constructor(name: string) {
 this.name = name;
 }
}

assert.equal(
 typeof Color, 'function')

const green: Color = new Color('green');

interface RgbColor extends Color {
 rgbValue: [number, number, number];
}

class Color {
 name: string;
 constructor(name: string) {
 this.name = name;
 }
}
class Person {
 name: string;
 constructor(name: string) {
 this.name = name;
 }
}
const person: Person = new Person('Jane');
const color: Color = person; // (A)

class Color {
 name: string;
 private branded = true;
 constructor(name: string) {
 this.name = name;
 }
}
class Person {
 name: string;
 private branded = true;
 constructor(name: string) {
 this.name = name;
 }
}
const person: Person = new Person('Jane');
// @ts-expect-error: Type 'Person' is not assignable to type 'Color'.
//   Types have separate declarations of a private property
//   'branded'. (2322)
const color: Color = person;

class Point {
 x: number;
 y: number;
 constructor(x: number, y: number) {
 this.x = x;
 this.y = y;
 }
}

function createPoint(PointClass: ???, x: number, y: number) {
 return new PointClass(x, y);
}

function createPoint(PointClass: typeof Point, x: number, y: number) { // (A)
 return new PointClass(x, y);
}
// %inferred-type: Point
const point = createPoint(Point, 3, 6);
assert.ok(point instanceof Point);

function createPoint(
 PointClass: new (x: number, y: number) => Point, // (A)
 x: number, y: number
) {
 return new PointClass(x, y);
}

function createPoint(
 PointClass: {new (x: number, y: number): Point},
 x: number, y: number
) {
 return new PointClass(x, y);
}

type Class<T> = new (...args: any[]) => T;

interface Class<T> {
 new(...args: any[]): T;
}

function createInstance<T>(AnyClass: Class<T>, ...args: any[]): T {
 return new AnyClass(...args);
}

class Person {
 constructor(public name: string) {}
}
// %inferred-type: Person
const jane = createInstance(Person, 'Jane');

function cast<T>(AnyClass: Class<T>, obj: any): T {
 if (! (obj instanceof AnyClass)) {
 throw new Error(`Not an instance of ${AnyClass.name}: ${obj}`)
 }
 return obj;
}

function parseObject(jsonObjectStr: string): Object {
 // %inferred-type: any
 const parsed = JSON.parse(jsonObjectStr);
 return cast(Object, parsed);
}

class TypeSafeMap {
 #data = new Map<any, any>();
 get<T>(key: Class<T>) {
 const value = this.#data.get(key);
 return cast(key, value);
 }
 set<T>(key: Class<T>, value: T): this {
 cast(key, value); // runtime check
 this.#data.set(key, value);
 return this;
 }
 has(key: any) {
 return this.#data.has(key);
 }
}

const map = new TypeSafeMap();
map.set(RegExp, /abc/);
// %inferred-type: RegExp
const re = map.get(RegExp);
// Static and dynamic error!
assert.throws(
 // @ts-expect-error: Argument of type '"abc"' is not assignable
 // to parameter of type 'Date'.
 () => map.set(Date, 'abc'));

abstract class Shape {
}
class Circle extends Shape {
 // ···
}
// @ts-expect-error: Type 'typeof Shape' is not assignable to type
// 'Class<Shape>'.
//   Cannot assign an abstract constructor type to a non-abstract
//   constructor type. (2322)
const shapeClasses1: Array<Class<Shape>> = [Circle, Shape];

type Class2<T> = Function & {prototype: T};
const shapeClasses2: Array<Class2<Shape>> = [Circle, Shape];

// Each Array element has the type `string`:
const myStringArray: string[] = ['fee', 'fi', 'fo', 'fum'];

const myStringArray: Array<string> = ['fee', 'fi', 'fo', 'fum'];

(number|string)[]
(() => boolean)[]

Array<number|string>
Array<() => boolean>

const yes: [string, string, boolean] = ['oui', 'sí', true];

interface StringArray {
 [index: number]: string;
}
const strArr: StringArray = ['Huey', 'Dewey', 'Louie'];

interface FirstNamesAndLastName {
 [index: number]: string;
 lastName: string;
}
const ducks: FirstNamesAndLastName = {
 0: 'Huey',
 1: 'Dewey',
 2: 'Louie',
 lastName: 'Duck',
};

const fields: Fields = [
 ['first', 'string', true],
 ['last', 'string', true],
 ['age', 'number', false],
];

type Fields = Array<[string, string, boolean]>;

type Fields = Array<[string, ('string'|'number'), boolean]>;

type Fields = Array<Array<string|boolean>>;

type Fields = [
 [string, string, boolean],
 [string, string, boolean],
 [string, string, boolean],
];

type Fields = [
 [string, 'string', boolean],
 [string, 'string', boolean],
 [string, 'number', boolean],
];

type Fields = [
 Array<string|boolean>,
 Array<string|boolean>,
 Array<string|boolean>,
];

// %inferred-type: (string | number)[]
const arr = [123, 'abc'];

function func(p: [number, number]) {
 return p;
}
// %inferred-type: number[]
const pair1 = [1, 2];
// @ts-expect-error: Argument of type 'number[]' is not assignable to
// parameter of type '[number, number]'. [...]
func(pair1);

const pair2: [number, number] = [1, 2];
func(pair2); // OK

// %inferred-type: any[]
const arr1 = [];
arr1.push(123);
// %inferred-type: number[]
arr1;
arr1.push('abc');
// %inferred-type: (string | number)[]
arr1;

// %inferred-type: any[]
const arr1 = [];
arr1[0] = 123;
// %inferred-type: number[]
arr1;
arr1[1] = 'abc';
// %inferred-type: (string | number)[]
arr1;

// %inferred-type: number[]
const arr = [123];
// @ts-expect-error: Argument of type '"abc"' is not assignable to
// parameter of type 'number'. (2345)
arr.push('abc');

// %inferred-type: readonly ["igneous", "metamorphic", "sedimentary"]
const rockCategories =
 ['igneous', 'metamorphic', 'sedimentary'] as const;

// @ts-expect-error: Property 'push' does not exist on type
// 'readonly ["igneous", "metamorphic", "sedimentary"]'. (2339)
rockCategories.push('sand');

// %inferred-type: string[]
const rockCategories2 = ['igneous', 'metamorphic', 'sedimentary'];

// %inferred-type: readonly [1, 2, 3, 4]
const numbers1 = [1, 2, 3, 4] as const;
// %inferred-type: number[]
const numbers2 = [1, 2, 3, 4];
// %inferred-type: readonly [true, "abc"]
const booleanAndString1 = [true, 'abc'] as const;
// %inferred-type: (string | boolean)[]
const booleanAndString2 = [true, 'abc'];

let arr = [1, 2] as const;
arr = [1, 2]; // OK
// @ts-expect-error: Type '3' is not assignable to type '2'. (2322)
arr = [1, 3];

let arr = [1, 2] as const;
// @ts-expect-error: Cannot assign to '1' because it is a read-only
// property. (2540)
arr[1] = 3;

const messages: string[] = ['Hello'];
// %inferred-type: string
const message = messages[3]; // (A)

const messages: [string] = ['Hello'];
// @ts-expect-error: Tuple type '[string]' of length '1' has no element
// at index '1'. (2493)
const message = messages[1];

function repeat1(str: string, times: number): string { // (A)
 return str.repeat(times);
}
assert.equal(
 repeat1('*', 5), '*****');

const repeat2 = (str: string, times: number): string => {
 return str.repeat(times);
};

const repeat3 = (str: string, times: number): string =>
 str.repeat(times);

type Repeat = (str: string, times: number) => string;

interface Repeat {
 (str: string, times: number): string; // (A)
}

interface Incrementor1 {
 (x: number): number;
 increment: number;
}

type Incrementor2 =
 (x: number) => number
 & { increment: number }
;

type StringPredicate = (str: string) => boolean;

const pred1: StringPredicate = (str) => str.length > 0;

function pred2(str: string): boolean {
 return str.length > 0;
}
// Assign the function to a type-annotated variable
const pred2ImplementsStringPredicate: StringPredicate = pred2;

function pred3(...[str]: Parameters<StringPredicate>)
 : ReturnType<StringPredicate> {
 return str.length > 0;
 }

function twice(str: string) {
 return str + str;
}

type StringMapFunction = (str: string) => string;
const twice: StringMapFunction = (str) => str + str; // (A)

assert.deepEqual(
 ['a', 'b', 'c'].map((str) => str + str),
 ['aa', 'bb', 'cc']);

interface Array<T> {
 map<U>(
 callbackfn: (value: T, index: number, array: T[]) => U,
 thisArg?: any
 ): U[];
 // ···
}

function trim1(str?: string): string {
 // Internal type of str:
 // %inferred-type: string | undefined
 str;
 if (str === undefined) {
 return '';
 }
 return str.trim();
}
// External type of trim1:
// %inferred-type: (str?: string | undefined) => string
trim1;

assert.equal(
 trim1('\n abc \t'), 'abc');
assert.equal(
 trim1(), '');
// `undefined` is equivalent to omitting the parameter
assert.equal(
 trim1(undefined), '');

function trim2(str: undefined|string): string {
 // Internal type of str:
 // %inferred-type: string | undefined
 str;
 if (str === undefined) {
 return '';
 }
 return str.trim();
}
// External type of trim2:
// %inferred-type: (str: string | undefined) => string
trim2;

assert.equal(
 trim2('\n abc \t'), 'abc');
// @ts-expect-error: Expected 1 arguments, but got 0\. (2554)
trim2(); // (A)
assert.equal(
 trim2(undefined), ''); // OK!

function trim3(str = ''): string {
 // Internal type of str:
 // %inferred-type: string
 str;
 return str.trim();
}
// External type of trim2:
// %inferred-type: (str?: string) => string
trim3;

assert.equal(
 trim3('\n abc \t'), 'abc');
// Omitting the parameter triggers the parameter default value:
assert.equal(
 trim3(), '');
// `undefined` is allowed and triggers the parameter default value:
assert.equal(
 trim3(undefined), '');

function trim4(str: string = ''): string {
 return str.trim();
}

function join(separator: string, ...parts: string[]) {
 return parts.join(separator);
}
assert.equal(
 join('-', 'state', 'of', 'the', 'art'),
 'state-of-the-art');

function repeat1(...[str, times]: [string, number]): string {
 return str.repeat(times);
}

function repeat2(str: string, times: number): string {
 return str.repeat(times);
}

assert.equal(
 padStart({str: '7', len: 3, fillStr: '0'}),
 '007');

function padStart({ str, len, fillStr = ' ' } // (A)
 : { str: string, len: number, fillStr: string }) { // (B)
 return str.padStart(len, fillStr);
}

interface EventSource {
 addEventListener(
 type: string,
 listener: (this: EventSource, ev: Event) => any,
 options?: boolean | AddEventListenerOptions
 ): void;
 // ···
}

function toIsoString(this: Date): string {
 return this.toISOString();
}
// @ts-expect-error: Argument of type '"abc"' is not assignable to
// parameter of type 'Date'. (2345)
assert.throws(() => toIsoString.call('abc')); // (A) error
toIsoString.call(new Date()); // (B) OK

const obj = { toIsoString };
// @ts-expect-error: The 'this' context of type
// '{ toIsoString: (this: Date) => string; }' is not assignable to
// method's 'this' of type 'Date'. [...]
assert.throws(() => obj.toIsoString()); // error
obj.toIsoString.call(new Date()); // OK

interface Customer {
 id: string;
 fullName: string;
}
const jane = {id: '1234', fullName: 'Jane Bond'};
const lars = {id: '5678', fullName: 'Lars Croft'};
const idToCustomer = new Map<string, Customer>([
 ['1234', jane],
 ['5678', lars],
]);
assert.equal(
 getFullName(idToCustomer, '1234'), 'Jane Bond'); // (A)
assert.equal(
 getFullName(lars), 'Lars Croft'); // (B)

function getFullName(
 customerOrMap: Customer | Map<string, Customer>,
 id?: string
): string {
 if (customerOrMap instanceof Map) {
 if (id === undefined) throw new Error();
 const customer = customerOrMap.get(id);
 if (customer === undefined) {
 throw new Error('Unknown ID: ' + id);
 }
 customerOrMap = customer;
 } else {
 if (id !== undefined) throw new Error();
 }
 return customerOrMap.fullName;
}

assert.throws(() => getFullName(idToCustomer)); // missing ID
assert.throws(() => getFullName(lars, '5678')); // ID not allowed