GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing angular.dev — Directive • Angular

API

@Directive({
  selector?: string | undefined;
  inputs?:
    | (
        | string
        | {
            name: string;
            alias?: string | undefined;
            required?: boolean | undefined;
            transform?: ((value: any) => any) | undefined;
          }
      )[]
    | undefined;
  outputs?: string[] | undefined;
  providers?: Provider[] | undefined;
  exportAs?: string | undefined;
  queries?: { [key: string]: any } | undefined;
  host?: { [key: string]: string } | undefined;
  jit?: true | undefined;
  standalone?: boolean | undefined;
  hostDirectives?:
    | (
        | Type<unknown>
        | {
            directive: Type<unknown>;
            inputs?: string[] | undefined;
            outputs?: string[] | undefined;
          }
      )[]
    | undefined;
})

The CSS selector that identifies this directive in a template and triggers instantiation of the directive.

Declare as one of the following:

element-name: Select by element name.
.class: Select by class name.
[attribute]: Select by attribute name.
[attribute=value]: Select by attribute name and value.
:not(sub_selector): Select only if the element does not match the sub_selector.
selector1, selector2: Select if either selector1 or selector2 matches.

Angular only allows directives to apply on CSS selectors that do not cross element boundaries.

For the following template HTML, a directive with an input[type=text] selector, would be instantiated only on the <input type="text"> element.

<form>
  <input type="text">
  <input type="radio">
<form>

Enumerates the set of data-bound input properties for a directive

Angular automatically updates input properties during change detection. The inputs property accepts either strings or object literals that configure the directive properties that should be exposed as inputs.

When an object literal is passed in, the name property indicates which property on the class the input should write to, while the alias determines the name under which the input will be available in template bindings. The required property indicates that the input is required which will trigger a compile-time error if it isn't passed in when the directive is used.

When a string is passed into the inputs array, it can have a format of 'name' or 'name: alias' where name is the property on the class that the directive should write to, while the alias determines the name under which the input will be available in template bindings. String-based input definitions are assumed to be optional.

Enumerates the set of event-bound output properties.

When an output property emits an event, an event handler attached to that event in the template is invoked.

The outputs property defines a set of directiveProperty to alias configuration:

directiveProperty specifies the component property that emits events.
alias specifies the DOM property the event handler is attached to.

Configures the injector of this directive or component with a token that maps to a provider of a dependency.

Defines the name that can be used in the template to assign this directive to a variable.

Configures the queries that will be injected into the directive.

Content queries are set before the ngAfterContentInit callback is called. View queries are set before the ngAfterViewInit callback is called.

Maps class properties to host element bindings for properties, attributes, and events, using a set of key-value pairs.

Angular automatically checks host property bindings during change detection. If a binding changes, Angular updates the directive's host element.

When the key is a property of the host element, the property value is propagated to the specified DOM property.

When the key is a static attribute in the DOM, the attribute value is propagated to the specified property in the host element.

For event handling:

The key is the DOM event that the directive listens to. The global target names that can be used to prefix an event name are document:, window: and body:.
The value is the statement to execute when the event occurs. If the statement evaluates to false, then preventDefault is applied on the DOM event. A handler method can refer to the $event local variable.

When present, this directive/component is ignored by the AOT compiler. It remains in distributed code, and the JIT compiler attempts to compile it at run time, in the browser. To ensure the correct behavior, the app must import @angular/compiler.

Set standalone to false if you want to import the directive into an NgModule.

Standalone directives that should be applied to the host whenever the directive is matched. By default, none of the inputs or outputs of the host directives will be available on the host, unless they are specified in the inputs or outputs properties.

You can additionally alias inputs and outputs by putting a colon and the alias after the original input or output name. For example, if a directive applied via hostDirectives defines an input named menuDisabled, you can alias this to disabled by adding 'menuDisabled: disabled' as an entry to inputs.

Description

Decorator that marks a class as an Angular directive. You can define your own directives to attach custom behavior to elements in the DOM.

The options provide configuration metadata that determines how the directive should be processed, instantiated and used at runtime.

Directive classes, like component classes, can implement life-cycle hooks to influence their configuration and behavior.

Usage Notes

To define a directive, mark the class with the decorator and provide metadata.

import {Directive} from '@angular/core';

@Directive({
  selector: 'my-directive',
})
export class MyDirective {
...
}

Declaring directives

By default, directives are marked as standalone, which makes them available to other components in your application.

@Directive({
  selector: 'my-directive',
})

Please make sure that directives marked as standalone are not already declared in an NgModule.

** Declaring a directive in an NgModule ** If you want to declare a directive in an ngModule, add the standalone: false flag to the Directive decorator metadata and add the directive to the declarations and exports fields of your ngModule.

@Directive({
  standalone: false,
  selector: 'my-directive',
})
class MyDirective {}

@NgModule({
  declarations: [MyDirective, SomeComponent],
  exports: [MyDirective], // making it available outside of this module
})
class SomeNgModule {}

When declaring a directive in an NgModule, please make sure that:

the directive is declared in exactly one NgModule.
the directive is not standalone.
you do not re-declare a directive imported from another module.
the directive is included into the exports field as well if you want this directive to be accessible for components outside of the NgModule.

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.