feat(core): added afterContentInit, afterViewInit, and afterViewChecked hooks

Closes #3897

modules/angular2/src/core/compiler/directive_lifecycle_reflector.dart

@@ -17,8 +17,14 @@ bool hasLifecycleHook(LifecycleEvent e, type, DirectiveMetadata annotation) {
       interface = OnChanges;
     } else if (e == LifecycleEvent.OnDestroy) {
       interface = OnDestroy;
+    } else if (e == LifecycleEvent.AfterContentInit) {
+      interface = AfterContentInit;
     } else if (e == LifecycleEvent.AfterContentChecked) {
       interface = AfterContentChecked;
+    } else if (e == LifecycleEvent.AfterViewInit) {
+      interface = AfterViewInit;
+    } else if (e == LifecycleEvent.AfterViewChecked) {
+      interface = AfterViewChecked;
     } else if (e == LifecycleEvent.DoCheck) {
       interface = DoCheck;
     } else if (e == LifecycleEvent.OnInit) {

modules/angular2/src/core/compiler/directive_lifecycle_reflector.ts

@@ -8,8 +8,14 @@ export function hasLifecycleHook(e: LifecycleEvent, type, annotation: DirectiveM
     if (!(type instanceof Type)) return false;
     var proto = (<any>type).prototype;
     switch (e) {
+      case LifecycleEvent.AfterContentInit:
+        return !!proto.afterContentInit;
       case LifecycleEvent.AfterContentChecked:
         return !!proto.afterContentChecked;
+      case LifecycleEvent.AfterViewInit:
+        return !!proto.afterViewInit;
+      case LifecycleEvent.AfterViewChecked:
+        return !!proto.afterViewChecked;
       case LifecycleEvent.OnChanges:
         return !!proto.onChanges;
       case LifecycleEvent.DoCheck:

modules/angular2/src/core/compiler/element_injector.ts

@@ -216,38 +216,41 @@ export class DirectiveBinding extends ResolvedBinding {
 
   get changeDetection() { return this.metadata.changeDetection; }
 
-  static createFromBinding(binding: Binding, ann: DirectiveMetadata): DirectiveBinding {
-    if (isBlank(ann)) {
-      ann = new DirectiveMetadata();
+  static createFromBinding(binding: Binding, meta: DirectiveMetadata): DirectiveBinding {
+    if (isBlank(meta)) {
+      meta = new DirectiveMetadata();
     }
 
     var rb = binding.resolve();
     var deps = ListWrapper.map(rb.dependencies, DirectiveDependency.createFrom);
-    var resolvedBindings = isPresent(ann.bindings) ? Injector.resolve(ann.bindings) : [];
-    var resolvedViewBindings = ann instanceof ComponentMetadata && isPresent(ann.viewBindings) ?
-                                   Injector.resolve(ann.viewBindings) :
+    var resolvedBindings = isPresent(meta.bindings) ? Injector.resolve(meta.bindings) : [];
+    var resolvedViewBindings = meta instanceof ComponentMetadata && isPresent(meta.viewBindings) ?
+                                   Injector.resolve(meta.viewBindings) :
                                    [];
     var metadata = RenderDirectiveMetadata.create({
       id: stringify(rb.key.token),
-      type: ann instanceof ComponentMetadata ? RenderDirectiveMetadata.COMPONENT_TYPE :
-                                               RenderDirectiveMetadata.DIRECTIVE_TYPE,
-      selector: ann.selector,
-      compileChildren: ann.compileChildren,
-      events: ann.events,
-      host: isPresent(ann.host) ? MapWrapper.createFromStringMap(ann.host) : null,
-      properties: ann.properties,
+      type: meta instanceof ComponentMetadata ? RenderDirectiveMetadata.COMPONENT_TYPE :
+                                                RenderDirectiveMetadata.DIRECTIVE_TYPE,
+      selector: meta.selector,
+      compileChildren: meta.compileChildren,
+      events: meta.events,
+      host: isPresent(meta.host) ? MapWrapper.createFromStringMap(meta.host) : null,
+      properties: meta.properties,
       readAttributes: DirectiveBinding._readAttributes(deps),
 
-      callOnDestroy: hasLifecycleHook(LifecycleEvent.OnDestroy, rb.key.token, ann),
-      callOnChanges: hasLifecycleHook(LifecycleEvent.OnChanges, rb.key.token, ann),
-      callDoCheck: hasLifecycleHook(LifecycleEvent.DoCheck, rb.key.token, ann),
-      callOnInit: hasLifecycleHook(LifecycleEvent.OnInit, rb.key.token, ann),
+      callOnDestroy: hasLifecycleHook(LifecycleEvent.OnDestroy, rb.key.token, meta),
+      callOnChanges: hasLifecycleHook(LifecycleEvent.OnChanges, rb.key.token, meta),
+      callDoCheck: hasLifecycleHook(LifecycleEvent.DoCheck, rb.key.token, meta),
+      callOnInit: hasLifecycleHook(LifecycleEvent.OnInit, rb.key.token, meta),
+      callAfterContentInit: hasLifecycleHook(LifecycleEvent.AfterContentInit, rb.key.token, meta),
       callAfterContentChecked:
-          hasLifecycleHook(LifecycleEvent.AfterContentChecked, rb.key.token, ann),
+          hasLifecycleHook(LifecycleEvent.AfterContentChecked, rb.key.token, meta),
+      callAfterViewInit: hasLifecycleHook(LifecycleEvent.AfterViewInit, rb.key.token, meta),
+      callAfterViewChecked: hasLifecycleHook(LifecycleEvent.AfterViewChecked, rb.key.token, meta),
 
-      changeDetection: ann instanceof ComponentMetadata ? ann.changeDetection : null,
+      changeDetection: meta instanceof ComponentMetadata ? meta.changeDetection : null,
 
-      exportAs: ann.exportAs
+      exportAs: meta.exportAs
     });
     return new DirectiveBinding(rb.key, rb.factory, deps, resolvedBindings, resolvedViewBindings,
                                 metadata);

modules/angular2/src/core/compiler/interfaces.ts

@@ -29,9 +29,30 @@ export interface DoCheck { doCheck(): boolean; }
  */
 export interface OnDestroy { onDestroy(): void; }
 
+/**
+ * Defines lifecycle method
+ * {@link metadata/LifeCycleEvent#AfterContentInit `LifeCycleEvent.afterContentInit`}
+ * called when the bindings of all its content children have been checked the first time.
+ */
+export interface AfterContentInit { afterContentInit(): void; }
+
 /**
  * Defines lifecycle method
  * {@link metadata/LifeCycleEvent#AfterContentChecked `LifeCycleEvent.afterContentChecked`}
- * called when the bindings of all its view children have been changed.
+ * called when the bindings of all its content children have been checked.
  */
 export interface AfterContentChecked { afterContentChecked(): void; }
+
+/**
+ * Defines lifecycle method
+ * {@link metadata/LifeCycleEvent#AfterViewInit `LifeCycleEvent.afterViewInit`}
+ * called when the bindings of all its view children have been checked the first time.
+ */
+export interface AfterViewInit { afterViewInit(): void; }
+
+/**
+ * Defines lifecycle method
+ * {@link metadata/LifeCycleEvent#AfterViewChecked `LifeCycleEvent.afterViewChecked`}
+ * called when the bindings of all its view children have been checked.
+ */
+export interface AfterViewChecked { afterViewChecked(): void; }

modules/angular2/src/core/compiler/proto_view_factory.ts

@@ -191,7 +191,10 @@ export class BindingRecordsCreator {
       this._directiveRecordsMap.set(
           id, new DirectiveRecord({
             directiveIndex: new DirectiveIndex(boundElementIndex, directiveIndex),
+            callAfterContentInit: directiveMetadata.callAfterContentInit,
             callAfterContentChecked: directiveMetadata.callAfterContentChecked,
+            callAfterViewInit: directiveMetadata.callAfterViewInit,
+            callAfterViewChecked: directiveMetadata.callAfterViewChecked,
             callOnChanges: directiveMetadata.callOnChanges,
             callDoCheck: directiveMetadata.callDoCheck,
             callOnInit: directiveMetadata.callOnInit,

modules/angular2/src/core/compiler/view.ts

@@ -212,6 +212,10 @@ export class AppView implements ChangeDispatcher, RenderEventDispatcher {
     }
   }
 
+  notifyAfterViewChecked(): void {
+    // required for query
+  }
+
   getDirectiveFor(directive: DirectiveIndex): any {
     var elementInjector = this.elementInjectors[this.elementOffset + directive.elementIndex];
     return elementInjector.getDirectiveAtIndex(directive.directiveIndex);