Complete Angular Developer in 2025: Zero to Mastery

1 Complete Angular Developer: Zero to Mastery
2 What Are We Building?
3 Understanding Frameworks
4 The Angular CLI
5 Upgrading Angular
6 Creating a New Application
7 Starting the Server
8 Reviewing the Configuration Files
9 Main Entry File
10 AOT Compilation
11 Bootstrapping Angular
12 Understanding Components
13 Creating Components
14 External Templates and Styles
15 Everything Else
16 Introduction to TypeScript
17 Installing TypeScript
18 Type Annotations
19 Variables
20 Union Types
21 Arrays
22 Objects
23 Interfaces
24 Classes
25 Generics
26 Why Decorators
27 TypeScript Configuration
28 Writing Decorators
29 Signals
30 Property Binding
31 Event Binding
32 Type Assertions
33 Creating a Component
34 Custom Properties
35 Required Inputs
36 Emitting Events
37 Content Projection
38 Discovering Lifecycle Hooks
39 Exploring More Lifecycle Hooks
40 Scoped CSS
41 Understanding Pipes
42 Pipe Basics
43 Angular Dev Tools
44 Pipe Parameters
45 Dealing with Numbers
46 Debugging with Pipes
47 Understanding Directives
48 The ngClass Directive
49 The ngStyle Directive
50 If Block
51 For Block
52 Introduction to the Master Project!
53 What is Tailwind?
54 Installing Tailwind
55 Configuring Tailwind
56 Practicing with Tailwind
57 Loading Static Assets
58 What’s Next?
59 Navigation and Modal Components
60 Designing a Modal
61 Creating a Shared Component
62 Creating a Reusable Modal
63 Multi-slot Content Projection
64 Understanding Services
65 Creating a Service
66 Understanding Dependency Injection
67 Injecting Services
68 Signal Queries
69 Opening the Modal
70 Closing the Modal
71 Memory Leaks
72 Fixing the memory leak
73 Creating a Tabs Component
74 The contentChildren Query Signal
75 Looping through the Tabs
76 Setting an Active Tab
77 Toggling Tabs
78 Preventing the Default Behavior
79 Preparing the Forms
80 Registering a New Form
81 Adding Form Controls
82 Binding a Form
83 Form Validation
84 Understanding Errors
85 Handling Errors
86 Form Controller Status
87 Designing an Input Component
88 Binding Form Controls
89 Updating the Template
90 Validating Emails
91 Validating Numbers
92 Validating Passwords with Patterns
93 Input Masking
94 Applying Input Masking
95 Disabling Buttons
96 Handling Form Submission
97 Designing an Alert Component
98 Importing the FormsModule
99 Registering a new Form
100 Two-way Binding
101 Template Variables
102 Attribute Validation
103 Handling Error Messages
104 Preparing the Password Field
105 Handling Form Submission
106 Introduction to RxJS
107 Observables
108 Observers
109 Pushing Asynchronous Values
110 Unsubscribing from Observables
111 Declarative Programming with Operators
112 Timing Operators
113 DOM Event Operators
114 The of and from Operators
115 Understanding Pipeable Operators
116 The Map Operator
117 Marble Diagram
118 Filter Operator
119 Reduce Operator
120 Take Operator
121 Tap Operator
122 Understanding Flattening Operators
123 mergeMap Operator
124 switchMap Operator
125 concatMap Operator
126 exhaustMap Operator
127 Flattening Operators Recap
128 Setting Up Firebase
129 Reviewing the Rules
130 Installing AngularFire
131 Importing AngularFire
132 User Registration
133 Handling the Response
134 Buckets, Collections and Documents
135 Firestore Provider
136 Storing User Data
137 Refactoring to a Service
138 Interfaces vs. Classes
139 Connecting the User with their Data
140 Database Rules
141 Understanding Authentication
142 Authentication after Registration
143 The User Observable
144 The Async Pipe
145 Setting Up the Login
146 Destroying the Modal
147 The Delay Operator
148 Signing Out
149 Sidebar JSON Web Tokens
150 Validating Passwords
151 Creating a Validator Class
152 Factory Functions
153 Handling Errors
154 Creating an Asynchronous Validator
155 Validating Unique Emails
156 Finalizing the Validator
157 Understanding Routing
158 Configuring the Router
159 Registering Routes
160 Exercise Registering a Route
161 Adding Navigation Links
162 Active Links
163 Creating the Manage Route
164 Forcing Redirection
165 A Quick Refactor
166 Adding Route Data
167 Filtering Router Events
168 Retrieving Data Outside of the Outlet
169 Exercise Registering a Route with Data
170 Route Parameters
171 Subscribing to Route Parameters
172 Query Parameters
173 Learning More About Query Parameters
174 Selecting an Option
175 Wildcard Routes
176 Updating Routes
177 Route Guards
178 Understanding File Uploads
179 Blocking Events with Directives
180 Handling Drag and Drop Events
181 Handling Files
182 Multi-Step Form
183 The Upload Form
184 Uploading Files with Firebase
185 Firebase Rules and Validation
186 Adding an Alert Component
187 Upload Progress Observable
188 Handling Errors and Successful Uploads
189 Storing the File Data
190 Adding the File Data to the Database
191 Firebase References and Snapshots
192 Disabling Forms
193 Canceling Uploads
194 Redirection after Upload
195 Storing a Timestamp
196 Querying the Database
197 Storing the List of Clips
198 Displaying the List of Clips
199 Preparing the Form
200 Passing on the Clip Data
201 Binding the Edit Form
202 Updating Clips
203 Updating the List of Clips
204 Deleting a Clip from the Storage and Database
205 Sorting Clips with Computed Signals
206 What is WebAssembly?
207 Getting Started with Rust
208 Exploring the Starter Project
209 Variables
210 Data Types
211 Debugging with Macros
212 Control Flow
213 Match Expressions
214 Arrays
215 Vectors
216 Structures
217 Ownership
218 Results
219 Preparing the Project
220 Installing Webpack
221 Configuring Webpack
222 Reading Files
223 Compiling Rust with Webpack
224 Importing Web Assembly
225 Logging Files
226 Base64 Decoding
227 Loading an Image from Memory
228 Grayscaling an Image
229 Buffering an Image
230 Encoding an Image
231 App Deployment
232 Understanding FFmpeg
233 Installing FFmpeg
234 Custom Asset Paths
235 Adding support for SharedArrayBuffer
236 Loading FFmpeg with a Service
237 Initializing FFMPeg
238 Saving Files in Memory
239 Generating a Screenshot
240 Generating Multiple Screenshots
241 Creating Screenshot URLs
242 Rendering Screenshots
243 Adding Feedback
244 Selecting a Screenshot
245 Updating the Firebase Storage Rules
246 Uploading a Blob
247 Recalculating the Upload Progress
248 The forkJoin Operator
249 Deleting Screenshots
250 Introduction
251 Creating a List Component
252 Handling Scroll Events
253 Querying for Clips
254 Rendering Clips on the Home page
255 Understanding Cross Origin Issues
256 Fixing Cross Origin Issues
257 Fixing the Timestamp
258 Rendering Clips on the Clip Page
259 Installing Videojs
260 Selecting the Video Player
261 Initializing the Video Player
262 Clip Styles
263 Resolving Data with a Guard
264 Dynamically Rendering the Video
265 Fixing the Manage Page
266 Copying Links to the Clipboard
267 Production Budgets
268 Modifying Firebase Rules
269 Deploying an App with Vercel
270 Introduction to Testing
271 Understanding Karma and Jasmine
272 Preparing Our App for Testing
273 Writing a Sanity Test
274 Angular’s Test Bed Utility
275 Testing a Component’s Instance
276 Querying the Component’s Template
277 Inverting Matchers
278 Testing Nested Components
279 Testing Content Projection
280 Custom Matcher Error Messages
281 Mocking Services
282 Overriding a Dependency
283 Providing the Router in Tests
284 Exercise Testing the Logout Link
285 Simulating DOM Events
286 Installing Cypress
287 Exploring Cypress
288 Writing an E2E Sanity Test
289 Testing the Video Player
290 Thank You!
291 Understanding Frameworks
292 The Angular CLI
293 Latest Version Of Angular
294 Creating a New Application
295 Starting the Server
296 Reviewing the Configuration Files
297 Main Entry File
298 AOT Compilation
299 Loading a Platform
300 Bootstrapping Angular
301 Enabling Production Mode
302 Understanding Modules
303 Creating Modules
304 Understanding Components
305 Creating Components
306 External Templates and Styles
307 Everything Else
308 Introduction to TypeScript
309 Installing TypeScript
310 Type Annotations
311 Variables
312 Union Types
313 Arrays
314 Objects
315 Interfaces
316 Classes
317 Generics
318 Why Decorators?
319 TypeScript Configuration
320 Writing Decorators
321 Interpolation
322 Property Binding
323 Event Binding
324 Type Assertions
325 Creating a Component
326 Custom Properties
327 Input Aliases
328 Emitting Events
329 Content Projection
330 Discovering Lifecycle Hooks
331 Exploring More Lifecycle Hooks
332 Scoped CSS
333 Understanding Pipes
334 Pipe Basics
335 Angular Dev Tools
336 Pipe Parameters
337 Dealing with Numbers
338 Debugging with Pipes
339 Understanding Directives
340 The ngClass Directive
341 The ngStyle Directive
342 Understanding ng-template
343 The ngIf Directive
344 The ngFor directive
345 Introduction to Master Project
346 What is Tailwind?
347 Installing Tailwind
348 Configuring Tailwind
349 Practicing with Tailwind
350 Loading Static Assets
351 What’s Next?
352 Creating a User Module
353 Navigation and Modal Components
354 Exporting Components
355 Designing a Modal
356 Creating a Shared Module
357 Creating a Reusable Modal
358 Multi-slot Content Projection
359 Understanding Services
360 Creating a Service
361 Understanding Dependency Injection
362 Injecting Services
363 Opening the Modal
364 Closing the Modal
365 Understanding Singletons
366 Creating an ID System
367 Refactoring the Service
368 Updating the Components
369 Memory Leaks
370 Fixing the Memory Leak
371 CSS Issues
372 Creating a Tabs Component
373 The ContentChildren Decorator
374 The QueryList Object
375 Looping through the Tabs
376 Setting an Active Tab
377 Toggling Tabs
378 Preventing the Default Behavior
379 Preparing the Forms
380 Registering a new Form
381 Adding Form Controls
382 Binding a Form
383 Form Validation
384 Understanding Errors
385 Handling Errors
386 Form Controller Status
387 Designing an Input Component
388 Binding Form Controls
389 Updating the Template
390 Validating Emails
391 Validating Numbers
392 Validating Passwords with Patterns
393 Input Masking
394 Applying Input Masking
395 Disabling Buttons
396 Handling Form Submission
397 Designing an Alert Component
398 Importing the FormsModule
399 Registering a new Form
400 Two-way Binding
401 Template Variables
402 Attribute Validation
403 Handling Error Messages
404 Preparing the Password Field
405 Handling Form Submission
406 Exercise: Imposter Syndrome
407 Introduction to RxJS
408 Observables
409 Observers
410 Pushing Asynchronous Values
411 Unsubscribing from Observables
412 Declarative Programming with Operators
413 Timing Operators
414 DOM Event Operators
415 The of and from operators
416 Understanding Pipeable Operators
417 The Map Operator
418 Marble Diagram
419 Filter Operator
420 Reduce Operator
421 Take Operator
422 Tap Operator
423 Understanding Flattening Operators
424 mergeMap Operator
425 switchMap Operator
426 concatMap Operator
427 exhaustMap Operator
428 Flattening Operators Recap
429 Setting up Firebase
430 Reviewing the Rules
431 Installing AngularFire
432 Importing AngularFire
433 User Registration
434 Handling the Response
435 Buckets, Collections, and Documents
436 Storing User Data
437 Refactoring to a Service
438 Interfaces vs. Classes
439 Collection Types
440 Connecting the User with their Data
441 Database Rules
442 Understanding Authentication
443 Authentication after Registration
444 The User Observable
445 The Async Pipe
446 Initializing Firebase First
447 Setting up the Login
448 Destroying the Modal
449 The Delay Operator
450 Signing Out
451 Sidebar: JSON Web Tokens
452 Creating a Validator Class
453 Static Methods
454 Validating Passwords
455 Factory Functions
456 Handling Errors
457 Creating an Asynchronous Validator
458 Validating Unique Emails
459 Finalizing the Validator
460 Understanding Routing
461 Configuring the Router
462 Registering Routes
463 Exercise: Registering a Route
464 Adding Navigation Links
465 Active Links
466 Generating a Routing Module
467 Forcing Redirection
468 A Quick Refactor
469 Adding Route Data
470 Filtering Router Events
471 Retrieving Data Outside of the Outlet
472 Exercise: Registering a Route with Data
473 Route Parameters
474 Subscribing to Route Parameters
475 Query Parameters
476 Learning More About Query Parameters
477 Selecting an Option
478 Wildcard Routes
479 Updating Routes
480 Route Guards
481 Understanding File Uploads
482 Blocking Events with Directives
483 Handling Drag and Drop Events
484 Handling Files
485 Multi Step Form
486 The Upload Form
487 Uploading Files with Firebase
488 Firebase Rules and Validation
489 Adding an Alert Component
490 Upload Progress Observable
491 Handling Errors and Successful Uploads
492 Storing the File Data
493 Adding the File Data to the Database
494 Firebase References and Snapshots
495 Disabling Forms
496 Fallback Upload
497 Canceling Uploads
498 Redirection after Upload
499 Storing a Timestamp
500 Querying the Database
501 Storing the List of Clips
502 Displaying the List of Clips
503 Preparing the Form
504 Passing on the Clip Data
505 Binding the Edit Form
506 Updating Clips
507 Updating the List of Clips
508 Deleting a Clip from the Storage/Database
509 Sorting Clips with Behavior Subjects
510 Composite Indexes
511 What is WebAssembly?
512 Getting Started with Rust
513 Exploring the Starter Project
514 Variables
515 Data Types
516 Debugging with Macros
517 Control Flow
518 Match Expressions
519 Arrays
520 Vectors
521 Structures
522 Ownership
523 Results
524 Preparing the Project
525 Installing Webpack
526 Configuring Webpack
527 Reading Files
528 Compiling Rust with Webpack
529 Importing Web Assembly
530 Logging Files
531 Base64 Decoding
532 Loading an Image from Memory
533 Grayscaling an Image
534 Buffering an Image
535 Encoding an Image
536 App Deployment
537 Understanding FFmpeg
538 Installing FFmpeg
539 Custom Asset Paths
540 Adding support for SharedArrayBuffer
541 Loading FFmpeg with a Service
542 Initializing FFMPeg
543 Saving Files in Memory
544 Generating a Screenshot
545 Generating Multiple Screenshots
546 Creating Screenshot URLs
547 Bypassing Sanitization with Pipes
548 Adding Feedback
549 Selecting a Screenshot
550 Updating the Firebase Storage Rules
551 Uploading a Blob
552 Recalculating the Upload Progress
553 The forkJoin Operator
554 Deleting Screenshots
555 Section Overview
556 Creating a List Component
557 Handling Scroll Events
558 Querying for Clips
559 Rendering Clips on the Home page
560 Understanding Cross Origin Issues
561 Fixing Cross Origin Issues
562 Fixing the Timestamp
563 Rendering Clips on the Clip Page
564 Installing Videojs
565 Selecting elements with the ViewChild Decorator
566 Initializing the Video Player
567 Styles without View Encapsulation
568 Tailwind’s Aspect Ratio Classes
569 Resolving Data with a Guard
570 Dynamically Rendering the Video
571 Fixing the Manage Page
572 Copying Links to the Clipboard
573 Lazy Loading Modules
574 Production Budgets
575 Modifying Firebase Rules
576 Deploying an App with Vercel
577 Introduction to Testing
578 Understanding Karma and Jasmine
579 Preparing our App for Testing
580 Writing a Sanity Test
581 Angular’s Test Bed Utility
582 Testing a Component’s Instance
583 Querying the Component’s Template
584 Inverting Matchers
585 Testing Nested Components
586 Testing Content Projection
587 Custom Matcher Error Messages
588 Mocking Services
589 Overriding a Dependency
590 Importing the Router Testing Module
591 Exercise: Testing the Logout Link
592 Simulating DOM Events
593 Installing Cypress
594 Exploring Cypress
595 Writing an E2E Sanity Test
596 Testing the Video Player