Mastering TypeScript 3

Other Books You May Enjoy

Summary

Observables – data filtering

Raising and consuming Domain Events

The Domain Events design pattern

Unit-testing Observables

Observables – forkJoin

Observables – concatMap

Rendering REST data

The BoardList component

The BoardSales application

The OpenAPI specification

Angular REST services

Parameterized API endpoints

Express API endpoints

Database structure

Database-driven APIs

Board Sales application

Let's Get Our Hands Dirty

Summary

Using Google user data

Configuring social login

Obtaining a Google API key

External authentication

Using Observables in anger – of pipe and map

Verifying JWT tokens

Using JWT tokens

Using Observables

Using HttpClient

Login form binding

Auth Guards

Using UI-designed HTML

Angular routing

Authentication

Creating a login panel

Using Emmet

Using Brackets

The UI experience

Server logging

Express server configuration

Angular Express server

Node and Angular integration

Building Applications

Summary

Recursive injection

Using dependency injection

Injecting properties

Finding parameter types

Parsing constructor parameters

Using a class definition

Decorator injection

Constructor injection

Class resolution

Enum resolution

Interface resolution

Building a dependency injector

Dependency Injection

Service Location anti-pattern

Service Location

Object dependency

Configuration settings

A service class

Using a local SMTP server

Using nodemailer

Sending mail

Dependency Injection

Summary

Reacting to DOM events

Using the Mediator

The Mediator class

Mediator interface implementation

Child components

RightScreen component

SideNav component

Navbar component

Modular code

The Mediator pattern

Concrete states

State interface

The State pattern

Coordinating transitions

Creating an overlay

Creating a side panel

Using Bootstrap and Font-Awesome

Angular setup

Conceptual design

User interface design

Dependency inversion

Interface segregation

Liskov substitution

Open-closed

Single responsibility

SOLID principles

Programming to an interface

Object-oriented principles

Object-Oriented Programming

Summary

Node REST testing

Lambda logging

Lambda node modules

TypeScript Lambda functions

Serverless deployment

Serverless configuration

Serverless

AWS setup

Lambda function architecture

AWS Lambda functions

HTTP Request redirection

Express POST events

Using Handlebars

Express templating

Express routing

Using modules with Express

Express setup

Using Express with Node

Bootstrapping Jasmine

SystemJS module dependencies

SystemJS browser configuration

SystemJS installation

SystemJS module loading

404 errors

Incorrect dependencies

Fixing Require config errors

Bootstrapping Require

AMD module dependencies

AMD browser configuration

Require configuration

AMD module setup

AMD compilation

AMD module loading

Import types

Exporting variables

Default exports

Module renaming

Importing modules

Exporting modules

Module basics

Modularization

Summary

React testing summary

React form submission

React form input

Initial state tests

Basic React Test format

Using Jest

Multiple entry points

React testing

Angular testing summary

Angular form tests

Angular rendering tests

Angular model tests

Angular test setup

Angular testing

Aurelia test summary

Aurelia DOM events

Rendering tests

Aurelia unit tests

Aurelia test setup

Aurelia testing

Backbone testing summary

Form tests

Collection view tests

DOM event tests

Rendering tests

Complex model tests

Model tests

Test setup

Backbone testing

Testing our sample application

Testing Typescript Compatible Frameworks

Summary

Integration test reporting

TeamCity

Jenkins

Team Foundation Server

Selecting a build server

Benefits of CI

Using continuous integration

Finding page elements

Using Selenium

Protractor

Headless testing

Karma

Testem

Jasmine runners

DOM events

Jasmine fixtures

HTML-based tests

Using async await

Using done()

Asynchronous tests

Using spies as fakes

Spying on callback functions

Using spies

Data-driven tests

Skipping tests

Forcing tests

Test start-up and tear-down

Matchers

Test reporters

A simple Jasmine test

Jasmine

Unit testing frameworks

Acceptance tests

Integration tests

Unit tests

Unit integration and acceptance tests

Test-driven development

Test-Driven Development

Summary

Performance comparison

React summary

Default properties

JSX template rest syntax

React TypeScript features

React state properties

React state change

React forms

React bootstrapping

React CollectionView

React ItemView

Configuring webpack

React setup

Using React

Angular summary

Using Reactive forms

Angular Reactive forms

Template form limitations

Angular template forms

Angular forms

Angular events

Angular views

Angular models

Angular setup

Angular

Aurelia summary

Aurelia forms

Aurelia events

Aurelia application bootstrap

Aurelia views

Aurelia controllers and models

Aurelia setup

Using Aurelia

Backbone summary

Backbone forms

Backbone application

Backbone ItemCollectionView

Backbone ItemView

Backbone models

Backbone structure

Backbone setup

Rendering performance

Using Backbone

Sample application outline

The Benefits of using MVC

MVC summary

The Controller

The View

The Model

What is MVC?

TypeScript Compatible Frameworks

Summary

An Ext JS-specific TypeScript compiler

Using type casting

Creating classes in Ext JS

ExtJS

Inheritance – Angular 1 versus Backbone

Angular 1 TypeScript compatibility

Angular classes and $scope

Angular 1

Backbone TypeScript compatibility

Using ECMAScript 5

Using generic syntax

Using interfaces

Using inheritance with Backbone

Backbone

Choosing a JavaScript framework

Using third-party libraries

Using npm and @types

Installing a specific version

Searching for package names

Installing packages

Using the Package Manager Console

Installing declaration files

Using the NuGet Extension Manager

Using NuGet

Using definition files

Third-Party Libraries

Summary

strictBindCallApply

noFallthroughCasesInSwitch

noImplicitReturns

noUnusedLocals and noUnusedParameters

strictPropertyInitialization

strictNullChecks

noImplicitAny

Strict compiler options

The declaration file syntax

The JavaScript syntax

Merging functions and modules

The declaration file syntax

The JavaScript syntax

Optional properties

The declaration file syntax

The JavaScript syntax

Function signatures

The declaration file syntax

The JavaScript syntax

Global functions

The declaration file syntax

The JavaScript syntax

Static properties and functions

The declaration file syntax

The JavaScript syntax

Class functions

The declaration file syntax

The JavaScript syntax

Class properties

The declaration file syntax

The JavaScript syntax

Class constructor overloads

The declaration file syntax

The JavaScript syntax

Class namespaces

The declaration file syntax

The JavaScript syntax

Classes

The declaration file syntax

The JavaScript syntax

Nested namespaces

The declaration file syntax

The JavaScript syntax

Function overrides

Declaration syntax reference

Module merging

Union types

Interfaces

The module keyword

Writing your own declaration file

Structured data

Using JavaScript code blocks in HTML

Global variables

Declaration Files and Strict Compiler Options

Summary

await messages

Promise versus await syntax

await errors

async and await

Returning values from promises

Callback versus promise syntax

Using promises

Promise syntax

Promises

Asynchronous language features

Partial Readonly Record and Pick

Mapped types

keyof with number

keyof

Conditional type inference

Distributed conditional types

Conditional types

Advanced types with generics

Creating new objects within generics

Generic interfaces

Constraining the type of T

Using the type T

Instantiating generic classes

Generic syntax

Generics

Using decorator metadata

Decorator metadata

Parameter decorators

Using method decorators

Method decorators

Static property decorators

Property decorators

Class decorator parameters

Decorator factories

Multiple decorators

Decorator syntax

Decorators

Decorators Generics and Asynchronous Features

Summary

Using the Factory class

The Factory class

Specialist classes

The Person class

The IPerson interface

What the Factory Design Pattern does

Business requirements

Using interfaces classes and inheritance – the Factory Design Pattern

instanceof

JavaScript closures

Abstract classes

Protected class members

Function overriding

The super keyword

Class inheritance

Interface inheritance

Inheritance

Namespaces

Static properties

Static functions

Class property accessors

Readonly properties

Constructor access modifiers

Class modifiers

Interface function definitions

Class functions

Class constructors

Implementing interfaces

Class properties

Classes

Type inference with the in operator

Weak types

Interface compilation

Optional properties

Interfaces

Interfaces Classes and Inheritance

Summary

Bigint

Tuples and rest syntax

Optional tuple elements

Tuple destructuring

Tuples

Rest and spread with arrays

Spread precedence

Object rest and spread

Unknown

Never

Null operands

Null and undefined

Type aliases

Type guards

Union types

Advanced types

Try catch

Function overrides

Function signatures

Function callbacks

Rest parameters

Default parameters

Optional parameters

Anonymous functions

Function return types

Functions

Numeric separators

Dotted property types

Definite assignment

The let keyword

Const values

Enum implementation

String enums

Const enums

Enums

Explicit casting

The any type

for...in and for...of

Arrays

Template strings

Duck typing

Inferred typing

Type syntax

TypeScript typing

JavaScript typing

Basic types

Types Variables and Function Techniques

Summary

Using --watch and Grunt

Other editors

Running the web page in Chrome

Building a simple HTML application

Default files

Creating a WebStorm project

WebStorm

Debugging in Visual Studio

Default project settings

Creating a Visual Studio project

Microsoft Visual Studio

Debugging web pages

Setting breakpoints

Creating a launch.json file

Building the project

Creating a tasks.json file

Exploring VSCode

Installing VSCode

Visual Studio Code

Localized messages

Creating a tsconfig.json file

Node-based compilation

TypeScript IDEs

Public and private accessors

TypeScript classes generate closures

Encapsulation

DefinitelyTyped

Type definitions for popular JavaScript libraries

TypeScript's syntactic sugar

Strong typing

Compiling

The benefits of TypeScript

JavaScript and the ECMAScript Standard

What is TypeScript?

TypeScript Tools and Framework Options

Reviews

Get in touch

Conventions used

Download the color images

Download the example code files

To get the most out of this book

What this book covers

Who this book is for

Preface

Packt is searching for authors like you

About the reviewers

About the author

Contributors

Packt.com

Why subscribe?

About Packt

Mastering TypeScript 3 Third Edition

Copyright and Credits

Title Page

coverpage

coverpage

Title Page

Copyright and Credits

Mastering TypeScript 3 Third Edition

About Packt

Why subscribe?

Packt.com

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

TypeScript Tools and Framework Options

What is TypeScript?

JavaScript and the ECMAScript Standard

The benefits of TypeScript

Compiling

Strong typing

TypeScript's syntactic sugar

Type definitions for popular JavaScript libraries

DefinitelyTyped

Encapsulation

TypeScript classes generate closures

Public and private accessors

TypeScript IDEs

Node-based compilation

Creating a tsconfig.json file

Localized messages

Visual Studio Code

Installing VSCode

Exploring VSCode

Creating a tasks.json file

Building the project

Creating a launch.json file

Setting breakpoints

Debugging web pages

Microsoft Visual Studio

Creating a Visual Studio project

Default project settings

Debugging in Visual Studio

WebStorm

Creating a WebStorm project

Default files

Building a simple HTML application

Running the web page in Chrome

Other editors

Using --watch and Grunt

Summary

Types Variables and Function Techniques

Basic types

JavaScript typing

TypeScript typing

Type syntax

Inferred typing

Duck typing

Template strings

Arrays

for...in and for...of

The any type

Explicit casting

Enums

Const enums

String enums

Enum implementation

Const values

The let keyword

Definite assignment

Dotted property types

Numeric separators

Functions

Function return types

Anonymous functions

Optional parameters

Default parameters

Rest parameters

Function callbacks

Function signatures

Function overrides

Try catch

Advanced types

Union types

Type guards

Type aliases

Null and undefined

Null operands

Never

Unknown

Object rest and spread

Spread precedence

Rest and spread with arrays

Tuples

Tuple destructuring

Optional tuple elements

Tuples and rest syntax

Bigint

Summary

Interfaces Classes and Inheritance

Interfaces

Optional properties

Interface compilation

Weak types

Type inference with the in operator

Classes

Class properties

Implementing interfaces

Class constructors

Class functions

Interface function definitions

Class modifiers

Constructor access modifiers

Readonly properties

Class property accessors

Static functions

Static properties

Namespaces

Inheritance

Interface inheritance

Class inheritance

The super keyword

Function overriding

Protected class members

Abstract classes

JavaScript closures

instanceof

Using interfaces classes and inheritance – the Factory Design Pattern

Business requirements

What the Factory Design Pattern does

The IPerson interface

The Person class

Specialist classes

The Factory class

Using the Factory class

Summary

Decorators Generics and Asynchronous Features

Decorators

Decorator syntax

Multiple decorators

Decorator factories

Class decorator parameters

Property decorators

Static property decorators

Method decorators

Using method decorators

Parameter decorators

Decorator metadata

Using decorator metadata

Generics

Generic syntax

Instantiating generic classes

Using the type T

Constraining the type of T

Generic interfaces

Creating new objects within generics

Advanced types with generics

Conditional types

Distributed conditional types

Conditional type inference

keyof

keyof with number

Mapped types

Partial Readonly Record and Pick

Asynchronous language features

Promises

Promise syntax

Using promises

Callback versus promise syntax

Returning values from promises

async and await

await errors

Promise versus await syntax

await messages

Summary

Declaration Files and Strict Compiler Options

Global variables

Using JavaScript code blocks in HTML

Structured data

Writing your own declaration file

The module keyword

Interfaces

Union types

Module merging

Declaration syntax reference

Function overrides

The JavaScript syntax

The declaration file syntax

Nested namespaces

The JavaScript syntax

The declaration file syntax

Classes

The JavaScript syntax

The declaration file syntax

Class namespaces

The JavaScript syntax

The declaration file syntax

Class constructor overloads

The JavaScript syntax

The declaration file syntax

Class properties

The JavaScript syntax

The declaration file syntax

Class functions

The JavaScript syntax

The declaration file syntax

Static properties and functions

The JavaScript syntax

The declaration file syntax

Global functions

The JavaScript syntax

The declaration file syntax

Function signatures

The JavaScript syntax

The declaration file syntax

Optional properties

The JavaScript syntax

The declaration file syntax

Merging functions and modules

The JavaScript syntax

The declaration file syntax

Strict compiler options

noImplicitAny

strictNullChecks

strictPropertyInitialization

noUnusedLocals and noUnusedParameters

noImplicitReturns

noFallthroughCasesInSwitch

strictBindCallApply

Summary

Third-Party Libraries

Using definition files

Using NuGet

Using the NuGet Extension Manager

Installing declaration files

Using the Package Manager Console

Installing packages

Searching for package names

Installing a specific version

Using npm and @types

Using third-party libraries

Choosing a JavaScript framework

Backbone

Using inheritance with Backbone

Using interfaces

Using generic syntax

Using ECMAScript 5

Backbone TypeScript compatibility

Angular 1

Angular classes and $scope

Angular 1 TypeScript compatibility

Inheritance – Angular 1 versus Backbone

ExtJS

Creating classes in Ext JS

Using type casting

An Ext JS-specific TypeScript compiler

Summary

TypeScript Compatible Frameworks

What is MVC?

The Model

The View

The Controller

MVC summary

The Benefits of using MVC

Sample application outline

Using Backbone

Rendering performance

Backbone setup

Backbone structure

Backbone models

Backbone ItemView

Backbone ItemCollectionView

Backbone application

Backbone forms

Backbone summary

Using Aurelia

Aurelia setup

Aurelia controllers and models

Aurelia views

Aurelia application bootstrap

Aurelia events

Aurelia forms

Aurelia summary

Angular

Angular setup

Angular models

Angular views

Angular events

Angular forms

Angular template forms

Template form limitations

Angular Reactive forms

Using Reactive forms

Angular summary

Using React

React setup

Configuring webpack

React ItemView

React CollectionView

React bootstrapping

React forms

React state change

React state properties

React TypeScript features

JSX template rest syntax

Default properties

React summary

Performance comparison

Summary

Test-Driven Development

Test-driven development

Unit integration and acceptance tests

Unit tests

Integration tests

Acceptance tests

Unit testing frameworks

Jasmine

A simple Jasmine test

Test reporters

Matchers

Test start-up and tear-down

Forcing tests

Skipping tests

Data-driven tests

Using spies

Spying on callback functions

Using spies as fakes

Asynchronous tests

Using done()

Using async await

HTML-based tests

Jasmine fixtures

DOM events

Jasmine runners

Testem

Karma

Headless testing

Protractor

Using Selenium

Finding page elements

Using continuous integration

Benefits of CI

Selecting a build server

Team Foundation Server

Jenkins

TeamCity

Integration test reporting

Summary

Testing Typescript Compatible Frameworks

Testing our sample application

Backbone testing

Test setup

Model tests

Complex model tests

Rendering tests

DOM event tests

Collection view tests

Form tests

Backbone testing summary

Aurelia testing

Aurelia test setup

Aurelia unit tests

Rendering tests

Aurelia DOM events

Aurelia test summary

Angular testing

Angular test setup

Angular model tests

Angular rendering tests

Angular form tests

Angular testing summary

React testing

Multiple entry points

Using Jest

Basic React Test format

Initial state tests

React form input

React form submission

React testing summary

Summary

Modularization

Module basics

Exporting modules

Importing modules

Module renaming

Default exports

Exporting variables

Import types

AMD module loading

AMD compilation

AMD module setup

Require configuration

AMD browser configuration

AMD module dependencies

Bootstrapping Require

Fixing Require config errors

Incorrect dependencies

404 errors

SystemJS module loading

SystemJS installation

SystemJS browser configuration

SystemJS module dependencies

Bootstrapping Jasmine

Using Express with Node

Express setup

Using modules with Express

Express routing

Express templating

Using Handlebars

Express POST events

HTTP Request redirection

AWS Lambda functions

Lambda function architecture

AWS setup

Serverless

Serverless configuration

Serverless deployment

TypeScript Lambda functions

Lambda node modules

Lambda logging

Node REST testing

Summary

Object-Oriented Programming

Object-oriented principles

Programming to an interface

SOLID principles

Single responsibility

Open-closed

Liskov substitution

Interface segregation

Dependency inversion

User interface design

Conceptual design

Angular setup

Using Bootstrap and Font-Awesome

Creating a side panel

Creating an overlay

Coordinating transitions

The State pattern

State interface

Concrete states

The Mediator pattern

Modular code

Navbar component

SideNav component

RightScreen component

Child components

Mediator interface implementation

The Mediator class

Using the Mediator

Reacting to DOM events

Summary

Dependency Injection

Sending mail

Using nodemailer

Using a local SMTP server

A service class

Configuration settings

Object dependency

Service Location

Service Location anti-pattern

Dependency Injection

Building a dependency injector

Interface resolution

Enum resolution

Class resolution

Constructor injection

Decorator injection

Using a class definition

Parsing constructor parameters

Finding parameter types

Injecting properties

Using dependency injection

Recursive injection

Summary

Building Applications

Node and Angular integration

Angular Express server

Express server configuration

Server logging

The UI experience

Using Brackets

Using Emmet

Creating a login panel

Authentication

Angular routing

Using UI-designed HTML

Auth Guards

Login form binding

Using HttpClient

Using Observables

Using JWT tokens

Verifying JWT tokens

Using Observables in anger – of pipe and map

External authentication

Obtaining a Google API key

Configuring social login

Using Google user data

Summary

Let's Get Our Hands Dirty

Board Sales application

Database-driven APIs

Database structure

Express API endpoints

Parameterized API endpoints

Angular REST services

The OpenAPI specification

The BoardSales application

The BoardList component

Rendering REST data

Observables – concatMap

Observables – forkJoin

Unit-testing Observables

The Domain Events design pattern

Raising and consuming Domain Events

Observables – data filtering

Summary

Other Books You May Enjoy