Using modal dialogs in web applications is fairly common. Whether you want to edit a record in a table without navigating to a different page, look up some data, or just show a warning message to your users, using a modal dialog may be a great user experience. Unfortunately, doing that is not very easy in Angular without a third party library. It requires writing some non trivial code and understanding of the internal mechanisms of the Angular framework. That is the reason why we developed a library at Developer Partners for showing modal dialogs in Angular. We are going to use our library in this article.
1. Install the Library
We will have to install our @developer-partners/ngx-modal-dialog library via NPM and include that in our Angular modules to be able to use it. Here is the NPM command to install it:
npm install @developer-partners/ngx-modal-dialog
Next, we have to include it in the Angular modules where we have to use modal dialogs. Our demo application is very small, it has only one module called AppModule
. We have to include ModalModule
from the library in the imports array of our AppModule
Angular module:
// Import ModalModule
import { ModalModule } from '@developer-partners/ngx-modal-dialog';
@NgModule({
declarations: [
// Declarations of your app.
],
imports: [
// Import other Angular modules
// Add ModalModule to your module imports.
ModalModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
We are all set. We can start using the modal dialog component in our application.
2. Show a Modal Dialog
As mentioned before, we are going to show our modal dialog when we want to add or edit a book in our list of books. Let's first create a component where we are going to show the list of books. We are going to create a new Angular component and call it BookListComponent
. This is the content of the BookListComponent
Typescript class:
import { Component } from "@angular/core";
import { ModalService } from "@developer-partners/ngx-modal-dialog";
import { Book } from "src/app/shared/models/book";
@Component({
selector: 'app-book-list',
templateUrl: './book-list.component.html'
})
export class BookListComponent {
public books?: Book[] = [
{
id: 1,
title: 'The Great Gatsby'
},
{
id: 2,
title: 'One Hundred Years of Solitude'
},
{
id: 3,
title: 'War and Peace'
},
{
id: 4,
title: 'Pride and Prejudice'
},
{
id: 5,
title: 'To Kill a Mockingbird'
}
];
constructor(private readonly _modalService: ModalService) {
}
}
Our BookListComponent
class uses a hardcoded list of books as the data to show in our table for simplicity. It also needs the ModalService
Angular service from the ngx-modal-dialog
library to be able to show the modal dialogs that is why we injected it into our constructor.
Next, we will create the HTML file for BookListComponent
where we will show the list of books in an HTML table:
<div>
<button type="button" class="btn btn-primary mb-3" (click)="createBook()">
Add New Book
</button>
<table class="table">
<thead>
<tr>
<th scope="col">ID</th>
<th scope="col">Title</th>
<th scope="col">Actions</th>
</tr>
</thead>
<tbody>
<tr *ngFor="let book of books">
<td>
{{book.id}}
</td>
<td>
{{book.title}}
</td>
</tr>
</tbody>
</table>
</div>
The HTML code above is pretty simple. It show the list of books in a table. It also has a button called "Add New Book". This is what the UI looks like so far:
When the "Add New Book" button is clicked, it calls the createBook
function in our Typescript class. The createBook
function shows the modal dialog for adding a new book to our table. This is the Typescript code of the createBook
function:
constructor(private readonly _modalService: ModalService) {
}
public createBook(): void {
this._modalService.show<Book>(CreateEditBookComponent, {
title: 'Create Book'
}).result()
.subscribe(newBook => {
this.books?.push(newBook);
})
}
The createBook
function shows the modal dialog by calling the show
function of the ModalService
class. The show
function takes 2 parameters: the class of the Angular component to show inside the modal dialog and the options of modal dialog which are the settings of the dialog such as the title, size, position, and a few other things. The modal dialog needs an Angular component to show in its body. Without that component, our modal dialog would be just an empty panel overlaying the screen. That component is CreateEditBookComponent
which is the first parameter of the show function in the code above.
The CreateEditBookComponent
Angular component is going to be responsible for both adding and editing books. We will start by working on the code for adding new books. Here is the HTML code of the CreateEditBookComponent
which has only a few fields for entering the ID and title of the book we want to create and has buttons for closing the dialog and saving the data:
<form (ngSubmit)="saveData()">
<div class="mb-3">
<label for="book-id" class="form-label">
ID
</label>
<input id="book-id"
name="id"
type="number"
min="0"
class="form-control"
required
[(ngModel)]="book.id" />
</div>
<div class="mb-3">
<label for="book-title" class="form-label">
Title
</label>
<input id="book-title"
name="title"
class="form-control"
required
[(ngModel)]="book.title" />
</div>
<div class="text-center">
<button type="button"
class="btn btn-secondary"
(click)="cancel()">
Cancel
</button>
<button type="submit" class="btn btn-primary ms-2">
Save
</button>
</div>
</form>
This is what the modal dialog UI looks like:
Here is the Typescript code of the CreateEditBookComponent
component:
import { Component } from "@angular/core";
import { ModalReference } from "@developer-partners/ngx-modal-dialog";
import { Book } from "src/app/shared/models/book";
@Component({
templateUrl: './create-edit-book.component.html'
})
export class CreateEditBookComponent {
public book: Book = {};
constructor(private readonly _modalReference: ModalReference<Book>) {
if (this._modalReference.config.model) {
let copy = { ...this._modalReference.config.model };
this.book = copy;
}
}
public cancel(): void {
this._modalReference.cancel();
}
public saveData(): void {
this._modalReference.closeSuccess(this.book);
}
}
The CreateEditBookComponent
component uses an Angular service called ModalReference
from the ngx-modal-dialog library. We use that service for interacting with the modal dialog where our component is placed such as closing the modal or subscribing to its events. We simply close the modal dialog in the cancel
function in the screenshot above. We call the cancel
function when the "Cancel" button from HTML is clicked. When we click the "Save" button in the HTML code, it submits the form which calls the saveData
function. In the saveData
function, we close the modal dialog just like in the cancel
function but we also pass the book property to it that contains the data for adding a new book to our list.
The ModalReference
service is a generic type. When we call the closeSuccess
function of the ModalReference
service, we have to pass an object of the same type as its generic parameter. In our case, it's a Typescript interface called Book
. The parameter that we pass to the closeSuccess
function is passed back to the component that created the modal dialog by calling the show function of the ModalService
class.
// Code from BookListComponent.
public createBook(): void {
this._modalService.show<Book>(CreateEditBookComponent, {
title: 'Create Book'
}).result()
.subscribe(newBook => {
this.books?.push(newBook);
})
}
When the call the closeSuccess
function of the ModalReference
service, it closes the modal dialog and triggers an RxJS
event passing the newly create book to the subscribers of that event. In the screenshot above, the newBook
parameter of our callback function is the newly created book that we received from the the modal dialog, so we simply add it to our books array to show it in the UI.
3. Passing Data to Modal Dialogs
There are some case that you need to pass some data to modal dialogs. For example, if we want to edit a book from the list, we can pass the book record that we want to edit to the modal dialog to have the initial data that we want to modify. Let's start by adding a button to the table rows for editing the row data:
<div>
<button type="button"
class="btn btn-primary mb-3"
(click)="createBook()">
Add New Book
</button>
<table class="table">
<thead>
<tr>
<th scope="col">ID</th>
<th scope="col">Title</th>
<th scope="col">Actions</th>
</tr>
</thead>
<tbody>
<tr *ngFor="let book of books">
<td>
{{book.id}}
</td>
<td>
{{book.title}}
</td>
<td>
<!--
Edit the selected book
when the button is clicked
-->
<button type="button"
class="btn btn-secondary"
(click)="editBook(book)">
Edit
</button>
</td>
</tr>
</tbody>
</table>
</div>
This is what the UI looks like with the Edit button in each row of the table:
The editBook
function has almost the same code as the createBook
function with just one important difference. It passes the book that we want to edit to the modal dialog by using the model property of the of the dialog options.
public editBook(book: Book): void {
this._modalService.show<Book>(CreateEditBookComponent, {
title: 'Edit Book',
// Pass the book object to the modal dialog.
model: book
}).result()
.subscribe(editedBook => {
let index = this.books?.indexOf(book);
this.books[index] = editedBook;
})
}
The parameter that we pass to the modal dialog using the model
property becomes available in the ModalReference
service in the component used inside the dialog via its config.model
property.
@Component({
templateUrl: './create-edit-book.component.html'
})
export class CreateEditBookComponent {
public book: Book = {};
constructor(
private readonly _modalReference: ModalReference<Book>
) {
if (this._modalReference.config.model) {
let copy = { ...this._modalReference.config.model };
this.book = copy;
}
}
}
In the code above, we are copying the passed parameter and assigning it to the book
property of the CreateEditBookComponent
component. The model
property of ModalReference.config
object is passed by reference, so any changes we make in the properties of that object will be reflected in the table where we show the list of books. The reason why we copy it is to not modify the row in the table until the user clicks the "Save" button. If the user clicks the "Cancel" button, the table data will not be updated.
This is that the Edit Book modal dialog looks like:
Conclusion
Building a modal dialog for Angular from scratch is not easy, but it is much easier with our modal dialog library. We went through how to setup the library and use it for showing modal dialogs in your project. We went through most basic use cases and features of the dialogs, but the @developer-partners/ngx-modal-dialog
library has a lot of other features that you may find useful in your real projects. Please follow the link below to learn more about it:
@developer-partners/ngx-modal-dialog
In case if you would like to show a nice loading spinner in your modal dialogs, please see our article about building a loading spinner in Angular:
How to Create a Loading Spinner in Angular
Top comments (0)