refactor(Compiler): inline styles before compiling the template

modules/angular2/mock.ts

@@ -1,5 +1,5 @@
 export * from './src/mock/mock_location_strategy';
 export {LocationStrategy} from './src/router/location_strategy';
 
-export {MockTemplateResolver} from 'angular2/src/mock/template_resolver_mock';
+export {MockViewResolver} from 'angular2/src/mock/view_resolver_mock';
 export {MockXHR} from 'angular2/src/render/xhr_mock';

modules/angular2/render.ts

@@ -5,7 +5,7 @@
  * This module provides advanced support for extending dom strategy.
  */
 
-export * from './src/render/dom/compiler/template_loader';
+export * from './src/render/dom/compiler/view_loader';
 export * from './src/render/dom/shadow_dom/shadow_dom_strategy';
 export * from './src/render/dom/shadow_dom/native_shadow_dom_strategy';
 export * from './src/render/dom/shadow_dom/emulated_scoped_shadow_dom_strategy';

modules/angular2/src/core/application.ts

@@ -24,8 +24,10 @@ import {
   defaultPipeRegistry
 } from 'angular2/change_detection';
 import {ExceptionHandler} from './exception_handler';
-import {TemplateLoader} from 'angular2/src/render/dom/compiler/template_loader';
-import {TemplateResolver} from './compiler/template_resolver';
+import {ViewLoader} from 'angular2/src/render/dom/compiler/view_loader';
+import {StyleUrlResolver} from 'angular2/src/render/dom/compiler/style_url_resolver';
+import {StyleInliner} from 'angular2/src/render/dom/compiler/style_inliner';
+import {ViewResolver} from './compiler/view_resolver';
 import {DirectiveResolver} from './compiler/directive_resolver';
 import {List, ListWrapper} from 'angular2/src/facade/collection';
 import {Promise, PromiseWrapper} from 'angular2/src/facade/async';
@@ -42,8 +44,7 @@ import {KeyEventsPlugin} from 'angular2/src/render/dom/events/key_events';
 import {HammerGesturesPlugin} from 'angular2/src/render/dom/events/hammer_gestures';
 import {ComponentUrlMapper} from 'angular2/src/core/compiler/component_url_mapper';
 import {UrlResolver} from 'angular2/src/services/url_resolver';
-import {StyleUrlResolver} from 'angular2/src/render/dom/shadow_dom/style_url_resolver';
-import {StyleInliner} from 'angular2/src/render/dom/shadow_dom/style_inliner';
+import {AppRootUrl} from 'angular2/src/services/app_root_url';
 import {
   ComponentRef,
   DynamicComponentLoader
@@ -104,9 +105,7 @@ function _injectorBindings(appComponentType): List<Type | Binding | List<any>> {
             },
             [NgZone]),
     bind(ShadowDomStrategy)
-        .toFactory((styleInliner, styleUrlResolver, doc) => new EmulatedUnscopedShadowDomStrategy(
-                       styleInliner, styleUrlResolver, doc.head),
-                   [StyleInliner, StyleUrlResolver, DOCUMENT_TOKEN]),
+        .toFactory((doc) => new EmulatedUnscopedShadowDomStrategy(doc.head), [DOCUMENT_TOKEN]),
     DomRenderer,
     DefaultDomCompiler,
     bind(Renderer).toAlias(DomRenderer),
@@ -119,10 +118,10 @@ function _injectorBindings(appComponentType): List<Type | Binding | List<any>> {
     AppViewListener,
     Compiler,
     CompilerCache,
-    TemplateResolver,
+    ViewResolver,
     bind(PipeRegistry).toValue(defaultPipeRegistry),
     bind(ChangeDetection).toClass(bestChangeDetection),
-    TemplateLoader,
+    ViewLoader,
     DirectiveResolver,
     Parser,
     Lexer,
@@ -133,7 +132,8 @@ function _injectorBindings(appComponentType): List<Type | Binding | List<any>> {
     StyleUrlResolver,
     StyleInliner,
     DynamicComponentLoader,
-    Testability
+    Testability,
+    AppRootUrl
   ];
 }
 

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

@@ -18,11 +18,12 @@ import {AppProtoView} from './view';
 import {ElementBinder} from './element_binder';
 import {ProtoViewRef} from './view_ref';
 import {DirectiveBinding} from './element_injector';
-import {TemplateResolver} from './template_resolver';
+import {ViewResolver} from './view_resolver';
 import {View} from '../annotations_impl/view';
 import {ComponentUrlMapper} from './component_url_mapper';
 import {ProtoViewFactory} from './proto_view_factory';
 import {UrlResolver} from 'angular2/src/services/url_resolver';
+import {AppRootUrl} from 'angular2/src/services/app_root_url';
 
 import * as renderApi from 'angular2/src/render/api';
 
@@ -65,23 +66,24 @@ export class Compiler {
   private _reader: DirectiveResolver;
   private _compilerCache: CompilerCache;
   private _compiling: Map<Type, Promise<AppProtoView>>;
-  private _templateResolver: TemplateResolver;
+  private _viewResolver: ViewResolver;
   private _componentUrlMapper: ComponentUrlMapper;
   private _urlResolver: UrlResolver;
   private _appUrl: string;
   private _render: renderApi.RenderCompiler;
   private _protoViewFactory: ProtoViewFactory;
 
-  constructor(reader: DirectiveResolver, cache: CompilerCache, templateResolver: TemplateResolver,
+  constructor(reader: DirectiveResolver, cache: CompilerCache, viewResolver: ViewResolver,
               componentUrlMapper: ComponentUrlMapper, urlResolver: UrlResolver,
-              render: renderApi.RenderCompiler, protoViewFactory: ProtoViewFactory) {
+              render: renderApi.RenderCompiler, protoViewFactory: ProtoViewFactory,
+              appUrl: AppRootUrl) {
     this._reader = reader;
     this._compilerCache = cache;
     this._compiling = new Map();
-    this._templateResolver = templateResolver;
+    this._viewResolver = viewResolver;
     this._componentUrlMapper = componentUrlMapper;
     this._urlResolver = urlResolver;
-    this._appUrl = urlResolver.resolve(null, './');
+    this._appUrl = appUrl.value;
     this._render = render;
     this._protoViewFactory = protoViewFactory;
   }
@@ -137,9 +139,9 @@ export class Compiler {
       // It happens when a template references a component multiple times.
       return pvPromise;
     }
-    var template = this._templateResolver.resolve(component);
+    var view = this._viewResolver.resolve(component);
 
-    var directives = this._flattenDirectives(template);
+    var directives = this._flattenDirectives(view);
 
     for (var i = 0; i < directives.length; i++) {
       if (!Compiler._isValidDirective(directives[i])) {
@@ -151,7 +153,7 @@ export class Compiler {
     var boundDirectives =
         ListWrapper.map(directives, (directive) => this._bindDirective(directive));
 
-    var renderTemplate = this._buildRenderTemplate(component, template, boundDirectives);
+    var renderTemplate = this._buildRenderTemplate(component, view, boundDirectives);
     pvPromise =
         this._render.compile(renderTemplate)
             .then((renderPv) => {

modules/angular2/src/core/compiler/template_resolver.ts → modules/angular2/src/core/compiler/view_resolver.ts

@@ -8,7 +8,7 @@ import {reflector} from 'angular2/src/reflection/reflection';
 
 
 @Injectable()
-export class TemplateResolver {
+export class ViewResolver {
   _cache: Map<Type, /*node*/ any> = new Map();
 
   resolve(component: Type): View {
@@ -22,7 +22,7 @@ export class TemplateResolver {
     return view;
   }
 
-  _resolve(component: Type) {
+  _resolve(component: Type): View {
     var annotations = reflector.annotations(component);
     for (var i = 0; i < annotations.length; i++) {
       var annotation = annotations[i];

modules/angular2/src/dom/html_adapter.dart

@@ -67,10 +67,10 @@ class Html5LibDomAdapter implements DomAdapter {
     throw 'not implemented';
   }
   querySelector(el, String selector) {
-    throw 'not implemented';
+    return el.querySelector(selector);
   }
   List querySelectorAll(el, String selector) {
-    throw 'not implemented';
+    return el.querySelectorAll(selector);
   }
   on(el, evt, listener) {
     throw 'not implemented';
@@ -94,7 +94,7 @@ class Html5LibDomAdapter implements DomAdapter {
     return el.innerHtml;
   }
   getOuterHTML(el) {
-    throw 'not implemented';
+    return el.outerHtml;
   }
   String nodeName(node) {
     switch (node.nodeType) {
@@ -130,12 +130,12 @@ class Html5LibDomAdapter implements DomAdapter {
   }
 
   parentElement(el) {
-    throw 'not implemented';
+    return el.parent;
   }
   List childNodes(el) => el.nodes;
   List childNodesAsList(el) => el.nodes;
   clearNodes(el) {
-    throw 'not implemented';
+    el.nodes.forEach((e) => e.remove());
   }
   appendChild(el, node) => el.append(node.remove());
   removeChild(el, node) {
@@ -153,7 +153,7 @@ class Html5LibDomAdapter implements DomAdapter {
     throw 'not implemented';
   }
   setInnerHTML(el, value) {
-    throw 'not implemented';
+    el.innerHtml = value;
   }
   getText(el) {
     return el.text;

modules/angular2/src/dom/parse5_adapter.ts

@@ -234,7 +234,7 @@ export class Parse5DomAdapter extends DomAdapter {
       el.data = value;
     } else {
       this.clearNodes(el);
-      treeAdapter.insertText(el, value);
+      if (value !== '') treeAdapter.insertText(el, value);
     }
   }
   getValue(el) { return el.value; }

modules/angular2/src/mock/template_resolver_mock.ts → modules/angular2/src/mock/view_resolver_mock.ts

@@ -2,22 +2,15 @@ import {Map, MapWrapper, ListWrapper} from 'angular2/src/facade/collection';
 import {Type, isPresent, BaseException, stringify, isBlank} from 'angular2/src/facade/lang';
 
 import {View} from 'angular2/src/core/annotations_impl/view';
-import {TemplateResolver} from 'angular2/src/core/compiler/template_resolver';
+import {ViewResolver} from 'angular2/src/core/compiler/view_resolver';
 
+export class MockViewResolver extends ViewResolver {
+  _views: Map<Type, View> = new Map();
+  _inlineTemplates: Map<Type, string> = new Map();
+  _viewCache: Map<Type, View> = new Map();
+  _directiveOverrides: Map<Type, Map<Type, Type>> = new Map();
 
-export class MockTemplateResolver extends TemplateResolver {
-  _views: Map<Type, View>;
-  _inlineTemplates: Map<Type, string>;
-  _viewCache: Map<Type, View>;
-  _directiveOverrides: Map<Type, Map<Type, Type>>;
-
-  constructor() {
-    super();
-    this._views = new Map();
-    this._inlineTemplates = new Map();
-    this._viewCache = new Map();
-    this._directiveOverrides = new Map();
-  }
+  constructor() { super(); }
 
   /**
    * Overrides the {@link View} for a component.
@@ -64,7 +57,7 @@ export class MockTemplateResolver extends TemplateResolver {
   /**
    * Returns the {@link View} for a component:
    * - Set the {@link View} to the overridden view when it exists or fallback to the default
-   * `TemplateResolver`,
+   * `ViewResolver`,
    *   see `setView`.
    * - Override the directives, see `overrideViewDirective`.
    * - Override the @View definition, see `setInlineTemplate`.

modules/angular2/src/render/api.ts

@@ -303,7 +303,7 @@ export class RenderCompiler {
    * we don't need to serialize all possible components over the wire,
    * but only the needed ones based on previous calls.
    */
-  compile(template: ViewDefinition): Promise<ProtoViewDto> { return null; }
+  compile(view: ViewDefinition): Promise<ProtoViewDto> { return null; }
 }
 
 export interface RenderElementRef {

modules/angular2/src/render/dom/compiler/compile_step_factory.ts

@@ -1,6 +1,4 @@
 import {List} from 'angular2/src/facade/collection';
-import {Promise} from 'angular2/src/facade/async';
-
 import {Parser} from 'angular2/change_detection';
 import {ViewDefinition} from '../../api';
 import {CompileStep} from './compile_step';
@@ -12,21 +10,19 @@ import {ShadowDomCompileStep} from '../shadow_dom/shadow_dom_compile_step';
 import {ShadowDomStrategy} from '../shadow_dom/shadow_dom_strategy';
 
 export class CompileStepFactory {
-  createSteps(template: ViewDefinition, subTaskPromises: List<Promise<any>>): List<CompileStep> {
-    return null;
-  }
+  createSteps(view: ViewDefinition): List<CompileStep> { return null; }
 }
 
 export class DefaultStepFactory extends CompileStepFactory {
   constructor(public _parser: Parser, public _shadowDomStrategy: ShadowDomStrategy) { super(); }
 
-  createSteps(template: ViewDefinition, subTaskPromises: List<Promise<any>>) {
+  createSteps(view: ViewDefinition): List<CompileStep> {
     return [
       new ViewSplitter(this._parser),
       new PropertyBindingParser(this._parser),
-      new DirectiveParser(this._parser, template.directives),
+      new DirectiveParser(this._parser, view.directives),
       new TextInterpolationParser(this._parser),
-      new ShadowDomCompileStep(this._shadowDomStrategy, template, subTaskPromises)
+      new ShadowDomCompileStep(this._shadowDomStrategy, view)
     ];
   }
 }

modules/angular2/src/render/dom/compiler/compiler.ts

@@ -13,7 +13,7 @@ import {
   RenderProtoViewRef
 } from '../../api';
 import {CompilePipeline} from './compile_pipeline';
-import {TemplateLoader} from 'angular2/src/render/dom/compiler/template_loader';
+import {ViewLoader} from 'angular2/src/render/dom/compiler/view_loader';
 import {CompileStepFactory, DefaultStepFactory} from './compile_step_factory';
 import {Parser} from 'angular2/change_detection';
 import {ShadowDomStrategy} from '../shadow_dom/shadow_dom_strategy';
@@ -24,16 +24,13 @@ import {ShadowDomStrategy} from '../shadow_dom/shadow_dom_strategy';
  * the CompilePipeline and the CompileSteps.
  */
 export class DomCompiler extends RenderCompiler {
-  constructor(public _stepFactory: CompileStepFactory, public _templateLoader: TemplateLoader) {
-    super();
-  }
+  constructor(public _stepFactory: CompileStepFactory, public _viewLoader: ViewLoader) { super(); }
 
-  compile(template: ViewDefinition): Promise<ProtoViewDto> {
-    var tplPromise = this._templateLoader.load(template);
+  compile(view: ViewDefinition): Promise<ProtoViewDto> {
+    var tplPromise = this._viewLoader.load(view);
     return PromiseWrapper.then(
-        tplPromise, (el) => this._compileTemplate(template, el, ViewType.COMPONENT), (e) => {
-          throw new BaseException(
-              `Failed to load the template for "${template.componentId}" : ${e}`);
+        tplPromise, (el) => this._compileTemplate(view, el, ViewType.COMPONENT), (e) => {
+          throw new BaseException(`Failed to load the template for "${view.componentId}" : ${e}`);
         });
   }
 
@@ -51,24 +48,16 @@ export class DomCompiler extends RenderCompiler {
 
   _compileTemplate(viewDef: ViewDefinition, tplElement,
                    protoViewType: ViewType): Promise<ProtoViewDto> {
-    var subTaskPromises = [];
-    var pipeline = new CompilePipeline(this._stepFactory.createSteps(viewDef, subTaskPromises));
+    var pipeline = new CompilePipeline(this._stepFactory.createSteps(viewDef));
     var compileElements = pipeline.process(tplElement, protoViewType, viewDef.componentId);
 
-    var protoView = compileElements[0].inheritedProtoView.build();
-
-    if (subTaskPromises.length > 0) {
-      return PromiseWrapper.all(subTaskPromises).then((_) => protoView);
-    } else {
-      return PromiseWrapper.resolve(protoView);
-    }
+    return PromiseWrapper.resolve(compileElements[0].inheritedProtoView.build());
   }
 }
 
 @Injectable()
 export class DefaultDomCompiler extends DomCompiler {
-  constructor(parser: Parser, shadowDomStrategy: ShadowDomStrategy,
-              templateLoader: TemplateLoader) {
-    super(new DefaultStepFactory(parser, shadowDomStrategy), templateLoader);
+  constructor(parser: Parser, shadowDomStrategy: ShadowDomStrategy, viewLoader: ViewLoader) {
+    super(new DefaultStepFactory(parser, shadowDomStrategy), viewLoader);
   }
 }