Angular Course

Introduction                                           32:35 ....................................................................................................

Introduction                                           02:51 
What is Angular                                        02:00
Architecture of Angular Apps                           03:48
Setting Up the Development Environment                 02:40
Your First Angular App                                 02:25
Structure of Angular Projects                          06:54
Webpack                                                03:15
Angular Version History                                03:34
Course Structure                                       03:46
Making a Promise                                       00:48
Asking Questions                                       00:34


TypeScript Fundamentals                             01:00:48 ....................................................................................................

Introduction                                           00:41
What is TypeScript?                                    02:24
Your First TypeScript Program                          03:00
Declaring Variables                                    04:49 `var` in a for is available outside. use `let`. ts compile will warn but still generate js.
Types                                                  05:43 type vardec without initialization is `any`. enum type "fields" get index vals.
Type Assertions                                        02:47 `(<type>id)` and `(id a string)`. access intellisense
Arrow Functions                                        01:44 let var = (params) => { body }
Interfaces                                             03:54 
Classes                                                04:31
Objects                                                04:09
Constructors                                           02:52
Access Modifiers                                       02:56
Access Modifiers in Constructor Parameters             01:41
Properties                                             05:18
Modules                                                04:31
Exercise                                               01:00
Solution                                               05:09
A Problem with the Current Implementation              03:39


Angular Fundamentals                                   38:14 ....................................................................................................

Introduction                                           00:19
Building Blocks of Angular Apps                        03:41
Components                                             09:38
Generating Components Using Angular CLI                04:41
Templates                                              02:28
Directives                                             03:27
Services                                               04:29 `courses.service.ts`. export class, add getter, 
Dependency Injection                                   07:20 make a constructor in component but pass coursesService into it
Generating Services Using Angular CLI                  02:11


Displaying Data and Handling Events                    44:26 ....................................................................................................

Introduction                                           00:24
Property Binding                                       03:16
Attribute Binding                                      03:35
Adding Bootstrap                                       04:53
Class Binding                                          01:47
Style Binding                                          01:19
Event Binding                                          04:30
Event Filtering                                        01:50
Template Variables                                     01:53
Two-way Binding                                        08:05
Pipes                                                  06:38
Custom Pipes                                           06:16

Building Re-usable Components                          49:44 ....................................................................................................

Introduction                                           00:26
Component API                                          04:22
Input Properties                                       04:44
Aliasing Input Properties                              04:22
Output Properties                                      03:22
Passing Event Data                                     05:51
Aliasing Output Properties                             02:05
Templates                                              02:41
Styles                                                 05:10
View Encapsulation                                     09:11
ngContent                                              04:56
ngContainer                                            02:34


Directives                                             49:02 ....................................................................................................

Introduction                                           00:31
ngIf                                                   06:11
Hidden Property                                        03:25
ngSwitchCase                                           06:36
ngFor                                                  04:18
ngFor and Change Detection                             03:28
ngFor and Trackby                                      05:47
The Leading Asterisk                                   01:47
ngClass                                                01:51
ngStyle                                                02:31
Safe Traversal Operator                                02:45
Creating Custom Directives                             09:52


Template-driven Forms                                  46:10 ....................................................................................................

Introduction                                           00:26
Building a Bootstrap Form                              04:05
Types of Forms                                         03:21
ngModel                                                05:30
Adding Validation                                      03:17
Specific Validation Errors                             04:20
Styling Invalid Input Fields                           01:26
Cleaner Templates                                      01:52
ngForm                                                 05:05
ngModelGroup                                           02:38
Control Classes and Directives                         01:47
Disabling the Submit Button                            01:08
Working with Check Boxes                               02:18
Working with Drop-down Lists                           06:02
Working with Radio Buttons                             02:55


Reactive Forms                                      01:01:30 ....................................................................................................

Introduction                                           01:15
Building a Bootstrap Form                              00:50
Creating Controls Programmatically                     06:14
Adding Validation                                      07:07
Specific Validation Errors                             02:33
Implementing Custom Validation                         07:01
Asynchronous Operations                                05:13
Asynchronous Validators                                08:04
Showing a Loader Image                                 01:37
Validating the Form Input Upon Submit                  04:58
Nested FormGroups                                      02:40
FormArray                                              08:43
FormBuilder                                            03:59
Quick Recap                                            01:16


Consuming HTTP Services                             01:41:47 ....................................................................................................

Introduction                                           01:03
JSONPlaceHolder                                        01:52
Getting Data                                           08:17
Creating Data                                          07:59
Updating Data                                          05:05
Deleting Data                                          01:59
OnInit Interface                                       03:54
Separation of Concerns                                 03:41
Extracting a Service                                   07:09
Handling Errors                                        03:21
Handling Unexpected Errors                             02:27
Handling Expected Errors                               04:28
Throwing Application-specific Errors                   08:32
Handling Bad Request Errors                            02:59
Importing Observable Operators and Factory Methods     03:08
Global Error Handling                                  07:03
Extracting a Reusable Error Handling Method            03:35
Extracting a Reusable Data Service                     07:39
The Map Operator                                       04:27
Optimistic vs Pessimistic Updates                      06:25
Observables vs Promises                                06:44


Routing and Navigation                                 53:59 ....................................................................................................

Introduction                                           00:30
Routing in a Nutshell                                  01:04
Configuring Routes                                     06:47
RouterOutlet                                           02:29
RouterLink                                             05:41
RouterLinkActive                                       01:52
Getting the Route Parameters                           05:23
Why Route Parameters Are Observables                   08:57
Routes with Multiple Parameters                        01:48
Query Parameters                                       04:28
Subscribing to Multiple Observables                    04:45
The SwitchMap Operator                                 07:59
Programmatic Navigation                                02:16


Authentication and Authorization                    01:05:00 ....................................................................................................

Introduction                                           00:46
Application Overview                                   02:29
Architecture                                           03:02
JSON Web Tokens                                        05:47
Starter Code                                           08:02
Implementing Login                                     06:08
Implementing Logout                                    01:47
Showing or Hiding Elements                             06:40
Showing or Hiding Elements based on the User's Role    04:15
Getting the Current User                               00:49
CanActivate Interface                                  05:35
Redirecting Users After Logging In                     04:34
Protecting Routes Based on the User's Role             05:45
Accessing Protected API Resources                      07:27
Quick Recap                                            01:54


Deployment                                          01:06:23 ....................................................................................................

Introduction                                           00:36
Preparing for Deployment                               05:36
JIT vs AOT Compilation                                 05:29
Angular Compiler in Action                             03:34
Building Applications with Angular CLI                 06:40
Environments                                           04:27
Adding Custom Environments                             03:10
Linting with Angular CLI                               04:45
Linting in VSCode                                      01:59
Other Deployment Options                               03:59
Deploying to GitHub Pages                              07:29
Deploying to Firebase                                  07:03
Heroku                                                 01:44
Deploying to Heroku                                    08:04
Engines                                                01:28
Exercise                                               00:20


Building Real-time Server-less Apps with Firebase      56:47 ....................................................................................................

Introduction                                           01:16
What is Firebase?                                      02:20
Your First Firebase Project                            00:41
Working with Firebase Databases                        04:58
Installing Firebase                                    05:08
Reading Lists                                          07:17
A Real-time Database                                   01:32
Observables and Memory Leaks                           02:53
Unsubscribing from Subscriptions                       04:08
Async Pipe                                             02:40
Reading an Object                                      03:26
As Keyword                                             02:21
Adding an Object                                       08:00
Updating an Object                                     05:06
Removing an Object                                     02:12
Additional Resources                                   02:49


Animations                                          01:35:58 ....................................................................................................

Introduction                                           00:44
Examples of Animations                                 02:23
Different Ways to Create Animations                    04:32
Angular Animations                                     04:08
Importing the Animations Module and Polyfills          02:44
Implementing a Fade-in Animation                       07:11
Implementing a Fade-out Animation                      01:58
States                                                 03:12
Transitions                                            02:10
Animatable Properties                                  00:06
Creating Reusable Triggers                             02:12
Easings                                                05:34
Keyframes                                              05:27
Creating Reusable Animations with animation()          07:53
Parameterizing Reusable Animations                     08:12
Animation Callbacks                                    02:45
Querying Child Elements with query()                   05:32
Animating Child Elements with animateChild()           03:02
Running Parallel Animations with group()               03:01
Staggering Animations with stagger()                   07:24
Working with Custom States                             10:01
Multi-step Animations                                  02:16
Separation of Concerns                                 03:31


Angular Material 2                                  02:11:36 ....................................................................................................

Introduction                                           00:42
What is Angular Material                               04:31
Installing Angular Material                            07:30
Check Boxes                                            04:28
Radio Buttons                                          05:43
Selects                                                05:07
Inputs                                                 07:31
Text Areas                                             01:49
Date Pickers                                           09:37
Icons                                                  03:40
Buttons                                                04:50
Chips                                                  05:45
Progress Spinners                                      07:31
Tooltips                                               02:18
Tabs                                                   02:24
Dialogs                                                08:39
Passing Data to Dialogs                                10:47
Other Components                                       00:28
Creating a Reusable Module                             05:51
Themes                                                 04:20
SASS                                                   08:46
Creating a Custom Theme                                09:10
Using Angular Material's Typography                    03:01
Customizing Typography                                 06:31
An Important Note                                      00:37


Redux                                               01:17:37 ....................................................................................................

Introduction                                           00:34
What is Redux                                          06:33
Building Blocks of Redux                               03:29
Pure Functions                                         04:13
Installing Redux                                       06:26
Working with Actions                                   07:56
The Select Decorator                                   06:25
Avoiding State Mutation                                05:03
Using Immutable.js                                     05:41
Exercise                                               01:53
Redux DevTools                                         08:45
Calling Backend APIs                                   09:06
Refactoring Fat Case Statements                        02:33
Dealing with Complex Domains                           09:00


Unit Testing                                        01:00:11 ....................................................................................................

Introduction                                           01:12
What is Automated Testing?                             07:27
Types of Tests                                         06:04
Unit Testing Fundamentals                              07:44
Working with Strings and Arrays                        03:14
Set Up and Tear Down                                   06:05
Working with Forms                                     03:30
Working with Event Emitters                            02:51
Working with Spies                                     06:56
Interaction Testing                                    06:26
Working with Confirmation Boxes                        03:09
Limitations of Unit Tests                              01:31
Code Coverage                                          03:30
Exercises                                              00:32


Integration Testing                                 01:11:33 ....................................................................................................

Introduction                                           00:44
The Setup                                              04:41
Generating the Setup Code                              04:53
Testing Property Bindings                              07:55
Testing Event Bindings                                 04:59
Providing Dependencies                                 02:37
Getting the Dependencies                               05:48
Providing Stubs                                        07:11
Testing the Navigation                                 04:02
Dealing with Route Params                              06:33
Testing RouterOutlet Components                        07:05
Shallow Component Tests                                04:54
Testing Attribute Directives                           04:30
Dealing with Asynchronous Operations                   05:41


Project - Getting Started                              43:19 ....................................................................................................

Introduction                                           04:57
Challenge                                              02:41
Accessing the Source Code                              00:38
Creating a New Project                                 05:16
Installing Bootstrap 4                                 04:54
Extracting NavBar Component                            01:59
Defining the Routes                                    07:51
Adding a Drop-down Menu                                06:44
Cleaning Up the NavBar                                 02:26
Fixing a Few Minor Issues                              03:02
Deployment                                             02:51


Project - Authentication and Authorization          01:16:04 ....................................................................................................

Introduction                                           02:06
Implementing Google Login                              08:27
Implementing the Logout                                03:12
Displaying the Current User                            02:20
Using the Async Pipe                                   04:42
Extracting a Service                                   07:57
Protecting the Routes                                  06:25
Redirecting after Logging In                           08:27
Storing Users in Firebase                              05:51
Defining Admins                                        05:47
Protecting the Admin Routes                            11:13
Showing or Hiding the Admin Links                      08:05
Fixing a Bug                                           01:32


Project - Product Management Module                 01:42:18 ....................................................................................................

Introduction                                           02:00
Building a Bootstrap Form                              07:35
Populating the Categories Drop-down List               08:57
Saving the Product in Firebase                         07:24
Implementing Validation                                05:32
Adding Custom Validation                               04:42
Adding a Bootstrap Card                                07:10
Displaying the List of Products                        04:05
Editing a Product                                      10:30
Updating a Product                                     04:09
Deleting a Product                                     03:59
Searching for Products                                 09:26
Extracting an Interface                                01:20
Adding a Data Table Component                          05:07
Configuring the Data Table                             04:32
Feeding the Data Table                                 08:04
Filtering with the Data Table                          03:18
Fixing a Bug with Redirecting Users                    02:52
Cleaning Up the Product Form                           01:36


Project - Product Catalog Module                       47:51 ....................................................................................................

Introduction                                           01:20
Displaying All the Products                            07:54
Displaying the Categories                              03:37
Filtering Products by Category                         08:09
Dealing with Multiple Asynchronous Operations          04:54
Refactoring - Extracting ProductFilterComponent        07:54
Refactoring - Extracting ProductCardComponent          08:32
Improving the Product Card                             02:31
Making Categories Sticky                               02:24
Wrap Up                                                00:36


Project - Shopping Cart Module                      02:17:01 ....................................................................................................

Introduction                                           02:59
Creating a Shopping Cart                               08:59
Refactoring - Moving the Responsibility to the Service 07:38
Adding a Product to the Shopping Cart                  07:28
Refactoring the addToCart Method                       06:10
Displaying the Quantity                                09:41
Improving the Card Footer                              04:36
Implementing the Change Quantity Buttons               06:59
Displaying the Number of Shopping Cart Items in NavBar 09:10
Refactoring - Creating a Rich Model                    09:03
Building the Shopping Cart Page                        06:11
Fixing a Design Issue                                  04:56
Displaying the Total Price                             05:43
Refactoring - Extracting ProductQuantityComponents     08:33
Discovering a Design Issue                             06:18
Flattening Shopping Cart Item Objects                  08:40
Better Object Initialization                           04:47
Clearing the Shopping Cart                             03:21
Fixing a Bug with Updating the Quantity                01:36
Improving the Layout                                   02:41
Adding a Thumbnail                                     03:20
More Refactoring                                       08:12


Project - Check Out Module                             51:09 ....................................................................................................

Introduction                                           02:00
Adding the Check Out Button                            02:43
Building a Shipping Form                               01:14
Saving the Order in Firebase                           08:39
Associating the Order with the Current User            02:10
Refactoring - Extract an Order Model                   04:29
Redirecting the User to the Order Success Page         02:54
Clearing the Shopping Cart                             02:52
Transactions                                           00:29
Adding an Order Summary Widget                         08:47
Refactoring - Extract ShippingFormComponent            09:15
Displaying the Orders                                  03:07
Fixing a Bug                                           01:12
What about Processing Payments?                        01:18


Project - Modularization and Final Improvements     01:00:49 ....................................................................................................

Introduction                                           01:02
Modules                                                05:54
Essential TypeScript Plugins                           04:12
Moving Files and Folders                               05:35
Creating the Shared Module                             05:55
Creating the Admin Module                              09:27
Creating the Shopping Module                           04:52
Creating the Core Module                               05:26
Importing and Exporting Modules                        06:22
Adding Icons                                           02:29
Aligning the NavBar Items                              03:34
Defining a Theme                                       05:38
Coupon to My Other Courses                             00:23