After picking up the basics from the previous chapter, we will now go on and create a task management application together in the upcoming chapters. You'll learn about some concepts during these chapters and then use them with practical examples. You'll also learn how to structure an application using components. This begins with the folder structure and ends with setting up the interaction between components.

The task management application, which we're going to create during the course of this book, should enable users to manage tasks easily and help them organize small projects. Usability is the central aspect of any application; therefore, you'll need to design a modern and flexible...

Let's start out by creating a new Angular project using the Angular CLI. We'll name it mastering-angular-components:

1. Open a console window and navigate to a proper workspace for our project. Let's use the Angular CLI to create our initial project structure:

ng new mastering-angular-components --prefix=mac

2. After the project has been successfully created, let's move into the project folder and start serving using the ng serve command:

cd mastering-angular-components
ng serve

After following the preceding steps, you should be able to open up your browser and point it to http://localhost:4200. You should be able to see the generated application app with a welcome message saying Welcome to mac!.

Now that we have our main application component set up, we can go on and start fleshing out our task management application. The second component that we're going to create will be responsible for listing tasks. Following the concept of composition, we'll create a task list component as a subcomponent of our main application component.

Let's create a new component for our task list by using the Angular CLI generator functionality. We already want to structure our application by area, where we put all task-relevant components into a tasks subfolder:

ng generate component --spec false -ve none tasks/task-list

Using the --spec false option while generating our component, we can skip creating test specifications. Since we're going to cover testing in a later chapter, we're skipping this process for the moment. Also, by using the -ve none...

Our task list is displayed correctly and the code we used to achieve this looks quite okay. However, if we want to follow a better approach for composition, we should rethink the design of our task list component. If we draw a line at enlisting the task list's responsibilities, we would come up with things such as listing tasks, adding new tasks to the list, sorting or filtering the task list; however, operations are not performed on an individual task itself. Also, rendering the task itself falls outside of the responsibilities of the task list. The task list component should only serve as a container for tasks.

If we look at our code again, we will see that we're violating the single responsibility principle and rendered the whole task body within our task list component. Let's take a look at how we can fix this by increasing the granularity...

Our task list looks nice already, but it would be quite useless if the user is unable to add new tasks to the list. Let's create a component for entering new tasks together. Let's create a new component with the responsibilities of handling all the UI logic necessary for entering a new task to our list.

Let's use the Angular CLI tool to create a new component stub:

ng generate component --spec false -ve none tasks/enter-task

Open up the template of the newly created component located at src/app/tasks/enter-task/enter-task.component.html and apply the following changes:

<input type="text"
       placeholder="Enter new task title..." 
       #titleInput> 
<button (click)="enterTask(titleInput)"> 
  Add Task 
</button>

This template consists of an input field as well as a button to enter a new task. If you...

The standard UI elements in the browser are great, but sometimes, modern web applications require smarter and more complex input elements than the ones available within the browser.

We'll now create two specific custom UI elements that we'll use within our application going forward in order to provide a nice user experience:

• Checkbox: There's already a native checkbox input in the browser, but sometimes, it's hard to fit it into the visual design of an application. Native checkboxes are limited in their styling possibilities, and therefore, it's hard to make them look great. Sometimes, it's those minor details that make an application look appealing.
• Toggle buttons: This is a list of toggle buttons, where only one button can be toggled within the list. They can also be represented with a native radio button list. However, like...

We have already learned a lot about building basic components and how to compose them together in order to form larger components. In the previous building block, we created a reusable checkbox UI component, which we've used to enhance the usability of our task list.

In this topic, we will use the toggle button component to create a filter for our task list. But before we start to introduce more complexity into our application, we're going to refactor our application by introducing data services. As our application gets larger, it's crucial to centralize our data manipulation and streamline our data flow. Services come in very handy since they allow us to store state which is accessible in all our components using Angular's dependency injection.

Going forward, we'll deal with quite a lot of data within our application. TypeScript supports...

In this section, we're going to implement some filter functionality for our task list. In order to control the active filter criteria, we are first building a toggle button list component. Let's go ahead and create a new component using the Angular CLI:

ng generate component --spec false -ve none ui/toggle

After running the Angular CLI generator command on your console, let's edit the HTML template of the newly created component in src/app/ui/toggle/toggle.component.html:

<button class="toggle-button" 
        *ngFor="let button of buttonList" 
        [class.active]="button === activeButton" 
        (click)="activate(button)">{{button}}</button> 

Nothing special here, really! We repeat a button by iterating over an instance field called buttonList using the NgFor directive. This button list will...

In this chapter, you learned a lot of new concepts on building UI component-based applications with Angular. We also built the core component of our task management application, which is the task list itself. You learned about the concept of input and output properties and how to use them to establish proper component communication.

We also covered the basics of the Angular component life cycle and how to use life cycle hooks to execute post-initialization steps within the OnInit hook.

As the last step, we integrated a toggle button list component within our task list to filter the task states. We refactored our task list component to use a service in order to obtain task data. For this, we used Angular's dependency injection.

Within the next chapter, we're going to look at ways how to improve our handling of data and state. There are plenty of ways how to deal...