Understanding TypeScript

Getting Started
1 Welcome to the Course
2 What Is TypeScript
3 Why Would You Use TypeScript
4 Join Our Learning Community
5 Installing and Using TypeScript
6 Editor and Project Setup
7 About This Course
8 How To Get The Most Out Of The Course
9 Course Setup and Course Code

TypeScript Basics and Basic Types
10 Module Introduction
11 Using Node js To Run JavaScript Code
12 Project Setup
13 Working with Types and Exploring Built-in Types
14 Vanilla JavaScript Has Types Too
15 Type Inference vs Type Assignment
16 Assigning Types To Function Parameters
17 The any Type
18 Understanding Union Types
19 Arrays and Types
20 Advanced Array Types
21 A First Glimpse At Generic Types – Alternative Array Type Declaration
22 Making Sense of Tuples
23 Object Types
24 Tricky The Must Not Be Null Type
25 Flexible Objects with the Record Type
26 Working with Enums
27 Being Specific With Literal Types
28 Type Aliases and Custom Types
29 Function Return Value Types
30 The void Type
31 The never Type
32 Functions As Types
33 null and undefined – Special Types
34 Inferred null and A First Look At Type Narrowing
35 Forced Not Null And Optional Chaining
36 Type Casting
37 The unknown Type
38 Optional Values and TypeScript
39 Nullish Coalescing

The TypeScript Compiler and its Configuration
40 Module Introduction
41 TypeScript Project Setup and Creating a tsconfig json File
42 Exploring tsconfig Options Target and Libs
43 Controlling File Input and Emission
44 Configuring Type Checking
45 Configuring Code Quality Checks
46 Example tsconfig json and Deep Dive
47 Compiling with tsconfig
48 Using TypeScripts Watch Mode
49 Installing Type Packages

TypeScript Essentials Demo Project
50 Module Introduction
51 Using Node js To Run Compiled JS Code
52 Getting Started and First Steps
53 Creating a First Custom Type
54 Defining a Function with a Union Type Return Value
55 Adding Application Logic
56 Connecting Functions and Passing Values
57 Compilation and Execution

Next-generation JavaScript and TypeScript
58 Module Introduction
59 let and const
60 Arrow Functions
61 Default Function Parameters
62 The Spread Operator
63 Rest Parameters
64 Array and Object Destructuring
65 How Code Gets Compiled and Wrap Up

Classes and Interfaces
66 Module Introduction
67 What are Classes
68 Creating a First Class
69 A Useful TypeScript Shortcut and Compiling to JavaScript
70 Making Sense of public and private
71 Marking Fields as readonly
72 Understanding Getters
73 Setting Values with Setters
74 Exploring Static Properties and Methods
75 Understanding Inheritance
76 The protected Modifier
77 Making Sense Of Abstract Classes
78 Introducing Interfaces
79 Creating a First Interface
80 Interfaces As Object Types
81 Interfaces vs Type Aliases and Understanding Declaration Merging
82 Using Interfaces To Define Function Types
83 Implementing Interfaces
84 Ensuring Base Types with Interfaces
85 Extending Interfaces
86 How Interfaces Get Not Compiled To JavaScript

Advanced Types
87 Module Introduction
88 Intersection Types
89 More on Type Guards
90 Discriminated Unions
91 Type Guards via instanceof
92 Outsourcing Type Guards and Using Type Predicates
93 Function Overloads
94 Rest Parameters and Types
95 Working with Function Overloads
96 Making Sense of Index Types
97 Constant Types with as const
98 Revisiting the Record Type
99 The satisfies Keyword

Generic Types
100 Module Introduction
101 A Generic Type We Already Know
102 Understanding Generic Types
103 Creating and Using a Generic Type
104 Generic Functions and Inference
105 Working with Multiple Generic Parameters
106 Generics and Constraints
107 Constraints and Multiple Generic Types
108 Working with Generic Classes and Interfaces
109 Summary

Classes and Generics – Demo Project
110 Module Introduction
111 What Is A Linked List
112 Creating List and Node Classes
113 Making the Class Generic
114 Adding an add Method
115 Adding Items More Efficiently
116 Accessing the Data and Compiling Running the Code
117 Finishing the Linked List

Deriving Types From Types
118 Module Introduction
119 Using typeof
120 typeof and A More Useful Example
121 Another Great Use-case for typeof
122 Extracting Keys with keyof
123 keyof and A More Useful Example
124 Understanding Indexed Access Types
125 Accessing Array Elements with Indexed Access Types
126 Introducing Mapped Types
127 Readonly Types and Optional Mapping
128 Exploring Template Literal Types
129 Introducing Conditional Types
130 Conditional Types – Another Example
131 Making Sense of the infer Keyword
132 TypeScripts Got You Covered Built-in Utility Types

ECMAScript Decorators
133 Module Introduction
134 What Are Decorators And ECMAScript Decorators vs Experimental Decorators
135 Exploring Different Types of Decorators
136 Building a First Decorator
137 Building a Class Decorators That Edits a Class
138 Understanding Decorator Code Execution Order
139 Creating a Method Decorator
140 Using Decorators To Solve A Common Problem
141 Implementing A Decorator-based Solution autobind
142 Replacing Methods with Decorators
143 Introducing the Field Decorator
144 Building Configurable Decorators with Factories
145 Onwards to Experimental Decorators

Experimental Decorators
146 Module Introduction
147 A First Class Decorator
148 Working with Decorator Factories
149 Building More Useful Decorators
150 Adding Multiple Decorators
151 Diving into Property Decorators
152 Accessor and Parameter Decorators
153 When Do Decorators Execute
154 Returning and changing a Class in a Class Decorator
155 Other Decorator Return Types
156 Example Creating an Autobind Decorator
157 Validation with Decorators – First Steps
158 Validation with Decorators – Finished
159 Fixing a Validator Bug
160 Wrap Up

Practice Time Lets build a Drag and Drop Project
161 Module Introduction
162 Getting Started
163 DOM Element Selection and OOP Rendering
164 Interacting with DOM Elements
165 Creating and Using an Autobind Decorator
166 Fetching User Input
167 Creating a Re-Usable Validation Functionality
168 Rendering Project Lists
169 Managing Application State with Singletons
170 More Classes and Custom Types
171 Filtering Projects with Enums
172 Adding Inheritance and Generics
173 Rendering Project Items with a Class
174 Using a Getter
175 Utilizing Interfaces to Implement Drag and Drop
176 Drag Events and Reflecting the Current State in the UI
177 Adding a Droppable Area
178 Finishing Drag and Drop
179 Wrap Up

Modules and Namespaces
180 Module Introduction
181 Writing Module Code – Your Options
182 Working with Namespaces
183 Organizing Files and Folders
184 A Problem with Namespace Imports
185 Using ES Modules
186 Configuring tsconfig
187 Understanding various Import and Export Syntaxes
188 How Does Code In Modules Execute
189 Understanding type Imports
190 Wrap Up

Creating and Running TypeScript Projects with Vite
191 Module Introduction
192 The Problem With The TypeScript Compiler
193 Building with Webpack or ESBuild
194 Introducing Vite
195 Using Vite
196 Installing TypeScript on a Per-Project Basis
197 Making Sense of d ts Files
198 Importing non-TS Files
199 Wrap Up

Using Webpack with TypeScript
200 About This Section
201 Module Introduction
202 What is Webpack and Why do we need it
203 Installing Webpack and Important Dependencies
204 Adding Entry and Output Configuration
205 Adding TypeScript Support with the ts-loader Package
206 Adjust Webpack Config
207 Finishing the Setup and Adding webpack-dev-server
208 Adding a Production Workflow
209 Wrap Up

rd Party Libraries and TypeScript
210 Module Introduction
211 Problem Using JavaScript Libraries with TypeScript
212 Solution Installing types Packages
213 Exploring d ts Files
214 Diving Deeper Into d ts Files
215 Using declare Manually
216 There Are Libraries With Great TypeScript Support
217 Exploring Zod As a TypeScript-first Library
218 Diving Deeper Into Zod
219 Runtime vs Compile-time Types with Zod

Time to Practice Lets build a Select and Share a Place App incl Google Maps
220 Module Introduction
221 Project Setup
222 Getting User Input
223 Setting Up a Google API Key
224 Using Axios to Fetch Coordinates for an Entered Address
225 Rendering a Map with Google Maps incl Types
226 Working with Maps without a Credit Card

React js and TypeScript
227 Module Introduction
228 Setting Up a React TypeScript Project
229 Typing Components and Props
230 Using Components and Props
231 The Special children Prop and Optional Props
232 Adding Another Components With Props
233 Component Functions and Types – An Alternative
234 Managing State
235 Passing Functions As Props
236 Handling Form Submission
237 Working with Refs
238 More Function Passing and State Updating
239 Wrap Up

Node js Express and TypeScript
240 Module Introduction
241 Node and TypeScript Options and Alternatives
242 Setting up a Project
243 First Server and Working with Node Types
244 Adding and Using Express Types
245 Managing Data with Help of TypeScript
246 Adding and Testing a First Route
247 Finishing The Basic App
248 Native Node js TypeScript Support Without Compilation
249 Type Stripping vs Type Transformation
250 Exploring Alternative Runtimes Like Bun

Course Roundup
251 Thanks for being part of the course

LEGACY TypeScript Basics and Basic Types
252 LEGACY Lectures Below
253 Module Introduction
254 Using Types
255 TypeScript Types vs JavaScript Types
256 Important Type Casing
257 Working with Numbers Strings and Booleans
258 Type Assignment and Type Inference
259 Object Types
260 Nested Objects and Types
261 Arrays Types
262 Working with Tuples
263 Working with Enums
264 The any Type
265 Union Types
266 Literal Types
267 Type Aliases – Custom Types
268 Type Aliases and Object Types
269 Function Return Types and void
270 Functions as Types
271 Function Types and Callbacks
272 The unknown Type
273 The never Type
274 Wrap Up
275 Where Should You Go Next

LEGACY The TypeScript Compiler and its Configuration
276 LEGACY Lectures Below
277 Module Introduction
278 Using Watch Mode
279 Compiling the Entire Project – Multiple Files
280 Including and Excluding Files
281 Setting a Compilation Target
282 Understanding TypeScript Core Libs
283 More Configuration and Compilation Options
284 Working with Source Maps
285 rootDir and outDir
286 Stop Emitting Files on Compilation Errors
287 Strict Compilation
288 Code Quality Options
289 Debugging with Visual Studio Code
290 Wrap Up
291 Useful Resources and Links
292 Where Should You Go Next

LEGACY Classes and Interfaces
293 LEGACY Lectures Below
294 Module Introduction
295 What are Classes
296 Creating a First Class
297 Compiling to JavaScript
298 Constructor Functions and The this Keyword
299 private and public Access Modifiers
300 Shorthand Initialization
301 readonly Properties
302 Inheritance
303 Overriding Properties and The protected Modifier
304 Getters and Setters
305 Static Methods and Properties
306 Abstract Classes
307 Singletons and Private Constructors
308 Classes – A Summary
309 A First Interface
310 Using Interfaces with Classes
311 Why Interfaces
312 Readonly Interface Properties
313 Extending Interfaces
314 Interfaces as Function Types
315 Optional Parameters and Properties
316 Compiling Interfaces to JavaScript
317 Wrap Up
318 Where Should You Go Next

LEGACY Generics
319 LEGACY Lectures Below
320 Module Introduction
321 Built-in Generics and What are Generics
322 Creating a Generic Function
323 Working with Constraints
324 Another Generic Function
325 The keyof Constraint
326 Generic Classes
327 A First Summary
328 Generic Utility Types
329 Generic Types vs Union Types
330 Where Should You Go Next