×

Welcome to Knowledge Base!

KB at your finger tips

This is one stop global knowledge base where you can learn about all the products, solutions and support features.

Categories
All
Web-Angular
Angular - Cheat Sheet

Cheat Sheet link

Bootstrapping Details
      
      import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
    
Import platformBrowserDynamic from @angular/platform-browser-dynamic .
      
      platformBrowserDynamic().bootstrapModule(AppModule);
    
Bootstraps the application, using the root component from the specified NgModule .
NgModules Details
      
      import { NgModule } from '@angular/core';
    
Import NgModule from @angular/core .
      
      @NgModule({ 
  declarations: …, 
  imports: …, 
  exports: …, 
  providers: …, 
  bootstrap:  
}) 
class MyModule {}
    
Defines a module that contains components, directives, pipes, and providers.
      
      declarations: [ 
  MyRedComponent, 
  MyBlueComponent, 
  MyDatePipe 
]
    
List of components, directives, and pipes that belong to this module.
      
      imports: [ 
  BrowserModule, 
  SomeOtherModule 
]
    
List of modules to import into this module. Everything from the imported modules is available to declarations of this module.
      
      exports: [ 
  MyRedComponent, 
  MyDatePipe 
]
    
List of components, directives, and pipes visible to modules that import this module.
      
      providers: [ 
  MyService, 
  { provide:  } 
]
    
List of dependency injection providers visible both to the contents of this module and to importers of this module.
      
      bootstrap: [MyAppComponent]
    
List of components to bootstrap when this module is bootstrapped.
Template syntax Details
      
      <input [value]="firstName">
    
Binds property value to the result of expression firstName .
      
      <div [attr.role]="myAriaRole">
    
Binds attribute role to the result of expression myAriaRole .
      
      <div [class.extra-sparkle]="isDelightful">
    
Binds the presence of the CSS class extra-sparkle on the element to the truthiness of the expression isDelightful .
      
      <div [style.width.px]="mySize">
    
Binds style property width to the result of expression mySize in pixels. Units are optional.
      
      <button (click)="readRainbow($event)">
    
Calls method readRainbow when a click event is triggered on this button element (or its children) and passes in the event object.
      
      <div title="Hello {{ponyName}}">
    
Binds a property to an interpolated string, for example, "Hello Seabiscuit". Equivalent to:
      
      <div [title]="'Hello ' + ponyName">
    
      
      <p> 
  Hello {{ponyName}} 
</p>
    
Binds text content to an interpolated string, for example, "Hello Seabiscuit".
      
      <my-cmp [(title)]="name">
    
Sets up two-way data binding. Equivalent to:
      
      <my-cmp [title]="name" (titleChange)="name=$event">
    
      
      <video #movieplayer></video> 
<button (click)="movieplayer.play()"> 
  Play 
</button>
    
Creates a local variable movieplayer that provides access to the video element instance in data-binding and event-binding expressions in the current template.
      
      <p *myUnless="myExpression"> 
  … 
</p>
    
The asterisk ( * ) character turns the current element into an embedded template. Equivalent to:
      
      <ng-template [myUnless]="myExpression"> 
  <p> 
    … 
  </p> 
</ng-template>
    
      
      <p> 
  Card No.: {{cardNumber | myCardNumberFormatter}} 
</p>
    
Transforms the current value of expression cardNumber using the pipe called myCardNumberFormatter .
      
      <p> 
  Employer: {{employer?.companyName}} 
</p>
    
The safe navigation operator ( ? ) means that the employer field is optional and if undefined , the rest of the expression should be ignored.
      
      <svg:rect x="0" 
          y="0" 
          width="100" 
          height="100"/>
    
An SVG snippet template needs an svg: prefix on its root element to disambiguate the SVG element from an HTML component.
      
      <svg> 
  <rect x="0" 
        y="0" 
        width="100" 
        height="100"/> 
</svg>
    
An <svg> root element is detected as an SVG element automatically, without the prefix.
Built-in directives Details
      
      import { CommonModule } from '@angular/common';
    
Import CommonModule from @angular/common .
      
      <section *ngIf="showSection">
    
Removes or recreates a portion of the DOM tree based on the showSection expression.
      
      <li *ngFor="let item of list">
    
Turns the li element and its contents into a template, and uses that to instantiate a view for each item in list.
      
      <div [ngSwitch]="conditionExpression">
  <ng-template [ngSwitchCase]="case1Exp"> 
    … 
  </ng-template>
  <ng-template ngSwitchCase="case2LiteralString"> 
    … 
  </ng-template>
  <ng-template ngSwitchDefault> 
    … 
  </ng-template> 
</div>
    
Conditionally swaps the contents of the div by selecting one of the embedded templates based on the current value of conditionExpression .
      
      <div [ngClass]="{'active': isActive, 
                 'disabled': isDisabled}">
    
Binds the presence of CSS classes on the element to the truthiness of the associated map values. The right-hand expression should return {class-name: true/false} map.
      
      <div [ngStyle]="{'property': 'value'}"> 
<div [ngStyle]="dynamicStyles()">
    
Allows you to assign styles to an HTML element using CSS. You can use CSS directly, as in the first example, or you can call a method from the component.
Forms Details
      
      import { FormsModule } from '@angular/forms';
    
Import FormsModule from @angular/forms .
      
      <input [(ngModel)]="userName">
    
Provides two-way data-binding, parsing, and validation for form controls.
Class decorators Details
      
      import { Directive,  } from '@angular/core';
    
Import Directive, &hellip; from @angular/core'; .
      
      @Component({…}) 
class MyComponent() {}
    
Declares that a class is a component and provides metadata about the component.
      
      @Directive({…}) 
class MyDirective() {}
    
Declares that a class is a directive and provides metadata about the directive.
      
      @Pipe({…}) 
class MyPipe() {}
    
Declares that a class is a pipe and provides metadata about the pipe.
      
      @Injectable() 
class MyService() {}
    
Declares that a class can be provided and injected by other classes. Without this decorator, the compiler won't generate enough metadata to allow the class to be created properly when it's injected somewhere.
Directive configuration Details
      
      @Directive({ 
  property1: value1, 
   
})
    
Add property1 property with value1 value to Directive.
      
      selector: '.cool-button:not(a)'
    
Specifies a CSS selector that identifies this directive within a template. Supported selectors include element , [attribute] , .class , and :not() .
Does not support parent-child relationship selectors.
      
      providers: [ 
  MyService, 
  { provide:  } 
]
    
List of dependency injection providers for this directive and its children.
Component configuration
@Component extends @Directive , so the @Directive configuration applies to components as well
Details
      
      moduleId: module.id
    
If set, the templateUrl and styleUrl are resolved relative to the component.
      
      viewProviders: [MyService, { provide:  }]
    
List of dependency injection providers scoped to this component's view.
      
      template: 'Hello {{name}}' 
templateUrl: 'my-component.html'
    
Inline template or external template URL of the component's view.
      
      styles: ['.primary {color: red}'] 
styleUrls: ['my-component.css']
    
List of inline CSS styles or external stylesheet URLs for styling the component's view.
Class field decorators for directives and components Details
      
      import { Input,  } from '@angular/core';
    
Import Input, ... from @angular/core .
      
      @Input() myProperty;
    
Declares an input property that you can update using property binding (example: <my-cmp [myProperty]="someExpression"> ).
      
      @Output() myEvent = new EventEmitter();
    
Declares an output property that fires events that you can subscribe to with an event binding (example: <my-cmp (myEvent)="doSomething()"> ).
      
      @HostBinding('class.valid') isValid;
    
Binds a host element property (here, the CSS class valid ) to a directive/component property ( isValid ).
      
      @HostListener('click', ['$event']) onClick(e) {…}
    
Subscribes to a host element event ( click ) with a directive/component method ( onClick ), optionally passing an argument ( $event ).
      
      @ContentChild(myPredicate) myChildComponent;
    
Binds the first result of the component content query ( myPredicate ) to a property ( myChildComponent ) of the class.
      
      @ContentChildren(myPredicate) myChildComponents;
    
Binds the results of the component content query ( myPredicate ) to a property ( myChildComponents ) of the class.
      
      @ViewChild(myPredicate) myChildComponent;
    
Binds the first result of the component view query ( myPredicate ) to a property ( myChildComponent ) of the class. Not available for directives.
      
      @ViewChildren(myPredicate) myChildComponents;
    
Binds the results of the component view query ( myPredicate ) to a property ( myChildComponents ) of the class. Not available for directives.
Directive and component change detection and lifecycle hooks (implemented as class methods) Details
      
      constructor(myService: MyService, …) {  }
    
Called before any other lifecycle hook. Use it to inject dependencies, but avoid any serious work here.
      
      ngOnChanges(changeRecord) {  }
    
Called after every change to input properties and before processing content or child views.
      
      ngOnInit() {  }
    
Called after the constructor, initializing input properties, and the first call to ngOnChanges .
      
      ngDoCheck() {  }
    
Called every time that the input properties of a component or a directive are checked. Use it to extend change detection by performing a custom check.
      
      ngAfterContentInit() {  }
    
Called after ngOnInit when the component's or directive's content has been initialized.
      
      ngAfterContentChecked() {  }
    
Called after every check of the component's or directive's content.
      
      ngAfterViewInit() {  }
    
Called after ngAfterContentInit when the component's views and child views / the view that a directive is in has been initialized.
      
      ngAfterViewChecked() {  }
    
Called after every check of the component's views and child views / the view that a directive is in.
      
      ngOnDestroy() {  }
    
Called once, before the instance is destroyed.
Dependency injection configuration Details
      
      { provide: MyService, useClass: MyMockService }
    
Sets or overrides the provider for MyService to the MyMockService class.
      
      { provide: MyService, useFactory: myFactory }
    
Sets or overrides the provider for MyService to the myFactory factory function.
      
      { provide: MyValue, useValue: 41 }
    
Sets or overrides the provider for MyValue to the value 41 .
Routing and navigation Details
      
      import { Routes, RouterModule,  } from '@angular/router';
    
Import Routes, RouterModule, ... from @angular/router .
      
      const routes: Routes = [ 
  { path: '', component: HomeComponent }, 
  { path: 'path/:routeParam', component: MyComponent }, 
  { path: 'staticPath', component:  }, 
  { path: '**', component:  }, 
  { path: 'oldPath', redirectTo: '/staticPath' }, 
  { path: …, component: …, data: { message: 'Custom' } } 
]); 
 
const routing = RouterModule.forRoot(routes);
    
Configures routes for the application. Supports static, parameterized, redirect, and wildcard routes. Also supports custom route data and resolve.
      
      <router-outlet></router-outlet> 
<router-outlet name="aux"></router-outlet>
    
Marks the location to load the component of the active route.
      
      <a routerLink="/path"> 
<a [routerLink]="[ '/path', routeParam ]"> 
<a [routerLink]="[ '/path', { matrixParam: 'value' } ]"> 
<a [routerLink]="[ '/path' ]" [queryParams]="{ page: 1 }"> 
<a [routerLink]="[ '/path' ]" fragment="anchor">
    
Creates a link to a different view based on a route instruction consisting of a route path, required and optional parameters, query parameters, and a fragment. To navigate to a root route, use the / prefix; for a child route, use the ./ prefix; for a sibling or parent, use the ../ prefix.
      
      <a [routerLink]="[ '/path' ]" routerLinkActive="active">
    
The provided classes are added to the element when the routerLink becomes the current active route.
      
      <a [routerLink]="[ '/path' ]" routerLinkActive="active" ariaCurrentWhenActive="page">
    
The provided classes and aria-current attribute are added to the element when the routerLink becomes the current active route.
      
      function canActivateGuard: CanActivateFn = 
  ( 
    route: ActivatedRouteSnapshot, 
    state: RouterStateSnapshot 
  ) => {  } 
 
{ path: …, canActivate: [canActivateGuard] }
    
An interface for defining a function that the router should call first to determine if it should activate this component. Should return a boolean|UrlTree or an Observable/Promise that resolves to a boolean|UrlTree .
      
      function canDeactivateGuard: CanDeactivateFn<T> = 
  ( 
    component: T, 
    route: ActivatedRouteSnapshot, 
    state: RouterStateSnapshot 
  ) => {  } 
 
{ path: …, canDeactivate: [canDeactivateGuard] }
    
An interface for defining a function that the router should call first to determine if it should deactivate this component after a navigation. Should return a boolean|UrlTree or an Observable/Promise that resolves to a boolean|UrlTree .
      
      function canActivateChildGuard: CanActivateChildFn = 
  ( 
    route: ActivatedRouteSnapshot, 
    state: RouterStateSnapshot 
  ) => {  } 
 
{ path: …, canActivateChild: [canActivateGuard], children:  }
    
An interface for defining a function that the router should call first to determine if it should activate the child route. Should return a boolean|UrlTree or an Observable/Promise that resolves to a boolean|UrlTree .
      
      function resolveGuard implements ResolveFn<T> = 
  ( 
    route: ActivatedRouteSnapshot, 
    state: RouterStateSnapshot 
  ) => {  }  
 
{ path: …, resolve: [resolveGuard] }
    
An interface for defining a function that the router should call first to resolve route data before rendering the route. Should return a value or an Observable/Promise that resolves to a value.
      
      function canLoadGuard: CanLoadFn = 
  ( 
    route: Route 
  ) => {  } 
 
{ path: …, canLoad: [canLoadGuard], loadChildren:  }
    
An interface for defining a function that the router should call first to check if the lazy loaded module should be loaded. Should return a boolean|UrlTree or an Observable/Promise that resolves to a boolean|UrlTree .
Last reviewed on Mon Feb 28 2022
Angular - Class and style binding

Class and style binding link

Use class and style bindings to add and remove CSS class names from an element's class attribute and to set styles dynamically.

Prerequisites link

  • Property binding

Binding to a single CSS class link

To create a single class binding, type the following:

[class.sale]="onSale"

Angular adds the class when the bound expression, onSale is truthy, and it removes the class when the expression is falsy—with the exception of undefined . See styling delegation for more information.

Binding to multiple CSS classes link

To bind to multiple classes, type the following:

[class]="classExpression"

The expression can be one of:

  • A space-delimited string of class names.
  • An object with class names as the keys and truthy or falsy expressions as the values.
  • An array of class names.

With the object format, Angular adds a class only if its associated value is truthy.

With any object-like expression—such as object , Array , Map , or Set —the identity of the object must change for Angular to update the class list. Updating the property without changing object identity has no effect.

If there are multiple bindings to the same class name, Angular uses styling precedence to determine which binding to use.

The following table summarizes class binding syntax.

Binding Type Syntax Input Type Example Input Values
Single class binding [class.sale]="onSale" boolean | undefined | null true , false
Multi-class binding [class]="classExpression" string "my-class-1 my-class-2 my-class-3"
Multi-class binding [class]="classExpression" Record<string, boolean | undefined | null> {foo: true, bar: false}
Multi-class binding [class]="classExpression" Array<string> ['foo', 'bar']

Binding to a single style link

To create a single style binding, use the prefix style followed by a dot and the name of the CSS style.

For example, to set the width style, type the following: [style.width]="width"

Angular sets the property to the value of the bound expression, which is usually a string. Optionally, you can add a unit extension like em or % , which requires a number type.

  1. To write a style in dash-case, type the following:

          
          <nav [style.background-color]="expression"></nav>
        
  2. To write a style in camelCase, type the following:

          
          <nav [style.backgroundColor]="expression"></nav>
        

Binding to multiple styles link

To toggle multiple styles, bind to the [style] attribute—for example, [style]="styleExpression" . The styleExpression can be one of:

  • A string list of styles such as "width: 100px; height: 100px; background-color: cornflowerblue;" .
  • An object with style names as the keys and style values as the values, such as {width: '100px', height: '100px', backgroundColor: 'cornflowerblue'} .

Note that binding an array to [style] is not supported.

When binding [style] to an object expression, the identity of the object must change for Angular to update the class list. Updating the property without changing object identity has no effect.

Single and multiple-style binding example link

nav-bar.component.ts
      
      @Component({
  selector: 'app-nav-bar',
  template: `
<nav [style]='navStyle'>
  <a [style.text-decoration]="activeLinkStyle">Home Page</a>
  <a [style.text-decoration]="linkStyle">Login</a>
</nav>`
})
export class NavBarComponent {
  navStyle = 'font-size: 1.2rem; color: cornflowerblue;';
  linkStyle = 'underline';
  activeLinkStyle = 'overline';
  /* . . . */
}
    

If there are multiple bindings to the same style attribute, Angular uses styling precedence to determine which binding to use.

The following table summarizes style binding syntax.

Binding Type Syntax Input Type Example Input Values
Single style binding [style.width]="width" string | undefined | null "100px"
Single style binding with units [style.width.px]="width" number | undefined | null 100
Multi-style binding [style]="styleExpression" string "width: 100px; height: 100px"
Multi-style binding [style]="styleExpression" Record<string, string | undefined | null> {width: '100px', height: '100px'}

Styling precedence link

A single HTML element can have its CSS class list and style values bound to multiple sources (for example, host bindings from multiple directives).

What’s next link

  • Component styles
  • Introduction to Angular animations
Last reviewed on Mon May 09 2022
Read article
Angular - Angular CLI builders

Angular CLI builders link

A number of Angular CLI commands run a complex process on your code, such as linting, building, or testing. The commands use an internal tool called Architect to run CLI builders , which apply another tool to accomplish the wanted task.

With Angular version 8, the CLI Builder API is stable and available to developers who want to customize the Angular CLI by adding or modifying commands. For example, you could supply a builder to perform an entirely new task, or to change which third-party tool is used by an existing command.

This document explains how CLI builders integrate with the workspace configuration file, and shows how you can create your own builder.

Find the code from the examples used here in this GitHub repository.

CLI builders link

The internal Architect tool delegates work to handler functions called builders . A builder handler function receives two arguments; a set of input options (a JSON object), and a context (a BuilderContext object).

The separation of concerns here is the same as with schematics, which are used for other CLI commands that touch your code (such as ng generate ).

  • The options object is provided by the CLI user, while the context object is provided by the CLI Builder API
  • In addition to the contextual information, the context object, which is an instance of the BuilderContext , also provides access to a scheduling method, context.scheduleTarget() . The scheduler executes the builder handler function with a given target configuration.

The builder handler function can be synchronous (return a value) or asynchronous (return a Promise), or it can watch and return multiple values (return an Observable). The return value or values must always be of type BuilderOutput . This object contains a Boolean success field and an optional error field that can contain an error message.

Angular provides some builders that are used by the CLI for commands such as ng build and ng test . Default target configurations for these and other built-in CLI builders can be found (and customized) in the "architect" section of the workspace configuration file, angular.json . Also, extend and customize Angular by creating your own builders, which you can run using the ng run CLI command.

Builder project structure link

A builder resides in a "project" folder that is similar in structure to an Angular workspace, with global configuration files at the top level, and more specific configuration in a source folder with the code files that define the behavior. For example, your myBuilder folder could contain the following files.

Files Purpose
src/my-builder.ts Main source file for the builder definition.
src/my-builder.spec.ts Source file for tests.
src/schema.json Definition of builder input options.
builders.json Builders definition.
package.json Dependencies. See https://docs.npmjs.com/files/package.json.
tsconfig.json TypeScript configuration.

Publish the builder to npm (see Publishing your Library). If you publish it as @example/my-builder , install it using the following command.

      
      npm install @example/my-builder
    

Creating a builder link

As an example, create a builder that copies a file. To create a builder, use the createBuilder() CLI Builder function, and return a Promise<BuilderOutput> object.

src/my-builder.ts (builder skeleton)
      
      import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
import { JsonObject } from '@angular-devkit/core';

interface Options extends JsonObject {
  source: string;
  destination: string;
}

export default createBuilder(copyFileBuilder);

async function copyFileBuilder(
  options: Options,
  context: BuilderContext,
): Promise<BuilderOutput> {
}
    

Now let's add some logic to it. The following code retrieves the source and destination file paths from user options and copies the file from the source to the destination (using the Promise version of the built-in NodeJS copyFile() function). If the copy operation fails, it returns an error with a message about the underlying problem.

src/my-builder.ts (builder)
      
      import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
import { JsonObject } from '@angular-devkit/core';
import { promises as fs } from 'fs';

interface Options extends JsonObject {
  source: string;
  destination: string;
}

export default createBuilder(copyFileBuilder);

async function copyFileBuilder(
  options: Options,
  context: BuilderContext,
): Promise<BuilderOutput> {
  try {
    await fs.copyFile(options.source, options.destination);
  } catch (err) {
    return {
      success: false,
      error: err.message,
    };
  }

  return { success: true };
}
    

Handling output link

By default, copyFile() does not print anything to the process standard output or error. If an error occurs, it might be difficult to understand exactly what the builder was trying to do when the problem occurred. Add some additional context by logging additional information using the Logger API. This also lets the builder itself be executed in a separate process, even if the standard output and error are deactivated (as in an Electron app).

You can retrieve a Logger instance from the context.

src/my-builder.ts (handling output)
      
      import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
import { JsonObject } from '@angular-devkit/core';
import { promises as fs } from 'fs';

interface Options extends JsonObject {
  source: string;
  destination: string;
}

export default createBuilder(copyFileBuilder);

async function copyFileBuilder(
  options: Options,
  context: BuilderContext,
): Promise<BuilderOutput> {
  try {
    await fs.copyFile(options.source, options.destination);
  } catch (err) {
    context.logger.error('Failed to copy file.');
    return {
      success: false,
      error: err.message,
    };
  }

  return { success: true };
}
    

Progress and status reporting link

The CLI Builder API includes progress and status reporting tools, which can provide hints for certain functions and interfaces.

To report progress, use the context.reportProgress() method, which takes a current value, (optional) total, and status string as arguments. The total can be any number; for example, if you know how many files you have to process, the total could be the number of files, and current should be the number processed so far. The status string is unmodified unless you pass in a new string value.

You can see an example of how the tslint builder reports progress.

In our example, the copy operation either finishes or is still executing, so there's no need for a progress report, but you can report status so that a parent builder that called our builder would know what's going on. Use the context.reportStatus() method to generate a status string of any length.

NOTE :
There's no guarantee that a long string will be shown entirely; it could be cut to fit the UI that displays it.

Pass an empty string to remove the status.

src/my-builder.ts (progress reporting)
      
      import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
import { JsonObject } from '@angular-devkit/core';
import { promises as fs } from 'fs';

interface Options extends JsonObject {
  source: string;
  destination: string;
}

export default createBuilder(copyFileBuilder);

async function copyFileBuilder(
  options: Options,
  context: BuilderContext,
): Promise<BuilderOutput> {
  context.reportStatus(`Copying ${options.source} to ${options.destination}.`);
  try {
    await fs.copyFile(options.source, options.destination);
  } catch (err) {
    context.logger.error('Failed to copy file.');
    return {
      success: false,
      error: err.message,
    };
  }

  context.reportStatus('Done.');
  return { success: true };
}
    

Builder input link

You can invoke a builder indirectly through a CLI command, or directly with the Angular CLI ng run command. In either case, you must provide required inputs, but can let other inputs default to values that are pre-configured for a specific target , provide a pre-defined, named override configuration, and provide further override option values on the command line.

Input validation link

You define builder inputs in a JSON schema associated with that builder. The Architect tool collects the resolved input values into an options object, and validates their types against the schema before passing them to the builder function. (The Schematics library does the same kind of validation of user input.)

For our example builder, you expect the options value to be a JsonObject with two keys: A source and a destination , each of which are a string.

You can provide the following schema for type validation of these values.

src/schema.json
      
      {
  "$schema": "http://json-schema.org/schema",
  "type": "object",
  "properties": {
    "source": {
      "type": "string"
    },
    "destination": {
      "type": "string"
    }
  }
}
    

This is a very simple example, but the use of a schema for validation can be very powerful. For more information, see the JSON schemas website.

To link our builder implementation with its schema and name, you need to create a builder definition file, which you can point to in package.json .

Create a file named builders.json that looks like this:

builders.json
      
      {
  "builders": {
    "copy": {
      "implementation": "./dist/my-builder.js",
      "schema": "./src/schema.json",
      "description": "Copies a file."
    }
  }
}
    

In the package.json file, add a builders key that tells the Architect tool where to find our builder definition file.

package.json
      
      {
  "name": "@example/copy-file",
  "version": "1.0.0",
  "description": "Builder for copying files",
  "builders": "builders.json",
  "dependencies": {
    "@angular-devkit/architect": "~0.1200.0",
    "@angular-devkit/core": "^12.0.0"
  }
}
    

The official name of our builder is now @example/copy-file:copy . The first part of this is the package name (resolved using node resolution), and the second part is the builder name (resolved using the builders.json file).

Using one of our options is very straightforward. You did this in the previous section when you accessed options.source and options.destination .

src/my-builder.ts (report status)
      
      context.reportStatus(`Copying ${options.source} to ${options.destination}.`);
try {
  await fs.copyFile(options.source, options.destination);
} catch (err) {
  context.logger.error('Failed to copy file.');
  return {
    success: false,
    error: err.message,
  };
}

context.reportStatus('Done.');
return { success: true };
    

Target configuration link

A builder must have a defined target that associates it with a specific input configuration and project.

Targets are defined in the angular.json CLI configuration file. A target specifies the builder to use, its default options configuration, and named alternative configurations. The Architect tool uses the target definition to resolve input options for a given run.

The angular.json file has a section for each project, and the "architect" section of each project configures targets for builders used by CLI commands such as 'build', 'test', and 'lint'. By default, for example, the build command runs the builder @angular-devkit/build-angular:browser to perform the build task, and passes in default option values as specified for the build target in angular.json .

angular.json
      
      {
  "myApp": {
    
    "architect": {
      "build": {
        "builder": "@angular-devkit/build-angular:browser",
        "options": {
          "outputPath": "dist/myApp",
          "index": "src/index.html",
          
        },
        "configurations": {
          "production": {
            "fileReplacements": [
              {
                "replace": "src/environments/environment.ts",
                "with": "src/environments/environment.prod.ts"
              }
            ],
            "optimization": true,
            "outputHashing": "all",
            
          }
        }
      },
      
    

The command passes the builder the set of default options specified in the "options" section. If you pass the --configuration=production flag, it uses the override values specified in the production alternative configuration. Specify further option overrides individually on the command line. You might also add more alternative configurations to the build target, to define other environments such as stage or qa .

Target strings link

The generic ng run CLI command takes as its first argument a target string of the following form.

      
      project:target[:configuration]
    
Details
project The name of the Angular CLI project that the target is associated with.
target A named builder configuration from the architect section of the angular.json file.
configuration (optional) The name of a specific configuration override for the given target, as defined in the angular.json file.

If your builder calls another builder, it might need to read a passed target string. Parse this string into an object by using the targetFromTargetString() utility function from @angular-devkit/architect .

Schedule and run link

Architect runs builders asynchronously. To invoke a builder, you schedule a task to be run when all configuration resolution is complete.

The builder function is not executed until the scheduler returns a BuilderRun control object. The CLI typically schedules tasks by calling the context.scheduleTarget() function, and then resolves input options using the target definition in the angular.json file.

Architect resolves input options for a given target by taking the default options object, then overwriting values from the configuration used (if any), then further overwriting values from the overrides object passed to context.scheduleTarget() . For the Angular CLI, the overrides object is built from command line arguments.

Architect validates the resulting options values against the schema of the builder. If inputs are valid, Architect creates the context and executes the builder.

For more information see Workspace Configuration.

You can also invoke a builder directly from another builder or test by calling context.scheduleBuilder() . You pass an options object directly to the method, and those option values are validated against the schema of the builder without further adjustment.

Only the context.scheduleTarget() method resolves the configuration and overrides through the angular.json file.

Default architect configuration link

Let's create a simple angular.json file that puts target configurations into context.

You can publish the builder to npm (see Publishing your Library), and install it using the following command:

      
      npm install @example/copy-file
    

If you create a new project with ng new builder-test , the generated angular.json file looks something like this, with only default builder configurations.

angular.json
      
      {
  // 
  "projects": {
    // 
    "builder-test": {
      // 
      "architect": {
        // 
        "build": {
          "builder": "@angular-devkit/build-angular:browser",
          "options": {
            //  more options
            "outputPath": "dist/builder-test",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": "src/polyfills.ts",
            "tsConfig": "src/tsconfig.app.json"
          },
          "configurations": {
            "production": {
              //  more options
              "optimization": true,
              "aot": true,
              "buildOptimizer": true
            }
          }
        }
      }
    }
  }
  // 
}
    

Adding a target link

Add a new target that will run our builder to copy a file. This target tells the builder to copy the package.json file.

You need to update the angular.json file to add a target for this builder to the "architect" section of our new project.

  • We'll add a new target section to the "architect" object for our project

  • The target named "copy-package" uses our builder, which you published to @example/copy-file . (See Publishing your Library.)

  • The options object provides default values for the two inputs that you defined; source , which is the existing file you are copying, and destination , the path you want to copy to

  • The configurations key is optional, we'll leave it out for now

angular.json
      
      {
  "projects": {
    "builder-test": {
      "architect": {
        "copy-package": {
          "builder": "@example/copy-file:copy",
          "options": {
            "source": "package.json",
            "destination": "package-copy.json"
          }
        },
        "build": {
          "builder": "@angular-devkit/build-angular:browser",
          "options": {
            "outputPath": "dist/builder-test",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": "src/polyfills.ts",
            "tsConfig": "src/tsconfig.app.json"
          },
          "configurations": {
            "production": {
              "fileReplacements": [
                {
                  "replace": "src/environments/environment.ts",
                  "with": "src/environments/environment.prod.ts"
                }
              ],
              "optimization": true,
              "aot": true,
              "buildOptimizer": true
            }
          }
        }
      }
    }
  }
}
    

Running the builder link

To run our builder with the new target's default configuration, use the following CLI command.

      
      ng run builder-test:copy-package
    

This copies the package.json file to package-copy.json .

Use command-line arguments to override the configured defaults. For example, to run with a different destination value, use the following CLI command.

      
      ng run builder-test:copy-package --destination=package-other.json
    

This copies the file to package-other.json instead of package-copy.json . Because you did not override the source option, it will copy from the package.json file (the default value provided for the target).

Testing a builder link

Use integration testing for your builder, so that you can use the Architect scheduler to create a context, as in this example.

  • In the builder source directory, you have created a new test file my-builder.spec.ts . The code creates new instances of JsonSchemaRegistry (for schema validation), TestingArchitectHost (an in-memory implementation of ArchitectHost ), and Architect .

  • We've added a builders.json file next to the builder's package.json file, and modified the package file to point to it.

Here's an example of a test that runs the copy file builder. The test uses the builder to copy the package.json file and validates that the copied file's contents are the same as the source.

src/my-builder.spec.ts
      
      import { Architect } from '@angular-devkit/architect';
import { TestingArchitectHost } from '@angular-devkit/architect/testing';
import { schema } from '@angular-devkit/core';
import { promises as fs } from 'fs';

describe('Copy File Builder', () => {
  let architect: Architect;
  let architectHost: TestingArchitectHost;

  beforeEach(async () => {
    const registry = new schema.CoreSchemaRegistry();
    registry.addPostTransform(schema.transforms.addUndefinedDefaults);

    // TestingArchitectHost() takes workspace and current directories.
    // Since we don't use those, both are the same in this case.
    architectHost = new TestingArchitectHost(__dirname, __dirname);
    architect = new Architect(architectHost, registry);

    // This will either take a Node package name, or a path to the directory
    // for the package.json file.
    await architectHost.addBuilderFromPackage('..');
  });

  it('can copy files', async () => {
    // A "run" can have multiple outputs, and contains progress information.
    const run = await architect.scheduleBuilder('@example/copy-file:copy', {
      source: 'package.json',
      destination: 'package-copy.json',
    });

    // The "result" member (of type BuilderOutput) is the next output.
    const output = await run.result;

    // Stop the builder from running. This stops Architect from keeping
    // the builder-associated states in memory, since builders keep waiting
    // to be scheduled.
    await run.stop();

    // Expect that the copied file is the same as its source.
    const sourceContent = await fs.readFile('package.json', 'utf8');
    const destinationContent = await fs.readFile('package-copy.json', 'utf8');
    expect(destinationContent).toBe(sourceContent);
  });
});
    

When running this test in your repo, you need the ts-node package. You can avoid this by renaming my-builder.spec.ts to my-builder.spec.js .

Watch mode link

Architect expects builders to run once (by default) and return. This behavior is not entirely compatible with a builder that watches for changes (like Webpack, for example). Architect can support watch mode, but there are some things to look out for.

  • To be used with watch mode, a builder handler function should return an Observable. Architect subscribes to the Observable until it completes and might reuse it if the builder is scheduled again with the same arguments.

  • The builder should always emit a BuilderOutput object after each execution. Once it's been executed, it can enter a watch mode, to be triggered by an external event. If an event triggers it to restart, the builder should execute the context.reportRunning() function to tell Architect that it is running again. This prevents Architect from stopping the builder if another run is scheduled.

When your builder calls BuilderRun.stop() to exit watch mode, Architect unsubscribes from the builder's Observable and calls the builder's teardown logic to clean up. (This behavior also allows for long-running builds to be stopped and cleaned up.)

In general, if your builder is watching an external event, you should separate your run into three phases.

Phases Details
Running For example, webpack compiles. This ends when webpack finishes and your builder emits a BuilderOutput object.
Watching Between two runs, watch an external event stream. For example, webpack watches the file system for any changes. This ends when webpack restarts building, and context.reportRunning() is called. This goes back to step 1.
Completion Either the task is fully completed (for example, webpack was supposed to run a number of times), or the builder run was stopped (using BuilderRun.stop() ). Your teardown logic is executed, and Architect unsubscribes from your builder's Observable.

Summary link

The CLI Builder API provides a new way of changing the behavior of the Angular CLI by using builders to execute custom logic.

  • Builders can be synchronous or asynchronous, execute once or watch for external events, and can schedule other builders or targets

  • Builders have option defaults specified in the angular.json configuration file, which can be overwritten by an alternate configuration for the target, and further overwritten by command line flags

  • We recommend that you use integration tests to test Architect builders. Use unit tests to validate the logic that the builder executes.

  • If your builder returns an Observable, it should clean up in the teardown logic of that Observable

Last reviewed on Mon Feb 28 2022
Read article
Angular - Observables compared to other techniques

Observables compared to other techniques link

You can often use observables instead of promises to deliver values asynchronously. Similarly, observables can take the place of event handlers. Finally, because observables deliver multiple values, you can use them where you might otherwise build and operate on arrays.

Observables behave somewhat differently from the alternative techniques in each of these situations, but offer some significant advantages. Here are detailed comparisons of the differences.

Observables compared to promises link

Observables are often compared to promises. Here are some key differences:

  • Observables are declarative; computation does not start until subscription. Promises execute immediately on creation. This makes observables useful for defining recipes that can be run whenever you need the result.

  • Observables provide many values. Promises provide one. This makes observables useful for getting multiple values over time.

  • Observables differentiate between chaining and subscription. Promises only have .then() clauses. This makes observables useful for creating complex transformation recipes to be used by other part of the system, without causing the work to be executed.

  • Observables subscribe() is responsible for handling errors. Promises push errors to the child promises. This makes observables useful for centralized and predictable error handling.

Creation and subscription link

  • Observables are not executed until a consumer subscribes. The subscribe() executes the defined behavior once, and it can be called again. Each subscription has its own computation. Resubscription causes recomputation of values.

    src/observables.ts (observable)
          
          // declare a publishing operation
    const observable = new Observable<number>(observer => {
      // Subscriber fn...
    });
    
    // initiate execution
    observable.subscribe(value => {
      // observer handles notifications
    });
        
  • Promises execute immediately, and just once. The computation of the result is initiated when the promise is created. There is no way to restart work. All then clauses (subscriptions) share the same computation.

    src/promises.ts (promise)
          
          // initiate execution
    let promise = new Promise<number>(resolve => {
      // Executer fn...
    });
    promise.then(value => {
      // handle result here
    });
        

Chaining link

  • Observables differentiate between transformation function such as a map and subscription. Only subscription activates the subscriber function to start computing the values.

    src/observables.ts (chain)
          
          observable.pipe(map(v => 2 * v));
        
  • Promises do not differentiate between the last .then clauses (equivalent to subscription) and intermediate .then clauses (equivalent to map).

    src/promises.ts (chain)
          
          promise.then(v => 2 * v);
        

Cancellation link

  • Observable subscriptions are cancellable. Unsubscribing removes the listener from receiving further values, and notifies the subscriber function to cancel work.

    src/observables.ts (unsubscribe)
          
          const subscription = observable.subscribe(() => {
      // observer handles notifications
    });
    
    subscription.unsubscribe();
        
  • Promises are not cancellable.

Error handling link

  • Observable execution errors are delivered to the subscriber's error handler, and the subscriber automatically unsubscribes from the observable.

    src/observables.ts (error)
          
          observable.subscribe(() => {
      throw new Error('my error');
    });
        
  • Promises push errors to the child promises.

    src/promises.ts (error)
          
          promise.then(() => {
      throw new Error('my error');
    });
        

Cheat sheet link

The following code snippets illustrate how the same kind of operation is defined using observables and promises.

Operation Observable Promise
Creation
      
      new Observable((observer) => { 
  observer.next(123); 
});
    
      
      new Promise((resolve, reject) => { 
  resolve(123); 
});
    
Transform
      
      obs.pipe(map((value) => value * 2));
    
      
      promise.then((value) => value * 2);
    
Subscribe
      
      sub = obs.subscribe((value) => { 
  console.log(value) 
});
    
      
      promise.then((value) => { 
  console.log(value); 
});
    
Unsubscribe
      
      sub.unsubscribe();
    
Implied by promise resolution.

Observables compared to events API link

Observables are very similar to event handlers that use the events API. Both techniques define notification handlers, and use them to process multiple values delivered over time. Subscribing to an observable is equivalent to adding an event listener. One significant difference is that you can configure an observable to transform an event before passing the event to the handler.

Using observables to handle events and asynchronous operations can have the advantage of greater consistency in contexts such as HTTP requests.

Here are some code samples that illustrate how the same kind of operation is defined using observables and the events API.

Observable Events API
Creation & cancellation
      
      // Setup 
const clicks$ = fromEvent(buttonEl, 'click'); 
// Begin listening 
const subscription = clicks$ 
  .subscribe(e => console.log('Clicked', e)) 
// Stop listening 
subscription.unsubscribe();
    
      
      function handler(e) { 
  console.log('Clicked', e); 
} 
// Setup & begin listening 
button.addEventListener('click', handler); 
// Stop listening 
button.removeEventListener('click', handler);
    
Subscription
      
      observable.subscribe(() => { 
  // notification handlers here 
});
    
      
      element.addEventListener(eventName, (event) => { 
  // notification handler here 
});
    
Configuration Listen for keystrokes, but provide a stream representing the value in the input.
      
      fromEvent(inputEl, 'keydown').pipe( 
  map(e => e.target.value) 
);
    
Does not support configuration.
      
      element.addEventListener(eventName, (event) => { 
  // Cannot change the passed Event into another 
  // value before it gets to the handler 
});
    

Observables compared to arrays link

An observable produces values over time. An array is created as a static set of values. In a sense, observables are asynchronous where arrays are synchronous. In the following examples, implies asynchronous value delivery.

Values Observable Array
Given
      
      obs: 12357
    
      
      obsB: 'a''b''c'
    
      
      arr: [1, 2, 3, 5, 7]
    
      
      arrB: ['a', 'b', 'c']
    
concat()
      
      concat(obs, obsB)
    
      
      12357'a''b''c'
    
      
      arr.concat(arrB)
    
      
      [1,2,3,5,7,'a','b','c']
    
filter()
      
      obs.pipe(filter((v) => v>3))
    
      
      57
    
      
      arr.filter((v) => v>3)
    
      
      [5, 7]
    
find()
      
      obs.pipe(find((v) => v>3))
    
      
      5
    
      
      arr.find((v) => v>3)
    
      
      5
    
findIndex()
      
      obs.pipe(findIndex((v) => v>3))
    
      
      3
    
      
      arr.findIndex((v) => v>3)
    
      
      3
    
forEach()
      
      obs.pipe(tap((v) => { 
  console.log(v); 
})) 
1 
2 
3 
5 
7
    
      
      arr.forEach((v) => { 
  console.log(v); 
}) 
1 
2 
3 
5 
7
    
map()
      
      obs.pipe(map((v) => -v))
    
      
      →-1→-2→-3→-5→-7
    
      
      arr.map((v) => -v)
    
      
      [-1, -2, -3, -5, -7]
    
reduce()
      
      obs.pipe(reduce((s,v)=> s+v, 0))
    
      
      18
    
      
      arr.reduce((s,v) => s+v, 0)
    
      
      18
    
Last reviewed on Mon Feb 28 2022
Read article
Angular - Complex animation sequences

Complex animation sequences link

Prerequisites link

A basic understanding of the following concepts:

  • Introduction to Angular animations
  • Transition and triggers

So far, we've learned simple animations of single HTML elements. Angular also lets you animate coordinated sequences, such as an entire grid or list of elements as they enter and leave a page. You can choose to run multiple animations in parallel, or run discrete animations sequentially, one following another.

The functions that control complex animation sequences are:

Functions Details
query() Finds one or more inner HTML elements.
stagger() Applies a cascading delay to animations for multiple elements.
group() Runs multiple animation steps in parallel.
sequence() Runs animation steps one after another.

The query() function link

Most complex animations rely on the query() function to find child elements and apply animations to them, basic examples of such are:

Examples Details
query() followed by animate() Used to query simple HTML elements and directly apply animations to them.
query() followed by animateChild() Used to query child elements, which themselves have animations metadata applied to them and trigger such animation (which would be otherwise be blocked by the current/parent element's animation).

The first argument of query() is a css selector string which can also contain the following Angular-specific tokens:

Tokens Details
:enter
:leave
For entering/leaving elements.
:animating For elements currently animating.
@*
@triggerName
For elements with any—or a specific—trigger.
:self The animating element itself.
Entering and Leaving Elements

Not all child elements are actually considered as entering/leaving; this can, at times, be counterintuitive and confusing. Please see the query api docs for more information.

You can also see an illustration of this in the animations live example (introduced in the animations introduction section) under the Querying tab.

Animate multiple elements using query() and stagger() functions link

After having queried child elements via query() , the stagger() function lets you define a timing gap between each queried item that is animated and thus animates elements with a delay between them.

The following example demonstrates how to use the query() and stagger() functions to animate a list (of heroes) adding each in sequence, with a slight delay, from top to bottom.

  • Use query() to look for an element entering the page that meets certain criteria

  • For each of these elements, use style() to set the same initial style for the element. Make it transparent and use transform to move it out of position so that it can slide into place.

  • Use stagger() to delay each animation by 30 milliseconds

  • Animate each element on screen for 0.5 seconds using a custom-defined easing curve, simultaneously fading it in and un-transforming it

src/app/hero-list-page.component.ts
      
      animations: [
  trigger('pageAnimations', [
    transition(':enter', [
      query('.hero', [
        style({opacity: 0, transform: 'translateY(-100px)'}),
        stagger(30, [
          animate('500ms cubic-bezier(0.35, 0, 0.25, 1)',
          style({ opacity: 1, transform: 'none' }))
        ])
      ])
    ])
  ]),
    

Parallel animation using group() function link

You've seen how to add a delay between each successive animation. But you might also want to configure animations that happen in parallel. For example, you might want to animate two CSS properties of the same element but use a different easing function for each one. For this, you can use the animation group() function.

NOTE :
The group() function is used to group animation steps , rather than animated elements.

The following example uses group() s on both :enter and :leave for two different timing configurations, thus applying two independent animations to the same element in parallel.

src/app/hero-list-groups.component.ts (excerpt)
      
      animations: [
  trigger('flyInOut', [
    state('in', style({
      width: '*',
      transform: 'translateX(0)', opacity: 1
    })),
    transition(':enter', [
      style({ width: 10, transform: 'translateX(50px)', opacity: 0 }),
      group([
        animate('0.3s 0.1s ease', style({
          transform: 'translateX(0)',
          width: '*'
        })),
        animate('0.3s ease', style({
          opacity: 1
        }))
      ])
    ]),
    transition(':leave', [
      group([
        animate('0.3s ease', style({
          transform: 'translateX(50px)',
          width: 10
        })),
        animate('0.3s 0.2s ease', style({
          opacity: 0
        }))
      ])
    ])
  ])
]
    

Sequential vs. parallel animations link

Complex animations can have many things happening at once. But what if you want to create an animation involving several animations happening one after the other? Earlier you used group() to run multiple animations all at the same time, in parallel.

A second function called sequence() lets you run those same animations one after the other. Within sequence() , the animation steps consist of either style() or animate() function calls.

  • Use style() to apply the provided styling data immediately.
  • Use animate() to apply styling data over a given time interval.

Filter animation example link

Take a look at another animation on the live example page. Under the Filter/Stagger tab, enter some text into the Search Heroes text box, such as Magnet or tornado .

The filter works in real time as you type. Elements leave the page as you type each new letter and the filter gets progressively stricter. The heroes list gradually re-enters the page as you delete each letter in the filter box.

The HTML template contains a trigger called filterAnimation .

src/app/hero-list-page.component.html
      
      <label for="search">Search heroes: </label>
<input type="text" id="search" #criteria
       (input)="updateCriteria(criteria.value)"
       placeholder="Search heroes">

<ul class="heroes" [@filterAnimation]="heroesTotal">
  <li *ngFor="let hero of heroes" class="hero">
    <div class="inner">
      <span class="badge">{{ hero.id }}</span>
      <span class="name">{{ hero.name }}</span>
    </div>
  </li>
</ul>
    

The filterAnimation in the component's decorator contains three transitions.

src/app/hero-list-page.component.ts
      
      @Component({
  animations: [
    trigger('filterAnimation', [
      transition(':enter, * => 0, * => -1', []),
      transition(':increment', [
        query(':enter', [
          style({ opacity: 0, width: 0 }),
          stagger(50, [
            animate('300ms ease-out', style({ opacity: 1, width: '*' })),
          ]),
        ], { optional: true })
      ]),
      transition(':decrement', [
        query(':leave', [
          stagger(50, [
            animate('300ms ease-out', style({ opacity: 0, width: 0 })),
          ]),
        ])
      ]),
    ]),
  ]
})
export class HeroListPageComponent implements OnInit {
  heroesTotal = -1;

  get heroes() { return this._heroes; }
  private _heroes: Hero[] = [];

  ngOnInit() {
    this._heroes = HEROES;
  }

  updateCriteria(criteria: string) {
    criteria = criteria ? criteria.trim() : '';

    this._heroes = HEROES.filter(hero => hero.name.toLowerCase().includes(criteria.toLowerCase()));
    const newTotal = this.heroes.length;

    if (this.heroesTotal !== newTotal) {
      this.heroesTotal = newTotal;
    } else if (!criteria) {
      this.heroesTotal = -1;
    }
  }
}
    

The code in this example performs the following tasks:

  • Skips animations when the user first opens or navigates to this page (the filter animation narrows what is already there, so it only works on elements that already exist in the DOM)
  • Filters heroes based on the search input's value

For each change:

  • Hides an element leaving the DOM by setting its opacity and width to 0

  • Animates an element entering the DOM over 300 milliseconds. During the animation, the element assumes its default width and opacity.

  • If there are multiple elements entering or leaving the DOM, staggers each animation starting at the top of the page, with a 50-millisecond delay between each element

Animating the items of a reordering list link

Although Angular animates correctly *ngFor list items out of the box, it will not be able to do so if their ordering changes. This is because it will lose track of which element is which, resulting in broken animations. The only way to help Angular keep track of such elements is by assigning a TrackByFunction to the NgForOf directive. This makes sure that Angular always knows which element is which, thus allowing it to apply the correct animations to the correct elements all the time.

IMPORTANT :
If you need to animate the items of an *ngFor list and there is a possibility that the order of such items will change during runtime, always use a TrackByFunction .

Animations and Component View Encapsulation link

Angular animations are based on the components DOM structure and do not directly take View Encapsulation into account, this means that components using ViewEncapsulation.Emulated behave exactly as if they were using ViewEncapsulation.None ( ViewEncapsulation.ShadowDom behaves differently as we'll discuss shortly).

For example if the query() function (which you'll see more of in the rest of the Animations guide) were to be applied at the top of a tree of components using the emulated view encapsulation, such query would be able to identify (and thus animate) DOM elements on any depth of the tree.

On the other hand the ViewEncapsulation.ShadowDom changes the component's DOM structure by "hiding" DOM elements inside ShadowRoot elements. Such DOM manipulations do prevent some of the animations implementation to work properly since it relies on simple DOM structures and doesn't take ShadowRoot elements into account. Therefore it is advised to avoid applying animations to views incorporating components using the ShadowDom view encapsulation.

Animation sequence summary link

Angular functions for animating multiple elements start with query() to find inner elements; for example, gathering all images within a <div> . The remaining functions, stagger() , group() , and sequence() , apply cascades or let you control how multiple animation steps are applied.

More on Angular animations link

You might also be interested in the following:

  • Introduction to Angular animations
  • Transition and triggers
  • Reusable animations
  • Route transition animations
Last reviewed on Mon Feb 28 2022
Read article
Angular - Component interaction

Component interaction link

This cookbook contains recipes for common component communication scenarios in which two or more components share information.

See the live example / download example .

Pass data from parent to child with input binding link

HeroChildComponent has two input properties , typically adorned with @Input() decorator.

component-interaction/src/app/hero-child.component.ts
      
      import { Component, Input } from '@angular/core';

import { Hero } from './hero';

@Component({
  selector: 'app-hero-child',
  template: `
    <h3>{{hero.name}} says:</h3>
    <p>I, {{hero.name}}, am at your service, {{masterName}}.</p>
  `
})
export class HeroChildComponent {
  @Input() hero!: Hero;
  @Input('master') masterName = '';
}
    

The second @Input aliases the child component property name masterName as 'master' .

The HeroParentComponent nests the child HeroChildComponent inside an *ngFor repeater, binding its master string property to the child's master alias, and each iteration's hero instance to the child's hero property.

component-interaction/src/app/hero-parent.component.ts
      
      import { Component } from '@angular/core';

import { HEROES } from './hero';

@Component({
  selector: 'app-hero-parent',
  template: `
    <h2>{{master}} controls {{heroes.length}} heroes</h2>

    <app-hero-child
      *ngFor="let hero of heroes"
      [hero]="hero"
      [master]="master">
    </app-hero-child>
  `
})
export class HeroParentComponent {
  heroes = HEROES;
  master = 'Master';
}
    

The running application displays three heroes:

Test it for Pass data from parent to child with input binding link

E2E test that all children were instantiated and displayed as expected:

component-interaction/e2e/src/app.e2e-spec.ts
      
      // ...
const heroNames = ['Dr. IQ', 'Magneta', 'Bombasto'];
const masterName = 'Master';

it('should pass properties to children properly', async () => {
  const parent = element(by.tagName('app-hero-parent'));
  const heroes = parent.all(by.tagName('app-hero-child'));

  for (let i = 0; i < heroNames.length; i++) {
    const childTitle = await heroes.get(i).element(by.tagName('h3')).getText();
    const childDetail = await heroes.get(i).element(by.tagName('p')).getText();
    expect(childTitle).toEqual(heroNames[i] + ' says:');
    expect(childDetail).toContain(masterName);
  }
});
// ...
    

Back to top

Intercept input property changes with a setter link

Use an input property setter to intercept and act upon a value from the parent.

The setter of the name input property in the child NameChildComponent trims the whitespace from a name and replaces an empty value with default text.

component-interaction/src/app/name-child.component.ts
      
      import { Component, Input } from '@angular/core';

@Component({
  selector: 'app-name-child',
  template: '<h3>"{{name}}"</h3>'
})
export class NameChildComponent {
  @Input()
  get name(): string { return this._name; }
  set name(name: string) {
    this._name = (name && name.trim()) || '<no name set>';
  }
  private _name = '';
}
    

Here's the NameParentComponent demonstrating name variations including a name with all spaces:

component-interaction/src/app/name-parent.component.ts
      
      import { Component } from '@angular/core';

@Component({
  selector: 'app-name-parent',
  template: `
    <h2>Master controls {{names.length}} names</h2>

    <app-name-child *ngFor="let name of names" [name]="name"></app-name-child>
  `
})
export class NameParentComponent {
  // Displays 'Dr. IQ', '<no name set>', 'Bombasto'
  names = ['Dr. IQ', '   ', '  Bombasto  '];
}
    

Test it for Intercept input property changes with a setter link

E2E tests of input property setter with empty and non-empty names:

component-interaction/e2e/src/app.e2e-spec.ts
      
      // ...
it('should display trimmed, non-empty names', async () => {
  const nonEmptyNameIndex = 0;
  const nonEmptyName = '"Dr. IQ"';
  const parent = element(by.tagName('app-name-parent'));
  const hero = parent.all(by.tagName('app-name-child')).get(nonEmptyNameIndex);

  const displayName = await hero.element(by.tagName('h3')).getText();
  expect(displayName).toEqual(nonEmptyName);
});

it('should replace empty name with default name', async () => {
  const emptyNameIndex = 1;
  const defaultName = '"<no name set>"';
  const parent = element(by.tagName('app-name-parent'));
  const hero = parent.all(by.tagName('app-name-child')).get(emptyNameIndex);

  const displayName = await hero.element(by.tagName('h3')).getText();
  expect(displayName).toEqual(defaultName);
});
// ...
    

Back to top

Intercept input property changes with ngOnChanges() link

Detect and act upon changes to input property values with the ngOnChanges() method of the OnChanges lifecycle hook interface.

You might prefer this approach to the property setter when watching multiple, interacting input properties.

Learn about ngOnChanges() in the Lifecycle Hooks chapter.

This VersionChildComponent detects changes to the major and minor input properties and composes a log message reporting these changes:

component-interaction/src/app/version-child.component.ts
      
      import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';

@Component({
  selector: 'app-version-child',
  template: `
    <h3>Version {{major}}.{{minor}}</h3>
    <h4>Change log:</h4>
    <ul>
      <li *ngFor="let change of changeLog">{{change}}</li>
    </ul>
  `
})
export class VersionChildComponent implements OnChanges {
  @Input() major = 0;
  @Input() minor = 0;
  changeLog: string[] = [];

  ngOnChanges(changes: SimpleChanges) {
    const log: string[] = [];
    for (const propName in changes) {
      const changedProp = changes[propName];
      const to = JSON.stringify(changedProp.currentValue);
      if (changedProp.isFirstChange()) {
        log.push(`Initial value of ${propName} set to ${to}`);
      } else {
        const from = JSON.stringify(changedProp.previousValue);
        log.push(`${propName} changed from ${from} to ${to}`);
      }
    }
    this.changeLog.push(log.join(', '));
  }
}
    

The VersionParentComponent supplies the minor and major values and binds buttons to methods that change them.

component-interaction/src/app/version-parent.component.ts
      
      import { Component } from '@angular/core';

@Component({
  selector: 'app-version-parent',
  template: `
    <h2>Source code version</h2>
    <button type="button" (click)="newMinor()">New minor version</button>
    <button type="button" (click)="newMajor()">New major version</button>
    <app-version-child [major]="major" [minor]="minor"></app-version-child>
  `
})
export class VersionParentComponent {
  major = 1;
  minor = 23;

  newMinor() {
    this.minor++;
  }

  newMajor() {
    this.major++;
    this.minor = 0;
  }
}
    

Here's the output of a button-pushing sequence:

Test it for Intercept input property changes with ngOnChanges() link

Test that both input properties are set initially and that button clicks trigger the expected ngOnChanges calls and values:

component-interaction/e2e/src/app.e2e-spec.ts
      
      // ...
// Test must all execute in this exact order
it('should set expected initial values', async () => {
  const actual = await getActual();

  const initialLabel = 'Version 1.23';
  const initialLog = 'Initial value of major set to 1, Initial value of minor set to 23';

  expect(actual.label).toBe(initialLabel);
  expect(actual.count).toBe(1);
  expect(await actual.logs.get(0).getText()).toBe(initialLog);
});

it("should set expected values after clicking 'Minor' twice", async () => {
  const repoTag = element(by.tagName('app-version-parent'));
  const newMinorButton = repoTag.all(by.tagName('button')).get(0);

  await newMinorButton.click();
  await newMinorButton.click();

  const actual = await getActual();

  const labelAfter2Minor = 'Version 1.25';
  const logAfter2Minor = 'minor changed from 24 to 25';

  expect(actual.label).toBe(labelAfter2Minor);
  expect(actual.count).toBe(3);
  expect(await actual.logs.get(2).getText()).toBe(logAfter2Minor);
});

it("should set expected values after clicking 'Major' once", async () => {
  const repoTag = element(by.tagName('app-version-parent'));
  const newMajorButton = repoTag.all(by.tagName('button')).get(1);

  await newMajorButton.click();
  const actual = await getActual();

  const labelAfterMajor = 'Version 2.0';
  const logAfterMajor = 'major changed from 1 to 2, minor changed from 23 to 0';

  expect(actual.label).toBe(labelAfterMajor);
  expect(actual.count).toBe(2);
  expect(await actual.logs.get(1).getText()).toBe(logAfterMajor);
});

async function getActual() {
  const versionTag = element(by.tagName('app-version-child'));
  const label = await versionTag.element(by.tagName('h3')).getText();
  const ul = versionTag.element((by.tagName('ul')));
  const logs = ul.all(by.tagName('li'));

  return {
    label,
    logs,
    count: await logs.count(),
  };
}
// ...
    

Back to top

Parent listens for child event link

The child component exposes an EventEmitter property with which it emits events when something happens. The parent binds to that event property and reacts to those events.

The child's EventEmitter property is an output property , typically adorned with an @Output() decorator as seen in this VoterComponent :

component-interaction/src/app/voter.component.ts
      
      import { Component, EventEmitter, Input, Output } from '@angular/core';

@Component({
  selector: 'app-voter',
  template: `
    <h4>{{name}}</h4>
    <button type="button" (click)="vote(true)"  [disabled]="didVote">Agree</button>
    <button type="button" (click)="vote(false)" [disabled]="didVote">Disagree</button>
  `
})
export class VoterComponent {
  @Input()  name = '';
  @Output() voted = new EventEmitter<boolean>();
  didVote = false;

  vote(agreed: boolean) {
    this.voted.emit(agreed);
    this.didVote = true;
  }
}
    

Clicking a button triggers emission of a true or false , the boolean payload .

The parent VoteTakerComponent binds an event handler called onVoted() that responds to the child event payload $event and updates a counter.

component-interaction/src/app/votetaker.component.ts
      
      import { Component } from '@angular/core';

@Component({
  selector: 'app-vote-taker',
  template: `
    <h2>Should mankind colonize the Universe?</h2>
    <h3>Agree: {{agreed}}, Disagree: {{disagreed}}</h3>

    <app-voter
      *ngFor="let voter of voters"
      [name]="voter"
      (voted)="onVoted($event)">
    </app-voter>
  `
})
export class VoteTakerComponent {
  agreed = 0;
  disagreed = 0;
  voters = ['Dr. IQ', 'Celeritas', 'Bombasto'];

  onVoted(agreed: boolean) {
    if (agreed) {
      this.agreed++;
    } else {
      this.disagreed++;
    }
  }
}
    

The framework passes the event argument —represented by $event — to the handler method, and the method processes it:

Test it for Parent listens for child event link

Test that clicking the Agree and Disagree buttons update the appropriate counters:

component-interaction/e2e/src/app.e2e-spec.ts
      
      // ...
it('should not emit the event initially', async () => {
  const voteLabel = element(by.tagName('app-vote-taker')).element(by.tagName('h3'));
  expect(await voteLabel.getText()).toBe('Agree: 0, Disagree: 0');
});

it('should process Agree vote', async () => {
  const voteLabel = element(by.tagName('app-vote-taker')).element(by.tagName('h3'));
  const agreeButton1 = element.all(by.tagName('app-voter')).get(0)
    .all(by.tagName('button')).get(0);

  await agreeButton1.click();

  expect(await voteLabel.getText()).toBe('Agree: 1, Disagree: 0');
});

it('should process Disagree vote', async () => {
  const voteLabel = element(by.tagName('app-vote-taker')).element(by.tagName('h3'));
  const agreeButton1 = element.all(by.tagName('app-voter')).get(1)
    .all(by.tagName('button')).get(1);

  await agreeButton1.click();

  expect(await voteLabel.getText()).toBe('Agree: 0, Disagree: 1');
});
// ...
    

Back to top

Parent interacts with child using local variable link

A parent component cannot use data binding to read child properties or invoke child methods. Do both by creating a template reference variable for the child element and then reference that variable within the parent template as seen in the following example.

The following is a child CountdownTimerComponent that repeatedly counts down to zero and launches a rocket. The start and stop methods control the clock and a countdown status message displays in its own template.

component-interaction/src/app/countdown-timer.component.ts
      
      import { Component, OnDestroy } from '@angular/core';

@Component({
  selector: 'app-countdown-timer',
  template: '<p>{{message}}</p>'
})
export class CountdownTimerComponent implements OnDestroy {

  intervalId = 0;
  message = '';
  seconds = 11;

  ngOnDestroy() { this.clearTimer(); }

  start() { this.countDown(); }
  stop()  {
    this.clearTimer();
    this.message = `Holding at T-${this.seconds} seconds`;
  }

  private clearTimer() { clearInterval(this.intervalId); }

  private countDown() {
    this.clearTimer();
    this.intervalId = window.setInterval(() => {
      this.seconds -= 1;
      if (this.seconds === 0) {
        this.message = 'Blast off!';
      } else {
        if (this.seconds < 0) { this.seconds = 10; } // reset
        this.message = `T-${this.seconds} seconds and counting`;
      }
    }, 1000);
  }
}
    

The CountdownLocalVarParentComponent that hosts the timer component is as follows:

component-interaction/src/app/countdown-parent.component.ts
      
      import { Component } from '@angular/core';
import { CountdownTimerComponent } from './countdown-timer.component';

@Component({
  selector: 'app-countdown-parent-lv',
  template: `
    <h3>Countdown to Liftoff (via local variable)</h3>
    <button type="button" (click)="timer.start()">Start</button>
    <button type="button" (click)="timer.stop()">Stop</button>
    <div class="seconds">{{timer.seconds}}</div>
    <app-countdown-timer #timer></app-countdown-timer>
  `,
  styleUrls: ['../assets/demo.css']
})
export class CountdownLocalVarParentComponent { }
    

The parent component cannot data bind to the child's start and stop methods nor to its seconds property.

Place a local variable, #timer , on the tag <app-countdown-timer> representing the child component. That gives you a reference to the child component and the ability to access any of its properties or methods from within the parent template.

This example wires parent buttons to the child's start and stop and uses interpolation to display the child's seconds property.

Here, the parent and child are working together.

Test it for Parent interacts with child using local variable link

Test that the seconds displayed in the parent template match the seconds displayed in the child's status message. Test also that clicking the Stop button pauses the countdown timer:

component-interaction/e2e/src/app.e2e-spec.ts
      
      // ...
// The tests trigger periodic asynchronous operations (via `setInterval()`), which will prevent
// the app from stabilizing. See https://angular.io/api/core/ApplicationRef#is-stable-examples
// for more details.
// To allow the tests to complete, we will disable automatically waiting for the Angular app to
// stabilize.
beforeEach(() => browser.waitForAngularEnabled(false));
afterEach(() => browser.waitForAngularEnabled(true));

it('timer and parent seconds should match', async () => {
  const parent = element(by.tagName(parentTag));
  const startButton = parent.element(by.buttonText('Start'));
  const seconds = parent.element(by.className('seconds'));
  const timer = parent.element(by.tagName('app-countdown-timer'));

  await startButton.click();

  // Wait for `<app-countdown-timer>` to be populated with any text.
  await browser.wait(() => timer.getText(), 2000);

  expect(await timer.getText()).toContain(await seconds.getText());
});

it('should stop the countdown', async () => {
  const parent = element(by.tagName(parentTag));
  const startButton = parent.element(by.buttonText('Start'));
  const stopButton = parent.element(by.buttonText('Stop'));
  const timer = parent.element(by.tagName('app-countdown-timer'));

  await startButton.click();
  expect(await timer.getText()).not.toContain('Holding');

  await stopButton.click();
  expect(await timer.getText()).toContain('Holding');
});
// ...
    

Back to top

Parent calls an @ViewChild() link

The local variable approach is straightforward. But it is limited because the parent-child wiring must be done entirely within the parent template. The parent component itself has no access to the child.

You can't use the local variable technique if the parent component's class relies on the child component's class . The parent-child relationship of the components is not established within each component's respective class with the local variable technique. Because the class instances are not connected to one another, the parent class cannot access the child class properties and methods.

When the parent component class requires that kind of access, inject the child component into the parent as a ViewChild .

The following example illustrates this technique with the same Countdown Timer example. Neither its appearance nor its behavior changes. The child CountdownTimerComponent is the same as well.

The switch from the local variable to the ViewChild technique is solely for the purpose of demonstration.

Here is the parent, CountdownViewChildParentComponent :

component-interaction/src/app/countdown-parent.component.ts
      
      import { AfterViewInit, ViewChild } from '@angular/core';
import { Component } from '@angular/core';
import { CountdownTimerComponent } from './countdown-timer.component';

@Component({
  selector: 'app-countdown-parent-vc',
  template: `
    <h3>Countdown to Liftoff (via ViewChild)</h3>
    <button type="button" (click)="start()">Start</button>
    <button type="button" (click)="stop()">Stop</button>
    <div class="seconds">{{ seconds() }}</div>
    <app-countdown-timer></app-countdown-timer>
  `,
  styleUrls: ['../assets/demo.css']
})
export class CountdownViewChildParentComponent implements AfterViewInit {

  @ViewChild(CountdownTimerComponent)
  private timerComponent!: CountdownTimerComponent;

  seconds() { return 0; }

  ngAfterViewInit() {
    // Redefine `seconds()` to get from the `CountdownTimerComponent.seconds` ...
    // but wait a tick first to avoid one-time devMode
    // unidirectional-data-flow-violation error
    setTimeout(() => this.seconds = () => this.timerComponent.seconds, 0);
  }

  start() { this.timerComponent.start(); }
  stop() { this.timerComponent.stop(); }
}
    

It takes a bit more work to get the child view into the parent component class .

First, you have to import references to the ViewChild decorator and the AfterViewInit lifecycle hook.

Next, inject the child CountdownTimerComponent into the private timerComponent property using the @ViewChild property decoration.

The #timer local variable is gone from the component metadata. Instead, bind the buttons to the parent component's own start and stop methods and present the ticking seconds in an interpolation around the parent component's seconds method.

These methods access the injected timer component directly.

The ngAfterViewInit() lifecycle hook is an important wrinkle. The timer component isn't available until after Angular displays the parent view. So it displays 0 seconds initially.

Then Angular calls the ngAfterViewInit lifecycle hook at which time it is too late to update the parent view's display of the countdown seconds. Angular's unidirectional data flow rule prevents updating the parent view's in the same cycle. The application must wait one turn before it can display the seconds.

Use setTimeout() to wait one tick and then revise the seconds() method so that it takes future values from the timer component.

Test it for Parent calls an @ViewChild() link

Use the same countdown timer tests as before.

Back to top

Parent and children communicate using a service link

A parent component and its children share a service whose interface enables bidirectional communication within the family .

The scope of the service instance is the parent component and its children. Components outside this component subtree have no access to the service or their communications.

This MissionService connects the MissionControlComponent to multiple AstronautComponent children.

component-interaction/src/app/mission.service.ts
      
      import { Injectable } from '@angular/core';
import { Subject } from 'rxjs';

@Injectable()
export class MissionService {

  // Observable string sources
  private missionAnnouncedSource = new Subject<string>();
  private missionConfirmedSource = new Subject<string>();

  // Observable string streams
  missionAnnounced$ = this.missionAnnouncedSource.asObservable();
  missionConfirmed$ = this.missionConfirmedSource.asObservable();

  // Service message commands
  announceMission(mission: string) {
    this.missionAnnouncedSource.next(mission);
  }

  confirmMission(astronaut: string) {
    this.missionConfirmedSource.next(astronaut);
  }
}
    

The MissionControlComponent both provides the instance of the service that it shares with its children (through the providers metadata array) and injects that instance into itself through its constructor:

component-interaction/src/app/missioncontrol.component.ts
      
      import { Component } from '@angular/core';

import { MissionService } from './mission.service';

@Component({
  selector: 'app-mission-control',
  template: `
    <h2>Mission Control</h2>
    <button type="button" (click)="announce()">Announce mission</button>

    <app-astronaut
      *ngFor="let astronaut of astronauts"
      [astronaut]="astronaut">
    </app-astronaut>

    <h3>History</h3>
    <ul>
      <li *ngFor="let event of history">{{event}}</li>
    </ul>
  `,
  providers: [MissionService]
})
export class MissionControlComponent {
  astronauts = ['Lovell', 'Swigert', 'Haise'];
  history: string[] = [];
  missions = ['Fly to the moon!',
              'Fly to mars!',
              'Fly to Vegas!'];
  nextMission = 0;

  constructor(private missionService: MissionService) {
    missionService.missionConfirmed$.subscribe(
      astronaut => {
        this.history.push(`${astronaut} confirmed the mission`);
      });
  }

  announce() {
    const mission = this.missions[this.nextMission++];
    this.missionService.announceMission(mission);
    this.history.push(`Mission "${mission}" announced`);
    if (this.nextMission >= this.missions.length) { this.nextMission = 0; }
  }
}
    

The AstronautComponent also injects the service in its constructor. Each AstronautComponent is a child of the MissionControlComponent and therefore receives its parent's service instance:

component-interaction/src/app/astronaut.component.ts
      
      import { Component, Input, OnDestroy } from '@angular/core';

import { MissionService } from './mission.service';
import { Subscription } from 'rxjs';

@Component({
  selector: 'app-astronaut',
  template: `
    <p>
      {{astronaut}}: <strong>{{mission}}</strong>
      <button
        type="button"
        (click)="confirm()"
        [disabled]="!announced || confirmed">
        Confirm
      </button>
    </p>
  `
})
export class AstronautComponent implements OnDestroy {
  @Input() astronaut = '';
  mission = '<no mission announced>';
  confirmed = false;
  announced = false;
  subscription: Subscription;

  constructor(private missionService: MissionService) {
    this.subscription = missionService.missionAnnounced$.subscribe(
      mission => {
        this.mission = mission;
        this.announced = true;
        this.confirmed = false;
    });
  }

  confirm() {
    this.confirmed = true;
    this.missionService.confirmMission(this.astronaut);
  }

  ngOnDestroy() {
    // prevent memory leak when component destroyed
    this.subscription.unsubscribe();
  }
}
    

Notice that this example captures the subscription and unsubscribe() when the AstronautComponent is destroyed. This is a memory-leak guard step. There is no actual risk in this application because the lifetime of a AstronautComponent is the same as the lifetime of the application itself. That would not always be true in a more complex application.

You don't add this guard to the MissionControlComponent because, as the parent, it controls the lifetime of the MissionService .

The History log demonstrates that messages travel in both directions between the parent MissionControlComponent and the AstronautComponent children, facilitated by the service:

Test it for Parent and children communicate using a service link

Tests click buttons of both the parent MissionControlComponent and the AstronautComponent children and verify that the history meets expectations:

component-interaction/e2e/src/app.e2e-spec.ts
      
      // ...
it('should announce a mission', async () => {
  const missionControl = element(by.tagName('app-mission-control'));
  const announceButton = missionControl.all(by.tagName('button')).get(0);
  const history = missionControl.all(by.tagName('li'));

  await announceButton.click();

  expect(await history.count()).toBe(1);
  expect(await history.get(0).getText()).toMatch(/Mission.* announced/);
});

it('should confirm the mission by Lovell', async () => {
  await testConfirmMission(1, 'Lovell');
});

it('should confirm the mission by Haise', async () => {
  await testConfirmMission(3, 'Haise');
});

it('should confirm the mission by Swigert', async () => {
  await testConfirmMission(2, 'Swigert');
});

async function testConfirmMission(buttonIndex: number, astronaut: string) {
  const missionControl = element(by.tagName('app-mission-control'));
  const announceButton = missionControl.all(by.tagName('button')).get(0);
  const confirmButton = missionControl.all(by.tagName('button')).get(buttonIndex);
  const history = missionControl.all(by.tagName('li'));

  await announceButton.click();
  await confirmButton.click();

  expect(await history.count()).toBe(2);
  expect(await history.get(1).getText()).toBe(`${astronaut} confirmed the mission`);
}
// ...
    

Back to top

Last reviewed on Mon Feb 28 2022
Read article

Still Thinking?
Give us a try!

We embrace agility in everything we do.
Our onboarding process is both simple and meaningful.
We can't wait to welcome you on AiDOOS!