When using Angular CLI in a PowerShell environment, you may encounter script execution policy problems that block script execution. For security considerations, PowerShell's default execution policy is frequently configured to a level that restricts script execution. This article will walk you through the process of fixing PowerShell script execution policy problems that are particular to the Angular CLI. Resolving the PowerShell Script Execution Policy Error for Angular CLI Step by Step.

1. Launch PowerShell as an administrator.
Start PowerShell with administrative privileges to resolve the script execution policy problem. Click the PowerShell icon and choose "Run as Administrator."

2. Investigate the Current Execution Policy
To investigate the current execution policy, use the following command.

PowerShell function
Get-ExecutionPolicy $executionPolicy
"Current Execution Policy: $executionPolicy" writes out.

1. Launch PowerShell as an administrator.
Start PowerShell with administrative privileges to resolve the script execution policy problem. Click the PowerShell icon and choose "Run as Administrator."

2. Investigate the Current Execution Policy
To investigate the current execution policy, use the following command.

Get-ExecutionPolicy $executionPolicy
"Current Execution Policy: $executionPolicy" writes out.

3. Change the Execution Policy
If the current execution policy is too restrictive (e.g., "Restricted"), consider changing it to a more permissive setting like `RemoteSigned.`
Set-ExecutionPolicy RemoteSigned

Confirm the change by selecting 'Y' (Yes) when prompted.

4. Run Your Angular CLI Command Again
Retry your Angular CLI command after modifying the execution policy.

Angular Terminal
ng generate component test

5. Restore the Original Execution Policy (Optional)
For security reasons, you can revert to the original execution policy after completing Angular CLI tasks.

Powershell
Set-ExecutionPolicy Restricted

Confirm the change by selecting 'Y' (Yes) when prompted.
By adopting the `RemoteSigned` execution policy, you allow the execution of locally created scripts while mandating that downloaded scripts be signed by a trusted publisher.
This approach balances security and convenience, making it suitable for development purposes.
If you encounter any issues or have further questions, feel free to let me know, and I'll be glad to assist.

Thank you for reading, and I hope this post has helped provide you with a better understanding of How to Resolve PowerShell Script Execution Policy Error for Angular CLI.
"Keep coding, keep innovating, and keep pushing the boundaries of what's possible. Happy Coding.

What are Angular Signals?
Angular Signals is a new feature in Angular 16 that allows you to develop reactive code in a new way. Signals are a reactive primitive, which implies they can alert their dependents when their value changes. This makes them suitable for use in reactive applications, where it is critical to be able to automatically adjust the UI in reaction to data changes.

To begin with Angular Signals, import the Signals module from the @angular/core package. The signal() method is then used to create a signal. This function takes two arguments: the signal's initial value and an options object. The options object is used to determine whether the signal is written or read-only, as well as other parameters.

The subscribe() function
You can subscribe to a signal after you've produced it with the subscribe() method. As an argument, this method accepts a function that will be called whenever the signal changes. You can also use the unsubscribe() method to unsubscribe from a signal.

Signals can be utilized to construct a wide range of reactive patterns. You can, for example, use a signal to represent a component's state and then subscribe to the signal to update the UI whenever the state changes. Signals can also be used to provide two-way data coupling between components.

Here's a simple demonstration of how to use Angular Signals.
import { Signals } from '@angular/core';

export class MyComponent {
  count = new Signals<number>(0);

  increment() {
    this.count.value++;
  }

  decrement() {
    this.count.value--;
  }

  constructor() {
    this.count.subscribe(value => {
      // Update the UI here
    });
  }
}

In this case, we'll build a signal to indicate the current count. Then, we subscribe to the signal so that the UI may be updated anytime the count changes. Angular Signals have several advantages over alternative methods of developing reactive Angular programs. They are more granular than observables, for example, and can be used to track changes to individual values or states. They are also more synchronous, which makes them easier to debug and comprehend.

Overall, Angular Signals is a potent new tool for writing more reactive and efficient Angular programs.

Benefits of using Angular Signals
Here are some of the benefits of using Angular Signals.

• Granular updates: Angular Signals allow you to track changes to specific values or states rather than having to track changes to entire observables. This can lead to more efficient change detection and faster updates to the UI.
• A new reactive primitive: Angular Signals are a new reactive primitive, which means that they can be used to implement a variety of different reactive patterns in a simple and straightforward way.
• Simplified framework: Angular Signals simplify the Angular framework by providing a unified way to represent and track reactive values. This makes it easier to write and maintain reactive Angular code.
• No side effects: Angular Signals are designed to be pure, which means that they do not have any side effects. This makes them easier to reason about and debug.
• Automatic dependency tracking: Angular Signals automatically track their dependencies, so you don't have to worry about manually unsubscribing from them. This can help to prevent memory leaks and improve the overall performance of your application.

If you are writing reactive Angular code, I encourage you to try using Angular Signals. They are a powerful new tool that can make your code more efficient, simpler, and more reliable.

In this article, we'll look at how to use Node.js to create a web application. Let's take it one step at a time.

Step 1: Download NodeJS from the NodeJS website.
Download the Windows Installer from the Nodejs website. Check that you have the most recent version of NodeJs. It comes with the NPM package management. Install node js already and skip the preceding step.

Step 2: Ensure that Node and NPM are installed and that their PATHs are configured.
Check If you're not sure whether you installed everything correctly, use "Command Prompt" to double-check.

To verify the installation and confirm whether the correct version was installed,

Enter the following command to Check the node version.
Node --version or Node -v

Check the npm version, and run this command:
npm --version or npm -v

Step 3. Create a new project
You can create a project folder wherever you want on your computer and name it whatever you want.

Step 4. Create a new js file
Create a .js File By using the .js file extension

I Create an app.js file in the project folder. Create a simple string variable in app.js and send the contents of the string to the console: save the file.
var message= “Hi C# Corner”;
console.log(message);

Step 5. Run the App
It's simple to run app.js with Node.js. From a terminal, just type: Node .\app.js

You can see the "Hi C# Corner" output to the terminal, and then Node.js returns

Step 6. Install NPM Packages
install npm package Go to the terminal and type npm init -y this command line, we highlight -y when we install in npm' npm init' Does that time ask a question: package name? We can give the package name as yourself. Otherwise, it takes the default name Project Folder Name. If entered, the command line npm init -y takes the saver name as the default.

I'm going to run this Project in package.js, So I have to add a line in scripts at package.js "serve": "node app.js".
"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "serve": "node app.js"
  },

I'm going to run the application with this command npm run serve.

What Is Express JS?    
Express is a node js web application framework that provides broad features for building web and mobile applications. It is used to build a single page, multipage, and hybrid web application.

Features of Express Framework
Allows to set up middlewares to respond to HTTP Requests.
Defines a routing table that is used to perform different actions based on HTTP Method and URL.
Allows to dynamically render HTML Pages based on passing arguments to templates
npm install express or npm i express

I recommend the nodemon package for Node. js-based applications by automatically restarting the node application when the file changes in the directory are detected.

nodemon will be installed globally on your system path.
npm install -g nodemon # or using yarn: yarn global add nodemon

Step 8. Write down the following code in the app.js file
const express = require("express");
const app = express();
const port = 3000;

//routes
app.get("/", (req, res) => {
  res.send("HI C# Corner!");
});


app.listen(port, () => {
  console.log(`My Sample Nodejs App Listening On Port ${port}`);
});

Following is a very basic Express app that starts a server and listens on port 3000 for the connection.
app.listen(port, () =>
{console.log(`My Sample Nodejs App Listening On Port ${port}`)
})

The app responds with "HI C# Corner!" for requests to the root URL (/) or route.
app.get('/', (req, res) => {
  res.send('HI C# Corner!')
})

`npm run serve`

This app starts a server and listens on port 3000 for connections.

Step 9. Now you can see the output on your browser
Now go to http://localhost:3000/ in the browser, and you will see the following output:

In this article, we will learn how to create a Node project and how we can develop a web application using Node.js. It is a runtime environment and library for running JavaScript code outside the browser. It must be installed on the system by downloading the software from the Node.js website and setting the path in the environment variables section.

ng-container
By enabling you to apply Angular directives without including additional items in the DOM (Document Object Model), the ng-container functions as a kind of transparent container. It is frequently employed when you wish to structure or conditionally include elements in your template.

As an illustration, consider creating a product page. If the product is in stock, you want to display the product details; otherwise, you want to display a notification stating the product is unavailable.

<ng-container *ngIf="productAvailable; else outOfStockTemplate">
  <div>Product Name: {{ productName }}</div>
  <div>Price: {{ productPrice }}</div>
</ng-container>

<ng-template #outOfStockTemplate>
  <div>This product is currently out of stock.</div>
</ng-template>

ng-template
The ng-template is like a template blueprint that doesn't get displayed immediately. It's used to define sections of your template that can be reused and conditionally rendered using structural directives.

Example: Let's say you're creating a list of blog posts. You want to show different styles for featured posts and regular posts.
<ul>
  <ng-container *ngFor="let post of posts">
    <ng-container *ngTemplateOutlet="post.featured ? featuredTemplate : regularTemplate; context: { post: post }"></ng-container>
  </ng-container>
</ul>

<ng-template #featuredTemplate let-post>
  <li class="featured">{{ post.title }}</li>
</ng-template>

<ng-template #regularTemplate let-post>
  <li>{{ post.title }}</li>
</ng-template>

ng-content
The ng-content is used to allow external content to be included within the template of your component. It's ideal for making more adaptable components that can be used in a variety of situations. Consider designing a card component that can display a variety of content.
<div class="card">
  <div class="card-header">
    <ng-content select=".card-title"></ng-content>
  </div>
  <div class="card-content">
    <ng-content></ng-content>
  </div>
  <div class="card-footer">
    <ng-content select=".card-actions"></ng-content>
  </div>
</div>

Now, when you use this component, you can provide custom content for each section:
<app-card>
  <div class="card-title">Card Title</div>
  <p>This is the content of the card.</p>
  <div class="card-actions">
    <button>Edit</button>
    <button>Delete</button>
  </div>
</app-card>

By combining these concepts, you can create components that are more dynamic and adaptable. ng-container, ng-template, and ng-content help you organize and structure your templates in a way that makes your code more readable and maintainable.

RxJS (Reactive Extensions for JavaScript) is a sophisticated tool used in Angular applications for handling asynchronous and event-based programming with observables. RxJS provides a diverse set of operators for manipulating, transforming, combining, and managing observables in a flexible and functional manner. These operators facilitate reactively working with data streams and asynchronous processes.

Here's a rundown of some of the most common RxJS operators and how they can be utilized in Angular:
map

The map operator is used to transform observable values into new ones. This is frequently used to do data transformations.

import { map } from 'rxjs/operators';

observable.pipe(
  map(data => data * 2)
).subscribe(result => console.log(result));

filter
The filter operator is used to remove values from an observable depending on a criterion.
import { filter } from 'rxjs/operators';

observable.pipe(
  filter(data => data > 5)
).subscribe(result => console.log(result));

mergeMap (flatMap)
The mergeMap operator is used to merge multiple observables into a single observable by applying a function to each emitted value and flattening the resulting observables.
import { mergeMap } from 'rxjs/operators';

observable.pipe(
  mergeMap(data => anotherObservable(data))
).subscribe(result => console.log(result));

switchMap
The switchMap the operator is similar to mergeMap, but it switches to a new inner observable whenever a new value is emitted from the source observable, canceling the previous inner observable.
import { switchMap } from 'rxjs/operators';

observable.pipe(
  switchMap(data => anotherObservable(data))
).subscribe(result => console.log(result));

debounceTime
The debounceTime operator delays emitted values for a specified amount of time and only emits the last value within that time frame.
import { debounceTime } from 'rxjs/operators';
inputObservable.pipe(
  debounceTime(300)
).subscribe(value => console.log(value));

combineLatest
The combineLatest operator combines the latest values from multiple observables whenever any of the observables emit a new value.
import { combineLatest } from 'rxjs/operators';

combineLatest(observable1, observable2).subscribe(([value1, value2]) => {
  console.log(value1, value2);
});

catchError
The catchError operator is used to handle errors emitted by an observable by providing an alternative observable or value.
import { catchError } from 'rxjs/operators';
import { of } from 'rxjs';

observable.pipe(
  catchError(error => of('An error occurred: ' + error))
).subscribe(result => console.log(result));

These are just a few examples of the many RxJS operators available. Using RxJS operators effectively can help you manage complex asynchronous workflows, handle data transformations, and create more responsive and reactive Angular applications.

Happy Learning :)

In this article, we will go over the fundamentals of observable and subject. The distinction between them is further demonstrated through practical examples and the various types of subjects.

What exactly is Angular?
Angular is a popular open-source JavaScript web application framework. It was created by Google and is presently maintained by the Google Angular Team. Angular enables developers to create dynamic, single-page applications (SPAs) and offers a disciplined way to developing complicated online apps.
Visible in Angular

• Observables are a component of the Reactive Extensions for JavaScript (RxJS) library in Angular.
• Observables allow you to send messages between components of your program.
• Observables are a useful tool in reactive programming that is widely used to handle asynchronous actions and data streams.
• Observables allow you to subscribe to and get notifications when new data or events are emitted, allowing you to react in real-time to changes.

//------------------Observables are unicast-----------------
//observable
let observable = new Observable<number>(ele =>
  ele.next(Math.random()))

//first subscriber
observable.subscribe(result => {
  this.first_subscriber_observable = result;
  console.log(result)
})

//second subscriber
observable.subscribe(result => {
  this.second_subscriber_observable = result;
  console.log(result)
})

//third subscriber
observable.subscribe(result => {
  this.thrid_subscriber_observable = result;
  console.log(result)
})
//--------------------------------------------------------

//------------------Subjects are multicast-----------------
//subject
let subject = new Subject<number>()

//first subscriber
subject.subscribe(result => {
  this.first_subscriber_subject = result;
  console.log(result)
})

//second subscriber
subject.subscribe(result => {
  this.second_subscriber_subject = result;
  console.log(result)
})

//third subscriber
subject.subscribe(result => {
  this.third_subscriber_subject = result;
  console.log(result)
})

subject.next(Math.random())
//--------------------------------------------------------

2. BehaviorSubject
The behavior subject is another type of subject in RxJS.
It has an initial value and will immediately emit the initial value to any subscriber as soon as they subscribe, even if no values have been emitted yet using the next() method.
After the initial value is emitted, it behaves like a regular Subject and notifies subscribers about new values emitted using next().
This is useful when you want to provide the last known value to new subscribers, such as the current state of an application or the latest data fetched from an API.

//----------Behavior Subject has default or last emitted value---------------
var behaviorSubject = new BehaviorSubject<number>(123)

behaviorSubject.subscribe(ele => {
  this.first_subscriber_behaviorSubject = ele
  console.log(`first subscriber ${ele}`)
})

behaviorSubject.next(456)

behaviorSubject.subscribe(ele => {
  this.second_subscriber_behaviorSubject = ele
  console.log(`second subscriber ${ele}`)
})

//--------------------------------------------------------------------------

3. ReplaySubject

The ReplaySubject is a subject that can buffer and replay a specific number of values to new subscribers.
When you create a ReplaySubject, you can specify the buffer size, which determines how many previous values should be replayed to new subscribers.
This is useful when you want to provide a history of values to new subscribers or when you need to cache values for later use.

//---------------Replay subject buffers old values not default one-----------

const replaySuject = new ReplaySubject(2) //If we we want to show only last 2 buffered value otherwise it will show all

replaySuject.next(111)
replaySuject.next(222)
replaySuject.next(333)

replaySuject.subscribe(e => {
  console.log(`First Subscriber ${e}`)
  this.first_subscriber_replaySubject.push(e);
})

//new values show to existing subsriber
replaySuject.next(444)

replaySuject.subscribe(e => {
  console.log(`Second Subscriber ${e}`)
  this.second_subscriber_replaySubject.push(e);
})

replaySuject.next(555)
//--------------------------------------------------------------------------

4. AsyncSubject

• The AsyncSubject is a subject that only emits the last value when it completes.
• It will not emit any values until the subject’s complete() method is called. When completed, it will emit the last value (if any) to subscribers.
• This is useful when you need to wait for an operation to complete before emitting a final value, such as waiting for an HTTP request to finish and emitting the response as a single value.

//---------------Async subject sends the latest value to subscribers when it's completed-----------
const asyncSubject = new AsyncSubject<number>();

asyncSubject.subscribe(e =>
  {
    console.log(`First Subscriber: ${e}`)
    this.first_subscriber_asyncSubject=e;
});

asyncSubject.next(111);
asyncSubject.next(222);
asyncSubject.next(333);
asyncSubject.next(444);

asyncSubject.subscribe(e => {
  console.log(`Second Subscriber: ${e}`)
  this.second_subscriber_asyncSubject=e;
});

asyncSubject.next(555);
asyncSubject.complete();

//--------------------------------------------------------------------------

In this article, learn about ng-container, ng-template, and ng-content in angular

In the context of Angular, ng-container, ng-template, and ng-content are three different Angular directives that serve different purposes. Let's explore each one:

ng-container
The ng-container directive is a non-rendered element that is used to group and manage structural directives, such as *ngIf, *ngFor, etc. It acts as a placeholder or wrapper for these structural directives when they need to be applied to multiple elements or when you want to use them without adding an additional DOM element. The ng-container itself doesn't create any extra elements in the final DOM, making it a useful tool for organizing and applying structural directives without affecting the layout.
<ng-container *ngIf="condition">
  <!-- Elements to show when the condition is true -->
</ng-container>

ng-template
The ng-template directive defines an Angular template that can be used to encapsulate HTML markup and Angular code that won't be rendered immediately. It acts as a template placeholder and can be referenced using the *ngTemplateOutlet directive or by using the <ng-container> element with the *ngTemplateOutlet attribute. ng-template is particularly useful when you want to reuse a piece of HTML code with its associated logic in multiple places.
<ng-template #myTemplate>
  <!-- Template content here -->
</ng-template>

<ng-container *ngTemplateOutlet="myTemplate"></ng-container>

ng-content
The ng-content directive is used to create content projection slots within a component. It allows you to pass content from the parent component to the child component's template. When you define <ng-content></ng-content> in the child component's template, it acts as a placeholder for the content that will be projected into it from the parent component.

Example. Parent Component Template.
<app-child>
  <!-- Content to project into the app-child component -->
</app-child>

As per the above snippet, the content is within the <app-child> tag.

Happy learning :)

DALL-E, developed by OpenAI, is an AI model that can generate images from textual descriptions. It combines the power of deep learning and generative modeling to create unique and imaginative visual outputs based on the provided text prompts. This technology has sparked excitement among researchers, artists, and developers alike.

To make the capabilities of DALL-E accessible to developers, OpenAI has released the DALL-E API. This API allows developers to interact with the DALL-E model programmatically; by using this, developers can generate images by giving text prompts. By using Node.js and  DALL-E, we can generate images programmatically.

Note. If you want to achieve this using Python, Please read my previous article on how to Generate Image Using DALL-E API and Python.

Prerequisites
It is essential to have a basic understanding of the following concepts and technologies.

Node.js
Node.js is a JavaScript runtime environment that allows you to run JavaScript code outside of a web browser. To use Node.js, you'll need to install it on your machine. Install Node.js from the official website.

Basic API Concepts
A basic understanding of API (Application Programming Interface) concepts is crucial. APIs provide a way for different software applications to communicate and exchange data. Familiarize yourself with concepts like endpoints, HTTP methods (GET, POST, etc.), request/response structure, and how to handle API responses using JavaScript.

Setting Up the Project
Open your terminal or command prompt and follow these steps.
    Create a new directory for your Project.
    mkdir dalle-image
    cd dalle-image

Initialize a new Node.js project by running the following command.
npm init -y

This will create a package.json file, keeping track of your Project's dependencies.

Install Required Dependencies
Install the Axios library to make API requests to the DALL-E API. Axios is a popular JavaScript library for making HTTP requests. It simplifies the process of sending asynchronous requests and handling responses. To install it, use the following command
npm install axios

Now, Axios is added to your Project's dependencies, and you can start using it to interact with the DALL-E API.

Writing the Node.js Code
Write the code to interact with the DALL-E API using Node.js. Follow the steps below.

Setting up the API Endpoint and Authorization
Navigate to the dalle-image directory and create a new JavaScript file, for example, dalle-api.js.
Require the Axios module at the top.
const axios = require('axios');

Next, declare a constant variable to store your DALL-E API key.
const API_KEY = 'YOUR_API_KEY';

Implementing the API Call using Axios
Implement the API call using Axios.
const axios = require('axios');
const API_KEY = 'YOUR_API_KEY';   //replace with your key

const generateImages = async () => {
  try {
    const response = await axios.post(
      'https://api.openai.com/v1/images/generations',
      {
        prompt: 'A beautiful sunset over a serene lake',
        n: 1,                                //define the number of images
        size: '512x512',                     //define the resolution of image
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${API_KEY}`,
        },
      }
    );

    console.log(response.data);
    // Handle the response here, e.g., extract image data and display or save it.
  } catch (error) {
    console.error('Error:', error.response.data);
  }
};

generateImages();

In the code above, we use the Axios. post method to make a POST request to the API endpoint. We pass the request payload as the second argument to the method and include the API key in the request headers.

Now run the Project using the following command.
node dalle-api.js

Check the console output to see the API response or any errors that occurred during the process.

Output

Reactive Extensions for JavaScript (RxJS) have become the backbone of modern Angular applications, enabling developers to handle complex asynchronous operations with elegance and ease. While many developers are familiar with basic RxJS operators, there are advanced patterns that can take your Angular development skills to the next level. In this article, we will explore some lesser-known yet powerful RxJS patterns that can significantly improve your developer experience.

1. Canceling Previous Requests with SwitchMap
One common scenario is handling user input, such as search queries, that trigger API calls. To prevent outdated responses and save bandwidth, we can use the switchMap operator. It automatically cancels previous requests when a new request is made.

Let's take a look at an example.
import { fromEvent } from 'rxjs';
import { switchMap } from 'rxjs/operators';

// Get the search input element
const searchInput = document.getElementById('search-input');

// Create an observable from input events
const searchObservable = fromEvent(searchInput, 'input').pipe(
  map((event: any) => event.target.value),
  switchMap(searchTerm => makeApiCall(searchTerm))
);

searchObservable.subscribe(response => {
  // Handle the API response
});

2. Throttling API Calls with DebounceTime
In scenarios where user input or events trigger API calls, we might want to throttle the rate of API requests to avoid overloading the server. The debounceTime operator can help us achieve this by delaying the emission of values from an Observable. Let's see it in action.
import { fromEvent } from 'rxjs';
import { debounceTime, distinctUntilChanged } from 'rxjs/operators';

// Get the search input element
const searchInput = document.getElementById('search-input');

// Create an observable from input events
const searchObservable = fromEvent(searchInput, 'input').pipe(
  map((event: any) => event.target.value),
  debounceTime(300),
  distinctUntilChanged(),
  switchMap(searchTerm => makeApiCall(searchTerm))
);

searchObservable.subscribe(response => {
  // Handle the API response
});

3. Sharing Cached Results with ShareReplay
Sometimes, we want multiple subscribers to receive the same cached result from an Observable. The shareReplay operator enables us to achieve this by caching and sharing emitted values. This is useful in scenarios where we want to avoid redundant API calls. Let's take a look.
import { interval } from 'rxjs';
import { take, shareReplay } from 'rxjs/operators';

// Create an interval observable that emits values every second
const sourceObservable = interval(1000).pipe(
  take(5),
  shareReplay(1) // Cache and share the emitted values
);

// Subscriber 1
sourceObservable.subscribe(value => {
  console.log(`Subscriber 1: ${value}`);
});

// Subscriber 2
setTimeout(() => {
  sourceObservable.subscribe(value => {
    console.log(`Subscriber 2: ${value}`);
  });
}, 3000);

4. Sequential Requests with ExhaustMap
In certain scenarios, we may need to perform a series of actions that depend on the completion of previous actions. The exhaustMap operator allows us to achieve this by ignoring new source values until the current inner Observable completes. Let's see it in action.
import { fromEvent } from 'rxjs';
import { exhaustMap } from 'rxjs/operators';

// Get the button element
const button = document.getElementById('button');

// Create an observable from button click events
const clickObservable = fromEvent(button, 'click').pipe(
  exhaustMap(() => performAction())
 );

clickObservable.subscribe(() => {
// Handle the action completion
});

5. Error Handling and Retries with RetryWhen
Handling errors and implementing retry logic is essential for robust applications. The `retryWhen` operator allows us to handle errors and retry the Observable based on specific conditions. Let's take a look.
import { throwError, timer } from 'rxjs';
import { mergeMap, retryWhen, delayWhen } from 'rxjs/operators';

// Create an observable that throws an error
const errorObservable = throwError('Something went wrong!');

// Retry the observable after a delay
errorObservable.pipe(
  retryWhen(errors =>
    errors.pipe(
      mergeMap((error, index) => {
        if (index === 2) {
          return throwError('Max retries reached'); // Throw error after 3 attempts
        }
        return timer(2000); // Retry after a 2-second delay
      })
    )
  )
).subscribe({
  next: () => console.log('Success!'),
  error: (error) => console.log(`Error: ${error}`)
});

By harnessing the power of advanced RxJS patterns in Angular, we can greatly enhance our developer experience. The switchMap, debounceTime, shareReplay, exhaustMap, retryWhen, and other operators provide us with powerful tools to handle complex asynchronous scenarios, improve performance, and build robust applications.

Information exchange between various application components is essential, and Angular is not an exception. Angular provides a number of built-in methods to facilitate this prevalent practise. Nonetheless, there may be instances in which these default approaches are insufficient, necessitating the implementation of more creative solutions.

In this session, we will investigate a few of the most common methods for component communication.

The resources I used to create this tutorial are listed below.

1. Visual Studio Code
2. Node 18.14.0
3. Angular 15

• You can transfer data between parent and offspring components using input properties.
• Define an input property in the secondary component using @Input(), and then bind the property in the parent component.
• Employ output properties with events to communicate from the child component to the parent component.
• Define an output property in the child component using @Output() and emit events with EventEmitter.

Let's examine the sample code below, which will give you an overview of parent-to-child and child-to-parent communications.

Parent Component

• Input and Output Properties (Parent-Child Communication)
• You can use input properties to pass data from parent to child components.
• Define an input property in the child component using the @Input() decorator, and then bind the property in the parent component.
• Use output properties with events to communicate from the child component back to the parent component.
• Define an output property in the child component using the @Output() decorator and emit events using EventEmitter.

Let us look at the sample code below, which will give you an overview of parent-to-child and child-to-parent communications.

Parent Component
import { Component } from '@angular/core';

@Component({
  selector: 'app-parent',
  template: `
    <h1>Parent Component</h1>
    <input [(ngModel)]="parentMessage"/>
    <p>{{ childMessage }}</p>
    <app-child [message]="parentMessage" (notify)="onNotify($event)"></app-child>`

})
export class IOParentComponent {
  parentMessage = 'Message from parent';
  childMessage ="";
  onNotify(message: string) {
    this.childMessage =message;
  }
}

Child Component
import { Component, Input, Output, EventEmitter } from '@angular/core';

@Component({
  selector: 'app-child',
  template: `
    <h2>Child Component</h2>
    <p>{{ message }}</p>
    <input [(ngModel)]="childMessage"/>
    <button (click)="notifyParent()">Notify Parent</button>
  `
})
export class IOChildComponent {
  @Input() message: string ='';
  @Output() notify = new EventEmitter<string>();
  childMessage: string ='Message from child';
  notifyParent() {

    this.notify.emit(this.childMessage);
  }
}

Services (Cross-Component Communication) using RxJS Observables and Subjects

• Create a service that can be injected into the components needing to communicate.
• The service acts as a shared source of data and functionality.
• Components can subscribe to data streams or invoke methods provided by the service to communicate with each other.

Let us take a look at the example

Shared Service
import { Injectable } from '@angular/core';
import { Subject } from 'rxjs';

@Injectable()
export class DataService {
  private dataSubject = new Subject<string>();

  setData(data: string) {
    this.dataSubject.next(data);
  }

  getData() {
    return this.dataSubject.asObservable();
  }
}

Component 1
import { Component } from '@angular/core';
import { DataService } from './dataservice.service';

@Component({
  selector: 'app-scomponent1',
  template: `    <h1>Component 1</h1>
    <input type="text" [(ngModel)]="message">
    <button (click)="sendMessage()">Send Message</button>
    <app-component2>/</app-component2>`

})
export class SComponentOne {
  message: string="";

  constructor(private dataService: DataService) { }

  sendMessage() {
    this.dataService.setData(this.message);
  }
}

Component 2
import { Component } from '@angular/core';
import { DataService } from './dataservice.service';

@Component({
  selector: 'app-component2',
  template: `
    <h1>Component 2</h1>
    <p>{{ receivedMessage }}</p>
  `
})
export class SComponentTwo {
  receivedMessage: string ='';

  constructor(private dataService: DataService) { }

  ngOnInit() {
    this.dataService.getData().subscribe(message => {
      this.receivedMessage = message;
    });
  }
}

The below reference link explains the Mediator and Service Bus approaches for component communication in Angular.

Component communication in Angular for Senior devs by 'iamprovidence'

These are some of the commonly used methods for component communication in Angular. The choice of method depends on the specific requirements of your application and the relationship between the components involved.