@angular/core 0.0.0-6 → 2.0.0-rc.2

package/esm/src/metadata/lifecycle_hooks.js

@@ -1,3 +1,6 @@
+/**
+ * @stable
+ */
 export var LifecycleHooks;
 (function (LifecycleHooks) {
     LifecycleHooks[LifecycleHooks["OnInit"] = 0] = "OnInit";
@@ -9,17 +12,468 @@ export var LifecycleHooks;
     LifecycleHooks[LifecycleHooks["AfterViewInit"] = 6] = "AfterViewInit";
     LifecycleHooks[LifecycleHooks["AfterViewChecked"] = 7] = "AfterViewChecked";
 })(LifecycleHooks || (LifecycleHooks = {}));
-/**
- * @internal
- */
 export var LIFECYCLE_HOOKS_VALUES = [
-    LifecycleHooks.OnInit,
-    LifecycleHooks.OnDestroy,
-    LifecycleHooks.DoCheck,
-    LifecycleHooks.OnChanges,
-    LifecycleHooks.AfterContentInit,
-    LifecycleHooks.AfterContentChecked,
-    LifecycleHooks.AfterViewInit,
+    LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,
+    LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,
     LifecycleHooks.AfterViewChecked
 ];
+/**
+ * Lifecycle hooks are guaranteed to be called in the following order:
+ * - `OnChanges` (if any bindings have changed),
+ * - `OnInit` (after the first check only),
+ * - `DoCheck`,
+ * - `AfterContentInit`,
+ * - `AfterContentChecked`,
+ * - `AfterViewInit`,
+ * - `AfterViewChecked`,
+ * - `OnDestroy` (at the very end before destruction)
+ */
+/**
+ * Implement this interface to get notified when any data-bound property of your directive changes.
+ *
+ * `ngOnChanges` is called right after the data-bound properties have been checked and before view
+ * and content children are checked if at least one of them has changed.
+ *
+ * The `changes` parameter contains an entry for each of the changed data-bound property. The key is
+ * the property name and the value is an instance of {@link SimpleChange}.
+ *
+ * ### Example ([live example](http://plnkr.co/edit/AHrB6opLqHDBPkt4KpdT?p=preview)):
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'my-cmp',
+ *   template: `<p>myProp = {{myProp}}</p>`
+ * })
+ * class MyComponent implements OnChanges {
+ *   @Input() myProp: any;
+ *
+ *   ngOnChanges(changes: SimpleChanges) {
+ *     console.log('ngOnChanges - myProp = ' + changes['myProp'].currentValue);
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <button (click)="value = value + 1">Change MyComponent</button>
+ *     <my-cmp [my-prop]="value"></my-cmp>`,
+ *   directives: [MyComponent]
+ * })
+ * export class App {
+ *   value = 0;
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ * @stable
+ */
+export class OnChanges {
+}
+/**
+ * Implement this interface to execute custom initialization logic after your directive's
+ * data-bound properties have been initialized.
+ *
+ * `ngOnInit` is called right after the directive's data-bound properties have been checked for the
+ * first time, and before any of its children have been checked. It is invoked only once when the
+ * directive is instantiated.
+ *
+ * ### Example ([live example](http://plnkr.co/edit/1MBypRryXd64v4pV03Yn?p=preview))
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'my-cmp',
+ *   template: `<p>my-component</p>`
+ * })
+ * class MyComponent implements OnInit, OnDestroy {
+ *   ngOnInit() {
+ *     console.log('ngOnInit');
+ *   }
+ *
+ *   ngOnDestroy() {
+ *     console.log('ngOnDestroy');
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <button (click)="hasChild = !hasChild">
+ *       {{hasChild ? 'Destroy' : 'Create'}} MyComponent
+ *     </button>
+ *     <my-cmp *ngIf="hasChild"></my-cmp>`,
+ *   directives: [MyComponent, NgIf]
+ * })
+ * export class App {
+ *   hasChild = true;
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ *  ```
+ * @stable
+ */
+export class OnInit {
+}
+/**
+ * Implement this interface to supplement the default change detection algorithm in your directive.
+ *
+ * `ngDoCheck` gets called to check the changes in the directives in addition to the default
+ * algorithm.
+ *
+ * The default change detection algorithm looks for differences by comparing bound-property values
+ * by reference across change detection runs.
+ *
+ * Note that a directive typically should not use both `DoCheck` and {@link OnChanges} to respond to
+ * changes on the same input. `ngOnChanges` will continue to be called when the default change
+ * detector
+ * detects changes, so it is usually unnecessary to respond to changes on the same input in both
+ * hooks.
+ * Reaction to the changes have to be handled from within the `ngDoCheck` callback.
+ *
+ * You can use {@link KeyValueDiffers} and {@link IterableDiffers} to help add your custom check
+ * mechanisms.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/QpnIlF0CR2i5bcYbHEUJ?p=preview))
+ *
+ * In the following example `ngDoCheck` uses an {@link IterableDiffers} to detect the updates to the
+ * array `list`:
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'custom-check',
+ *   template: `
+ *     <p>Changes:</p>
+ *     <ul>
+ *       <li *ngFor="let line of logs">{{line}}</li>
+ *     </ul>`,
+ *   directives: [NgFor]
+ * })
+ * class CustomCheckComponent implements DoCheck {
+ *   @Input() list: any[];
+ *   differ: any;
+ *   logs = [];
+ *
+ *   constructor(differs: IterableDiffers) {
+ *     this.differ = differs.find([]).create(null);
+ *   }
+ *
+ *   ngDoCheck() {
+ *     var changes = this.differ.diff(this.list);
+ *
+ *     if (changes) {
+ *       changes.forEachAddedItem(r => this.logs.push('added ' + r.item));
+ *       changes.forEachRemovedItem(r => this.logs.push('removed ' + r.item))
+ *     }
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <button (click)="list.push(list.length)">Push</button>
+ *     <button (click)="list.pop()">Pop</button>
+ *     <custom-check [list]="list"></custom-check>`,
+ *   directives: [CustomCheckComponent]
+ * })
+ * export class App {
+ *   list = [];
+ * }
+ * ```
+ * @stable
+ */
+export class DoCheck {
+}
+/**
+ * Implement this interface to get notified when your directive is destroyed.
+ *
+ * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the
+ * instance is destroyed
+ *
+ * ### Example ([live example](http://plnkr.co/edit/1MBypRryXd64v4pV03Yn?p=preview))
+ *
+ * ```typesript
+ * @Component({
+ *   selector: 'my-cmp',
+ *   template: `<p>my-component</p>`
+ * })
+ * class MyComponent implements OnInit, OnDestroy {
+ *   ngOnInit() {
+ *     console.log('ngOnInit');
+ *   }
+ *
+ *   ngOnDestroy() {
+ *     console.log('ngOnDestroy');
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <button (click)="hasChild = !hasChild">
+ *       {{hasChild ? 'Destroy' : 'Create'}} MyComponent
+ *     </button>
+ *     <my-cmp *ngIf="hasChild"></my-cmp>`,
+ *   directives: [MyComponent, NgIf]
+ * })
+ * export class App {
+ *   hasChild = true;
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ *
+ *
+ * To create a stateful Pipe, you should implement this interface and set the `pure`
+ * parameter to `false` in the {@link PipeMetadata}.
+ *
+ * A stateful pipe may produce different output, given the same input. It is
+ * likely that a stateful pipe may contain state that should be cleaned up when
+ * a binding is destroyed. For example, a subscription to a stream of data may need to
+ * be disposed, or an interval may need to be cleared.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/i8pm5brO4sPaLxBx56MR?p=preview))
+ *
+ * In this example, a pipe is created to countdown its input value, updating it every
+ * 50ms. Because it maintains an internal interval, it automatically clears
+ * the interval when the binding is destroyed or the countdown completes.
+ *
+ * ```
+ * import {OnDestroy, Pipe, PipeTransform} from '@angular/core'
+ * @Pipe({name: 'countdown', pure: false})
+ * class CountDown implements PipeTransform, OnDestroy {
+ *   remainingTime:Number;
+ *   interval:SetInterval;
+ *   ngOnDestroy() {
+ *     if (this.interval) {
+ *       clearInterval(this.interval);
+ *     }
+ *   }
+ *   transform(value: any, args: any[] = []) {
+ *     if (!parseInt(value, 10)) return null;
+ *     if (typeof this.remainingTime !== 'number') {
+ *       this.remainingTime = parseInt(value, 10);
+ *     }
+ *     if (!this.interval) {
+ *       this.interval = setInterval(() => {
+ *         this.remainingTime-=50;
+ *         if (this.remainingTime <= 0) {
+ *           this.remainingTime = 0;
+ *           clearInterval(this.interval);
+ *           delete this.interval;
+ *         }
+ *       }, 50);
+ *     }
+ *     return this.remainingTime;
+ *   }
+ * }
+ * ```
+ *
+ * Invoking `{{ 10000 | countdown }}` would cause the value to be decremented by 50,
+ * every 50ms, until it reaches 0.
+ *
+ * @stable
+ */
+export class OnDestroy {
+}
+/**
+ * Implement this interface to get notified when your directive's content has been fully
+ * initialized.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/plamXUpsLQbIXpViZhUO?p=preview))
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'child-cmp',
+ *   template: `{{where}} child`
+ * })
+ * class ChildComponent {
+ *   @Input() where: string;
+ * }
+ *
+ * @Component({
+ *   selector: 'parent-cmp',
+ *   template: `<ng-content></ng-content>`
+ * })
+ * class ParentComponent implements AfterContentInit {
+ *   @ContentChild(ChildComponent) contentChild: ChildComponent;
+ *
+ *   constructor() {
+ *     // contentChild is not initialized yet
+ *     console.log(this.getMessage(this.contentChild));
+ *   }
+ *
+ *   ngAfterContentInit() {
+ *     // contentChild is updated after the content has been checked
+ *     console.log('AfterContentInit: ' + this.getMessage(this.contentChild));
+ *   }
+ *
+ *   private getMessage(cmp: ChildComponent): string {
+ *     return cmp ? cmp.where + ' child' : 'no child';
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <parent-cmp>
+ *       <child-cmp where="content"></child-cmp>
+ *     </parent-cmp>`,
+ *   directives: [ParentComponent, ChildComponent]
+ * })
+ * export class App {
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ * @stable
+ */
+export class AfterContentInit {
+}
+/**
+ * Implement this interface to get notified after every check of your directive's content.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/tGdrytNEKQnecIPkD7NU?p=preview))
+ *
+ * ```typescript
+ * @Component({selector: 'child-cmp', template: `{{where}} child`})
+ * class ChildComponent {
+ *   @Input() where: string;
+ * }
+ *
+ * @Component({selector: 'parent-cmp', template: `<ng-content></ng-content>`})
+ * class ParentComponent implements AfterContentChecked {
+ *   @ContentChild(ChildComponent) contentChild: ChildComponent;
+ *
+ *   constructor() {
+ *     // contentChild is not initialized yet
+ *     console.log(this.getMessage(this.contentChild));
+ *   }
+ *
+ *   ngAfterContentChecked() {
+ *     // contentChild is updated after the content has been checked
+ *     console.log('AfterContentChecked: ' + this.getMessage(this.contentChild));
+ *   }
+ *
+ *   private getMessage(cmp: ChildComponent): string {
+ *     return cmp ? cmp.where + ' child' : 'no child';
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `
+ *     <parent-cmp>
+ *       <button (click)="hasContent = !hasContent">Toggle content child</button>
+ *       <child-cmp *ngIf="hasContent" where="content"></child-cmp>
+ *     </parent-cmp>`,
+ *   directives: [NgIf, ParentComponent, ChildComponent]
+ * })
+ * export class App {
+ *   hasContent = true;
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ * @stable
+ */
+export class AfterContentChecked {
+}
+/**
+ * Implement this interface to get notified when your component's view has been fully initialized.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/LhTKVMEM0fkJgyp4CI1W?p=preview))
+ *
+ * ```typescript
+ * @Component({selector: 'child-cmp', template: `{{where}} child`})
+ * class ChildComponent {
+ *   @Input() where: string;
+ * }
+ *
+ * @Component({
+ *   selector: 'parent-cmp',
+ *   template: `<child-cmp where="view"></child-cmp>`,
+ *   directives: [ChildComponent]
+ * })
+ * class ParentComponent implements AfterViewInit {
+ *   @ViewChild(ChildComponent) viewChild: ChildComponent;
+ *
+ *   constructor() {
+ *     // viewChild is not initialized yet
+ *     console.log(this.getMessage(this.viewChild));
+ *   }
+ *
+ *   ngAfterViewInit() {
+ *     // viewChild is updated after the view has been initialized
+ *     console.log('ngAfterViewInit: ' + this.getMessage(this.viewChild));
+ *   }
+ *
+ *   private getMessage(cmp: ChildComponent): string {
+ *     return cmp ? cmp.where + ' child' : 'no child';
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `<parent-cmp></parent-cmp>`,
+ *   directives: [ParentComponent]
+ * })
+ * export class App {
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ * @stable
+ */
+export class AfterViewInit {
+}
+/**
+ * Implement this interface to get notified after every check of your component's view.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/0qDGHcPQkc25CXhTNzKU?p=preview))
+ *
+ * ```typescript
+ * @Component({selector: 'child-cmp', template: `{{where}} child`})
+ * class ChildComponent {
+ *   @Input() where: string;
+ * }
+ *
+ * @Component({
+ *   selector: 'parent-cmp',
+ *   template: `
+ *     <button (click)="showView = !showView">Toggle view child</button>
+ *     <child-cmp *ngIf="showView" where="view"></child-cmp>`,
+ *   directives: [NgIf, ChildComponent]
+ * })
+ * class ParentComponent implements AfterViewChecked {
+ *   @ViewChild(ChildComponent) viewChild: ChildComponent;
+ *   showView = true;
+ *
+ *   constructor() {
+ *     // viewChild is not initialized yet
+ *     console.log(this.getMessage(this.viewChild));
+ *   }
+ *
+ *   ngAfterViewChecked() {
+ *     // viewChild is updated after the view has been checked
+ *     console.log('AfterViewChecked: ' + this.getMessage(this.viewChild));
+ *   }
+ *
+ *   private getMessage(cmp: ChildComponent): string {
+ *     return cmp ? cmp.where + ' child' : 'no child';
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `<parent-cmp></parent-cmp>`,
+ *   directives: [ParentComponent]
+ * })
+ * export class App {
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ * @stable
+ */
+export class AfterViewChecked {
+}
 //# sourceMappingURL=lifecycle_hooks.js.map

package/esm/src/metadata/lifecycle_hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle_hooks.js","sourceRoot":"/Users/iminar/Dev/angular/modules/@angular/core/","sources":["src/metadata/lifecycle_hooks.ts"],"names":[],"mappings":"AAMA,WAAY,cASX;AATD,WAAY,cAAc;IACxB,uDAAM,CAAA;IACN,6DAAS,CAAA;IACT,yDAAO,CAAA;IACP,6DAAS,CAAA;IACT,2EAAgB,CAAA;IAChB,iFAAmB,CAAA;IACnB,qEAAa,CAAA;IACb,2EAAgB,CAAA;AAClB,CAAC,EATW,cAAc,KAAd,cAAc,QASzB;AAED;;GAEG;AACH,OAAO,IAAI,sBAAsB,GAAG;IAClC,cAAc,CAAC,MAAM;IACrB,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,OAAO;IACtB,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,gBAAgB;IAC/B,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,aAAa;IAC5B,cAAc,CAAC,gBAAgB;CAChC,CAAC"}
+{"version":3,"file":"lifecycle_hooks.js","sourceRoot":"","sources":["../../../../../../modules/@angular/core/src/metadata/lifecycle_hooks.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,WAAY,cASX;AATD,WAAY,cAAc;IACxB,uDAAM,CAAA;IACN,6DAAS,CAAA;IACT,yDAAO,CAAA;IACP,6DAAS,CAAA;IACT,2EAAgB,CAAA;IAChB,iFAAmB,CAAA;IACnB,qEAAa,CAAA;IACb,2EAAgB,CAAA;AAClB,CAAC,EATW,cAAc,KAAd,cAAc,QASzB;AASD,OAAO,IAAI,sBAAsB,GAAG;IAClC,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS;IACjG,cAAc,CAAC,gBAAgB,EAAE,cAAc,CAAC,mBAAmB,EAAE,cAAc,CAAC,aAAa;IACjG,cAAc,CAAC,gBAAgB;CAChC,CAAC;AAEF;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;AAEA,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;AAA2E,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH;AAA6E,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH;AAAiF,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;AAA+F,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;AAEA,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;AAAyF,CAAC;AAE1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;AAA+F,CAAC;AAAA","sourcesContent":["import {SimpleChange} from '../change_detection/change_detection_util';\n\n/**\n * @stable\n */\nexport enum LifecycleHooks {\n  OnInit,\n  OnDestroy,\n  DoCheck,\n  OnChanges,\n  AfterContentInit,\n  AfterContentChecked,\n  AfterViewInit,\n  AfterViewChecked\n}\n\n/**\n * A `changes` object whose keys are property names and\n * values are instances of {@link SimpleChange}. See {@link OnChanges}\n * @stable\n */\nexport interface SimpleChanges { [propName: string]: SimpleChange; }\n\nexport var LIFECYCLE_HOOKS_VALUES = [\n  LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,\n  LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,\n  LifecycleHooks.AfterViewChecked\n];\n\n/**\n * Lifecycle hooks are guaranteed to be called in the following order:\n * - `OnChanges` (if any bindings have changed),\n * - `OnInit` (after the first check only),\n * - `DoCheck`,\n * - `AfterContentInit`,\n * - `AfterContentChecked`,\n * - `AfterViewInit`,\n * - `AfterViewChecked`,\n * - `OnDestroy` (at the very end before destruction)\n */\n\n/**\n * Implement this interface to get notified when any data-bound property of your directive changes.\n *\n * `ngOnChanges` is called right after the data-bound properties have been checked and before view\n * and content children are checked if at least one of them has changed.\n *\n * The `changes` parameter contains an entry for each of the changed data-bound property. The key is\n * the property name and the value is an instance of {@link SimpleChange}.\n *\n * ### Example ([live example](http://plnkr.co/edit/AHrB6opLqHDBPkt4KpdT?p=preview)):\n *\n * ```typescript\n * @Component({\n *   selector: 'my-cmp',\n *   template: `<p>myProp = {{myProp}}</p>`\n * })\n * class MyComponent implements OnChanges {\n *   @Input() myProp: any;\n *\n *   ngOnChanges(changes: SimpleChanges) {\n *     console.log('ngOnChanges - myProp = ' + changes['myProp'].currentValue);\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <button (click)=\"value = value + 1\">Change MyComponent</button>\n *     <my-cmp [my-prop]=\"value\"></my-cmp>`,\n *   directives: [MyComponent]\n * })\n * export class App {\n *   value = 0;\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n * ```\n * @stable\n */\nexport abstract class OnChanges {\n  abstract ngOnChanges(changes: SimpleChanges): any /** TODO #9100 */;\n}\n\n/**\n * Implement this interface to execute custom initialization logic after your directive's\n * data-bound properties have been initialized.\n *\n * `ngOnInit` is called right after the directive's data-bound properties have been checked for the\n * first time, and before any of its children have been checked. It is invoked only once when the\n * directive is instantiated.\n *\n * ### Example ([live example](http://plnkr.co/edit/1MBypRryXd64v4pV03Yn?p=preview))\n *\n * ```typescript\n * @Component({\n *   selector: 'my-cmp',\n *   template: `<p>my-component</p>`\n * })\n * class MyComponent implements OnInit, OnDestroy {\n *   ngOnInit() {\n *     console.log('ngOnInit');\n *   }\n *\n *   ngOnDestroy() {\n *     console.log('ngOnDestroy');\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <button (click)=\"hasChild = !hasChild\">\n *       {{hasChild ? 'Destroy' : 'Create'}} MyComponent\n *     </button>\n *     <my-cmp *ngIf=\"hasChild\"></my-cmp>`,\n *   directives: [MyComponent, NgIf]\n * })\n * export class App {\n *   hasChild = true;\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n *  ```\n * @stable\n */\nexport abstract class OnInit { abstract ngOnInit(): any /** TODO #9100 */; }\n\n/**\n * Implement this interface to supplement the default change detection algorithm in your directive.\n *\n * `ngDoCheck` gets called to check the changes in the directives in addition to the default\n * algorithm.\n *\n * The default change detection algorithm looks for differences by comparing bound-property values\n * by reference across change detection runs.\n *\n * Note that a directive typically should not use both `DoCheck` and {@link OnChanges} to respond to\n * changes on the same input. `ngOnChanges` will continue to be called when the default change\n * detector\n * detects changes, so it is usually unnecessary to respond to changes on the same input in both\n * hooks.\n * Reaction to the changes have to be handled from within the `ngDoCheck` callback.\n *\n * You can use {@link KeyValueDiffers} and {@link IterableDiffers} to help add your custom check\n * mechanisms.\n *\n * ### Example ([live demo](http://plnkr.co/edit/QpnIlF0CR2i5bcYbHEUJ?p=preview))\n *\n * In the following example `ngDoCheck` uses an {@link IterableDiffers} to detect the updates to the\n * array `list`:\n *\n * ```typescript\n * @Component({\n *   selector: 'custom-check',\n *   template: `\n *     <p>Changes:</p>\n *     <ul>\n *       <li *ngFor=\"let line of logs\">{{line}}</li>\n *     </ul>`,\n *   directives: [NgFor]\n * })\n * class CustomCheckComponent implements DoCheck {\n *   @Input() list: any[];\n *   differ: any;\n *   logs = [];\n *\n *   constructor(differs: IterableDiffers) {\n *     this.differ = differs.find([]).create(null);\n *   }\n *\n *   ngDoCheck() {\n *     var changes = this.differ.diff(this.list);\n *\n *     if (changes) {\n *       changes.forEachAddedItem(r => this.logs.push('added ' + r.item));\n *       changes.forEachRemovedItem(r => this.logs.push('removed ' + r.item))\n *     }\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <button (click)=\"list.push(list.length)\">Push</button>\n *     <button (click)=\"list.pop()\">Pop</button>\n *     <custom-check [list]=\"list\"></custom-check>`,\n *   directives: [CustomCheckComponent]\n * })\n * export class App {\n *   list = [];\n * }\n * ```\n * @stable\n */\nexport abstract class DoCheck { abstract ngDoCheck(): any /** TODO #9100 */; }\n\n/**\n * Implement this interface to get notified when your directive is destroyed.\n *\n * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the\n * instance is destroyed\n *\n * ### Example ([live example](http://plnkr.co/edit/1MBypRryXd64v4pV03Yn?p=preview))\n *\n * ```typesript\n * @Component({\n *   selector: 'my-cmp',\n *   template: `<p>my-component</p>`\n * })\n * class MyComponent implements OnInit, OnDestroy {\n *   ngOnInit() {\n *     console.log('ngOnInit');\n *   }\n *\n *   ngOnDestroy() {\n *     console.log('ngOnDestroy');\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <button (click)=\"hasChild = !hasChild\">\n *       {{hasChild ? 'Destroy' : 'Create'}} MyComponent\n *     </button>\n *     <my-cmp *ngIf=\"hasChild\"></my-cmp>`,\n *   directives: [MyComponent, NgIf]\n * })\n * export class App {\n *   hasChild = true;\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n * ```\n *\n *\n * To create a stateful Pipe, you should implement this interface and set the `pure`\n * parameter to `false` in the {@link PipeMetadata}.\n *\n * A stateful pipe may produce different output, given the same input. It is\n * likely that a stateful pipe may contain state that should be cleaned up when\n * a binding is destroyed. For example, a subscription to a stream of data may need to\n * be disposed, or an interval may need to be cleared.\n *\n * ### Example ([live demo](http://plnkr.co/edit/i8pm5brO4sPaLxBx56MR?p=preview))\n *\n * In this example, a pipe is created to countdown its input value, updating it every\n * 50ms. Because it maintains an internal interval, it automatically clears\n * the interval when the binding is destroyed or the countdown completes.\n *\n * ```\n * import {OnDestroy, Pipe, PipeTransform} from '@angular/core'\n * @Pipe({name: 'countdown', pure: false})\n * class CountDown implements PipeTransform, OnDestroy {\n *   remainingTime:Number;\n *   interval:SetInterval;\n *   ngOnDestroy() {\n *     if (this.interval) {\n *       clearInterval(this.interval);\n *     }\n *   }\n *   transform(value: any, args: any[] = []) {\n *     if (!parseInt(value, 10)) return null;\n *     if (typeof this.remainingTime !== 'number') {\n *       this.remainingTime = parseInt(value, 10);\n *     }\n *     if (!this.interval) {\n *       this.interval = setInterval(() => {\n *         this.remainingTime-=50;\n *         if (this.remainingTime <= 0) {\n *           this.remainingTime = 0;\n *           clearInterval(this.interval);\n *           delete this.interval;\n *         }\n *       }, 50);\n *     }\n *     return this.remainingTime;\n *   }\n * }\n * ```\n *\n * Invoking `{{ 10000 | countdown }}` would cause the value to be decremented by 50,\n * every 50ms, until it reaches 0.\n *\n * @stable\n */\nexport abstract class OnDestroy { abstract ngOnDestroy(): any /** TODO #9100 */; }\n\n/**\n * Implement this interface to get notified when your directive's content has been fully\n * initialized.\n *\n * ### Example ([live demo](http://plnkr.co/edit/plamXUpsLQbIXpViZhUO?p=preview))\n *\n * ```typescript\n * @Component({\n *   selector: 'child-cmp',\n *   template: `{{where}} child`\n * })\n * class ChildComponent {\n *   @Input() where: string;\n * }\n *\n * @Component({\n *   selector: 'parent-cmp',\n *   template: `<ng-content></ng-content>`\n * })\n * class ParentComponent implements AfterContentInit {\n *   @ContentChild(ChildComponent) contentChild: ChildComponent;\n *\n *   constructor() {\n *     // contentChild is not initialized yet\n *     console.log(this.getMessage(this.contentChild));\n *   }\n *\n *   ngAfterContentInit() {\n *     // contentChild is updated after the content has been checked\n *     console.log('AfterContentInit: ' + this.getMessage(this.contentChild));\n *   }\n *\n *   private getMessage(cmp: ChildComponent): string {\n *     return cmp ? cmp.where + ' child' : 'no child';\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <parent-cmp>\n *       <child-cmp where=\"content\"></child-cmp>\n *     </parent-cmp>`,\n *   directives: [ParentComponent, ChildComponent]\n * })\n * export class App {\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n * ```\n * @stable\n */\nexport abstract class AfterContentInit { abstract ngAfterContentInit(): any /** TODO #9100 */; }\n\n/**\n * Implement this interface to get notified after every check of your directive's content.\n *\n * ### Example ([live demo](http://plnkr.co/edit/tGdrytNEKQnecIPkD7NU?p=preview))\n *\n * ```typescript\n * @Component({selector: 'child-cmp', template: `{{where}} child`})\n * class ChildComponent {\n *   @Input() where: string;\n * }\n *\n * @Component({selector: 'parent-cmp', template: `<ng-content></ng-content>`})\n * class ParentComponent implements AfterContentChecked {\n *   @ContentChild(ChildComponent) contentChild: ChildComponent;\n *\n *   constructor() {\n *     // contentChild is not initialized yet\n *     console.log(this.getMessage(this.contentChild));\n *   }\n *\n *   ngAfterContentChecked() {\n *     // contentChild is updated after the content has been checked\n *     console.log('AfterContentChecked: ' + this.getMessage(this.contentChild));\n *   }\n *\n *   private getMessage(cmp: ChildComponent): string {\n *     return cmp ? cmp.where + ' child' : 'no child';\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <parent-cmp>\n *       <button (click)=\"hasContent = !hasContent\">Toggle content child</button>\n *       <child-cmp *ngIf=\"hasContent\" where=\"content\"></child-cmp>\n *     </parent-cmp>`,\n *   directives: [NgIf, ParentComponent, ChildComponent]\n * })\n * export class App {\n *   hasContent = true;\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n * ```\n * @stable\n */\nexport abstract class AfterContentChecked {\n  abstract ngAfterContentChecked(): any /** TODO #9100 */;\n}\n\n/**\n * Implement this interface to get notified when your component's view has been fully initialized.\n *\n * ### Example ([live demo](http://plnkr.co/edit/LhTKVMEM0fkJgyp4CI1W?p=preview))\n *\n * ```typescript\n * @Component({selector: 'child-cmp', template: `{{where}} child`})\n * class ChildComponent {\n *   @Input() where: string;\n * }\n *\n * @Component({\n *   selector: 'parent-cmp',\n *   template: `<child-cmp where=\"view\"></child-cmp>`,\n *   directives: [ChildComponent]\n * })\n * class ParentComponent implements AfterViewInit {\n *   @ViewChild(ChildComponent) viewChild: ChildComponent;\n *\n *   constructor() {\n *     // viewChild is not initialized yet\n *     console.log(this.getMessage(this.viewChild));\n *   }\n *\n *   ngAfterViewInit() {\n *     // viewChild is updated after the view has been initialized\n *     console.log('ngAfterViewInit: ' + this.getMessage(this.viewChild));\n *   }\n *\n *   private getMessage(cmp: ChildComponent): string {\n *     return cmp ? cmp.where + ' child' : 'no child';\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `<parent-cmp></parent-cmp>`,\n *   directives: [ParentComponent]\n * })\n * export class App {\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n * ```\n * @stable\n */\nexport abstract class AfterViewInit { abstract ngAfterViewInit(): any /** TODO #9100 */; }\n\n/**\n * Implement this interface to get notified after every check of your component's view.\n *\n * ### Example ([live demo](http://plnkr.co/edit/0qDGHcPQkc25CXhTNzKU?p=preview))\n *\n * ```typescript\n * @Component({selector: 'child-cmp', template: `{{where}} child`})\n * class ChildComponent {\n *   @Input() where: string;\n * }\n *\n * @Component({\n *   selector: 'parent-cmp',\n *   template: `\n *     <button (click)=\"showView = !showView\">Toggle view child</button>\n *     <child-cmp *ngIf=\"showView\" where=\"view\"></child-cmp>`,\n *   directives: [NgIf, ChildComponent]\n * })\n * class ParentComponent implements AfterViewChecked {\n *   @ViewChild(ChildComponent) viewChild: ChildComponent;\n *   showView = true;\n *\n *   constructor() {\n *     // viewChild is not initialized yet\n *     console.log(this.getMessage(this.viewChild));\n *   }\n *\n *   ngAfterViewChecked() {\n *     // viewChild is updated after the view has been checked\n *     console.log('AfterViewChecked: ' + this.getMessage(this.viewChild));\n *   }\n *\n *   private getMessage(cmp: ChildComponent): string {\n *     return cmp ? cmp.where + ' child' : 'no child';\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `<parent-cmp></parent-cmp>`,\n *   directives: [ParentComponent]\n * })\n * export class App {\n * }\n *\n * bootstrap(App).catch(err => console.error(err));\n * ```\n * @stable\n */\nexport abstract class AfterViewChecked { abstract ngAfterViewChecked(): any /** TODO #9100 */; }\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/esm/src/metadata/lifecycle_hooks.metadata.json

@@ -1 +1 @@
-{"__symbolic":"module","metadata":{"LIFECYCLE_HOOKS_VALUES":[{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"OnInit"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"OnDestroy"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"DoCheck"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"OnChanges"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterContentInit"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterContentChecked"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterViewInit"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterViewChecked"}]}}
+{"__symbolic":"module","version":1,"metadata":{"LIFECYCLE_HOOKS_VALUES":[{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"OnInit"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"OnDestroy"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"DoCheck"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"OnChanges"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterContentInit"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterContentChecked"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterViewInit"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"LifecycleHooks"},"member":"AfterViewChecked"}]}}

package/esm/src/metadata/view.d.ts

@@ -1,8 +1,10 @@
-import { Type } from '../../src/facade/lang';
+import { AnimationEntryMetadata } from '../animation/metadata';
+import { Type } from '../facade/lang';
 /**
  * Defines template and style encapsulation options available for Component's {@link View}.
  *
  * See {@link ViewMetadata#encapsulation}.
+ * @stable
  */
 export declare enum ViewEncapsulation {
     /**
@@ -111,7 +113,8 @@ export declare class ViewMetadata {
      * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
      */
     encapsulation: ViewEncapsulation;
-    constructor({templateUrl, template, directives, pipes, encapsulation, styles, styleUrls}?: {
+    animations: AnimationEntryMetadata[];
+    constructor({templateUrl, template, directives, pipes, encapsulation, styles, styleUrls, animations}?: {
         templateUrl?: string;
         template?: string;
         directives?: Array<Type | any[]>;
@@ -119,5 +122,6 @@ export declare class ViewMetadata {
         encapsulation?: ViewEncapsulation;
         styles?: string[];
         styleUrls?: string[];
+        animations?: AnimationEntryMetadata[];
     });
 }

package/esm/src/metadata/view.js

@@ -2,6 +2,7 @@
  * Defines template and style encapsulation options available for Component's {@link View}.
  *
  * See {@link ViewMetadata#encapsulation}.
+ * @stable
  */
 export var ViewEncapsulation;
 (function (ViewEncapsulation) {
@@ -58,7 +59,7 @@ export var VIEW_ENCAPSULATION_VALUES = [ViewEncapsulation.Emulated, ViewEncapsul
  * @ts2dart_const
  */
 export class ViewMetadata {
-    constructor({ templateUrl, template, directives, pipes, encapsulation, styles, styleUrls } = {}) {
+    constructor({ templateUrl, template, directives, pipes, encapsulation, styles, styleUrls, animations } = {}) {
         this.templateUrl = templateUrl;
         this.template = template;
         this.styleUrls = styleUrls;
@@ -66,6 +67,7 @@ export class ViewMetadata {
         this.directives = directives;
         this.pipes = pipes;
         this.encapsulation = encapsulation;
+        this.animations = animations;
     }
 }
 //# sourceMappingURL=view.js.map

package/esm/src/metadata/view.js.map

@@ -1 +1 @@
-{"version":3,"file":"view.js","sourceRoot":"/Users/iminar/Dev/angular/modules/@angular/core/","sources":["src/metadata/view.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,WAAY,iBAqBX;AArBD,WAAY,iBAAiB;IAC3B;;;;;;;OAOG;IACH,iEAAQ,CAAA;IACR;;;;;OAKG;IACH,6DAAM,CAAA;IACN;;OAEG;IACH,yDAAI,CAAA;AACN,CAAC,EArBW,iBAAiB,KAAjB,iBAAiB,QAqB5B;AAED,OAAO,IAAI,yBAAyB,GAChC,CAAC,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;AAGnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IA6DE,YAAY,EAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAC,GAQpF,EAAE;QACJ,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;AACH,CAAC;AAAA"}
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../modules/@angular/core/src/metadata/view.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,WAAY,iBAqBX;AArBD,WAAY,iBAAiB;IAC3B;;;;;;;OAOG;IACH,iEAAQ,CAAA;IACR;;;;;OAKG;IACH,6DAAM,CAAA;IACN;;OAEG;IACH,yDAAI,CAAA;AACN,CAAC,EArBW,iBAAiB,KAAjB,iBAAiB,QAqB5B;AAED,OAAO,IAAI,yBAAyB,GAChC,CAAC,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;AAGnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IA+DE,YACI,EAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAC,GASpF,EAAE;QACR,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;AACH,CAAC;AAAA","sourcesContent":["import {AnimationEntryMetadata} from '../animation/metadata';\nimport {Type} from '../facade/lang';\n\n\n/**\n * Defines template and style encapsulation options available for Component's {@link View}.\n *\n * See {@link ViewMetadata#encapsulation}.\n * @stable\n */\nexport enum ViewEncapsulation {\n  /**\n   * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host\n   * Element and pre-processing the style rules provided via\n   * {@link ViewMetadata#styles} or {@link ViewMetadata#stylesUrls}, and adding the new Host Element\n   * attribute to all selectors.\n   *\n   * This is the default option.\n   */\n  Emulated,\n  /**\n   * Use the native encapsulation mechanism of the renderer.\n   *\n   * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   * creating a ShadowRoot for Component's Host Element.\n   */\n  Native,\n  /**\n   * Don't provide any template or style encapsulation.\n   */\n  None\n}\n\nexport var VIEW_ENCAPSULATION_VALUES =\n    [ViewEncapsulation.Emulated, ViewEncapsulation.Native, ViewEncapsulation.None];\n\n\n/**\n * Metadata properties available for configuring Views.\n *\n * Each Angular component requires a single `@Component` and at least one `@View` annotation. The\n * `@View` annotation specifies the HTML template to use, and lists the directives that are active\n * within the template.\n *\n * When a component is instantiated, the template is loaded into the component's shadow root, and\n * the expressions and statements in the template are evaluated against the component.\n *\n * For details on the `@Component` annotation, see {@link ComponentMetadata}.\n *\n * ### Example\n *\n * ```\n * @Component({\n *   selector: 'greet',\n *   template: 'Hello {{name}}!',\n *   directives: [GreetUser, Bold]\n * })\n * class Greet {\n *   name: string;\n *\n *   constructor() {\n *     this.name = 'World';\n *   }\n * }\n * ```\n * @ts2dart_const\n */\nexport class ViewMetadata {\n  /**\n   * Specifies a template URL for an Angular component.\n   *\n   * NOTE: Only one of `templateUrl` or `template` can be defined per View.\n   *\n   * <!-- TODO: what's the url relative to? -->\n   */\n  templateUrl: string;\n\n  /**\n   * Specifies an inline template for an Angular component.\n   *\n   * NOTE: Only one of `templateUrl` or `template` can be defined per View.\n   */\n  template: string;\n\n  /**\n   * Specifies stylesheet URLs for an Angular component.\n   *\n   * <!-- TODO: what's the url relative to? -->\n   */\n  styleUrls: string[];\n\n  /**\n   * Specifies an inline stylesheet for an Angular component.\n   */\n  styles: string[];\n\n  /**\n   * Specifies a list of directives that can be used within a template.\n   *\n   * Directives must be listed explicitly to provide proper component encapsulation.\n   *\n   * ### Example\n   *\n   * ```javascript\n   * @Component({\n   *   selector: 'my-component',\n   *   directives: [NgFor]\n   *   template: '\n   *   <ul>\n   *     <li *ngFor=\"let item of items\">{{item}}</li>\n   *   </ul>'\n   * })\n   * class MyComponent {\n   * }\n   * ```\n   */\n  directives: Array<Type|any[]>;\n\n  pipes: Array<Type|any[]>;\n\n  /**\n   * Specify how the template and the styles should be encapsulated.\n   * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view\n   * has styles,\n   * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.\n   */\n  encapsulation: ViewEncapsulation;\n\n  animations: AnimationEntryMetadata[];\n\n  constructor(\n      {templateUrl, template, directives, pipes, encapsulation, styles, styleUrls, animations}: {\n        templateUrl?: string,\n        template?: string,\n        directives?: Array<Type|any[]>,\n        pipes?: Array<Type|any[]>,\n        encapsulation?: ViewEncapsulation,\n        styles?: string[],\n        styleUrls?: string[],\n        animations?: AnimationEntryMetadata[]\n      } = {}) {\n    this.templateUrl = templateUrl;\n    this.template = template;\n    this.styleUrls = styleUrls;\n    this.styles = styles;\n    this.directives = directives;\n    this.pipes = pipes;\n    this.encapsulation = encapsulation;\n    this.animations = animations;\n  }\n}\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/esm/src/metadata/view.metadata.json

@@ -1 +1 @@
-{"__symbolic":"module","metadata":{"VIEW_ENCAPSULATION_VALUES":[{"__symbolic":"select","expression":{"__symbolic":"reference","name":"ViewEncapsulation"},"member":"Emulated"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"ViewEncapsulation"},"member":"Native"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"ViewEncapsulation"},"member":"None"}]}}
+{"__symbolic":"module","version":1,"metadata":{"VIEW_ENCAPSULATION_VALUES":[{"__symbolic":"select","expression":{"__symbolic":"reference","name":"ViewEncapsulation"},"member":"Emulated"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"ViewEncapsulation"},"member":"Native"},{"__symbolic":"select","expression":{"__symbolic":"reference","name":"ViewEncapsulation"},"member":"None"}]}}