chore(rename): rename View and Template concepts for #1244

modules/angular2/src/render/api.js

@@ -20,7 +20,7 @@ export class ElementBinder {
   parentIndex:number;
   distanceToParent:number;
   directives:List<DirectiveBinder>;
-  nestedProtoView:ProtoView;
+  nestedProtoView:ProtoViewDto;
   propertyBindings: Map<string, ASTWithSource>;
   variableBindings: Map<string, ASTWithSource>;
   // Note: this contains a preprocessed AST
@@ -51,7 +51,7 @@ export class ElementBinder {
 }
 
 export class DirectiveBinder {
-  // Index into the array of directives in the Template instance
+  // Index into the array of directives in the View instance
   directiveIndex:any;
   propertyBindings: Map<string, ASTWithSource>;
   // Note: this contains a preprocessed AST
@@ -67,7 +67,7 @@ export class DirectiveBinder {
   }
 }
 
-export class ProtoView {
+export class ProtoViewDto {
   render: ProtoViewRef;
   elementBinders:List<ElementBinder>;
   variableBindings: Map<string, string>;
@@ -86,27 +86,27 @@ export class DirectiveMetadata {
   id:any;
   selector:string;
   compileChildren:boolean;
-  events:Map<string, string>;
-  bind:Map<string, string>;
+  hostListeners:Map<string, string>;
+  properties:Map<string, string>;
   setters:List<string>;
   readAttributes:List<string>;
   type:number;
-  constructor({id, selector, compileChildren, events, bind, setters, readAttributes, type}) {
+  constructor({id, selector, compileChildren, hostListeners, properties, setters, readAttributes, type}) {
     this.id = id;
     this.selector = selector;
     this.compileChildren = isPresent(compileChildren) ? compileChildren : true;
-    this.events = events;
-    this.bind = bind;
+    this.hostListeners = hostListeners;
+    this.properties = properties;
     this.setters = setters;
     this.readAttributes = readAttributes;
     this.type = type;
   }
 }
 
-// An opaque reference to a ProtoView
+// An opaque reference to a RenderProtoView
 export class ProtoViewRef {}
 
-// An opaque reference to a View
+// An opaque reference to a RenderView
 export class ViewRef {}
 
 export class ViewContainerRef {
@@ -118,43 +118,43 @@ export class ViewContainerRef {
   }
 }
 
-export class Template {
+export class ViewDefinition {
   componentId: string;
   absUrl: string;
-  inline: string;
+  template: string;
   directives: List<DirectiveMetadata>;
 
-  constructor({componentId, absUrl, inline, directives}) {
+  constructor({componentId, absUrl, template, directives}) {
     this.componentId = componentId;
     this.absUrl = absUrl;
-    this.inline = inline;
+    this.template = template;
     this.directives = directives;
   }
 }
 
 export class Renderer {
   /**
-   * Compiles a single ProtoView. Non recursive so that
+   * Compiles a single RenderProtoView. Non recursive so that
    * we don't need to serialize all possible components over the wire,
    * but only the needed ones based on previous calls.
    */
-  compile(template:Template):Promise<ProtoView> { return null; }
+  compile(template:ViewDefinition):Promise<ProtoViewDto> { return null; }
 
   /**
    * Sets the preset nested components,
    * which will be instantiated when this protoView is instantiated.
    * Note: We can't create new ProtoViewRefs here as we need to support cycles / recursive components.
    * @param {List<ProtoViewRef>} protoViewRefs
-   *    ProtoView for every element with a component in this protoView or in a view container's protoView
+   *    RenderProtoView for every element with a component in this protoView or in a view container's protoView
    */
   mergeChildComponentProtoViews(protoViewRef:ProtoViewRef, componentProtoViewRefs:List<ProtoViewRef>) { return null; }
 
   /**
-   * Creats a ProtoView that will create a root view for the given element,
+   * Creats a RenderProtoView that will create a root view for the given element,
    * i.e. it will not clone the element but only attach other proto views to it.
    * Contains a single nested component with the given componentId.
    */
-  createRootProtoView(selectorOrElement, componentId):Promise<ProtoView> { return null; }
+  createRootProtoView(selectorOrElement, componentId):Promise<ProtoViewDto> { return null; }
 
   /**
    * Creates a view and all of its nested child components.
@@ -182,7 +182,7 @@ export class Renderer {
   /**
    * Sets a property on an element.
    * Note: This will fail if the property was not mentioned previously as a propertySetter
-   * in the Template.
+   * in the View.
    */
   setElementProperty(view:ViewRef, elementIndex:number, propertyName:string, propertyValue:any):void {}
 
@@ -195,7 +195,7 @@ export class Renderer {
   /**
    * This will set the value for a text node.
    * Note: This needs to be separate from setElementProperty as we don't have ElementBinders
-   * for text nodes in the ProtoView either.
+   * for text nodes in the RenderProtoView either.
    */
   setText(view:ViewRef, textNodeIndex:number, text:string):void {}
 

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

@@ -2,7 +2,7 @@ import {List} from 'angular2/src/facade/collection';
 import {Promise} from 'angular2/src/facade/async';
 
 import {Parser} from 'angular2/change_detection';
-import {Template} from '../../api';
+import {ViewDefinition} from '../../api';
 import {CompileStep} from './compile_step';
 import {PropertyBindingParser} from './property_binding_parser';
 import {TextInterpolationParser} from './text_interpolation_parser';
@@ -12,7 +12,7 @@ import {ShadowDomCompileStep} from '../shadow_dom/shadow_dom_compile_step';
 import {ShadowDomStrategy} from '../shadow_dom/shadow_dom_strategy';
 
 export class CompileStepFactory {
-  createSteps(template: Template, subTaskPromises: List<Promise>):List<CompileStep> {
+  createSteps(template: ViewDefinition, subTaskPromises: List<Promise>):List<CompileStep> {
     return null;
   }
 }
@@ -27,7 +27,7 @@ export class DefaultStepFactory extends CompileStepFactory {
     this._shadowDomStrategy = shadowDomStrategy;
   }
 
-  createSteps(template: Template, subTaskPromises: List<Promise>) {
+  createSteps(template: ViewDefinition, subTaskPromises: List<Promise>) {
     return [
       new ViewSplitter(this._parser),
       new PropertyBindingParser(this._parser),
@@ -36,4 +36,4 @@ export class DefaultStepFactory extends CompileStepFactory {
       new ShadowDomCompileStep(this._shadowDomStrategy, template, subTaskPromises)
     ];
   }
-}
+}

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

@@ -3,7 +3,7 @@ import {Injectable} from 'angular2/di';
 import {PromiseWrapper, Promise} from 'angular2/src/facade/async';
 import {BaseException} from 'angular2/src/facade/lang';
 
-import {Template, ProtoView} from '../../api';
+import {ViewDefinition, ProtoViewDto} from '../../api';
 import {CompilePipeline} from './compile_pipeline';
 import {TemplateLoader} from 'angular2/src/render/dom/compiler/template_loader';
 import {CompileStepFactory, DefaultStepFactory} from './compile_step_factory';
@@ -24,7 +24,7 @@ export class Compiler {
     this._stepFactory = stepFactory;
   }
 
-  compile(template: Template):Promise<ProtoView> {
+  compile(template: ViewDefinition):Promise<ProtoViewDto> {
     var tplPromise = this._templateLoader.load(template);
     return PromiseWrapper.then(tplPromise,
       (el) => this._compileTemplate(template, el),
@@ -32,7 +32,7 @@ export class Compiler {
     );
   }
 
-  _compileTemplate(template: Template, tplElement):Promise<ProtoView> {
+  _compileTemplate(template: ViewDefinition, tplElement):Promise<ProtoViewDto> {
     var subTaskPromises = [];
     var pipeline = new CompilePipeline(this._stepFactory.createSteps(template, subTaskPromises));
     var compileElements;
@@ -54,4 +54,4 @@ export class DefaultCompiler extends Compiler {
   constructor(parser:Parser, shadowDomStrategy:ShadowDomStrategy, templateLoader: TemplateLoader) {
     super(new DefaultStepFactory(parser, shadowDomStrategy), templateLoader);
   }
-}
+}

modules/angular2/src/render/dom/compiler/directive_parser.js

@@ -58,13 +58,13 @@ export class DirectiveParser extends CompileStep {
       var directive = this._directives[directiveIndex];
       var directiveBinder = elementBinder.bindDirective(directiveIndex);
       current.compileChildren = current.compileChildren && directive.compileChildren;
-      if (isPresent(directive.bind)) {
-        MapWrapper.forEach(directive.bind, (bindConfig, dirProperty) => {
+      if (isPresent(directive.properties)) {
+        MapWrapper.forEach(directive.properties, (bindConfig, dirProperty) => {
           this._bindDirectiveProperty(dirProperty, bindConfig, current, directiveBinder);
         });
       }
-      if (isPresent(directive.events)) {
-        MapWrapper.forEach(directive.events, (action, eventName) => {
+      if (isPresent(directive.hostListeners)) {
+        MapWrapper.forEach(directive.hostListeners, (action, eventName) => {
           this._bindDirectiveEvent(eventName, action, current, directiveBinder);
         });
       }

modules/angular2/src/render/dom/compiler/template_loader.js

@@ -6,7 +6,7 @@ import {DOM} from 'angular2/src/dom/dom_adapter';
 
 import {XHR} from 'angular2/src/services/xhr';
 
-import {Template} from '../../api';
+import {ViewDefinition} from '../../api';
 import {UrlResolver} from 'angular2/src/services/url_resolver';
 
 /**
@@ -23,9 +23,9 @@ export class TemplateLoader {
     this._htmlCache = StringMapWrapper.create();
   }
 
-  load(template: Template):Promise {
-    if (isPresent(template.inline)) {
-      return PromiseWrapper.resolve(DOM.createTemplate(template.inline));
+  load(template: ViewDefinition):Promise {
+    if (isPresent(template.template)) {
+      return PromiseWrapper.resolve(DOM.createTemplate(template.template));
     }
     var url = template.absUrl;
     if (isPresent(url)) {
@@ -42,6 +42,6 @@ export class TemplateLoader {
       return promise;
     }
 
-    throw new BaseException('Templates should have either their url or inline property set');
+    throw new BaseException('View should have either the url or template property set');
   }
 }

modules/angular2/src/render/dom/direct_dom_renderer.js

@@ -4,8 +4,8 @@ import {List, ListWrapper} from 'angular2/src/facade/collection';
 import {isBlank, isPresent} from 'angular2/src/facade/lang';
 
 import * as api from '../api';
-import {View} from './view/view';
-import {ProtoView} from './view/proto_view';
+import {RenderView} from './view/view';
+import {RenderProtoView} from './view/proto_view';
 import {ViewFactory} from './view/view_factory';
 import {Compiler} from './compiler/compiler';
 import {ShadowDomStrategy} from './shadow_dom/shadow_dom_strategy';
@@ -23,7 +23,7 @@ function _resolveProtoView(protoViewRef:DirectDomProtoViewRef) {
   return isPresent(protoViewRef) ? protoViewRef.delegate : null;
 }
 
-function _wrapView(view:View) {
+function _wrapView(view:RenderView) {
   return new DirectDomViewRef(view);
 }
 
@@ -44,18 +44,18 @@ function _collectComponentChildViewRefs(view, target = null) {
 
 // public so that the compiler can use it.
 export class DirectDomProtoViewRef extends api.ProtoViewRef {
-  delegate:ProtoView;
+  delegate:RenderProtoView;
 
-  constructor(delegate:ProtoView) {
+  constructor(delegate:RenderProtoView) {
     super();
     this.delegate = delegate;
   }
 }
 
 export class DirectDomViewRef extends api.ViewRef {
-  delegate:View;
+  delegate:RenderView;
 
-  constructor(delegate:View) {
+  constructor(delegate:RenderView) {
     super();
     this.delegate = delegate;
   }
@@ -75,7 +75,7 @@ export class DirectDomRenderer extends api.Renderer {
     this._shadowDomStrategy = shadowDomStrategy;
   }
 
-  compile(template:api.Template):Promise<api.ProtoView> {
+  compile(template:api.ViewDefinition):Promise<api.ProtoViewDto> {
     // Note: compiler already uses a DirectDomProtoViewRef, so we don't
     // need to do anything here
     return this._compiler.compile(template);
@@ -87,7 +87,7 @@ export class DirectDomRenderer extends api.Renderer {
     );
   }
 
-  createRootProtoView(selectorOrElement, componentId):Promise<api.ProtoView> {
+  createRootProtoView(selectorOrElement, componentId):Promise<api.ProtoViewDto> {
     var element = selectorOrElement; // TODO: select the element if it is not a real element...
     var rootProtoViewBuilder = new ProtoViewBuilder(element);
     rootProtoViewBuilder.setIsRootView(true);

modules/angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy.js

@@ -33,12 +33,12 @@ export class EmulatedUnscopedShadowDomStrategy extends ShadowDomStrategy {
     return false;
   }
 
-  attachTemplate(el, view:viewModule.View) {
+  attachTemplate(el, view:viewModule.RenderView) {
     DOM.clearNodes(el);
     moveViewNodesIntoParent(el, view);
   }
 
-  constructLightDom(lightDomView:viewModule.View, shadowDomView:viewModule.View, el): LightDom {
+  constructLightDom(lightDomView:viewModule.RenderView, shadowDomView:viewModule.RenderView, el): LightDom {
     return new LightDom(lightDomView, shadowDomView, el);
   }
 
@@ -51,4 +51,4 @@ export class EmulatedUnscopedShadowDomStrategy extends ShadowDomStrategy {
     insertSharedStyleText(cssText, this.styleHost, styleEl);
     return null;
   }
-}
+}

modules/angular2/src/render/dom/shadow_dom/light_dom.js

@@ -23,14 +23,14 @@ class _Root {
 // once interfaces are supported
 export class LightDom {
   // The light DOM of the element is enclosed inside the lightDomView
-  lightDomView:viewModule.View;
+  lightDomView:viewModule.RenderView;
   // The shadow DOM
-  shadowDomView:viewModule.View;
+  shadowDomView:viewModule.RenderView;
   // The nodes of the light DOM
   nodes:List;
   roots:List<_Root>;
 
-  constructor(lightDomView:viewModule.View, shadowDomView:viewModule.View, element) {
+  constructor(lightDomView:viewModule.RenderView, shadowDomView:viewModule.RenderView, element) {
     this.lightDomView = lightDomView;
     this.shadowDomView = shadowDomView;
     this.nodes = DOM.childNodesAsList(element);
@@ -50,7 +50,7 @@ export class LightDom {
   }
 
   // Collects the Content directives from the view and all its child views
-  _collectAllContentTags(view: viewModule.View, acc:List<Content>):List<Content> {
+  _collectAllContentTags(view: viewModule.RenderView, acc:List<Content>):List<Content> {
     var contentTags = view.contentTags;
     var vcs = view.viewContainers;
     for (var i=0; i<vcs.length; i++) {

modules/angular2/src/render/dom/shadow_dom/native_shadow_dom_strategy.js

@@ -22,7 +22,7 @@ export class NativeShadowDomStrategy extends ShadowDomStrategy {
     this.styleUrlResolver = styleUrlResolver;
   }
 
-  attachTemplate(el, view:viewModule.View){
+  attachTemplate(el, view:viewModule.RenderView){
     moveViewNodesIntoParent(DOM.createShadowRoot(el), view);
   }
 

modules/angular2/src/render/dom/shadow_dom/shadow_dom_compile_step.js

@@ -7,15 +7,15 @@ import {DOM} from 'angular2/src/dom/dom_adapter';
 import {CompileStep} from '../compiler/compile_step';
 import {CompileElement} from '../compiler/compile_element';
 import {CompileControl} from '../compiler/compile_control';
-import {Template} from '../../api';
+import {ViewDefinition} from '../../api';
 import {ShadowDomStrategy} from './shadow_dom_strategy';
 
 export class ShadowDomCompileStep extends CompileStep {
   _shadowDomStrategy: ShadowDomStrategy;
-  _template: Template;
+  _template: ViewDefinition;
   _subTaskPromises: List<Promise>;
 
-  constructor(shadowDomStrategy: ShadowDomStrategy, template: Template, subTaskPromises:List<Promise>) {
+  constructor(shadowDomStrategy: ShadowDomStrategy, template: ViewDefinition, subTaskPromises:List<Promise>) {
     super();
     this._shadowDomStrategy = shadowDomStrategy;
     this._template = template;

modules/angular2/src/render/dom/shadow_dom/shadow_dom_strategy.js

@@ -9,9 +9,9 @@ export class ShadowDomStrategy {
     return true;
   }
 
-  attachTemplate(el, view:viewModule.View) {}
+  attachTemplate(el, view:viewModule.RenderView) {}
 
-  constructLightDom(lightDomView:viewModule.View, shadowDomView:viewModule.View, el): LightDom {
+  constructLightDom(lightDomView:viewModule.RenderView, shadowDomView:viewModule.RenderView, el): LightDom {
     return null;
   }
 

modules/angular2/src/render/dom/view/element_binder.js

@@ -6,7 +6,7 @@ import * as protoViewModule from './proto_view';
 export class ElementBinder {
   contentTagSelector: string;
   textNodeIndices: List<number>;
-  nestedProtoView: protoViewModule.ProtoView;
+  nestedProtoView: protoViewModule.RenderProtoView;
   eventLocals: AST;
   eventNames: List<string>;
   componentId: string;

modules/angular2/src/render/dom/view/proto_view.js

@@ -6,7 +6,7 @@ import {List, Map, ListWrapper, MapWrapper} from 'angular2/src/facade/collection
 import {ElementBinder} from './element_binder';
 import {NG_BINDING_CLASS} from '../util';
 
-export class ProtoView {
+export class RenderProtoView {
   element;
   elementBinders:List<ElementBinder>;
   isTemplateElement:boolean;
@@ -25,7 +25,7 @@ export class ProtoView {
     this.rootBindingOffset = (isPresent(this.element) && DOM.hasClass(this.element, NG_BINDING_CLASS)) ? 1 : 0;
   }
 
-  mergeChildComponentProtoViews(componentProtoViews:List<ProtoView>) {
+  mergeChildComponentProtoViews(componentProtoViews:List<RenderProtoView>) {
     var componentProtoViewIndex = 0;
     for (var i=0; i<this.elementBinders.length; i++) {
       var eb = this.elementBinders[i];

modules/angular2/src/render/dom/view/proto_view_builder.js

@@ -7,7 +7,7 @@ import {
 } from 'angular2/change_detection';
 import {SetterFn} from 'angular2/src/reflection/types';
 
-import {ProtoView} from './proto_view';
+import {RenderProtoView} from './proto_view';
 import {ElementBinder} from './element_binder';
 import {setterFactory} from './property_setter_factory';
 
@@ -39,7 +39,7 @@ export class ProtoViewBuilder {
 
   bindVariable(name, value) {
     // Store the variable map from value to variable, reflecting how it will be used later by
-    // View. When a local is set to the view, a lookup for the variable name will take place keyed
+    // RenderView. When a local is set to the view, a lookup for the variable name will take place keyed
     // by the "value", or exported identifier. For example, ng-repeat sets a view local of "index".
     // When this occurs, a lookup keyed by "index" must occur to find if there is a var referencing
     // it.
@@ -50,7 +50,7 @@ export class ProtoViewBuilder {
     this.isRootView = value;
   }
 
-  build():api.ProtoView {
+  build():api.ProtoViewDto {
     var renderElementBinders = [];
 
     var apiElementBinders = [];
@@ -91,8 +91,8 @@ export class ProtoViewBuilder {
         propertySetters: propertySetters
       }));
     });
-    return new api.ProtoView({
-      render: new directDomRenderer.DirectDomProtoViewRef(new ProtoView({
+    return new api.ProtoViewDto({
+      render: new directDomRenderer.DirectDomProtoViewRef(new RenderProtoView({
         element: this.rootElement,
         elementBinders: renderElementBinders,
         isRootView: this.isRootView
@@ -183,7 +183,7 @@ export class ElementBinderBuilder {
       this.nestedProtoView.bindVariable(name, value);
     } else {
       // Store the variable map from value to variable, reflecting how it will be used later by
-      // View. When a local is set to the view, a lookup for the variable name will take place keyed
+      // RenderView. When a local is set to the view, a lookup for the variable name will take place keyed
       // by the "value", or exported identifier. For example, ng-repeat sets a view local of "index".
       // When this occurs, a lookup keyed by "index" must occur to find if there is a var referencing
       // it.
@@ -283,4 +283,4 @@ export class EventLocalsAstSplitter extends AstTransformer {
   buildEventNames() {
     return this.eventNames;
   }
-}
+}

modules/angular2/src/render/dom/view/view.js

@@ -3,7 +3,7 @@ import {ListWrapper, MapWrapper, Map, StringMapWrapper, List} from 'angular2/src
 import {int, isPresent, isBlank, BaseException} from 'angular2/src/facade/lang';
 
 import {ViewContainer} from './view_container';
-import {ProtoView} from './proto_view';
+import {RenderProtoView} from './proto_view';
 import {LightDom} from '../shadow_dom/light_dom';
 import {Content} from '../shadow_dom/content_tag';
 
@@ -16,7 +16,7 @@ const NG_BINDING_CLASS = 'ng-binding';
 /**
  * Const of making objects: http://jsperf.com/instantiate-size-of-object
  */
-export class View {
+export class RenderView {
   boundElements:List;
   boundTextNodes:List;
   /// When the view is part of render tree, the DocumentFragment is empty, which is why we need
@@ -24,16 +24,16 @@ export class View {
   rootNodes:List;
   // TODO(tbosch): move componentChildViews, viewContainers, contentTags, lightDoms into
   // a single array with records inside
-  componentChildViews: List<View>;
+  componentChildViews: List<RenderView>;
   viewContainers: List<ViewContainer>;
   contentTags: List<Content>;
   lightDoms: List<LightDom>;
-  proto: ProtoView;
+  proto: RenderProtoView;
   _hydrated: boolean;
   _eventDispatcher: any/*EventDispatcher*/;
 
   constructor(
-      proto:ProtoView, rootNodes:List,
+      proto:RenderProtoView, rootNodes:List,
       boundTextNodes: List, boundElements:List, viewContainers:List, contentTags:List) {
     this.proto = proto;
     this.rootNodes = rootNodes;
@@ -61,7 +61,7 @@ export class View {
   }
 
   setComponentView(strategy: ShadowDomStrategy,
-      elementIndex:number, childView:View) {
+      elementIndex:number, childView:RenderView) {
     var element = this.boundElements[elementIndex];
     var lightDom = strategy.constructLightDom(this, childView, element);
     strategy.attachTemplate(element, childView);

modules/angular2/src/render/dom/view/view_container.js

@@ -9,7 +9,7 @@ import * as vfModule from './view_factory';
 export class ViewContainer {
   _viewFactory: vfModule.ViewFactory;
   templateElement;
-  _views: List<viewModule.View>;
+  _views: List<viewModule.RenderView>;
   _lightDom: ldModule.LightDom;
   _hostLightDom: ldModule.LightDom;
   _hydrated: boolean;
@@ -53,7 +53,7 @@ export class ViewContainer {
     this._hydrated = false;
   }
 
-  get(index: number): viewModule.View {
+  get(index: number): viewModule.RenderView {
     return this._views[index];
   }
 
@@ -71,7 +71,7 @@ export class ViewContainer {
         'Cannot change dehydrated ViewContainer');
   }
 
-  insert(view, atIndex=-1): viewModule.View {
+  insert(view, atIndex=-1): viewModule.RenderView {
     if (!view.hydrated()) {
       view.hydrate(this._hostLightDom);
     }

modules/angular2/src/render/dom/view/view_factory.js

@@ -19,7 +19,7 @@ export const VIEW_POOL_CAPACITY = 'render.ViewFactory.viewPoolCapacity';
 @Injectable()
 export class ViewFactory {
   _poolCapacity:number;
-  _pooledViews:List<viewModule.View>;
+  _pooledViews:List<viewModule.RenderView>;
   _eventManager:EventManager;
   _shadowDomStrategy:ShadowDomStrategy;
 
@@ -30,7 +30,7 @@ export class ViewFactory {
     this._shadowDomStrategy = shadowDomStrategy;
   }
 
-  getView(protoView:pvModule.ProtoView):viewModule.View {
+  getView(protoView:pvModule.RenderProtoView):viewModule.RenderView {
     // TODO(tbosch): benchmark this scanning of views and maybe
     // replace it with a fancy LRU Map/List combination...
     var view;
@@ -46,7 +46,7 @@ export class ViewFactory {
     return view;
   }
 
-  returnView(view:viewModule.View) {
+  returnView(view:viewModule.RenderView) {
     if (view.hydrated()) {
       view.dehydrate();
     }
@@ -56,7 +56,7 @@ export class ViewFactory {
     }
   }
 
-  _createView(protoView:pvModule.ProtoView): viewModule.View {
+  _createView(protoView:pvModule.RenderProtoView): viewModule.RenderView {
     var rootElementClone = protoView.isRootView ? protoView.element : DOM.importIntoDoc(protoView.element);
     var elementsWithBindingsDynamic;
     if (protoView.isTemplateElement) {
@@ -73,7 +73,7 @@ export class ViewFactory {
     var viewRootNodes;
     if (protoView.isTemplateElement) {
       var childNode = DOM.firstChild(DOM.content(rootElementClone));
-      viewRootNodes = []; // TODO(perf): Should be fixed size, since we could pre-compute in in pvModule.ProtoView
+      viewRootNodes = []; // TODO(perf): Should be fixed size, since we could pre-compute in in pvModule.RenderProtoView
       // Note: An explicit loop is the fastest way to convert a DOM array into a JS array!
       while(childNode != null) {
         ListWrapper.push(viewRootNodes, childNode);
@@ -121,7 +121,7 @@ export class ViewFactory {
       contentTags[binderIdx] = contentTag;
     }
 
-    var view = new viewModule.View(
+    var view = new viewModule.RenderView(
       protoView, viewRootNodes,
       boundTextNodes, boundElements, viewContainers, contentTags
     );
@@ -156,4 +156,4 @@ export class ViewFactory {
       view.dispatchEvent(elementIndex, eventName, event);
     });
   }
-}
+}