@angular/core 6.0.3 → 6.0.7

package/esm5/src/metadata/di.js

@@ -14,6 +14,7 @@ import { makeParamDecorator, makePropDecorator } from '../util/decorators';
  * All components that are referenced in the `useValue` value (either directly
  * or in a nested array or map) will be added to the `entryComponents` property.
  *
+ * @usageNotes
  * ### Example
  * The following example shows how the router can populate the `entryComponents`
  * field of an NgModule based on the router configuration which refers
@@ -46,39 +47,22 @@ export var ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryCom
 /**
  * Attribute decorator and metadata.
  *
- *
  * @Annotation
  */
 export var Attribute = makeParamDecorator('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });
 /**
  * Base class for query metadata.
  *
- * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for
- * more information.
- *
- *
- */
-var /**
- * Base class for query metadata.
- *
- * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for
- * more information.
- *
- *
+ * @see `ContentChildren`.
+ * @see `ContentChild`.
+ * @see `ViewChildren`.
+ * @see `ViewChild`.
  */
-Query = /** @class */ (function () {
+var Query = /** @class */ (function () {
     function Query() {
     }
     return Query;
 }());
-/**
- * Base class for query metadata.
- *
- * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for
- * more information.
- *
- *
- */
 export { Query };
 /**
  * ContentChildren decorator and metadata.
@@ -103,7 +87,6 @@ export var ContentChild = makePropDecorator('ContentChild', function (selector,
 /**
  * ViewChildren decorator and metadata.
  *
- *
  * @Annotation
  */
 export var ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {
@@ -113,11 +96,10 @@ export var ViewChildren = makePropDecorator('ViewChildren', function (selector,
 /**
  * ViewChild decorator and metadata.
  *
- *
  * @Annotation
  */
 export var ViewChild = makePropDecorator('ViewChild', function (selector, data) {
     return (tslib_1.__assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data));
 }, Query);
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/metadata/di.ts"],"names":[],"mappings":";;;;;;;;AAQA,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAC,kBAAkB,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCzE,MAAM,CAAC,IAAM,4BAA4B,GAAG,IAAI,cAAc,CAAM,2BAA2B,CAAC,CAAC;;;;;;;AA8DjG,MAAM,CAAC,IAAM,SAAS,GAClB,kBAAkB,CAAC,WAAW,EAAE,UAAC,aAAsB,IAAK,OAAA,CAAC,EAAC,aAAa,eAAA,EAAC,CAAC,EAAjB,CAAiB,CAAC,CAAC;;;;;;;;;AAuBnF;;;;;;;;AAAA;;;gBApIA;IAoI8B,CAAA;;;;;;;;;AAA9B,iBAA8B;;;;;;;AA2D9B,MAAM,CAAC,IAAM,eAAe,GAA6B,iBAAiB,CACtE,iBAAiB,EACjB,UAAC,QAAc,EAAE,IAAc;IAAd,qBAAA,EAAA,SAAc;IAC3B,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,IAAK,IAAI,EAAE;AAA3E,CAA2E,EAC/E,KAAK,CAAC,CAAC;;;;;;;AAyDX,MAAM,CAAC,IAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,EAAE,UAAC,QAAc,EAAE,IAAc;IAAd,qBAAA,EAAA,SAAc;IAC3B,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAAzE,CAAyE,EAC7F,KAAK,CAAC,CAAC;;;;;;;AAwDX,MAAM,CAAC,IAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,EAAE,UAAC,QAAc,EAAE,IAAc;IAAd,qBAAA,EAAA,SAAc;IAC3B,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAAzE,CAAyE,EAC7F,KAAK,CAAC,CAAC;;;;;;;AAsDX,MAAM,CAAC,IAAM,SAAS,GAAuB,iBAAiB,CAC1D,WAAW,EAAE,UAAC,QAAa,EAAE,IAAS;IACrB,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAAxE,CAAwE,EACzF,KAAK,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../di/injection_token';\nimport {Type} from '../type';\nimport {makeParamDecorator, makePropDecorator} from '../util/decorators';\n\n/**\n * This token can be used to create a virtual provider that will populate the\n * `entryComponents` fields of components and ng modules based on its `useValue`.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) will be added to the `entryComponents` property.\n *\n * ### Example\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on the router configuration which refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @experimental\n */\nexport const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken<any>('AnalyzeForEntryComponents');\n\n/**\n * Type of the Attribute decorator / constructor function.\n *\n *\n */\nexport interface AttributeDecorator {\n  /**\n   * Specifies that a constant attribute value should be injected.\n   *\n   * The directive can inject constant string literals of host element attributes.\n   *\n   * ### Example\n   *\n   * Suppose we have an `<input>` element and want to know its `type`.\n   *\n   * ```html\n   * <input type=\"text\">\n   * ```\n   *\n   * A decorator can inject string literal `text` like so:\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n   *\n   * ### Example as TypeScript Decorator\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeFactory'}\n   *\n   * ### Example as ES5 annotation\n   *\n   * ```\n   * var MyComponent = function(title) {\n   *   ...\n   * };\n   *\n   * MyComponent.annotations = [\n   *   new ng.Component({...})\n   * ]\n   * MyComponent.parameters = [\n   *   [new ng.Attribute('title')]\n   * ]\n   * ```\n   *\n   *\n   */\n  (name: string): any;\n  new (name: string): Attribute;\n}\n\n\n/**\n * Type of the Attribute metadata.\n */\nexport interface Attribute { attributeName?: string; }\n\n/**\n * Attribute decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Attribute: AttributeDecorator =\n    makeParamDecorator('Attribute', (attributeName?: string) => ({attributeName}));\n\n/**\n * Type of the Query metadata.\n *\n *\n */\nexport interface Query {\n  descendants: boolean;\n  first: boolean;\n  read: any;\n  isViewQuery: boolean;\n  selector: any;\n}\n\n/**\n * Base class for query metadata.\n *\n * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for\n * more information.\n *\n *\n */\nexport abstract class Query {}\n\n/**\n * Type of the ContentChildren decorator / constructor function.\n *\n * See {@link ContentChildren}.\n *\n *\n */\nexport interface ContentChildrenDecorator {\n  /**\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/contentChildren/content_children_howto.ts region='HowTo'}\n   *\n   * @description\n   * Configures a content query.\n   *\n   * You can use ContentChildren to get the {@link QueryList} of elements or directives from the\n   * content DOM. Any time a child element is added, removed, or moved, the query list will be\n   * updated,\n   * and the changes observable of the query list will emit a new value.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **descendants** - include only direct children or all descendants.\n   * * **read** - read a different token from the queried elements.\n   *\n   * Let's look at an example:\n   *\n   * {@example core/di/ts/contentChildren/content_children_example.ts region='Component'}\n   *\n   * **npm package**: `@angular/core`\n   *\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {descendants?: boolean, read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {descendants?: boolean, read?: any}): Query;\n}\n\n/**\n * Type of the ContentChildren metadata.\n *\n *\n * @Annotation\n */\nexport type ContentChildren = Query;\n\n/**\n * ContentChildren decorator and metadata.\n *\n *\n *  @Annotation\n */\nexport const ContentChildren: ContentChildrenDecorator = makePropDecorator(\n    'ContentChildren',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: false, isViewQuery: false, descendants: false, ...data}),\n    Query);\n\n/**\n * Type of the ContentChild decorator / constructor function.\n *\n *\n *\n */\nexport interface ContentChildDecorator {\n  /**\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}\n   *\n   * @description\n   * Configures a content query.\n   *\n   * You can use ContentChild to get the first element or the directive matching the selector from\n   * the content DOM. If the content DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **read** - read a different token from the queried element.\n   *\n   * Let's look at an example:\n   *\n   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}\n   *\n   * **npm package**: `@angular/core`\n   *\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {read?: any}): ContentChild;\n}\n\n/**\n * Type of the ContentChild metadata.\n *\n * See {@link ContentChild}.\n *\n *\n */\nexport type ContentChild = Query;\n\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const ContentChild: ContentChildDecorator = makePropDecorator(\n    'ContentChild', (selector?: any, data: any = {}) =>\n                        ({selector, first: true, isViewQuery: false, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChildren decorator / constructor function.\n *\n * See {@link ViewChildren}.\n *\n *\n */\nexport interface ViewChildrenDecorator {\n  /**\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}\n   *\n   * @description\n   * Configures a view query.\n   *\n   * You can use ViewChildren to get the {@link QueryList} of elements or directives from the\n   * view DOM. Any time a child element is added, removed, or moved, the query list will be updated,\n   * and the changes observable of the query list will emit a new value.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **read** - read a different token from the queried elements.\n   *\n   * Let's look at an example:\n   *\n   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}\n   *\n   * **npm package**: `@angular/core`\n   *\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {read?: any}): ViewChildren;\n}\n\n/**\n * Type of the ViewChildren metadata.\n *\n *\n */\nexport type ViewChildren = Query;\n\n/**\n * ViewChildren decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const ViewChildren: ViewChildrenDecorator = makePropDecorator(\n    'ViewChildren', (selector?: any, data: any = {}) =>\n                        ({selector, first: false, isViewQuery: true, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChild decorator / constructor function.\n *\n * See {@link ViewChild}\n *\n *\n */\nexport interface ViewChildDecorator {\n  /**\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChild/view_child_howto.ts region='HowTo'}\n   *\n   * @description\n   * Configures a view query.\n   *\n   * You can use ViewChild to get the first element or the directive matching the selector from the\n   * view DOM. If the view DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **read** - read a different token from the queried elements.\n   *\n   * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}\n   *\n   * **npm package**: `@angular/core`\n   *\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {read?: any}): ViewChild;\n}\n\n/**\n * Type of the ViewChild metadata.\n *\n *\n */\nexport type ViewChild = Query;\n\n/**\n * ViewChild decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const ViewChild: ViewChildDecorator = makePropDecorator(\n    'ViewChild', (selector: any, data: any) =>\n                     ({selector, first: true, isViewQuery: true, descendants: true, ...data}),\n    Query);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/metadata/di.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAC,kBAAkB,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,IAAM,4BAA4B,GAAG,IAAI,cAAc,CAAM,2BAA2B,CAAC,CAAC;AAyDjG;;;;GAIG;AACH,MAAM,CAAC,IAAM,SAAS,GAClB,kBAAkB,CAAC,WAAW,EAAE,UAAC,aAAsB,IAAK,OAAA,CAAC,EAAC,aAAa,eAAA,EAAC,CAAC,EAAjB,CAAiB,CAAC,CAAC;AAanF;;;;;;;GAOG;AACH;IAAA;IAA6B,CAAC;IAAD,YAAC;AAAD,CAAC,AAA9B,IAA8B;;AAmD9B;;;;;GAKG;AACH,MAAM,CAAC,IAAM,eAAe,GAA6B,iBAAiB,CACtE,iBAAiB,EACjB,UAAC,QAAc,EAAE,IAAc;IAAd,qBAAA,EAAA,SAAc;IAC3B,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,IAAK,IAAI,EAAE;AAA3E,CAA2E,EAC/E,KAAK,CAAC,CAAC;AA+CX;;;;;GAKG;AACH,MAAM,CAAC,IAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,EAAE,UAAC,QAAc,EAAE,IAAc;IAAd,qBAAA,EAAA,SAAc;IAC3B,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAAzE,CAAyE,EAC7F,KAAK,CAAC,CAAC;AA6CX;;;;GAIG;AACH,MAAM,CAAC,IAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,EAAE,UAAC,QAAc,EAAE,IAAc;IAAd,qBAAA,EAAA,SAAc;IAC3B,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAAzE,CAAyE,EAC7F,KAAK,CAAC,CAAC;AA4CX;;;;GAIG;AACH,MAAM,CAAC,IAAM,SAAS,GAAuB,iBAAiB,CAC1D,WAAW,EAAE,UAAC,QAAa,EAAE,IAAS;IACrB,OAAA,oBAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAAxE,CAAwE,EACzF,KAAK,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../di/injection_token';\nimport {Type} from '../type';\nimport {makeParamDecorator, makePropDecorator} from '../util/decorators';\n\n/**\n * This token can be used to create a virtual provider that will populate the\n * `entryComponents` fields of components and ng modules based on its `useValue`.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) will be added to the `entryComponents` property.\n *\n * @usageNotes\n * ### Example\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on the router configuration which refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @experimental\n */\nexport const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken<any>('AnalyzeForEntryComponents');\n\n/**\n * Type of the Attribute decorator / constructor function.\n *\n *\n */\nexport interface AttributeDecorator {\n  /**\n   * Specifies that a constant attribute value should be injected.\n   *\n   * The directive can inject constant string literals of host element attributes.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * Suppose we have an `<input>` element and want to know its `type`.\n   *\n   * ```html\n   * <input type=\"text\">\n   * ```\n   *\n   * A decorator can inject string literal `text` like so:\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n   *\n   * ### Example as TypeScript Decorator\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeFactory'}\n   *\n   * ### Example as ES5 annotation\n   *\n   * ```\n   * var MyComponent = function(title) {\n   *   ...\n   * };\n   *\n   * MyComponent.annotations = [\n   *   new ng.Component({...})\n   * ]\n   * MyComponent.parameters = [\n   *   [new ng.Attribute('title')]\n   * ]\n   * ```\n   *\n   *\n   */\n  (name: string): any;\n  new (name: string): Attribute;\n}\n\n\n/**\n * Type of the Attribute metadata.\n */\nexport interface Attribute { attributeName?: string; }\n\n/**\n * Attribute decorator and metadata.\n *\n * @Annotation\n */\nexport const Attribute: AttributeDecorator =\n    makeParamDecorator('Attribute', (attributeName?: string) => ({attributeName}));\n\n/**\n * Type of the Query metadata.\n */\nexport interface Query {\n  descendants: boolean;\n  first: boolean;\n  read: any;\n  isViewQuery: boolean;\n  selector: any;\n}\n\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n */\nexport abstract class Query {}\n\n/**\n * Type of the ContentChildren decorator / constructor function.\n *\n * @see `ContentChildren`.\n */\nexport interface ContentChildrenDecorator {\n  /**\n   * Configures a content query.\n   *\n   * You can use ContentChildren to get the `QueryList` of elements or directives from the\n   * content DOM. Any time a child element is added, removed, or moved, the query list will be\n   * updated, and the changes observable of the query list will emit a new value.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **descendants** - include only direct children or all descendants.\n   * * **read** - read a different token from the queried elements.\n   *\n   * @usageNotes\n   * ### Basic Example\n   *\n   * Here is a simple demonstration of how the `ContentChildren` decorator can be used.\n   *\n   * {@example core/di/ts/contentChildren/content_children_howto.ts region='HowTo'}\n   *\n   * ### Tab-pane Example\n   *\n   * Here is a slightly more realistic example that shows how `ContentChildren` decorators\n   * can be used to implement a tab pane component.\n   *\n   * {@example core/di/ts/contentChildren/content_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {descendants?: boolean, read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {descendants?: boolean, read?: any}): Query;\n}\n\n/**\n * Type of the ContentChildren metadata.\n *\n *\n * @Annotation\n */\nexport type ContentChildren = Query;\n\n/**\n * ContentChildren decorator and metadata.\n *\n *\n *  @Annotation\n */\nexport const ContentChildren: ContentChildrenDecorator = makePropDecorator(\n    'ContentChildren',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: false, isViewQuery: false, descendants: false, ...data}),\n    Query);\n\n/**\n * Type of the ContentChild decorator / constructor function.\n *\n *\n *\n */\nexport interface ContentChildDecorator {\n  /**\n   * Configures a content query.\n   *\n   * You can use ContentChild to get the first element or the directive matching the selector from\n   * the content DOM. If the content DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **read** - read a different token from the queried element.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {read?: any}): ContentChild;\n}\n\n/**\n * Type of the ContentChild metadata.\n *\n * @see `ContentChild`.\n *\n *\n */\nexport type ContentChild = Query;\n\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const ContentChild: ContentChildDecorator = makePropDecorator(\n    'ContentChild', (selector?: any, data: any = {}) =>\n                        ({selector, first: true, isViewQuery: false, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChildren decorator / constructor function.\n *\n * @see `ViewChildren`.\n *\n *\n */\nexport interface ViewChildrenDecorator {\n  /**\n   * Configures a view query.\n   *\n   * You can use ViewChildren to get the `QueryList` of elements or directives from the\n   * view DOM. Any time a child element is added, removed, or moved, the query list will be updated,\n   * and the changes observable of the query list will emit a new value.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **read** - read a different token from the queried elements.\n   *\n   * @usageNotes\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {read?: any}): ViewChildren;\n}\n\n/**\n * Type of the ViewChildren metadata.\n */\nexport type ViewChildren = Query;\n\n/**\n * ViewChildren decorator and metadata.\n *\n * @Annotation\n */\nexport const ViewChildren: ViewChildrenDecorator = makePropDecorator(\n    'ViewChildren', (selector?: any, data: any = {}) =>\n                        ({selector, first: false, isViewQuery: true, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChild decorator / constructor function.\n *\n * @see `ViewChild`.\n */\nexport interface ViewChildDecorator {\n  /**\n   * @description\n   * Configures a view query.\n   *\n   * You can use ViewChild to get the first element or the directive matching the selector from the\n   * view DOM. If the view DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - the directive type or the name used for querying.\n   * * **read** - read a different token from the queried elements.\n   *\n   * @usageNotes\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/viewChild/view_child_howto.ts region='HowTo'}\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|Function|string, opts?: {read?: any}): any;\n  new (selector: Type<any>|Function|string, opts?: {read?: any}): ViewChild;\n}\n\n/**\n * Type of the ViewChild metadata.\n */\nexport type ViewChild = Query;\n\n/**\n * ViewChild decorator and metadata.\n *\n * @Annotation\n */\nexport const ViewChild: ViewChildDecorator = makePropDecorator(\n    'ViewChild', (selector: any, data: any) =>\n                     ({selector, first: true, isViewQuery: true, descendants: true, ...data}),\n    Query);\n"]}

package/esm5/src/metadata/directives.js

@@ -9,10 +9,7 @@ import * as tslib_1 from "tslib";
 import { ChangeDetectionStrategy } from '../change_detection/constants';
 import { makeDecorator, makePropDecorator } from '../util/decorators';
 /**
- * Directive decorator and metadata.
- *
- *
- * @Annotation
+ * Type of the Component metadata.
  */
 export var Directive = makeDecorator('Directive', function (dir) {
     if (dir === void 0) { dir = {}; }
@@ -21,6 +18,88 @@ export var Directive = makeDecorator('Directive', function (dir) {
 /**
  * Component decorator and metadata.
  *
+ * @usageNotes
+ *
+ * ### Using animations
+ *
+ * The following snippet shows an animation trigger in a component's
+ * metadata. The trigger is attached to an element in the component's
+ * template, using "@_trigger_name_", and a state expression that is evaluated
+ * at run time to determine whether the animation should start.
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'animation-cmp',
+ *   templateUrl: 'animation-cmp.html',
+ *   animations: [
+ *     trigger('myTriggerName', [
+ *       state('on', style({ opacity: 1 }),
+ *       state('off', style({ opacity: 0 }),
+ *       transition('on => off', [
+ *         animate("1s")
+ *       ])
+ *     ])
+ *   ]
+ * })
+ * ```
+ *
+ * ```html
+ * <!-- animation-cmp.html -->
+ * <div @myTriggerName="expression">...</div>
+ * ```
+ *
+ * ### Preserving whitespace
+ *
+ * Removing whitespace can greatly reduce AOT-generated code size, and speed up view creation.
+ * As of Angular 6, default for `preserveWhitespaces` is false (whitespace is removed).
+ * To change the default setting for all components in your application, set
+ * the `preserveWhitespaces` option of the AOT compiler.
+ *
+ * Current implementation removes whitespace characters as follows:
+ * - Trims all whitespaces at the beginning and the end of a template.
+ * - Removes whitespace-only text nodes. For example,
+ * `<button>Action 1</button>  <button>Action 2</button>` becomes
+ * `<button>Action 1</button><button>Action 2</button>`.
+ * - Replaces a series of whitespace characters in text nodes with a single space.
+ * For example, `<span>\n some text\n</span>` becomes `<span> some text </span>`.
+ * - Does NOT alter text nodes inside HTML tags such as `<pre>` or `<textarea>`,
+ * where whitespace characters are significant.
+ *
+ * Note that these transformations can influence DOM nodes layout, although impact
+ * should be minimal.
+ *
+ * You can override the default behavior to preserve whitespace characters
+ * in certain fragments of a template. For example, you can exclude an entire
+ * DOM sub-tree by using the `ngPreserveWhitespaces` attribute:
+ *
+ * ```html
+ * <div ngPreserveWhitespaces>
+ *     whitespaces are preserved here
+ *     <span>    and here </span>
+ * </div>
+ * ```
+ *
+ * You can force a single space to be preserved in a text node by using `&ngsp;`,
+ * which is replaced with a space character by Angular's template
+ * compiler:
+ *
+ * ```html
+ * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>
+ * <!-->compiled to be equivalent to:</>
+ *  <a>Spaces</a> <a>between</a> <a>links.</a>
+ * ```
+ *
+ * Note that sequences of `&ngsp;` are still collapsed to just one space character when
+ * the `preserveWhitespaces` option is set to `false`.
+ *
+ * ```html
+ * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>
+ * <!-->compiled to be equivalent to:</>
+ *  <a>Spaces</a> <a>between</a> <a>links.</a>
+ * ```
+ *
+ * To preserve sequences of whitespace characters, use the
+ * `ngPreserveWhitespaces` attribute.
  *
  * @Annotation
  */
@@ -29,45 +108,57 @@ export var Component = makeDecorator('Component', function (c) {
     return (tslib_1.__assign({ changeDetection: ChangeDetectionStrategy.Default }, c));
 }, Directive);
 /**
- * Pipe decorator and metadata.
- *
- * Use the `@Pipe` annotation to declare that a given class is a pipe. A pipe
- * class must also implement {@link PipeTransform} interface.
- *
- * To use the pipe include a reference to the pipe class in
- * {@link NgModule#declarations}.
  *
  *
  * @Annotation
  */
 export var Pipe = makeDecorator('Pipe', function (p) { return (tslib_1.__assign({ pure: true }, p)); });
 /**
- * Input decorator and metadata.
- *
  *
  * @Annotation
  */
 export var Input = makePropDecorator('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });
 /**
- * Output decorator and metadata.
- *
  *
  * @Annotation
  */
 export var Output = makePropDecorator('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });
 /**
- * HostBinding decorator and metadata.
- *
  *
  * @Annotation
  */
 export var HostBinding = makePropDecorator('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); });
 /**
- * HostListener decorator and metadata.
- *
+ * Binds a CSS event to a host listener and supplies configuration metadata.
+ * Angular invokes the supplied handler method when the host element emits the specified event,
+ * and updates the bound element with the result.
+ * If the handler method returns false, applies `preventDefault` on the bound element.
+ *
+ * @usageNotes
+ *
+ * The following example declares a directive
+ * that attaches a click listener to a button and counts clicks.
+ *
+ * ```
+ * @Directive({selector: 'button[counting]'})
+ * class CountClicks {
+ *   numberOfClicks = 0;
+ *
+ *   @HostListener('click', ['$event.target'])
+ *   onClick(btn) {
+ *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);
+ *  }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: '<button counting>Increment</button>',
+ * })
+ * class App {}
+ * ```
  *
  * @Annotation
  */
 export var HostListener = makePropDecorator('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); });
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directives.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/metadata/directives.ts"],"names":[],"mappings":";;;;;;;;AAQA,OAAO,EAAC,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAgB,aAAa,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;;;;;;;AAuYnF,MAAM,CAAC,IAAM,SAAS,GAClB,aAAa,CAAC,WAAW,EAAE,UAAC,GAAmB;IAAnB,oBAAA,EAAA,QAAmB;IAAK,OAAA,GAAG;AAAH,CAAG,CAAC,CAAC;;;;;;;AA+V7D,MAAM,CAAC,IAAM,SAAS,GAAuB,aAAa,CACtD,WAAW,EAAE,UAAC,CAAiB;IAAjB,kBAAA,EAAA,MAAiB;IAAK,OAAA,oBAAE,eAAe,EAAE,uBAAuB,CAAC,OAAO,IAAK,CAAC,EAAE;AAA1D,CAA0D,EAC9F,SAAS,CAAC,CAAC;;;;;;;;;;;;;AA8Df,MAAM,CAAC,IAAM,IAAI,GAAkB,aAAa,CAAC,MAAM,EAAE,UAAC,CAAO,IAAK,OAAA,oBAAE,IAAI,EAAE,IAAI,IAAK,CAAC,EAAE,EAApB,CAAoB,CAAC,CAAC;;;;;;;AAuE5F,MAAM,CAAC,IAAM,KAAK,GACd,iBAAiB,CAAC,OAAO,EAAE,UAAC,mBAA4B,IAAK,OAAA,CAAC,EAAC,mBAAmB,qBAAA,EAAC,CAAC,EAAvB,CAAuB,CAAC,CAAC;;;;;;;AAiE1F,MAAM,CAAC,IAAM,MAAM,GACf,iBAAiB,CAAC,QAAQ,EAAE,UAAC,mBAA4B,IAAK,OAAA,CAAC,EAAC,mBAAmB,qBAAA,EAAC,CAAC,EAAvB,CAAuB,CAAC,CAAC;;;;;;;AA2D3F,MAAM,CAAC,IAAM,WAAW,GACpB,iBAAiB,CAAC,aAAa,EAAE,UAAC,gBAAyB,IAAK,OAAA,CAAC,EAAC,gBAAgB,kBAAA,EAAC,CAAC,EAApB,CAAoB,CAAC,CAAC;;;;;;;AA6D1F,MAAM,CAAC,IAAM,YAAY,GACrB,iBAAiB,CAAC,cAAc,EAAE,UAAC,SAAkB,EAAE,IAAe,IAAK,OAAA,CAAC,EAAC,SAAS,WAAA,EAAE,IAAI,MAAA,EAAC,CAAC,EAAnB,CAAmB,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ChangeDetectionStrategy} from '../change_detection/constants';\nimport {Provider} from '../di';\nimport {Type} from '../type';\nimport {TypeDecorator, makeDecorator, makePropDecorator} from '../util/decorators';\n\nimport {ViewEncapsulation} from './view';\n\n\n/**\n * Type of the Directive decorator / constructor function.\n *\n *\n */\nexport interface DirectiveDecorator {\n  /**\n   * @usageNotes\n   *\n   * ```\n   * import {Directive} from '@angular/core';\n   *\n   * @Directive({\n   *   selector: 'my-directive',\n   * })\n   * export class MyDirective {\n   * }\n   * ```\n   *\n   * @description\n   *\n   * Marks a class as an Angular directive and collects directive configuration\n   * metadata.\n   *\n   * Directive decorator allows you to mark a class as an Angular directive and provide additional\n   * metadata that determines how the directive should be processed, instantiated and used at\n   * runtime.\n   *\n   * Directives allow you to attach behavior to elements in the DOM..\n   *\n   * A directive must belong to an NgModule in order for it to be usable\n   * by another directive, component, or application. To specify that a directive is a member of an\n   * NgModule,\n   * you should list it in the `declarations` field of that NgModule.\n   *\n   * In addition to the metadata configuration specified via the Directive decorator,\n   * directives can control their runtime behavior by implementing various Life-Cycle hooks.\n   *\n   * **Metadata Properties:**\n   *\n   * * **exportAs** - name under which the component instance is exported in a template. Can be\n   * given a single name or a comma-delimited list of names.\n   * * **host** - map of class property to host element bindings for events, properties and\n   * attributes\n   * * **inputs** - list of class property names to data-bind as component inputs\n   * * **outputs** - list of class property names that expose output events that others can\n   * subscribe to\n   * * **providers** - list of providers available to this component and its children\n   * * **queries** -  configure queries that can be injected into the component\n   * * **selector** - css selector that identifies this component in a template\n   *\n   *\n   * @Annotation\n   */\n  (obj: Directive): TypeDecorator;\n\n  /**\n   * See the {@link Directive} decorator.\n   */\n  new (obj: Directive): Directive;\n}\n\nexport interface Directive {\n  /**\n   * The CSS selector that triggers the instantiation of a directive.\n   *\n   * Angular only allows directives to trigger on CSS selectors that do not cross element\n   * boundaries.\n   *\n   * `selector` may be declared as one of the following:\n   *\n   * - `element-name`: select by element name.\n   * - `.class`: select by class name.\n   * - `[attribute]`: select by attribute name.\n   * - `[attribute=value]`: select by attribute name and value.\n   * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.\n   * - `selector1, selector2`: select if either `selector1` or `selector2` matches.\n   *\n   *\n   * ### Example\n   *\n   * Suppose we have a directive with an `input[type=text]` selector.\n   *\n   * And the following HTML:\n   *\n   * ```html\n   * <form>\n   *   <input type=\"text\">\n   *   <input type=\"radio\">\n   * <form>\n   * ```\n   *\n   * The directive would only be instantiated on the `<input type=\"text\">` element.\n   *\n   */\n  selector?: string;\n\n  /**\n   * Enumerates the set of data-bound input properties for a directive\n   *\n   * Angular automatically updates input properties during change detection.\n   *\n   * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property where the value is written.\n   * - `bindingProperty` specifies the DOM property where the value is read from.\n   *\n   * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/ivhfXY?p=preview))\n   *\n   * The following example creates a component with two data-bound properties.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   inputs: ['bankName', 'id: account-id'],\n   *   template: `\n   *     Bank Name: {{bankName}}\n   *     Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   bankName: string;\n   *   id: string;\n   *\n   *   // this property is not bound, and won't be automatically updated by Angular\n   *   normalizedBankName: string;\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <bank-account bankName=\"RBC\" account-id=\"4747\"></bank-account>\n   *   `\n   * })\n   * class App {}\n   * ```\n   *\n   */\n  inputs?: string[];\n\n  /**\n   * Enumerates the set of event-bound output properties.\n   *\n   * When an output property emits an event, an event handler attached to that event\n   * the template is invoked.\n   *\n   * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property that emits events.\n   * - `bindingProperty` specifies the DOM property the event handler is attached to.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/d5CNq7?p=preview))\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'interval-dir',\n   *   outputs: ['everySecond', 'five5Secs: everyFiveSeconds']\n   * })\n   * class IntervalDir {\n   *   everySecond = new EventEmitter();\n   *   five5Secs = new EventEmitter();\n   *\n   *   constructor() {\n   *     setInterval(() => this.everySecond.emit(\"event\"), 1000);\n   *     setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n   *     </interval-dir>\n   *   `\n   * })\n   * class App {\n   *   everySecond() { console.log('second'); }\n   *   everyFiveSeconds() { console.log('five seconds'); }\n   * }\n   * ```\n   *\n   */\n  outputs?: string[];\n\n  /**\n   * Specify the events, actions, properties and attributes related to the host element.\n   *\n   * ## Host Listeners\n   *\n   * Specifies which DOM events a directive listens to via a set of `(event)` to `method`\n   * key-value pairs:\n   *\n   * - `event`: the DOM event that the directive listens to.\n   * - `statement`: the statement to execute when the event occurs.\n   * If the evaluation of the statement returns `false`, then `preventDefault`is applied on the DOM\n   * event.\n   *\n   * To listen to global events, a target must be added to the event name.\n   * The target can be `window`, `document` or `body`.\n   *\n   * When writing a directive event binding, you can also refer to the $event local variable.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/DlA5KU?p=preview))\n   *\n   * The following example declares a directive that attaches a click listener to the button and\n   * counts clicks.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'button[counting]',\n   *   host: {\n   *     '(click)': 'onClick($event.target)'\n   *   }\n   * })\n   * class CountClicks {\n   *   numberOfClicks = 0;\n   *\n   *   onClick(btn) {\n   *     console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<button counting>Increment</button>`\n   * })\n   * class App {}\n   * ```\n   *\n   * ## Host Property Bindings\n   *\n   * Specifies which DOM properties a directive updates.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, it will update the host element of the directive.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/gNg0ED?p=preview))\n   *\n   * The following example creates a directive that sets the `valid` and `invalid` classes\n   * on the DOM element that has ngModel directive on it.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[ngModel]',\n   *   host: {\n   *     '[class.valid]': 'valid',\n   *     '[class.invalid]': 'invalid'\n   *   }\n   * })\n   * class NgModelStatus {\n   *   constructor(public control:NgModel) {}\n   *   get valid { return this.control.valid; }\n   *   get invalid { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   *\n   * ## Attributes\n   *\n   * Specifies static attributes that should be propagated to a host element.\n   *\n   * ### Example\n   *\n   * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element\n   * (here: `<div>` ) will ensure that this element will get the \"button\" role.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[my-button]',\n   *   host: {\n   *     'role': 'button'\n   *   }\n   * })\n   * class MyButton {\n   * }\n   * ```\n   */\n  host?: {[key: string]: string};\n\n  /**\n   * Defines the set of injectable objects that are visible to a Directive and its light DOM\n   * children.\n   *\n   * ## Simple Example\n   *\n   * Here is an example of a class that can be injected:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'greet',\n   *   providers: [\n   *     Greeter\n   *   ]\n   * })\n   * class HelloWorld {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   * ```\n   */\n  providers?: Provider[];\n\n  /**\n   * Defines the name that can be used in the template to assign this directive to a variable.\n   *\n   * ## Simple Example\n   *\n   * ```\n   * @Directive({\n   *   selector: 'child-dir',\n   *   exportAs: 'child'\n   * })\n   * class ChildDir {\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `<child-dir #c=\"child\"></child-dir>`\n   * })\n   * class MainComponent {\n   * }\n   *\n   * ```\n   */\n  exportAs?: string;\n\n  /**\n   * Configures the queries that will be injected into the directive.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * ### Example\n   *\n   * ```\n   * @Component({\n   *   selector: 'someDir',\n   *   queries: {\n   *     contentChildren: new ContentChildren(ChildDirective),\n   *     viewChildren: new ViewChildren(ChildDirective)\n   *   },\n   *   template: '<child-directive></child-directive>'\n   * })\n   * class SomeDir {\n   *   contentChildren: QueryList<ChildDirective>,\n   *   viewChildren: QueryList<ChildDirective>\n   *\n   *   ngAfterContentInit() {\n   *     // contentChildren is set\n   *   }\n   *\n   *   ngAfterViewInit() {\n   *     // viewChildren is set\n   *   }\n   * }\n   * ```\n   */\n  queries?: {[key: string]: any};\n}\n\n/**\n * Directive decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Directive: DirectiveDecorator =\n    makeDecorator('Directive', (dir: Directive = {}) => dir);\n\n/**\n * Type of the Component decorator / constructor function.\n *\n *\n */\nexport interface ComponentDecorator {\n  /**\n   * @usageNotes\n   *\n   * {@example core/ts/metadata/metadata.ts region='component'}\n   *\n   * @description\n   * Marks a class as an Angular component and collects component configuration\n   * metadata.\n   *\n   * Component decorator allows you to mark a class as an Angular component and provide additional\n   * metadata that determines how the component should be processed, instantiated and used at\n   * runtime.\n   *\n   * Components are the most basic building block of an UI in an Angular application.\n   * An Angular application is a tree of Angular components.\n   * Angular components are a subset of directives. Unlike directives, components always have\n   * a template and only one component can be instantiated per an element in a template.\n   *\n   * A component must belong to an NgModule in order for it to be usable\n   * by another component or application. To specify that a component is a member of an NgModule,\n   * you should list it in the `declarations` field of that NgModule.\n   *\n   * In addition to the metadata configuration specified via the Component decorator,\n   * components can control their runtime behavior by implementing various Life-Cycle hooks.\n   *\n   * **Metadata Properties:**\n   *\n   * * **animations** - list of animations of this component\n   * * **changeDetection** - change detection strategy used by this component\n   * * **encapsulation** - style encapsulation strategy used by this component\n   * * **entryComponents** - list of components that are dynamically inserted into the view of this\n   *   component\n   * * **exportAs** - name under which the component instance is exported in a template\n   * * **host** - map of class property to host element bindings for events, properties and\n   *   attributes\n   * * **inputs** - list of class property names to data-bind as component inputs\n   * * **interpolation** - custom interpolation markers used in this component's template\n   * * **moduleId** - ES/CommonJS module id of the file in which this component is defined\n   * * **outputs** - list of class property names that expose output events that others can\n   *   subscribe to\n   * * **providers** - list of providers available to this component and its children\n   * * **queries** -  configure queries that can be injected into the component\n   * * **selector** - css selector that identifies this component in a template\n   * * **styleUrls** - list of urls to stylesheets to be applied to this component's view\n   * * **styles** - inline-defined styles to be applied to this component's view\n   * * **template** - inline-defined template for the view\n   * * **templateUrl** - url to an external file containing a template for the view\n   * * **viewProviders** - list of providers available to this component and its view children\n   *\n   * ### Example\n   *\n   * {@example core/ts/metadata/metadata.ts region='component'}\n   *\n   *\n   * @Annotation\n   */\n  (obj: Component): TypeDecorator;\n  /**\n   * See the {@link Component} decorator.\n   */\n  new (obj: Component): Component;\n}\n\n/**\n * Type of the Component metadata.\n *\n *\n */\nexport interface Component extends Directive {\n  /**\n   * Defines the used change detection strategy.\n   *\n   * When a component is instantiated, Angular creates a change detector, which is responsible for\n   * propagating the component's bindings.\n   *\n   * The `changeDetection` property defines, whether the change detection will be checked every time\n   * or only when the component tells it to do so.\n   */\n  changeDetection?: ChangeDetectionStrategy;\n\n  /**\n   * Defines the set of injectable objects that are visible to its view DOM children.\n   *\n   * ## Simple Example\n   *\n   * Here is an example of a class that can be injected:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'needs-greeter'\n   * })\n   * class NeedsGreeter {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'greet',\n   *   viewProviders: [\n   *     Greeter\n   *   ],\n   *   template: `<needs-greeter></needs-greeter>`\n   * })\n   * class HelloWorld {\n   * }\n   *\n   * ```\n   */\n  viewProviders?: Provider[];\n\n  /**\n   * The module id of the module that contains the component.\n   * Needed to be able to resolve relative urls for templates and styles.\n   * In CommonJS, this can always be set to `module.id`, similarly SystemJS exposes `__moduleName`\n   * variable within each module.\n   *\n   *\n   * ## Simple Example\n   *\n   * ```\n   * @Directive({\n   *   selector: 'someDir',\n   *   moduleId: module.id\n   * })\n   * class SomeDir {\n   * }\n   *\n   * ```\n   */\n  moduleId?: string;\n\n  /**\n   * Specifies a template URL for an Angular component.\n   *\n   *Only one of `templateUrl` or `template` can be defined per View.\n   */\n  templateUrl?: string;\n\n  /**\n   * Specifies an inline template for an Angular component.\n   *\n   * Only one of `templateUrl` or `template` can be defined per Component.\n   */\n  template?: string;\n\n  /**\n   * Specifies stylesheet URLs for an Angular component.\n   */\n  styleUrls?: string[];\n\n  /**\n   * Specifies inline stylesheets for an Angular component.\n   */\n  styles?: string[];\n\n  /**\n   * Animations are defined on components via an animation-like DSL. This DSL approach to describing\n   * animations allows for a flexibility that both benefits developers and the framework.\n   *\n   * Animations work by listening on state changes that occur on an element within\n   * the template. When a state change occurs, Angular can then take advantage and animate the\n   * arc in between. This works similar to how CSS transitions work, however, by having a\n   * programmatic DSL, animations are not limited to environments that are DOM-specific.\n   * (Angular can also perform optimizations behind the scenes to make animations more performant.)\n   *\n   * For animations to be available for use, animation state changes are placed within\n   * {@link trigger animation triggers} which are housed inside of the `animations` annotation\n   * metadata. Within a trigger both {@link state state} and {@link transition transition} entries\n   * can be placed.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'animation-cmp',\n   *   templateUrl: 'animation-cmp.html',\n   *   animations: [\n   *     // this here is our animation trigger that\n   *     // will contain our state change animations.\n   *     trigger('myTriggerName', [\n   *       // the styles defined for the `on` and `off`\n   *       // states declared below are persisted on the\n   *       // element once the animation completes.\n   *       state('on', style({ opacity: 1 }),\n   *       state('off', style({ opacity: 0 }),\n   *\n   *       // this here is our animation that kicks off when\n   *       // this state change jump is true\n   *       transition('on => off', [\n   *         animate(\"1s\")\n   *       ])\n   *     ])\n   *   ]\n   * })\n   * ```\n   *\n   * As depicted in the code above, a group of related animation states are all contained within\n   * an animation `trigger` (the code example above called the trigger `myTriggerName`).\n   * When a trigger is created then it can be bound onto an element within the component's\n   * template via a property prefixed by an `@` symbol followed by trigger name and an expression\n   * that\n   * is used to determine the state value for that trigger.\n   *\n   * ```html\n   * <!-- animation-cmp.html -->\n   * <div @myTriggerName=\"expression\">...</div>\n   * ```\n   *\n   * For state changes to be executed, the `expression` value must change value from its existing\n   * value\n   * to something that we have set an animation to animate on (in the example above we are listening\n   * to a change of state between `on` and `off`). The `expression` value attached to the trigger\n   * must be something that can be evaluated with the template/component context.\n   *\n   * ### DSL Animation Functions\n   *\n   * Please visit each of the animation DSL functions listed below to gain a better understanding\n   * of how and why they are used for crafting animations in Angular:\n   *\n   * - {@link trigger trigger()}\n   * - {@link state state()}\n   * - {@link transition transition()}\n   * - {@link group group()}\n   * - {@link sequence sequence()}\n   * - {@link style style()}\n   * - {@link animate animate()}\n   * - {@link keyframes keyframes()}\n   */\n  animations?: any[];\n\n  /**\n   * Specifies how the template and the styles should be encapsulated:\n   * - {@link ViewEncapsulation#Native `ViewEncapsulation.Native`} to use shadow roots - only works\n   *   if natively available on the platform,\n   * - {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} to use shimmed CSS that\n   *   emulates the native behavior,\n   * - {@link ViewEncapsulation#None `ViewEncapsulation.None`} to use global CSS without any\n   *   encapsulation.\n   *\n   * When no `encapsulation` is defined for the component, the default value from the\n   * {@link CompilerOptions} is used. The default is `ViewEncapsulation.Emulated`}. Provide a new\n   * `CompilerOptions` to override this value.\n   *\n   * If the encapsulation is set to `ViewEncapsulation.Emulated` and the component has no `styles`\n   * nor `styleUrls` the encapsulation will automatically be switched to `ViewEncapsulation.None`.\n   */\n  encapsulation?: ViewEncapsulation;\n\n  /**\n   * Overrides the default encapsulation start and end delimiters (respectively `{{` and `}}`)\n   */\n  interpolation?: [string, string];\n\n  /**\n   * Defines the components that should be compiled as well when\n   * this component is defined. For each components listed here,\n   * Angular will create a {@link ComponentFactory} and store it in the\n   * {@link ComponentFactoryResolver}.\n   */\n  entryComponents?: Array<Type<any>|any[]>;\n\n  /**\n   * If {@link Component#preserveWhitespaces Component.preserveWhitespaces} is set to `false`\n   * potentially superfluous whitespace characters (ones matching the `\\s` character class in\n   * JavaScript regular expressions) will be removed from a compiled template. This can greatly\n   * reduce AOT-generated code size as well as speed up view creation.\n   *\n   * Current implementation works according to the following rules:\n   * - all whitespaces at the beginning and the end of a template are removed (trimmed);\n   * - text nodes consisting of whitespaces only are removed (ex.:\n   *   `<button>Action 1</button>  <button>Action 2</button>` will be converted to\n   *   `<button>Action 1</button><button>Action 2</button>` (no whitespaces between buttons);\n   * - series of whitespaces in text nodes are replaced with one space (ex.:\n   *   `<span>\\n some text\\n</span>` will be converted to `<span> some text </span>`);\n   * - text nodes are left as-is inside HTML tags where whitespaces are significant (ex. `<pre>`,\n   *   `<textarea>`).\n   *\n   * Described transformations may (potentially) influence DOM nodes layout. However, the impact\n   * should so be minimal. That's why starting from Angular 6, the\n   * `preserveWhitespaces` option is `false` by default (whitespace removal).\n   * If you want to change the default setting for all components in your application you can use\n   * the `preserveWhitespaces` option of the AOT compiler.\n   *\n   * Even with the default behavior of whitespace removal, there are ways of preserving whitespaces\n   * in certain fragments of a template. You can either exclude entire DOM sub-tree by using the\n   * `ngPreserveWhitespaces` attribute, ex.:\n   *\n   * ```html\n   * <div ngPreserveWhitespaces>\n   *     whitespaces are preserved here\n   *     <span>    and here </span>\n   * </div>\n   * ```\n   *\n   * Alternatively you can force a space to be preserved in a text node by using the `&ngsp;`\n   * pseudo-entity. `&ngsp;` will be replaced with a space character by Angular's template\n   * compiler, ex.:\n   *\n   * ```html\n   * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>\n   * ```\n   *\n   * will be compiled to the equivalent of:\n   *\n   * ```html\n   * <a>Spaces</a> <a>between</a> <a>links.</a>\n   * ```\n   *\n   * Please note that sequences of `&ngsp;` are still collapsed to just one space character when\n   * the `preserveWhitespaces` option is set to `false`. Ex.:\n   *\n   * ```html\n   * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>\n   * ```\n   *\n   * would be equivalent to:\n   *\n   * ```html\n   * <a>before</a> <a>after</a>\n   * ```\n   *\n   * The `&ngsp;` pseudo-entity is useful for forcing presence of\n   * one space (a text node having `&ngsp;` pseudo-entities will never be removed), but it is not\n   * meant to mark sequences of whitespace characters. The previously described\n   * `ngPreserveWhitespaces` attribute is more useful for preserving sequences of whitespace\n   * characters.\n   */\n  preserveWhitespaces?: boolean;\n}\n\n/**\n * Component decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Component: ComponentDecorator = makeDecorator(\n    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),\n    Directive);\n\n/**\n * Type of the Pipe decorator / constructor function.\n *\n *\n */\nexport interface PipeDecorator {\n  /**\n   * Declare reusable pipe function.\n   *\n   * A \"pure\" pipe is only re-evaluated when either the input or any of the arguments change.\n   *\n   * When not specified, pipes default to being pure.\n   */\n  (obj: Pipe): TypeDecorator;\n\n  /**\n   * See the {@link Pipe} decorator.\n   */\n  new (obj: Pipe): Pipe;\n}\n\n/**\n * Type of the Pipe metadata.\n *\n *\n */\nexport interface Pipe {\n  /**\n   * Name of the pipe.\n   *\n   * The pipe name is used in template bindings. For example if a pipe is named\n   * `myPipe` then it would be used in the template binding expression like\n   * so:  `{{ exp | myPipe }}`.\n   */\n  name: string;\n\n  /**\n   * If Pipe is pure (its output depends only on its input.)\n   *\n   * Normally pipe's `transform` method is only invoked when the inputs to pipe`s\n   * `transform` method change. If the pipe has internal state (it's result are\n   * dependent on state other than its arguments) than set `pure` to `false` so\n   * that the pipe is invoked on each change-detection even if the arguments to the\n   * pipe do not change.\n   */\n  pure?: boolean;\n}\n\n/**\n * Pipe decorator and metadata.\n *\n * Use the `@Pipe` annotation to declare that a given class is a pipe. A pipe\n * class must also implement {@link PipeTransform} interface.\n *\n * To use the pipe include a reference to the pipe class in\n * {@link NgModule#declarations}.\n *\n *\n * @Annotation\n */\nexport const Pipe: PipeDecorator = makeDecorator('Pipe', (p: Pipe) => ({pure: true, ...p}));\n\n\n/**\n * Type of the Input decorator / constructor function.\n *\n *\n */\nexport interface InputDecorator {\n  /**\n   * Declares a data-bound input property.\n   *\n   * Angular automatically updates data-bound properties during change detection.\n   *\n   * `Input` takes an optional parameter that specifies the name\n   * used when instantiating a component in the template. When not provided,\n   * the name of the decorated property is used.\n   *\n   * ### Example\n   *\n   * The following example creates a component with two input properties.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   template: `\n   *     Bank Name: {{bankName}}\n   *     Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   @Input() bankName: string;\n   *   @Input('account-id') id: string;\n   *\n   *   // this property is not bound, and won't be automatically updated by Angular\n   *   normalizedBankName: string;\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <bank-account bankName=\"RBC\" account-id=\"4747\"></bank-account>\n   *   `\n   * })\n   *\n   * class App {}\n   * ```\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Input metadata.\n *\n *\n */\nexport interface Input {\n  /**\n   * Name used when instantiating a component in the template.\n   */\n  bindingPropertyName?: string;\n}\n\n/**\n * Input decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Input: InputDecorator =\n    makePropDecorator('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n/**\n * Type of the Output decorator / constructor function.\n *\n *\n */\nexport interface OutputDecorator {\n  /**\n   * Declares an event-bound output property.\n   *\n   * When an output property emits an event, an event handler attached to that event\n   * the template is invoked.\n   *\n   * `Output` takes an optional parameter that specifies the name\n   * used when instantiating a component in the template. When not provided,\n   * the name of the decorated property is used.\n   *\n   * ### Example\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'interval-dir',\n   * })\n   * class IntervalDir {\n   *   @Output() everySecond = new EventEmitter();\n   *   @Output('everyFiveSeconds') five5Secs = new EventEmitter();\n   *\n   *   constructor() {\n   *     setInterval(() => this.everySecond.emit(\"event\"), 1000);\n   *     setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n   *     </interval-dir>\n   *   `\n   * })\n   * class App {\n   *   everySecond() { console.log('second'); }\n   *   everyFiveSeconds() { console.log('five seconds'); }\n   * }\n   * ```\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Output metadata.\n *\n *\n */\nexport interface Output { bindingPropertyName?: string; }\n\n/**\n * Output decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Output: OutputDecorator =\n    makePropDecorator('Output', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n\n/**\n * Type of the HostBinding decorator / constructor function.\n *\n *\n */\nexport interface HostBindingDecorator {\n  /**\n   * Declares a host property binding.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, it will update the host element of the directive.\n   *\n   * `HostBinding` takes an optional parameter that specifies the property\n   * name of the host element that will be updated. When not provided,\n   * the class property name is used.\n   *\n   * ### Example\n   *\n   * The following example creates a directive that sets the `valid` and `invalid` classes\n   * on the DOM element that has ngModel directive on it.\n   *\n   * ```typescript\n   * @Directive({selector: '[ngModel]'})\n   * class NgModelStatus {\n   *   constructor(public control:NgModel) {}\n   *   @HostBinding('class.valid') get valid() { return this.control.valid; }\n   *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`,\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   *\n   */\n  (hostPropertyName?: string): any;\n  new (hostPropertyName?: string): any;\n}\n\n/**\n * Type of the HostBinding metadata.\n *\n *\n */\nexport interface HostBinding { hostPropertyName?: string; }\n\n/**\n * HostBinding decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const HostBinding: HostBindingDecorator =\n    makePropDecorator('HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));\n\n\n/**\n * Type of the HostListener decorator / constructor function.\n *\n *\n */\nexport interface HostListenerDecorator {\n  /**\n   * Declares a host listener.\n   *\n   * Angular will invoke the decorated method when the host element emits the specified event.\n   *\n   * If the decorated method returns `false`, then `preventDefault` is applied on the DOM event.\n   *\n   * ### Example\n   *\n   * The following example declares a directive that attaches a click listener to the button and\n   * counts clicks.\n   *\n   * ```typescript\n   * @Directive({selector: 'button[counting]'})\n   * class CountClicks {\n   *   numberOfClicks = 0;\n   *\n   *   @HostListener('click', ['$event.target'])\n   *   onClick(btn) {\n   *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: '<button counting>Increment</button>',\n   * })\n   * class App {}\n   * ```\n   *\n   * @Annotation\n   */\n  (eventName: string, args?: string[]): any;\n  new (eventName: string, args?: string[]): any;\n}\n\n/**\n * Type of the HostListener metadata.\n *\n *\n */\nexport interface HostListener {\n  eventName?: string;\n  args?: string[];\n}\n\n/**\n * HostListener decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const HostListener: HostListenerDecorator =\n    makePropDecorator('HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directives.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/metadata/directives.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAC,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAgB,aAAa,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAycnF;;GAEG;AACH,MAAM,CAAC,IAAM,SAAS,GAClB,aAAa,CAAC,WAAW,EAAE,UAAC,GAAmB;IAAnB,oBAAA,EAAA,QAAmB;IAAK,OAAA,GAAG;AAAH,CAAG,CAAC,CAAC;AAiM7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,MAAM,CAAC,IAAM,SAAS,GAAuB,aAAa,CACtD,WAAW,EAAE,UAAC,CAAiB;IAAjB,kBAAA,EAAA,MAAiB;IAAK,OAAA,oBAAE,eAAe,EAAE,uBAAuB,CAAC,OAAO,IAAK,CAAC,EAAE;AAA1D,CAA0D,EAC9F,SAAS,CAAC,CAAC;AAyCf;;;;GAIG;AACH,MAAM,CAAC,IAAM,IAAI,GAAkB,aAAa,CAAC,MAAM,EAAE,UAAC,CAAO,IAAK,OAAA,oBAAE,IAAI,EAAE,IAAI,IAAK,CAAC,EAAE,EAApB,CAAoB,CAAC,CAAC;AAkF5F;;;GAGG;AACH,MAAM,CAAC,IAAM,KAAK,GACd,iBAAiB,CAAC,OAAO,EAAE,UAAC,mBAA4B,IAAK,OAAA,CAAC,EAAC,mBAAmB,qBAAA,EAAC,CAAC,EAAvB,CAAuB,CAAC,CAAC;AA8B1F;;;GAGG;AACH,MAAM,CAAC,IAAM,MAAM,GACf,iBAAiB,CAAC,QAAQ,EAAE,UAAC,mBAA4B,IAAK,OAAA,CAAC,EAAC,mBAAmB,qBAAA,EAAC,CAAC,EAAvB,CAAuB,CAAC,CAAC;AA6C3F;;;GAGG;AACH,MAAM,CAAC,IAAM,WAAW,GACpB,iBAAiB,CAAC,aAAa,EAAE,UAAC,gBAAyB,IAAK,OAAA,CAAC,EAAC,gBAAgB,kBAAA,EAAC,CAAC,EAApB,CAAoB,CAAC,CAAC;AAyB1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,IAAM,YAAY,GACrB,iBAAiB,CAAC,cAAc,EAAE,UAAC,SAAkB,EAAE,IAAe,IAAK,OAAA,CAAC,EAAC,SAAS,WAAA,EAAE,IAAI,MAAA,EAAC,CAAC,EAAnB,CAAmB,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ChangeDetectionStrategy} from '../change_detection/constants';\nimport {Provider} from '../di';\nimport {Type} from '../type';\nimport {TypeDecorator, makeDecorator, makePropDecorator} from '../util/decorators';\n\nimport {ViewEncapsulation} from './view';\n\n\n/**\n * Type of the Directive decorator / constructor function.\n */\nexport interface DirectiveDecorator {\n  /**\n   * Marks a class as an Angular directive and collects directive configuration\n   * metadata.\n   *\n   * Directive decorator allows you to mark a class as an Angular directive and provide additional\n   * metadata that determines how the directive should be processed, instantiated and used at\n   * runtime.\n   *\n   * Directives allow you to attach behavior to elements in the DOM..\n   *\n   * A directive must belong to an NgModule in order for it to be usable\n   * by another directive, component, or application. To specify that a directive is a member of an\n   * NgModule,\n   * you should list it in the `declarations` field of that NgModule.\n   *\n   * In addition to the metadata configuration specified via the Directive decorator,\n   * directives can control their runtime behavior by implementing various Life-Cycle hooks.\n   *\n   * **Metadata Properties:**\n   *\n   * * **exportAs** - name under which the component instance is exported in a template. Can be\n   * given a single name or a comma-delimited list of names.\n   * * **host** - map of class property to host element bindings for events, properties and\n   * attributes\n   * * **inputs** - list of class property names to data-bind as component inputs\n   * * **outputs** - list of class property names that expose output events that others can\n   * subscribe to\n   * * **providers** - list of providers available to this component and its children\n   * * **queries** -  configure queries that can be injected into the component\n   * * **selector** - css selector that identifies this component in a template\n   *\n   * @usageNotes\n   *\n   * ```\n   * import {Directive} from '@angular/core';\n   *\n   * @Directive({\n   *   selector: 'my-directive',\n   * })\n   * export class MyDirective {\n   * }\n   * ```\n   *\n   * @Annotation\n   */\n  (obj: Directive): TypeDecorator;\n\n  /**\n   * See the `Directive` decorator.\n   */\n  new (obj: Directive): Directive;\n}\n\nexport interface Directive {\n  /**\n   * The CSS selector that triggers the instantiation of a directive.\n   *\n   * Angular only allows directives to trigger on CSS selectors that do not cross element\n   * boundaries.\n   *\n   * `selector` may be declared as one of the following:\n   *\n   * - `element-name`: select by element name.\n   * - `.class`: select by class name.\n   * - `[attribute]`: select by attribute name.\n   * - `[attribute=value]`: select by attribute name and value.\n   * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.\n   * - `selector1, selector2`: select if either `selector1` or `selector2` matches.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * Suppose we have a directive with an `input[type=text]` selector.\n   *\n   * And the following HTML:\n   *\n   * ```html\n   * <form>\n   *   <input type=\"text\">\n   *   <input type=\"radio\">\n   * <form>\n   * ```\n   *\n   * The directive would only be instantiated on the `<input type=\"text\">` element.\n   *\n   */\n  selector?: string;\n\n  /**\n   * Enumerates the set of data-bound input properties for a directive\n   *\n   * Angular automatically updates input properties during change detection.\n   *\n   * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property where the value is written.\n   * - `bindingProperty` specifies the DOM property where the value is read from.\n   *\n   * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example creates a component with two data-bound properties.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   inputs: ['bankName', 'id: account-id'],\n   *   template: `\n   *     Bank Name: {{bankName}}\n   *     Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   bankName: string;\n   *   id: string;\n   *\n   * ```\n   */\n  inputs?: string[];\n\n  /**\n   * Enumerates the set of event-bound output properties.\n   *\n   * When an output property emits an event, an event handler attached to that event\n   * the template is invoked.\n   *\n   * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property that emits events.\n   * - `bindingProperty` specifies the DOM property the event handler is attached to.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'child-dir',\n   *   exportAs: 'child'\n   * })\n   * class ChildDir {\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `<child-dir #c=\"child\"></child-dir>`\n   * })\n   * class MainComponent {\n   * }\n   * ```\n   */\n  outputs?: string[];\n\n  /**\n   * Specify the events, actions, properties and attributes related to the host element.\n   *\n   * @usageNotes\n   * The key corresponds to the name of the event, property or attribute on the host to\n   * bind. The value is formatted differently depending upon the type of the binding.\n   *\n   * ### Host Listeners\n   *\n   * Specifies which DOM events a directive listens to via a set of `(event)` to `method`\n   * key-value pairs:\n   *\n   * - `event`: the DOM event that the directive listens to.\n   * - `statement`: the statement to execute when the event occurs.\n   * If the evaluation of the statement returns `false`, then `preventDefault`is applied on the DOM\n   * event.\n   *\n   * To listen to global events, a target must be added to the event name.\n   * The target can be `window`, `document` or `body`.\n   *\n   * When writing a directive event binding, you can also refer to the $event local variable.\n   *\n   * The following example declares a directive that attaches a click listener to the button and\n   * counts clicks.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'button[counting]',\n   *   host: {\n   *     '(click)': 'onClick($event.target)'\n   *   }\n   * })\n   * class CountClicks {\n   *   numberOfClicks = 0;\n   *\n   *   onClick(btn) {\n   *     console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<button counting>Increment</button>`\n   * })\n   * class App {}\n   * ```\n   * See [live demo](http://plnkr.co/edit/DlA5KU?p=preview)\n   *\n   * ### Host Property Bindings\n   *\n   * Specifies which DOM properties a directive updates.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, it will update the host element of the directive.\n   *\n   * The following example creates a directive that sets the `valid` and `invalid` classes\n   * on the DOM element that has ngModel directive on it.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[ngModel]',\n   *   host: {\n   *     '[class.valid]': 'valid',\n   *     '[class.invalid]': 'invalid'\n   *   }\n   * })\n   * class NgModelStatus {\n   *   constructor(public control:NgModel) {}\n   *   get valid { return this.control.valid; }\n   *   get invalid { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   * See [live demo](http://plnkr.co/edit/gNg0ED?p=preview).\n   *\n   * ### Attributes\n   *\n   * Specifies static attributes that should be propagated to a host element.\n   *\n   * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element\n   * (here: `<div>` ) will ensure that this element will get the \"button\" role.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[my-button]',\n   *   host: {\n   *     'role': 'button'\n   *   }\n   * })\n   * class MyButton {\n   * }\n   * ```\n   * Attaching the `my-button` directive to the host `<div>` element\n   * ensures that this element gets the \"button\" role.\n   *\n   * ```html\n   * <div my-button></div>\n   * ```\n   *\n   * @usageNotes\n   * ### Simple Example\n   *\n   * The following simple example shows how a class is injected,\n   * using a provider specified in the directive metadata:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'greet',\n   *   providers: [\n   *     Greeter\n   *   ]\n   * })\n   * class HelloWorld {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   * ```\n   */\n  providers?: Provider[];\n\n  /**\n   * Defines the name that can be used in the template to assign this directive to a variable.\n   *\n   * @usageNotes\n   * ### Simple Example\n   *\n   * ```\n   * @Directive({\n   *   selector: 'child-dir',\n   *   exportAs: 'child'\n   * })\n   * class ChildDir {\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `<child-dir #c=\"child\"></child-dir>`\n   * })\n   * class MainComponent {\n   * }\n   *\n   * ```\n   */\n  exportAs?: string;\n\n  /**\n   * Configures the queries that will be injected into the directive.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The followoing example (shows what??)\n   * ```\n   * @Component({\n   *   selector: 'someDir',\n   *   queries: {\n   *     contentChildren: new ContentChildren(ChildDirective),\n   *     viewChildren: new ViewChildren(ChildDirective)\n   *   },\n   *   template: '<child-directive></child-directive>'\n   * })\n   * class SomeDir {\n   *   contentChildren: QueryList<ChildDirective>,\n   *   viewChildren: QueryList<ChildDirective>\n   *\n   *   ngAfterContentInit() {\n   *     // contentChildren is set\n   *   }\n   *\n   *   ngAfterViewInit() {\n   *     // viewChildren is set\n   *   }\n   * }\n   * ```\n   *\n   * @Annotation\n   */\n  queries?: {[key: string]: any};\n}\n\n/**\n * Directive decorator and metadata.\n *\n * @Annotation\n */\nexport interface Directive {\n  /**\n   * The CSS selector that identifies this directive in a template\n   * and triggers instantiation of the directive.\n   *\n   * Declare as one of the following:\n   *\n   * - `element-name`: Select by element name.\n   * - `.class`: Select by class name.\n   * - `[attribute]`: Select by attribute name.\n   * - `[attribute=value]`: Select by attribute name and value.\n   * - `:not(sub_selector)`: Select only if the element does not match the `sub_selector`.\n   * - `selector1, selector2`: Select if either `selector1` or `selector2` matches.\n   *\n   * Angular only allows directives to apply on CSS selectors that do not cross\n   * element boundaries.\n   *\n   * For the following template HTML, a directive with an `input[type=text]` selector,\n   * would be instantiated only on the `<input type=\"text\">` element.\n   *\n   * ```html\n   * <form>\n   *   <input type=\"text\">\n   *   <input type=\"radio\">\n   * <form>\n   * ```\n   *\n   */\n  selector?: string;\n\n  /**\n   * The set of event-bound output properties.\n   * When an output property emits an event, an event handler attached\n   * to that event in the template is invoked.\n   *\n   * Each output property maps a `directiveProperty` to a `bindingProperty`:\n   * - `directiveProperty` specifies the component property that emits events.\n   * - `bindingProperty` specifies the HTML attribute the event handler is attached to.\n   *\n   */\n  outputs?: string[];\n\n  /**\n   * Maps class properties to host element bindings for properties,\n   * attributes, and events, using a set of key-value pairs.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, Angular updates the directive's host element.\n   *\n   * When the key is a property of the host element, the property value is\n   * the propagated to the specified DOM property.\n   *\n   * When the key is a static attribute in the DOM, the attribute value\n   * is propagated to the specified property in the host element.\n   *\n   * For event handling:\n   * - The key is the DOM event that the directive listens to.\n   * To listen to global events, add the target to the event name.\n   * The target can be `window`, `document` or `body`.\n   * - The value is the statement to execute when the event occurs. If the\n   * statement evalueates to `false`, then `preventDefault` is applied on the DOM\n   * event. A handler method can refer to the `$event` local variable.\n   *\n   */\n  host?: {[key: string]: string};\n\n  /**\n   * See the `Component` decorator.\n   */\n  providers?: Provider[];\n\n  /**\n   * The name or names that can be used in the template to assign this directive to a variable.\n   * For multiple names, use a comma-separated string.\n   *\n   */\n  exportAs?: string;\n\n  /**\n   * Configures the queries that will be injected into the directive.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   */\n  queries?: {[key: string]: any};\n}\n\n/**\n * Type of the Component metadata.\n */\nexport const Directive: DirectiveDecorator =\n    makeDecorator('Directive', (dir: Directive = {}) => dir);\n/**\n * Component decorator interface\n *\n */\nexport interface ComponentDecorator {\n  /**\n   * Decorator that marks a class as an Angular component and provides configuration\n   * metadata that determines how the component should be processed,\n   * instantiated, and used at runtime.\n   *\n   * Components are the most basic UI building block of an Angular app.\n   * An Angular app contains a tree of Angular components.\n   *\n   * Angular components are a subset of directives, always associated with a template.\n   * Unlike other directives, only one component can be instantiated per an element in a template.\n   *\n   * A component must belong to an NgModule in order for it to be available\n   * to another component or application. To make it a member of an NgModule,\n   * list it in the `declarations` field of the `@NgModule` metadata.\n   *\n   * Note that, in addition to these options for configuring a directive,\n   * you can control a component's runtime behavior by implementing\n   * life-cycle hooks. For more information, see the\n   * [Lifecycle Hooks](guide/lifecycle-hooks) guide.\n   *\n   * @usageNotes\n   *\n   * ### Setting component inputs\n   *\n   * The following example creates a component with two data-bound properties,\n   * specified by the `inputs` value.\n   *\n   * <code-example path=\"core/ts/metadata/directives.ts\" region=\"component-input\">\n   * </code-example>\n   *\n   *\n   * ### Setting component outputs\n   *\n   * The following example shows two event emitters that emit on an interval. One\n   * emits an output every second, while the other emits every five seconds.\n   *\n   * {@example core/ts/metadata/directives.ts region='component-output-interval'}\n   *\n   * ### Injecting a class with a view provider\n   *\n   * The following simple example injects a class into a component\n   * using the view provider specified in component metadata:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'needs-greeter'\n   * })\n   * class NeedsGreeter {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'greet',\n   *   viewProviders: [\n   *     Greeter\n   *   ],\n   *   template: `<needs-greeter></needs-greeter>`\n   * })\n   * class HelloWorld {\n   * }\n   *\n   * ```\n   *\n   *\n   * @Annotation\n   */\n  (obj: Component): TypeDecorator;\n  /**\n   * See the `@Component` decorator.\n   */\n  new (obj: Component): Component;\n}\n\n/**\n * Supplies configuration metadata for an Angular component.\n */\nexport interface Component extends Directive {\n  /**\n   * The change-detection strategy to use for this component.\n   *\n   * When a component is instantiated, Angular creates a change detector,\n   * which is responsible for propagating the component's bindings.\n   * The strategy is one of:\n   * - `ChangeDetectionStrategy#OnPush` sets the strategy to `CheckOnce` (on demand).\n   * - `ChangeDetectionStrategy#Default` sets the strategy to `CheckAlways`.\n   */\n  changeDetection?: ChangeDetectionStrategy;\n\n  /**\n   * Defines the set of injectable objects that are visible to its view DOM children.\n   * See [example](#injecting-a-class-with-a-view-provider).\n   *\n   */\n  viewProviders?: Provider[];\n\n  /**\n   * The module ID of the module that contains the component.\n   * The component must be able to resolve relative URLs for templates and styles.\n   * SystemJS exposes the `__moduleName` variable within each module.\n   * In CommonJS, this can  be set to `module.id`.\n   *\n   */\n  moduleId?: string;\n\n  /**\n   * The URL of a template file for an Angular component. If provided,\n   * do not supply an inline template using `template`.\n   *\n   */\n  templateUrl?: string;\n\n  /**\n   * An inline template for an Angular component. If provided,\n   * do not supply a template file using `templateUrl`.\n   *\n   */\n  template?: string;\n\n  /**\n   * One or more URLs for files containing CSS stylesheets to use\n   * in this component.\n   */\n  styleUrls?: string[];\n\n  /**\n   * One or more inline CSS stylesheets to use\n   * in this component.\n   */\n  styles?: string[];\n\n  /**\n   * One or more animation `trigger()` calls, containing\n   * `state()` and `transition()` definitions.\n   * See the [Animations guide](/guide/animations) and animations API documentation.\n   *\n   */\n  animations?: any[];\n\n  /**\n   * An encapsulation policy for the template and CSS styles. One of:\n   * - `ViewEncapsulation.Native`: Use shadow roots. This works\n   * only if natively available on the platform.\n   * - `ViewEncapsulation.Emulated`: Use shimmed CSS that\n   * emulates the native behavior.\n   * - `ViewEncapsulation.None`: Use global CSS without any\n   * encapsulation.\n   *\n   * If not supplied, the value is taken from `CompilerOptions`. The default compiler option is\n   * `ViewEncapsulation.Emulated`.\n   *\n   * If the policy is set to `ViewEncapsulation.Emulated` and the component has no `styles`\n   * or `styleUrls` specified, the policy is automatically switched to `ViewEncapsulation.None`.\n   */\n  encapsulation?: ViewEncapsulation;\n\n  /**\n   * Overrides the default encapsulation start and end delimiters (`{{` and `}}`)\n   */\n  interpolation?: [string, string];\n\n  /**\n   * A set of components that should be compiled along with\n   * this component. For each component listed here,\n   * Angular creates a {@link ComponentFactory} and stores it in the\n   * {@link ComponentFactoryResolver}.\n   */\n  entryComponents?: Array<Type<any>|any[]>;\n\n  /**\n   * True to preserve or false to remove potentially superfluous whitespace characters\n   * from the compiled template. Whitespace characters are those matching the `\\s`\n   * character class in JavaScript regular expressions. Default is false, unless\n   * overridden in compiler options.\n   */\n  preserveWhitespaces?: boolean;\n}\n\n/**\n * Component decorator and metadata.\n *\n * @usageNotes\n *\n * ### Using animations\n *\n * The following snippet shows an animation trigger in a component's\n * metadata. The trigger is attached to an element in the component's\n * template, using \"@_trigger_name_\", and a state expression that is evaluated\n * at run time to determine whether the animation should start.\n *\n * ```typescript\n * @Component({\n *   selector: 'animation-cmp',\n *   templateUrl: 'animation-cmp.html',\n *   animations: [\n *     trigger('myTriggerName', [\n *       state('on', style({ opacity: 1 }),\n *       state('off', style({ opacity: 0 }),\n *       transition('on => off', [\n *         animate(\"1s\")\n *       ])\n *     ])\n *   ]\n * })\n * ```\n *\n * ```html\n * <!-- animation-cmp.html -->\n * <div @myTriggerName=\"expression\">...</div>\n * ```\n *\n * ### Preserving whitespace\n *\n * Removing whitespace can greatly reduce AOT-generated code size, and speed up view creation.\n * As of Angular 6, default for `preserveWhitespaces` is false (whitespace is removed).\n * To change the default setting for all components in your application, set\n * the `preserveWhitespaces` option of the AOT compiler.\n *\n * Current implementation removes whitespace characters as follows:\n * - Trims all whitespaces at the beginning and the end of a template.\n * - Removes whitespace-only text nodes. For example,\n * `<button>Action 1</button>  <button>Action 2</button>` becomes\n * `<button>Action 1</button><button>Action 2</button>`.\n * - Replaces a series of whitespace characters in text nodes with a single space.\n * For example, `<span>\\n some text\\n</span>` becomes `<span> some text </span>`.\n * - Does NOT alter text nodes inside HTML tags such as `<pre>` or `<textarea>`,\n * where whitespace characters are significant.\n *\n * Note that these transformations can influence DOM nodes layout, although impact\n * should be minimal.\n *\n * You can override the default behavior to preserve whitespace characters\n * in certain fragments of a template. For example, you can exclude an entire\n * DOM sub-tree by using the `ngPreserveWhitespaces` attribute:\n *\n * ```html\n * <div ngPreserveWhitespaces>\n *     whitespaces are preserved here\n *     <span>    and here </span>\n * </div>\n * ```\n *\n * You can force a single space to be preserved in a text node by using `&ngsp;`,\n * which is replaced with a space character by Angular's template\n * compiler:\n *\n * ```html\n * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>\n * <!-->compiled to be equivalent to:</>\n *  <a>Spaces</a> <a>between</a> <a>links.</a>\n * ```\n *\n * Note that sequences of `&ngsp;` are still collapsed to just one space character when\n * the `preserveWhitespaces` option is set to `false`.\n *\n * ```html\n * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>\n * <!-->compiled to be equivalent to:</>\n *  <a>Spaces</a> <a>between</a> <a>links.</a>\n * ```\n *\n * To preserve sequences of whitespace characters, use the\n * `ngPreserveWhitespaces` attribute.\n *\n * @Annotation\n */\nexport const Component: ComponentDecorator = makeDecorator(\n    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),\n    Directive);\n\n/**\n * Type of the Pipe decorator / constructor function.\n */\nexport interface PipeDecorator {\n  /**\n   * Declares a reusable pipe function, and supplies configuration metadata.\n   *\n   */\n  (obj: Pipe): TypeDecorator;\n\n  /**\n   * See the `Pipe` decorator.\n   */\n  new (obj: Pipe): Pipe;\n}\n\n/**\n * Type of the Pipe metadata.\n */\nexport interface Pipe {\n  /**\n   * The pipe name to use in template bindings.\n   *\n   */\n  name: string;\n\n  /**\n   * When true, the pipe is pure, meaning that the\n   * `transform()` method is invoked only when its input arguments\n   * change. Pipes are pure by default.\n   *\n   * If the pipe has internal state (that is, the result\n   * depends on state other than its arguments), set `pure` to false.\n   * In this case, the pipe is invoked on each change-detection cycle,\n   * even if the arguments have not changed.\n   */\n  pure?: boolean;\n}\n\n/**\n *\n *\n * @Annotation\n */\nexport const Pipe: PipeDecorator = makeDecorator('Pipe', (p: Pipe) => ({pure: true, ...p}));\n\n\n/**\n *\n */\nexport interface InputDecorator {\n  /**\n   * Decorator that marks a class as pipe and supplies configuration metadata.\n   *\n   * A pipe class must implement the `PipeTransform` interface.\n   * For example, if the name is \"myPipe\", use a template binding expression\n   * such as the following:\n   *\n   * ```\n   * {{ exp | myPipe }}\n   * ```\n   *\n   * The result of the expression is passed to the pipe's `transform()` method.\n   *\n   * A pipe must belong to an NgModule in order for it to be available\n   * to a template. To make it a member of an NgModule,\n   * list it in the `declarations` field of the `@NgModule` metadata.\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of metadata for an `Input` property.\n *\n *\n */\nexport interface Input {\n  /**\n   * Decorator that marks a class field as an input property and supplies configuration metadata.\n   * Declares a data-bound input property, which Angular automatically updates\n   * during change detection.\n   *\n   * @usageNotes\n   *\n   * You can supply an optional name to use in templates when the\n   * component is instantiated, that maps to the\n   * name of the bound property. By default, the original\n   * name of the bound property is used for input binding.\n   *\n   * The following example creates a component with two input properties,\n   * one of which is given a special binding name.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   template: `\n   *     Bank Name: {{bankName}}\n  *      Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   // This property is bound using its original name.\n   *   @Input() bankName: string;\n   *   // this property value is bound to a different property name\n   *   // when this component is instantiated in a template.\n   *   @Input('account-id') id: string;\n   *\n   *   // this property is not bound, and is not automatically updated by Angular\n   *   normalizedBankName: string;\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <bank-account bankName=\"RBC\" account-id=\"4747\"></bank-account>\n   *   `\n   * })\n   *\n   * class App {}\n   * ```\n   */\n  bindingPropertyName?: string;\n}\n\n/**\n *\n * @Annotation\n */\nexport const Input: InputDecorator =\n    makePropDecorator('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n/**\n * Type of the Output decorator / constructor function.\n */\nexport interface OutputDecorator {\n  /**\n  * Decorator that marks a class field as an output property and supplies configuration metadata.\n  * Declares a data-bound output property, which Angular automatically updates\n  * during change detection.\n  *\n  * @usageNotes\n  *\n  * You can supply an optional name to use in templates when the\n  * component is instantiated, that maps to the\n  * name of the bound property. By default, the original\n  * name of the bound property is used for output binding.\n  *\n  * See `@Input` decorator for an example of providing a binding name.\n  *\n  */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Output metadata.\n */\nexport interface Output { bindingPropertyName?: string; }\n\n/**\n *\n * @Annotation\n */\nexport const Output: OutputDecorator =\n    makePropDecorator('Output', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n\n/**\n * Type of the HostBinding decorator / constructor function.\n */\nexport interface HostBindingDecorator {\n  /**\n   * Decorator that marks a DOM property as a host-binding property and supplies configuration\n   * metadata.\n   * Angular automatically checks host property bindings during change detection, and\n   * if a binding changes it updates the host element of the directive.\n   *\n   * @usageNotes\n   *\n   * The following example creates a directive that sets the `valid` and `invalid`\n   * properties on the DOM element that has an `ngModel` directive on it.\n   *\n   * ```typescript\n   * @Directive({selector: '[ngModel]'})\n   * class NgModelStatus {\n   *   constructor(public control: NgModel) {}\n   *   @HostBinding('class.valid') get valid() { return this.control.valid; }\n   *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`,\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   */\n  (hostPropertyName?: string): any;\n  new (hostPropertyName?: string): any;\n}\n\n/**\n * Type of the HostBinding metadata.\n *\n */\nexport interface HostBinding { hostPropertyName?: string; }\n\n/**\n *\n * @Annotation\n */\nexport const HostBinding: HostBindingDecorator =\n    makePropDecorator('HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));\n\n\n/**\n * Type of the HostListener decorator / constructor function.\n */\nexport interface HostListenerDecorator {\n  (eventName: string, args?: string[]): any;\n  new (eventName: string, args?: string[]): any;\n}\n\n/**\n * Type of the HostListener metadata.\n */\nexport interface HostListener {\n  /**\n   * The CSS event to listen for.\n   */\n  eventName?: string;\n  /**\n   * A set of arguments to pass to the handler method when the event occurs.\n   */\n  args?: string[];\n}\n\n/**\n * Binds a CSS event to a host listener and supplies configuration metadata.\n * Angular invokes the supplied handler method when the host element emits the specified event,\n * and updates the bound element with the result.\n * If the handler method returns false, applies `preventDefault` on the bound element.\n *\n * @usageNotes\n *\n * The following example declares a directive\n * that attaches a click listener to a button and counts clicks.\n *\n * ```\n * @Directive({selector: 'button[counting]'})\n * class CountClicks {\n *   numberOfClicks = 0;\n *\n *   @HostListener('click', ['$event.target'])\n *   onClick(btn) {\n *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);\n *  }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: '<button counting>Increment</button>',\n * })\n * class App {}\n * ```\n *\n * @Annotation\n */\nexport const HostListener: HostListenerDecorator =\n    makePropDecorator('HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));\n"]}

package/esm5/src/metadata/lifecycle_hooks.js

@@ -6,4 +6,4 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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