Method Decorators A Method Decorator is declared just before a method declaration. The decorator is applied to the Property Descriptor for the method, and can be used to observe, modify, or replace a method definition. A method decorator cannot be used in a declaration file, on an overload, or in any other ambient context (such as in a declare class). The expression for the method decorator will be called as a function at runtime, with the following three arguments: Either the constructor funct

Metadata Some examples use the reflect-metadata library which adds a polyfill for an experimental metadata API. This library is not yet part of the ECMAScript (JavaScript) standard. However, once decorators are officially adopted as part of the ECMAScript standard these extensions will be proposed for adoption. You can install this library via npm: npm i reflect-metadata --save TypeScript includes experimental support for emitting certain types of metadata for declarations that have decorators

Merging Namespaces with Classes This gives the user a way of describing inner classes. class Album { label: Album.AlbumLabel; } namespace Album { export class AlbumLabel { } } The visibility rules for merged members is the same as described in the ‘Merging Namespaces’ section, so we must export the AlbumLabel class for the merged class to see it. The end result is a class managed inside of another class. You can also use namespaces to add more static members to an existing class. In additi

Merging Namespaces Similarly to interfaces, namespaces of the same name will also merge their members. Since namespaces create both a namespace and a value, we need to understand how both merge. To merge the namespaces, type definitions from exported interfaces declared in each namespace are themselves merged, forming a single namespace with merged interface definitions inside. To merge the namespace value, at each declaration site, if a namespace already exists with the given name, it is furth

Merging Interfaces The simplest, and perhaps most common, type of declaration merging is interface merging. At the most basic level, the merge mechanically joins the members of both declarations into a single interface with the same name. interface Box { height: number; width: number; } interface Box { scale: number; } let box: Box = {height: 5, width: 6, scale: 10}; Non-function members of the interfaces must be unique. The compiler will issue an error if the interfaces both declare a

Symbol.match A regular expression method that matches the regular expression against a string. Called by the String.prototype.match method.

Mappings Compiler Option MSBuild Property Name Allowed Values --allowJs Not supported in MSBuild --allowSyntheticDefaultImports TypeScriptAllowSyntheticDefaultImports boolean --allowUnreachableCode TypeScriptAllowUnreachableCode boolean --allowUnusedLabels TypeScriptAllowUnusedLabels boolean --baseUrl TypeScriptBaseUrl File path --charset TypeScriptCharset --declaration TypeScriptGeneratesDeclarations boolean --declarationDir TypeScriptDeclarationDir File path --diagnostics Not supported in

Library Structures The Library Structures guide helps you understand common library formats and how to write a correct declaration file for each format. If you’re editing an existing file, you probably don’t need to read this section. Authors of new declaration files must read this section to properly understand how the format of the library influences the writing of the declaration file.

let declarations By now you’ve figured out that var has some problems, which is precisely why let statements were introduced. Apart from the keyword used, let statements are written the same way var statements are. let hello = "Hello!"; The key difference is not in the syntax, but in the semantics, which we’ll now dive into.

Lay out the project Let’s start out with a new directory. We’ll name it proj for now, but you can change it to whatever you want. mkdir proj cd proj To start, we’re going to structure our project in the following way: proj/ +- src/ | +- components/ | +- dist/ TypeScript files will start out in your src folder, run through the TypeScript compiler, then webpack, and end up in a bundle.js file in dist. Any components that we write will go in the src/components folder. Let’s scaffold