Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

angular

Learn Angular

This course is perfect for those looking for a lightweight alternative to NgRx Store that scales effortlessly.

Scalable Signals Angular Architecture with NGRX Signal Store

Using Angular's `toSignal` function with the HTTP client enables components to reactively fetch and display data from external services. 

This approach simplifies code and handles undefined initial values, but note that `toSignal` immediately subscribes and makes the HTTP request when used. So, keep in mind if you're using it in a component or some root level service.

Fetch Data via HTTP Using RxJS Observables and toSignal

The `toSignal` function in Angular enables the conversion of an RxJS observable into a signal. 

It allows you to wrap an observable and handle the initial value of the resulting signal. You can explicitly define the initial value, require a synchronous emission from the observable, and more! 

Turn an RxJS Observable Into an Angular Signal With toSignal

Angular's `toObservable` function enables converting signals to RxJS observables. This allows creating observable properties that stay synchronized with signal values. 

Whenever the signal value changes, the corresponding observable emits a notification, facilitating the interoperability between signals and observables.

Turn an Angular Signal Into an RxJS Observable

In Angular, effects are often assigned to class properties during the constructor phase. However, there may be cases where the effect needs to be parameterized with values from parent components, which are not available during construction.

When running effects outside the constructor, such as in the `ngOnInit` lifecycle hook, you need to manually provide the `injector` instance to the `effect` configuration.

Bind an Angular Signal Effect to an Injector for Automatic Cleanup

Angular provides a `manualCleanup` configuration option for effects, preventing automatic cleanup when the owner component/service is destroyed. 

With `manualCleanup: true`, you gain control but must manually call `.destroy()` on the `EffectRef` that is returned by your `effect` to release resources like intervals or subscriptions. 

Remember, with great power comes great responsibility!

Destroy an Angular Signal Effect Automatically or Manually

Sometimes you will need to properly clean up your effects to prevent memory leaks. Like if you use timeouts or intervals. 

Implement cleanup logic using the `onCleanup` callback. In your effect you can call `onCleanup`, pass it a callback, and define actions like clearing intervals or unsubscribing from observables when effects are no longer needed. 

Set up an Angular Signal Effect Cleanup Handler

You may find that you need to implement similar effects across multiple components or services. To avoid code duplication, you can create reusable effect functions.

A reusable effect function should:

1. Accept any necessary configuration parameters (e.g., a key for local storage synchronization).
2. Accept a function that retrieves the reactive value(s) to track (e.g., a signal getter).
3. Set up and return the effect, using the provided configuration and reactive value getter.

Create a Reusable Angular Effect

Angular's reactive signals provide a way to manage state, but you may also want to persist that state across page refreshes or browser sessions. 

This can be achieved by synchronizing the signal's value with the browser's local storage using an `effect`

Synchronize Angular Signal or Computed Value With LocalStorage Using Effect

Angular's reactive signals provide a way to manage state and automatically update the view when the signal value changes. However, you can customize how Angular determines if a signal's value has changed by configuring the signal's `equal` property.

For example, you can use the `lodash.isEqual` function to perform a deep equality check, ignoring changes in object or array references if the contents remain the same. 

Make an Angular Signal Compare Object Values Instead of References

The `untracked` function in Angular allows you to read a signal's value without causing the effect or computed signal to re-evaluate when that signal changes.

Effects will only re-evaluate when tracked dependencies change.

`untracked` always accepts a callback function that returns the value of the underlying signal. Outside `untracked`, reading the signal is reactive, but inside `untracked`, the same read becomes non-reactive.

Read an Angular Signal Value While Being Untracked

The `effect` function in Angular runs a callback when a signal value it depends on changes. The callback is also invoked when the component first renders.

An `effect` can depend on multiple signals or computed signals. When any of these signals change, the `effect` callback executes.

Instead of running `effect` in the constructor, it's best to assign it to a component property. This allows for manual interaction with the `EffectRef` if needed.

Create an Angular Signal Effect

Moving a signal and related methods to an Angular service allows sharing between components. 

The service we create will expose a read-only property for the signal and methods to update it.

Share Angular Signal State Using Services

Read-only signals in Angular let you share values between components safely. They update automatically when the original signal changes. 

They can't be changed directly, like computed signals. And, they are useful in services.

Make an Angular Signal Readonly

Signal values can be updated using the `set` or `update` methods. When updating signal values, it's crucial to follow immutable practices.

Key points to keep in mind:
* Use the `set` method for updating primitive values like strings or numbers
* Use the `update` method with a callback that returns a new object or array when updating complex values
* Avoid mutating signal values directly

Failure to follow immutable practices can result in stale data being displayed in the template.

Update an Angular Signal's Value and Make Computed Signal Emit Updates

Computed signals in Angular allow for the creation of derived values based on other signals, including other computed signals. This enables the composition of complex calculations and transformations by building upon existing signals.

When creating computed signals that depend on other computed signals, it's crucial to:
* Ensure that there are no cyclic dependencies, where two or more computed signals directly or indirectly depend on each other
* Consume the computed signal by a live consumer, such as a template, to trigger re-evaluation when dependencies change

Angular's reactivity system automatically detects and prevents cyclic dependencies in computed signals, throwing an error if such a scenario is encountered. 


Create an Angular Computed Signal on Top of Another Computed

Computed signals in Angular allow for the creation of derived values based on existing signals. By defining a new property and assigning it a computed signal, you can perform calculations or transformations on top of an existing signal's value.

To create a computed signal that remains responsive to changes in its dependencies, it's essential to:
* Define the computed signal's callback function, which calculates the derived value based on other signals
* Ensure that the computed signal is consumed by a live consumer, such as a template, to trigger re-evaluation when dependencies change

The reactivity flow in Angular ensures that whenever a dependency of a computed signal changes, the computed value is automatically re-evaluated. This re-evaluation only occurs if there is a live consumer, such as a template, that depends on the computed signal.



Create an Angular Computed Signal Which Depends on Another Signal

Event handlers can be created in Angular components to interact with signals. By defining a method in the component class and binding it to an event in the template, the current value of a signal can be accessed and logged when the event occurs.

It's important to note the difference between:
- Reactive signal calls in the template, which automatically update the view when the signal value changes
- Imperative signal calls in the TypeScript class code, which retrieve the current value only when the event is triggered


Access an Angular Signal's Value Inside Event Handler Methods

In some cases, using the optional chaining operator may not be sufficient to narrow down a signal's value type, such as from `string | undefined` to `string`. To achieve type narrowing, you can use Angular's `@if` directive in combination with a getter expression.

By moving the signal to a private property and exposing its value through a public getter property, you can ensure that TypeScript correctly narrows down the type within the `@if` block. 

This approach guarantees that the same value is used throughout the template, allowing TypeScript to compile the code without errors.

Narrow Down Angular's Signal Value Type Within an If Statement

Signals are functions that return their current value. The component template is guaranteed to be updated when the signal value changes. 

TypeScript helps catch errors when using signals of different types. Signals can also be used with Angular's `ngFor` directive to loop over arrays.

Access an Angular Signal's Value and Display It Within the Component Template

This lesson teaches how to create a signal in Angular with the signal function from @angular/core. Signals need an initial value, which can be a primitive, object, or any other valid expression in JavaScript. 

TypeScript infers the signal's type and catches errors during compilation.

Create an Angular Signal Which Stores a Value

While running `zod` schema validation agains domain-rich objects, the error message saying that _a string is not a number_ might not be really useful.

Especially, when you need to provide a meaningful feeback to the user, e.g. after they have submitted a form with lots of data.

`zod` allows to customize messages on a very granular level. We can also extract repeatable customization to `zod` error maps.

Finally, in order to process an error message further (e.g. display it to the user), we need to handle the `zod` validation errors effectively. Especially, when a big object validation has failed and we could receive a handful of errors.

That's what we learn in this lesson. 🔥

Customize zod Error Messages and Handle zod Errors Effectively

customize zod validation messages, customize zod schema property messages, reuse error maps across different schemas, navigate through zod error objects

You might want to run `zod` schema checks in different styles.

Sometimes you prefer to conditionally throw the error - that's what `parse` does. But another time you'd prefer to receive a `boolean` property that determines whether the validation was successful or not - and perform further actions accordingly.

Additionally, the error-throwing API of `parse` works extremely well with [TypeScript assertion functions](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions). Their combination is just... perfect! 👌

That's what we learn in this lesson.

Use parse and safeParse Runtime Type-checks with zod

use zod parse function to conditionally throw ZodError, use zod safeParse to get a boolean value and run typescript type guard over success property

In this lesson we learn that TypeScript cannot guarantee correct shapes of responses. That's due to TS performing checks in compile-time, while the response will be availbale in runtime - when TS doesn't exist anymore.

In some situations, such as HTTP requests, runtime type checks such as `zod` are essential for providing quick feedback around data-related errors.

Understand where are the possible mistakes to make while using TypeScript with HTTP calls. Use `fetch` and `axios` along with `zod` schema checks.

Also, note that similar mistakes or mistakes could happen while using web storage (e.g. `localStorage`)

Validate HTTP API Response with zod, fetch and axios

use zod as an HTTP response validation tool along with fetch and axios in order to make sure that the response has expected data structure

In this lesson we learn that the `zod` schemas become the single source of truth.

We shall not update TypeScript types manually, since they are generated automatically from the schema.

Same with validation functions.

Whenever the schema changes, all the rest will update accordingly. It's an important mind shift.

Treat zod Schemas as Single Source of Truth

Zod Schemas are the single source of truth for both typescript types, and interfaces - and runtime validation functions. Schemas should be updated first.

`zod` is powerful, but writing the schemas manually for existing JSON objects, especially big ones, can be time-consuming.

But that's what `quicktype` is for! You can get 80% work done instantly! 🥳

Depending on your need - whether you want to automate the process, or do it just one time, you can:
- use an online app
- use an IDE extension
- run a CLI script
- generate a script to be executed within CI/CD environment/tooling

And this is what we learn in this lesson! 🔥🔥🔥

Get started with zod quickly!

Generate zod Schemas Automatically using Quicktype App, Extensions and Scripts

Use quicktype app, extension or scripts to automatically generate zod schemas from existing json files. Save time and get started with zod quickly!

`zod` is a powerful library allowing to run runtime type-checks.

It's complementary to TypeScript, which does type checks in compile time.

In this lesson we create few schemas that represent primitive type values, along with `zod` utilities which make these more precise. We also create object schemas and nest one inside another.

All schemas are being validated against example values. We analyze how to interpret error messages in case of failures.

Perform Runtime Type-checks on Primitives and Objects with zod

Create zod schemas to validate primitive type and object type values in runtime. Analyze the errors to see how a value doesn't correspond to schema expectations


Using Cursor Chat, you can easily reference an entire directory of files and ask it to generate anything based on those files. This opens up the possibility of using your current code as a reference guide to create new code that follows existing patterns. With this approach, the result can be a polished prompt you can use with any AI to generate consistent and reliable output.

Focus less on crafting the perfect prompt upfront - what matters most is testing and iterating based on the AI's responses. The more results you see from the prompt, the more you can reinforce the good results and prune out the bad results until your prompt is polished enough that you can rely on the prompt to give you consistent quality results.


Create AI Prompts Based on a Directory of Files


With Cursor's "Composer" feature, you can select and entire directory and make changes to every file. This video walks through the process of selecting a folder and refactoring all the files from JavaScript to TypeScript. It also demonstrates other tips around generating terminal commands and customizing your main Cursor "Rules for AI".


Run an AI Refactor on Every File in a Directory with Cursor


This lesson breaks down the concept of asynchronous iterators and generators in JavaScript. Using the Node.js glob function as a practical example, you'll learn how Array.fromAsync facilitates the creation of arrays from asynchronous iterables and how generators can improve performance in file processing tasks.

Efficient File Processing in Node.js with Async Generators and Array.fromAsync

Learn the concept of asynchronous iterators and generators in JavaScript and Node.js Array.fromAsync


With the introduction of Svelte 5, the Svelte team has created a CLI, `sv`, that unifies all the tasks that previously spread across a handful of CLIS (create, add plugins, and migrate).

This lesson will create a Svelte project using the new `sv` CLI and build a counter component to showcase the new `$state`, `$derived`, and `$effect` runes that ship with the new version.



Get Started with Svelte 5 using the sv CLI

You'll create a SvelteKit project using the sv CLI and build a counter component showcasing Svelte $state, $derived, and $effect runes.

Angular

Search Results