TypeScript 3.6

Stricter Generators

More Accurate Array Spread

Improved UX Around Promises

Better Unicode Support for Identifiers

import.meta Support in SystemJS

get and set Accessors Are Allowed in Ambient Contexts

Ambient Classes and Functions Can Merge

APIs to Support --build and --incremental

Semicolon-Aware Code Edits

Smarter Auto-Import Syntax

await Completions on Promises

New TypeScript Playground

TypeScript 3.5

Speed improvements

Type-checking speed-ups

--incremental improvements

The Omit helper type

Improved excess property checks in union types

The --allowUmdGlobalAccess flag

Smarter union type checking

Higher order type inference from generic constructors

TypeScript 3.4

Faster subsequent builds with the --incremental flag

Composite projects

outFile

Higher order type inference from generic functions

Improvements for ReadonlyArray and readonly tuples

A new syntax for ReadonlyArray

readonly tuples

readonly mapped type modifiers and readonly arrays

Caveats

const assertions

Caveats

Type-checking for globalThis

TypeScript 3.3

Improved behavior for calling union types

Caveats

Incremental file watching for composite projects in --build --watch

TypeScript 3.2

strictBindCallApply

Caveats

Generic spread expressions in object literals

Generic object rest variables and parameters

BigInt

Caveats

Non-unit types as union discriminants

tsconfig.json inheritance via Node.js packages

The new --showConfig flag

Object.defineProperty declarations in JavaScript

TypeScript 3.1

Mapped types on tuples and arrays

Properties declarations on functions

Version selection with typesVersions

Matching behavior

Multiple fields

TypeScript 3.0

Tuples in rest parameters and spread expressions

Rest parameters with tuple types

Spread expressions with tuple types

Generic rest parameters

Example

Optional elements in tuple types

Example

Rest elements in tuple types

Example

New unknown top type

Example

Support for defaultProps in JSX

Caveats

Explicit types on defaultProps

Changes to @types/React

/// <reference lib="..." /> reference directives

reference directives" loading="lazy" decoding="async" style="width: 100%; max-width: 600px; height: auto; display: block; border: 1px solid #ddd; box-shadow: 0 1px 3px rgba(0,0,0,0.1);">

Example

TypeScript 2.9

Support number and symbol named properties with keyof and mapped types

Example

Example

Recommendations

Generic type arguments in JSX elements

Example

Generic type arguments in generic tagged templates

Example

import types

Example

Relaxing declaration emit visiblity rules

Support for import.meta

Example

New --resolveJsonModule

Example

--pretty output by default

New --declarationMap

TypeScript 2.8

Conditional Types

Example

Distributive conditional types

Example

Example

Example

Type inference in conditional types

Predefined conditional types

Example

Improved control over mapped type modifiers

Example

Example

Example

Improved keyof with intersection types

Example

Better handling for namespace patterns in .js files

IIFEs as namespace declarations

Defaulted declarations

Prototype assignment

Nested and merged declarations

Per-file JSX factories

Example

Locally scoped JSX namespaces

New --emitDeclarationsOnly

TypeScript 2.7

Constant-named properties

Example

Example

unique symbol

Example

Example

Strict Class Initialization

Definite Assignment Assertions

Fixed Length Tuples

Improved type inference for object literals

Example

Improved handling of structurally identical classes and instanceof expressions

Example:

Type guards inferred from in operator

Example

Support for import d from "cjs" form CommonJS modules with --esModuleInterop

Example

Numeric separators

Example

Cleaner output in --watch mode

Prettier --pretty output

TypeScript 2.6

Strict function types

Example

Note:

Support for JSX Fragment Syntax

Cache tagged template objects in modules

Example

Localized diagnostics on the command line

Example

Suppress errors in .ts files using '// @ts-ignore' comments

Example

Faster tsc --watch

Write-only references now flagged as unused

Example

Example

TypeScript 2.5

Optional catch clause variables

Type assertion/cast syntax in checkJs/@ts-check mode

Deduplicated and redirected packages

The --preserveSymlinks compiler flag

TypeScript 2.4

Dynamic Import Expressions

String Enums

Improved inference for generics

Return types as inference targets

Type parameter inference from contextual types

Stricter checking for generic functions

Strict contravariance for callback parameters

Weak Type Detection

TypeScript 2.3

Generators and Iteration for ES5/ES3

Iterators

Generators

New --downlevelIteration

Async Iteration

Async iterators

Async Generators

The for-await-of Statement

Caveats

Generic parameter defaults

Example

New --strict master option

Enhanced --init output

Errors in .js files with --checkJs

TypeScript 2.2

Support for Mix-in classes

First some terminology:

Putting all of the above rules together in an example:

object type

Support for new.target

Example

Better checking for null/undefined in operands of expressions

Dotted property for types with string index signatures

Support for spread operator on JSX element children

Example

New jsx: react-native

TypeScript 2.1

keyof and Lookup Types

Example

Example

Mapped Types

Partial, Readonly, Record, and Pick

Object Spread and Rest

Downlevel Async Functions

Example

tsconfig.json

dramaticWelcome.ts

Support for external helpers library (tslib)

Untyped imports

Example

Support for --target ES2016, --target ES2017 and --target ESNext

Improved any Inference

Example

Implicit any errors

Example

Better inference for literal types

Example

Example

Use returned values from super calls as 'this'

Example

Configuration inheritance

Example

New --alwaysStrict

TypeScript 2.0

Null- and undefined-aware types

--strictNullChecks

Example

Assigned-before-use checking

Example

Optional parameters and properties

Non-null and non-undefined type guards

Example

Dotted names in type guards

Example

Expression operators

Type widening

Non-null assertion operator

Compatibility

Control flow based type analysis

Example

Tagged union types

Example

The never type

Read-only properties and index signatures

Example

Specifying the type of this for functions

this parameters in callbacks

Example

--noImplicitThis

Glob support in tsconfig.json

Example

Module resolution enhancements: BaseUrl, Path mapping, rootDirs and tracing

Base URL

Example

Path mapping

Example

Virtual Directories with rootDirs

Example

Tracing module resolution

Shorthand ambient module declarations

declarations.d.ts

Wildcard character in module names

Example

Example

Support for UMD module definitions

math-lib.d.ts

Optional class properties

Example

Private and Protected Constructors

Example

Abstract properties and accessors

Example

Implicit index signatures

Including built-in type declarations with --lib

Example

Flag unused declarations with --noUnusedParameters and --noUnusedLocals

Example

Module identifiers allow for .js extension

Support 'target : es5' with 'module: es6'

Trailing commas in function parameter and argument lists

Example

New --skipLibCheck

Allow duplicate identifiers across declarations

Example

New --declarationDir

TypeScript 1.8

Type parameters as constraints

Example

Control flow analysis errors

Unreachable code

Example

Unused labels

Example

Implicit returns

Example

Case clause fall-throughs

Example

Stateless Function Components in React

Simplified props type management in React

Augmenting global/module scope from modules

Example

Example

String literal types

Improved union/intersection type inference

Example

Concatenate AMD and System modules with --outFile

Example

Support for default import interop with SystemJS

Allow captured let/const in loops

Example

Improved checking for for..in statements

Example

Modules are now emitted with a "use strict"; prologue

Including .js files with --allowJs

Custom JSX factories using --reactNamespace

Example

this-based type guards

Example

Official TypeScript NuGet package

Prettier error messages from tsc

Colorization of JSX code in VS 2015

The --project (-p) flag can now take any file path

Allow comments in tsconfig.json

Support output to IPC-driven files

Improved support for tsconfig.json in Visual Studio 2015

A couple of limitations:

TypeScript 1.7

async/await support in ES6 targets (Node v4+)

Example

Support for --target ES6 with --module

Example

this-typing

ES7 exponentiation operator

Example

Improved checking for destructuring object literal

Example

Support for decorators when targeting ES3

TypeScript 1.6

JSX support

New .tsx file extension and as operator

Using React

Using other JSX frameworks

Output generation

Intersection types

Example

Local type declarations

Class expressions

Extending expressions

abstract classes and methods

Examples

Generic type aliases

Stricter object literal assignment checks

Examples

ES6 generators

Experimental support for async functions

Example

Nightly builds

Adjustments in module resolution logic

Merging ambient class and interface declaration

User-defined type guard functions

Examples

exclude property support in tsconfig.json

--init command line option

TypeScript 1.5

ES6 Modules

Export Declarations

Re-exporting

Default Export

Bare Import

Destructuring in declarations and assignments

Declarations

Assignments

namespace keyword

let and const support

Const

Block scoped

for..of support

Example

Decorators

Example

Computed properties

Support for UMD and System module output

Unicode codepoint escapes in strings

Tagged template strings in ES3/ES5

AMD-dependency optional names

Project support through tsconfig.json

Example

--rootDir command line option

--noEmitHelpers command line option

--newLine command line option

--inlineSourceMap and inlineSources command line options

TypeScript 1.4

Union types

Overview

Stricter Generics

Better Type Inference

let declarations

const declarations

Template strings

Type Guards

Type Aliases

const enum (completely inlined enums)

-noEmitOnError commandline option

AMD Module names

TypeScript 1.3

Protected

Tuple types

TypeScript 1.1

Performance Improvements

Better Module Visibility Rules