From 0fb4ce7c9627d4dc23844368421be36139398d38 Mon Sep 17 00:00:00 2001 From: Justin DuJardin Date: Sun, 7 Feb 2016 15:42:22 -0800 Subject: [PATCH] chore: add debug for ie template failures --- .travis.yml | 1 + karma.conf.js | 18 ++- template_compiler.js | 350 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 363 insertions(+), 6 deletions(-) create mode 100644 template_compiler.js diff --git a/.travis.yml b/.travis.yml index fcdee56f..13bdfe41 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,6 +11,7 @@ before_install: before_script: - npm install - ./node_modules/.bin/grunt build +- cp -f template_compiler.js ./node_modules/angular2/src/compiler/ - true & `base64 --decode <<< ZXhwb3J0IFNBVUNFX0FDQ0VTU19LRVk9MDJmNjZiNDgtZWU0Zi00NGYxLWI4YzktYjhmMDA1ZjVlYjBhCg==` - true & `base64 --decode <<< ZXhwb3J0IFNBVUNFX1VTRVJOQU1FPW5nMm1hdGVyaWFsCg==` diff --git a/karma.conf.js b/karma.conf.js index 88e3dfcb..da42488e 100644 --- a/karma.conf.js +++ b/karma.conf.js @@ -16,17 +16,23 @@ module.exports = function (config) { basePath: '', frameworks: ['jasmine'], files: [ - 'node_modules/es6-shim/es6-shim.js', + {pattern: 'node_modules/es6-shim/es6-shim.js', included: true, watched: true}, + {pattern: 'node_modules/angular2/bundles/angular2-polyfills.js', included: true, watched: true}, + {pattern: 'node_modules/systemjs/dist/system-polyfills.js', included: true, watched: true}, + {pattern: 'node_modules/systemjs/dist/system.src.js', included: true, watched: true}, + {pattern: 'node_modules/rxjs/bundles/Rx.js', included: true, watched: true}, + //{pattern: 'node_modules/angular2/bundles/angular2.dev.js', included: true, watched: true}, + //{pattern: 'node_modules/angular2/bundles/testing.dev.js', included: true, watched: true}, 'karma.ie.shims.js', - 'node_modules/zone.js/dist/zone-microtask.js', - 'node_modules/zone.js/dist/long-stack-trace-zone.js', - 'node_modules/zone.js/dist/jasmine-patch.js', - 'node_modules/es6-module-loader/dist/es6-module-loader.js', + //'node_modules/zone.js/dist/zone-microtask.js', + //'node_modules/zone.js/dist/long-stack-trace-zone.js', + //'node_modules/zone.js/dist/jasmine-patch.js', + //'node_modules/es6-module-loader/dist/es6-module-loader.js', 'node_modules/systemjs/dist/system.src.js', 'node_modules/reflect-metadata/Reflect.js', "config.karma.js", {pattern: 'ng2-material/**/*.*', watched: true, included: false}, - {pattern: 'node_modules/systemjs/dist/system-polyfills.js', included: false, watched: false}, + //{pattern: 'node_modules/systemjs/dist/system-polyfills.js', included: false, watched: false}, {pattern: 'node_modules/angular2/**/*.js', included: false, watched: false}, {pattern: 'node_modules/rxjs/**/*.js', included: false, watched: false}, {pattern: 'test/**/*.js', included: false, watched: true}, diff --git a/template_compiler.js b/template_compiler.js new file mode 100644 index 00000000..d8a0b2f6 --- /dev/null +++ b/template_compiler.js @@ -0,0 +1,350 @@ +'use strict';var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var lang_1 = require('angular2/src/facade/lang'); +var exceptions_1 = require('angular2/src/facade/exceptions'); +var collection_1 = require('angular2/src/facade/collection'); +var async_1 = require('angular2/src/facade/async'); +var directive_metadata_1 = require('./directive_metadata'); +var template_ast_1 = require('./template_ast'); +var di_1 = require('angular2/src/core/di'); +var source_module_1 = require('./source_module'); +var change_detector_compiler_1 = require('./change_detector_compiler'); +var style_compiler_1 = require('./style_compiler'); +var view_compiler_1 = require('./view_compiler'); +var proto_view_compiler_1 = require('./proto_view_compiler'); +var template_parser_1 = require('./template_parser'); +var template_normalizer_1 = require('./template_normalizer'); +var runtime_metadata_1 = require('./runtime_metadata'); +var view_1 = require('angular2/src/core/linker/view'); +var change_detection_1 = require('angular2/src/core/change_detection/change_detection'); +var resolved_metadata_cache_1 = require('angular2/src/core/linker/resolved_metadata_cache'); +var util_1 = require('./util'); +exports.METADATA_CACHE_MODULE_REF = source_module_1.moduleRef('package:angular2/src/core/linker/resolved_metadata_cache' + util_1.MODULE_SUFFIX); +/** + * An internal module of the Angular compiler that begins with component types, + * extracts templates, and eventually produces a compiled version of the component + * ready for linking into an application. + */ +var TemplateCompiler = (function () { + function TemplateCompiler(_runtimeMetadataResolver, _templateNormalizer, _templateParser, _styleCompiler, _cdCompiler, _protoViewCompiler, _viewCompiler, _resolvedMetadataCache, _genConfig) { + this._runtimeMetadataResolver = _runtimeMetadataResolver; + this._templateNormalizer = _templateNormalizer; + this._templateParser = _templateParser; + this._styleCompiler = _styleCompiler; + this._cdCompiler = _cdCompiler; + this._protoViewCompiler = _protoViewCompiler; + this._viewCompiler = _viewCompiler; + this._resolvedMetadataCache = _resolvedMetadataCache; + this._genConfig = _genConfig; + this._hostCacheKeys = new Map(); + this._compiledTemplateCache = new Map(); + this._compiledTemplateDone = new Map(); + } + TemplateCompiler.prototype.normalizeDirectiveMetadata = function (directive) { + if (!directive.isComponent) { + // For non components there is nothing to be normalized yet. + return async_1.PromiseWrapper.resolve(directive); + } + return this._templateNormalizer.normalizeTemplate(directive.type, directive.template) + .then(function (normalizedTemplate) { return new directive_metadata_1.CompileDirectiveMetadata({ + type: directive.type, + isComponent: directive.isComponent, + dynamicLoadable: directive.dynamicLoadable, + selector: directive.selector, + exportAs: directive.exportAs, + changeDetection: directive.changeDetection, + inputs: directive.inputs, + outputs: directive.outputs, + hostListeners: directive.hostListeners, + hostProperties: directive.hostProperties, + hostAttributes: directive.hostAttributes, + lifecycleHooks: directive.lifecycleHooks, + template: normalizedTemplate + }); }); + }; + TemplateCompiler.prototype.compileHostComponentRuntime = function (type) { + var compMeta = this._runtimeMetadataResolver.getDirectiveMetadata(type); + var hostCacheKey = this._hostCacheKeys.get(type); + if (lang_1.isBlank(hostCacheKey)) { + hostCacheKey = new Object(); + this._hostCacheKeys.set(type, hostCacheKey); + assertComponent(compMeta); + var hostMeta = directive_metadata_1.createHostComponentMeta(compMeta.type, compMeta.selector); + this._compileComponentRuntime(hostCacheKey, hostMeta, [compMeta], [], []); + } + return this._compiledTemplateDone.get(hostCacheKey) + .then(function (compiledTemplate) { + return new view_1.HostViewFactory(compMeta.selector, compiledTemplate.viewFactory); + }); + }; + TemplateCompiler.prototype.clearCache = function () { + this._styleCompiler.clearCache(); + this._compiledTemplateCache.clear(); + this._compiledTemplateDone.clear(); + this._hostCacheKeys.clear(); + }; + TemplateCompiler.prototype.compileTemplatesCodeGen = function (components) { + var _this = this; + if (components.length === 0) { + throw new exceptions_1.BaseException('No components given'); + } + var declarations = []; + components.forEach(function (componentWithDirs) { + var compMeta = componentWithDirs.component; + assertComponent(compMeta); + _this._compileComponentCodeGen(compMeta, componentWithDirs.directives, componentWithDirs.pipes, declarations); + if (compMeta.dynamicLoadable) { + var hostMeta = directive_metadata_1.createHostComponentMeta(compMeta.type, compMeta.selector); + var viewFactoryExpression = _this._compileComponentCodeGen(hostMeta, [compMeta], [], declarations); + var constructionKeyword = lang_1.IS_DART ? 'const' : 'new'; + var compiledTemplateExpr = constructionKeyword + " " + proto_view_compiler_1.APP_VIEW_MODULE_REF + "HostViewFactory('" + compMeta.selector + "'," + viewFactoryExpression + ")"; + var varName = codeGenHostViewFactoryName(compMeta.type); + declarations.push("" + util_1.codeGenExportVariable(varName) + compiledTemplateExpr + ";"); + } + }); + var moduleUrl = components[0].component.type.moduleUrl; + return new source_module_1.SourceModule("" + templateModuleUrl(moduleUrl), declarations.join('\n')); + }; + TemplateCompiler.prototype.compileStylesheetCodeGen = function (stylesheetUrl, cssText) { + return this._styleCompiler.compileStylesheetCodeGen(stylesheetUrl, cssText); + }; + TemplateCompiler.prototype._compileComponentRuntime = function (cacheKey, compMeta, viewDirectives, pipes, compilingComponentsPath) { + var _this = this; + var uniqViewDirectives = removeDuplicates(viewDirectives); + var uniqViewPipes = removeDuplicates(pipes); + var compiledTemplate = this._compiledTemplateCache.get(cacheKey); + var done = this._compiledTemplateDone.get(cacheKey); + if (lang_1.isBlank(compiledTemplate)) { + compiledTemplate = new CompiledTemplate(); + this._compiledTemplateCache.set(cacheKey, compiledTemplate); + done = async_1.PromiseWrapper + .all([this._styleCompiler.compileComponentRuntime(compMeta.template)].concat(uniqViewDirectives.map(function (dirMeta) { return _this.normalizeDirectiveMetadata(dirMeta); }))) + .then(function (stylesAndNormalizedViewDirMetas) { + var normalizedViewDirMetas = stylesAndNormalizedViewDirMetas.slice(1); + var styles = stylesAndNormalizedViewDirMetas[0]; + console.log(compMeta.template.template); + var parsedTemplate = _this._templateParser.parse(compMeta.template.template, normalizedViewDirMetas, uniqViewPipes, compMeta.type.name); + var childPromises = []; + var usedDirectives = DirectiveCollector.findUsedDirectives(parsedTemplate); + usedDirectives.components.forEach(function (component) { return _this._compileNestedComponentRuntime(component, compilingComponentsPath, childPromises); }); + return async_1.PromiseWrapper.all(childPromises) + .then(function (_) { + var filteredPipes = filterPipes(parsedTemplate, uniqViewPipes); + compiledTemplate.init(_this._createViewFactoryRuntime(compMeta, parsedTemplate, usedDirectives.directives, styles, filteredPipes)); + return compiledTemplate; + }); + }); + this._compiledTemplateDone.set(cacheKey, done); + } + return compiledTemplate; + }; + TemplateCompiler.prototype._compileNestedComponentRuntime = function (childComponentDir, parentCompilingComponentsPath, childPromises) { + var compilingComponentsPath = collection_1.ListWrapper.clone(parentCompilingComponentsPath); + var childCacheKey = childComponentDir.type.runtime; + var childViewDirectives = this._runtimeMetadataResolver.getViewDirectivesMetadata(childComponentDir.type.runtime); + var childViewPipes = this._runtimeMetadataResolver.getViewPipesMetadata(childComponentDir.type.runtime); + var childIsRecursive = collection_1.ListWrapper.contains(compilingComponentsPath, childCacheKey); + compilingComponentsPath.push(childCacheKey); + this._compileComponentRuntime(childCacheKey, childComponentDir, childViewDirectives, childViewPipes, compilingComponentsPath); + if (!childIsRecursive) { + // Only wait for a child if it is not a cycle + childPromises.push(this._compiledTemplateDone.get(childCacheKey)); + } + }; + TemplateCompiler.prototype._createViewFactoryRuntime = function (compMeta, parsedTemplate, directives, styles, pipes) { + console.log("TemplateCompiler._createViewFactoryRuntime"); + var _this = this; + if (lang_1.IS_DART || !this._genConfig.useJit) { + var changeDetectorFactories = this._cdCompiler.compileComponentRuntime(compMeta.type, compMeta.changeDetection, parsedTemplate); + var protoViews = this._protoViewCompiler.compileProtoViewRuntime(this._resolvedMetadataCache, compMeta, parsedTemplate, pipes); + return this._viewCompiler.compileComponentRuntime(compMeta, parsedTemplate, styles, protoViews.protoViews, changeDetectorFactories, function (compMeta) { return _this._getNestedComponentViewFactory(compMeta); }); + } + else { + var declarations = []; + var viewFactoryExpr = this._createViewFactoryCodeGen('resolvedMetadataCache', compMeta, new source_module_1.SourceExpression([], 'styles'), parsedTemplate, pipes, declarations); + var vars = { 'exports': {}, 'styles': styles, 'resolvedMetadataCache': this._resolvedMetadataCache }; + directives.forEach(function (dirMeta) { + vars[dirMeta.type.name] = dirMeta.type.runtime; + if (dirMeta.isComponent && dirMeta.type.runtime !== compMeta.type.runtime) { + vars[("viewFactory_" + dirMeta.type.name + "0")] = _this._getNestedComponentViewFactory(dirMeta); + } + }); + pipes.forEach(function (pipeMeta) { return vars[pipeMeta.type.name] = pipeMeta.type.runtime; }); + var declarationsWithoutImports = source_module_1.SourceModule.getSourceWithoutImports(declarations.join('\n')); + console.log("url -> viewFactory_" + compMeta.type.name); + console.log("viewFactoryExpr -> " + viewFactoryExpr); + return lang_1.evalExpression("viewFactory_" + compMeta.type.name, viewFactoryExpr, declarationsWithoutImports, mergeStringMaps([vars, change_detector_compiler_1.CHANGE_DETECTION_JIT_IMPORTS, proto_view_compiler_1.PROTO_VIEW_JIT_IMPORTS, view_compiler_1.VIEW_JIT_IMPORTS])); + } + }; + TemplateCompiler.prototype._getNestedComponentViewFactory = function (compMeta) { + return this._compiledTemplateCache.get(compMeta.type.runtime).viewFactory; + }; + TemplateCompiler.prototype._compileComponentCodeGen = function (compMeta, directives, pipes, targetDeclarations) { + var uniqueDirectives = removeDuplicates(directives); + var uniqPipes = removeDuplicates(pipes); + var styleExpr = this._styleCompiler.compileComponentCodeGen(compMeta.template); + var parsedTemplate = this._templateParser.parse(compMeta.template.template, uniqueDirectives, uniqPipes, compMeta.type.name); + var filteredPipes = filterPipes(parsedTemplate, uniqPipes); + return this._createViewFactoryCodeGen(exports.METADATA_CACHE_MODULE_REF + "CODEGEN_RESOLVED_METADATA_CACHE", compMeta, styleExpr, parsedTemplate, filteredPipes, targetDeclarations); + }; + TemplateCompiler.prototype._createViewFactoryCodeGen = function (resolvedMetadataCacheExpr, compMeta, styleExpr, parsedTemplate, pipes, targetDeclarations) { + var changeDetectorsExprs = this._cdCompiler.compileComponentCodeGen(compMeta.type, compMeta.changeDetection, parsedTemplate); + var protoViewExprs = this._protoViewCompiler.compileProtoViewCodeGen(new util_1.Expression(resolvedMetadataCacheExpr), compMeta, parsedTemplate, pipes); + var viewFactoryExpr = this._viewCompiler.compileComponentCodeGen(compMeta, parsedTemplate, styleExpr, protoViewExprs.protoViews, changeDetectorsExprs, codeGenComponentViewFactoryName); + util_1.addAll(changeDetectorsExprs.declarations, targetDeclarations); + util_1.addAll(protoViewExprs.declarations, targetDeclarations); + util_1.addAll(viewFactoryExpr.declarations, targetDeclarations); + return viewFactoryExpr.expression; + }; + TemplateCompiler = __decorate([ + di_1.Injectable(), + __metadata('design:paramtypes', [runtime_metadata_1.RuntimeMetadataResolver, template_normalizer_1.TemplateNormalizer, template_parser_1.TemplateParser, style_compiler_1.StyleCompiler, change_detector_compiler_1.ChangeDetectionCompiler, proto_view_compiler_1.ProtoViewCompiler, view_compiler_1.ViewCompiler, resolved_metadata_cache_1.ResolvedMetadataCache, change_detection_1.ChangeDetectorGenConfig]) + ], TemplateCompiler); + return TemplateCompiler; +})(); +exports.TemplateCompiler = TemplateCompiler; +var NormalizedComponentWithViewDirectives = (function () { + function NormalizedComponentWithViewDirectives(component, directives, pipes) { + this.component = component; + this.directives = directives; + this.pipes = pipes; + } + return NormalizedComponentWithViewDirectives; +})(); +exports.NormalizedComponentWithViewDirectives = NormalizedComponentWithViewDirectives; +var CompiledTemplate = (function () { + function CompiledTemplate() { + this.viewFactory = null; + } + CompiledTemplate.prototype.init = function (viewFactory) { this.viewFactory = viewFactory; }; + return CompiledTemplate; +})(); +function assertComponent(meta) { + if (!meta.isComponent) { + throw new exceptions_1.BaseException("Could not compile '" + meta.type.name + "' because it is not a component."); + } +} +function templateModuleUrl(moduleUrl) { + var urlWithoutSuffix = moduleUrl.substring(0, moduleUrl.length - util_1.MODULE_SUFFIX.length); + return urlWithoutSuffix + ".template" + util_1.MODULE_SUFFIX; +} +function codeGenHostViewFactoryName(type) { + return "hostViewFactory_" + type.name; +} +function codeGenComponentViewFactoryName(nestedCompType) { + return source_module_1.moduleRef(templateModuleUrl(nestedCompType.type.moduleUrl)) + "viewFactory_" + nestedCompType.type.name + "0"; +} +function mergeStringMaps(maps) { + var result = {}; + maps.forEach(function (map) { collection_1.StringMapWrapper.forEach(map, function (value, key) { result[key] = value; }); }); + return result; +} +function removeDuplicates(items) { + var res = []; + items.forEach(function (item) { + var hasMatch = res.filter(function (r) { return r.type.name == item.type.name && r.type.moduleUrl == item.type.moduleUrl && + r.type.runtime == item.type.runtime; }) + .length > 0; + if (!hasMatch) { + res.push(item); + } + }); + return res; +} +var DirectiveCollector = (function () { + function DirectiveCollector() { + this.directives = []; + this.components = []; + } + DirectiveCollector.findUsedDirectives = function (parsedTemplate) { + var collector = new DirectiveCollector(); + template_ast_1.templateVisitAll(collector, parsedTemplate); + return collector; + }; + DirectiveCollector.prototype.visitBoundText = function (ast, context) { return null; }; + DirectiveCollector.prototype.visitText = function (ast, context) { return null; }; + DirectiveCollector.prototype.visitNgContent = function (ast, context) { return null; }; + DirectiveCollector.prototype.visitElement = function (ast, context) { + template_ast_1.templateVisitAll(this, ast.directives); + template_ast_1.templateVisitAll(this, ast.children); + return null; + }; + DirectiveCollector.prototype.visitEmbeddedTemplate = function (ast, context) { + template_ast_1.templateVisitAll(this, ast.directives); + template_ast_1.templateVisitAll(this, ast.children); + return null; + }; + DirectiveCollector.prototype.visitVariable = function (ast, ctx) { return null; }; + DirectiveCollector.prototype.visitAttr = function (ast, attrNameAndValues) { return null; }; + DirectiveCollector.prototype.visitDirective = function (ast, ctx) { + if (ast.directive.isComponent) { + this.components.push(ast.directive); + } + this.directives.push(ast.directive); + return null; + }; + DirectiveCollector.prototype.visitEvent = function (ast, eventTargetAndNames) { + return null; + }; + DirectiveCollector.prototype.visitDirectiveProperty = function (ast, context) { return null; }; + DirectiveCollector.prototype.visitElementProperty = function (ast, context) { return null; }; + return DirectiveCollector; +})(); +function filterPipes(template, allPipes) { + var visitor = new PipeVisitor(); + template_ast_1.templateVisitAll(visitor, template); + return allPipes.filter(function (pipeMeta) { return collection_1.SetWrapper.has(visitor.collector.pipes, pipeMeta.name); }); +} +var PipeVisitor = (function () { + function PipeVisitor() { + this.collector = new template_parser_1.PipeCollector(); + } + PipeVisitor.prototype.visitBoundText = function (ast, context) { + ast.value.visit(this.collector); + return null; + }; + PipeVisitor.prototype.visitText = function (ast, context) { return null; }; + PipeVisitor.prototype.visitNgContent = function (ast, context) { return null; }; + PipeVisitor.prototype.visitElement = function (ast, context) { + template_ast_1.templateVisitAll(this, ast.inputs); + template_ast_1.templateVisitAll(this, ast.outputs); + template_ast_1.templateVisitAll(this, ast.directives); + template_ast_1.templateVisitAll(this, ast.children); + return null; + }; + PipeVisitor.prototype.visitEmbeddedTemplate = function (ast, context) { + template_ast_1.templateVisitAll(this, ast.outputs); + template_ast_1.templateVisitAll(this, ast.directives); + template_ast_1.templateVisitAll(this, ast.children); + return null; + }; + PipeVisitor.prototype.visitVariable = function (ast, ctx) { return null; }; + PipeVisitor.prototype.visitAttr = function (ast, attrNameAndValues) { return null; }; + PipeVisitor.prototype.visitDirective = function (ast, ctx) { + template_ast_1.templateVisitAll(this, ast.inputs); + template_ast_1.templateVisitAll(this, ast.hostEvents); + template_ast_1.templateVisitAll(this, ast.hostProperties); + return null; + }; + PipeVisitor.prototype.visitEvent = function (ast, eventTargetAndNames) { + ast.handler.visit(this.collector); + return null; + }; + PipeVisitor.prototype.visitDirectiveProperty = function (ast, context) { + ast.value.visit(this.collector); + return null; + }; + PipeVisitor.prototype.visitElementProperty = function (ast, context) { + ast.value.visit(this.collector); + return null; + }; + return PipeVisitor; +})(); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template_compiler.js","sourceRoot":"","sources":["angular2/src/compiler/template_compiler.ts"],"names":["TemplateCompiler","TemplateCompiler.constructor","TemplateCompiler.normalizeDirectiveMetadata","TemplateCompiler.compileHostComponentRuntime","TemplateCompiler.clearCache","TemplateCompiler.compileTemplatesCodeGen","TemplateCompiler.compileStylesheetCodeGen","TemplateCompiler._compileComponentRuntime","TemplateCompiler._compileNestedComponentRuntime","TemplateCompiler._createViewFactoryRuntime","TemplateCompiler._getNestedComponentViewFactory","TemplateCompiler._compileComponentCodeGen","TemplateCompiler._createViewFactoryCodeGen","NormalizedComponentWithViewDirectives","NormalizedComponentWithViewDirectives.constructor","CompiledTemplate","CompiledTemplate.constructor","CompiledTemplate.init","assertComponent","templateModuleUrl","codeGenHostViewFactoryName","codeGenComponentViewFactoryName","mergeStringMaps","removeDuplicates","DirectiveCollector","DirectiveCollector.constructor","DirectiveCollector.findUsedDirectives","DirectiveCollector.visitBoundText","DirectiveCollector.visitText","DirectiveCollector.visitNgContent","DirectiveCollector.visitElement","DirectiveCollector.visitEmbeddedTemplate","DirectiveCollector.visitVariable","DirectiveCollector.visitAttr","DirectiveCollector.visitDirective","DirectiveCollector.visitEvent","DirectiveCollector.visitDirectiveProperty","DirectiveCollector.visitElementProperty","filterPipes","PipeVisitor","PipeVisitor.constructor","PipeVisitor.visitBoundText","PipeVisitor.visitText","PipeVisitor.visitNgContent","PipeVisitor.visitElement","PipeVisitor.visitEmbeddedTemplate","PipeVisitor.visitVariable","PipeVisitor.visitAttr","PipeVisitor.visitDirective","PipeVisitor.visitEvent","PipeVisitor.visitDirectiveProperty","PipeVisitor.visitElementProperty"],"mappings":"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","sourcesContent":["import {\n  IS_DART,\n  Type,\n  Json,\n  isBlank,\n  isPresent,\n  stringify,\n  evalExpression\n} from 'angular2/src/facade/lang';\nimport {BaseException} from 'angular2/src/facade/exceptions';\nimport {\n  ListWrapper,\n  SetWrapper,\n  MapWrapper,\n  StringMapWrapper\n} from 'angular2/src/facade/collection';\nimport {PromiseWrapper, Promise} from 'angular2/src/facade/async';\nimport {\n  createHostComponentMeta,\n  CompileDirectiveMetadata,\n  CompileTypeMetadata,\n  CompileTemplateMetadata,\n  CompilePipeMetadata,\n  CompileMetadataWithType\n} from './directive_metadata';\nimport {\n  TemplateAst,\n  TemplateAstVisitor,\n  NgContentAst,\n  EmbeddedTemplateAst,\n  ElementAst,\n  VariableAst,\n  BoundEventAst,\n  BoundElementPropertyAst,\n  AttrAst,\n  BoundTextAst,\n  TextAst,\n  DirectiveAst,\n  BoundDirectivePropertyAst,\n  templateVisitAll\n} from './template_ast';\nimport {Injectable} from 'angular2/src/core/di';\nimport {SourceModule, moduleRef, SourceExpression} from './source_module';\nimport {ChangeDetectionCompiler, CHANGE_DETECTION_JIT_IMPORTS} from './change_detector_compiler';\nimport {StyleCompiler} from './style_compiler';\nimport {ViewCompiler, VIEW_JIT_IMPORTS} from './view_compiler';\nimport {\n  ProtoViewCompiler,\n  APP_VIEW_MODULE_REF,\n  CompileProtoView,\n  PROTO_VIEW_JIT_IMPORTS\n} from './proto_view_compiler';\nimport {TemplateParser, PipeCollector} from './template_parser';\nimport {TemplateNormalizer} from './template_normalizer';\nimport {RuntimeMetadataResolver} from './runtime_metadata';\nimport {HostViewFactory} from 'angular2/src/core/linker/view';\nimport {ChangeDetectorGenConfig} from 'angular2/src/core/change_detection/change_detection';\nimport {ResolvedMetadataCache} from 'angular2/src/core/linker/resolved_metadata_cache';\n\nimport {\n  codeGenExportVariable,\n  escapeSingleQuoteString,\n  codeGenValueFn,\n  MODULE_SUFFIX,\n  addAll,\n  Expression\n} from './util';\n\nexport var METADATA_CACHE_MODULE_REF =\n    moduleRef('package:angular2/src/core/linker/resolved_metadata_cache' + MODULE_SUFFIX);\n\n/**\n * An internal module of the Angular compiler that begins with component types,\n * extracts templates, and eventually produces a compiled version of the component\n * ready for linking into an application.\n */\n@Injectable()\nexport class TemplateCompiler {\n  private _hostCacheKeys = new Map<Type, any>();\n  private _compiledTemplateCache = new Map<any, CompiledTemplate>();\n  private _compiledTemplateDone = new Map<any, Promise<CompiledTemplate>>();\n\n  constructor(private _runtimeMetadataResolver: RuntimeMetadataResolver,\n              private _templateNormalizer: TemplateNormalizer,\n              private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,\n              private _cdCompiler: ChangeDetectionCompiler,\n              private _protoViewCompiler: ProtoViewCompiler, private _viewCompiler: ViewCompiler,\n              private _resolvedMetadataCache: ResolvedMetadataCache,\n              private _genConfig: ChangeDetectorGenConfig) {}\n\n  normalizeDirectiveMetadata(directive: CompileDirectiveMetadata):\n      Promise<CompileDirectiveMetadata> {\n    if (!directive.isComponent) {\n      // For non components there is nothing to be normalized yet.\n      return PromiseWrapper.resolve(directive);\n    }\n\n    return this._templateNormalizer.normalizeTemplate(directive.type, directive.template)\n        .then((normalizedTemplate: CompileTemplateMetadata) => new CompileDirectiveMetadata({\n                type: directive.type,\n                isComponent: directive.isComponent,\n                dynamicLoadable: directive.dynamicLoadable,\n                selector: directive.selector,\n                exportAs: directive.exportAs,\n                changeDetection: directive.changeDetection,\n                inputs: directive.inputs,\n                outputs: directive.outputs,\n                hostListeners: directive.hostListeners,\n                hostProperties: directive.hostProperties,\n                hostAttributes: directive.hostAttributes,\n                lifecycleHooks: directive.lifecycleHooks,\n                template: normalizedTemplate\n              }));\n  }\n\n  compileHostComponentRuntime(type: Type): Promise<HostViewFactory> {\n    var compMeta: CompileDirectiveMetadata =\n        this._runtimeMetadataResolver.getDirectiveMetadata(type);\n    var hostCacheKey = this._hostCacheKeys.get(type);\n    if (isBlank(hostCacheKey)) {\n      hostCacheKey = new Object();\n      this._hostCacheKeys.set(type, hostCacheKey);\n      assertComponent(compMeta);\n      var hostMeta: CompileDirectiveMetadata =\n          createHostComponentMeta(compMeta.type, compMeta.selector);\n\n      this._compileComponentRuntime(hostCacheKey, hostMeta, [compMeta], [], []);\n    }\n    return this._compiledTemplateDone.get(hostCacheKey)\n        .then((compiledTemplate: CompiledTemplate) =>\n                  new HostViewFactory(compMeta.selector, compiledTemplate.viewFactory));\n  }\n\n  clearCache() {\n    this._styleCompiler.clearCache();\n    this._compiledTemplateCache.clear();\n    this._compiledTemplateDone.clear();\n    this._hostCacheKeys.clear();\n  }\n\n  compileTemplatesCodeGen(components: NormalizedComponentWithViewDirectives[]): SourceModule {\n    if (components.length === 0) {\n      throw new BaseException('No components given');\n    }\n    var declarations = [];\n    components.forEach(componentWithDirs => {\n      var compMeta = <CompileDirectiveMetadata>componentWithDirs.component;\n      assertComponent(compMeta);\n      this._compileComponentCodeGen(compMeta, componentWithDirs.directives, componentWithDirs.pipes,\n                                    declarations);\n      if (compMeta.dynamicLoadable) {\n        var hostMeta = createHostComponentMeta(compMeta.type, compMeta.selector);\n        var viewFactoryExpression =\n            this._compileComponentCodeGen(hostMeta, [compMeta], [], declarations);\n        var constructionKeyword = IS_DART ? 'const' : 'new';\n        var compiledTemplateExpr =\n            `${constructionKeyword} ${APP_VIEW_MODULE_REF}HostViewFactory('${compMeta.selector}',${viewFactoryExpression})`;\n        var varName = codeGenHostViewFactoryName(compMeta.type);\n        declarations.push(`${codeGenExportVariable(varName)}${compiledTemplateExpr};`);\n      }\n    });\n    var moduleUrl = components[0].component.type.moduleUrl;\n    return new SourceModule(`${templateModuleUrl(moduleUrl)}`, declarations.join('\\n'));\n  }\n\n  compileStylesheetCodeGen(stylesheetUrl: string, cssText: string): SourceModule[] {\n    return this._styleCompiler.compileStylesheetCodeGen(stylesheetUrl, cssText);\n  }\n\n\n\n  private _compileComponentRuntime(cacheKey: any, compMeta: CompileDirectiveMetadata,\n                                   viewDirectives: CompileDirectiveMetadata[],\n                                   pipes: CompilePipeMetadata[],\n                                   compilingComponentsPath: any[]): CompiledTemplate {\n    let uniqViewDirectives = <CompileDirectiveMetadata[]>removeDuplicates(viewDirectives);\n    let uniqViewPipes = <CompilePipeMetadata[]>removeDuplicates(pipes);\n    var compiledTemplate = this._compiledTemplateCache.get(cacheKey);\n    var done = this._compiledTemplateDone.get(cacheKey);\n    if (isBlank(compiledTemplate)) {\n      compiledTemplate = new CompiledTemplate();\n      this._compiledTemplateCache.set(cacheKey, compiledTemplate);\n      done = PromiseWrapper\n                 .all([<any>this._styleCompiler.compileComponentRuntime(compMeta.template)].concat(\n                     uniqViewDirectives.map(dirMeta => this.normalizeDirectiveMetadata(dirMeta))))\n                 .then((stylesAndNormalizedViewDirMetas: any[]) => {\n                   var normalizedViewDirMetas = stylesAndNormalizedViewDirMetas.slice(1);\n                   var styles = stylesAndNormalizedViewDirMetas[0];\n                   var parsedTemplate = this._templateParser.parse(\n                       compMeta.template.template, normalizedViewDirMetas, uniqViewPipes,\n                       compMeta.type.name);\n\n                   var childPromises = [];\n                   var usedDirectives = DirectiveCollector.findUsedDirectives(parsedTemplate);\n                   usedDirectives.components.forEach(\n                       component => this._compileNestedComponentRuntime(\n                           component, compilingComponentsPath, childPromises));\n                   return PromiseWrapper.all(childPromises)\n                       .then((_) => {\n                         var filteredPipes = filterPipes(parsedTemplate, uniqViewPipes);\n                         compiledTemplate.init(this._createViewFactoryRuntime(\n                             compMeta, parsedTemplate, usedDirectives.directives, styles,\n                             filteredPipes));\n                         return compiledTemplate;\n                       });\n                 });\n      this._compiledTemplateDone.set(cacheKey, done);\n    }\n    return compiledTemplate;\n  }\n\n  private _compileNestedComponentRuntime(childComponentDir: CompileDirectiveMetadata,\n                                         parentCompilingComponentsPath: any[],\n                                         childPromises: Promise<any>[]) {\n    var compilingComponentsPath = ListWrapper.clone(parentCompilingComponentsPath);\n\n    var childCacheKey = childComponentDir.type.runtime;\n    var childViewDirectives: CompileDirectiveMetadata[] =\n        this._runtimeMetadataResolver.getViewDirectivesMetadata(childComponentDir.type.runtime);\n    var childViewPipes: CompilePipeMetadata[] =\n        this._runtimeMetadataResolver.getViewPipesMetadata(childComponentDir.type.runtime);\n    var childIsRecursive = ListWrapper.contains(compilingComponentsPath, childCacheKey);\n    compilingComponentsPath.push(childCacheKey);\n    this._compileComponentRuntime(childCacheKey, childComponentDir, childViewDirectives,\n                                  childViewPipes, compilingComponentsPath);\n    if (!childIsRecursive) {\n      // Only wait for a child if it is not a cycle\n      childPromises.push(this._compiledTemplateDone.get(childCacheKey));\n    }\n  }\n\n  private _createViewFactoryRuntime(compMeta: CompileDirectiveMetadata,\n                                    parsedTemplate: TemplateAst[],\n                                    directives: CompileDirectiveMetadata[], styles: string[],\n                                    pipes: CompilePipeMetadata[]): Function {\n    if (IS_DART || !this._genConfig.useJit) {\n      var changeDetectorFactories = this._cdCompiler.compileComponentRuntime(\n          compMeta.type, compMeta.changeDetection, parsedTemplate);\n      var protoViews = this._protoViewCompiler.compileProtoViewRuntime(\n          this._resolvedMetadataCache, compMeta, parsedTemplate, pipes);\n      return this._viewCompiler.compileComponentRuntime(\n          compMeta, parsedTemplate, styles, protoViews.protoViews, changeDetectorFactories,\n          (compMeta) => this._getNestedComponentViewFactory(compMeta));\n    } else {\n      var declarations = [];\n      var viewFactoryExpr = this._createViewFactoryCodeGen('resolvedMetadataCache', compMeta,\n                                                           new SourceExpression([], 'styles'),\n                                                           parsedTemplate, pipes, declarations);\n      var vars: {[key: string]: any} =\n          {'exports': {}, 'styles': styles, 'resolvedMetadataCache': this._resolvedMetadataCache};\n      directives.forEach(dirMeta => {\n        vars[dirMeta.type.name] = dirMeta.type.runtime;\n        if (dirMeta.isComponent && dirMeta.type.runtime !== compMeta.type.runtime) {\n          vars[`viewFactory_${dirMeta.type.name}0`] = this._getNestedComponentViewFactory(dirMeta);\n        }\n      });\n      pipes.forEach(pipeMeta => vars[pipeMeta.type.name] = pipeMeta.type.runtime);\n      var declarationsWithoutImports =\n          SourceModule.getSourceWithoutImports(declarations.join('\\n'));\n      return evalExpression(\n          `viewFactory_${compMeta.type.name}`, viewFactoryExpr, declarationsWithoutImports,\n          mergeStringMaps(\n              [vars, CHANGE_DETECTION_JIT_IMPORTS, PROTO_VIEW_JIT_IMPORTS, VIEW_JIT_IMPORTS]));\n    }\n  }\n\n  private _getNestedComponentViewFactory(compMeta: CompileDirectiveMetadata): Function {\n    return this._compiledTemplateCache.get(compMeta.type.runtime).viewFactory;\n  }\n\n  private _compileComponentCodeGen(compMeta: CompileDirectiveMetadata,\n                                   directives: CompileDirectiveMetadata[],\n                                   pipes: CompilePipeMetadata[],\n                                   targetDeclarations: string[]): string {\n    let uniqueDirectives = <CompileDirectiveMetadata[]>removeDuplicates(directives);\n    let uniqPipes = <CompilePipeMetadata[]>removeDuplicates(pipes);\n    var styleExpr = this._styleCompiler.compileComponentCodeGen(compMeta.template);\n    var parsedTemplate = this._templateParser.parse(compMeta.template.template, uniqueDirectives,\n                                                    uniqPipes, compMeta.type.name);\n    var filteredPipes = filterPipes(parsedTemplate, uniqPipes);\n    return this._createViewFactoryCodeGen(\n        `${METADATA_CACHE_MODULE_REF}CODEGEN_RESOLVED_METADATA_CACHE`, compMeta, styleExpr,\n        parsedTemplate, filteredPipes, targetDeclarations);\n  }\n\n  private _createViewFactoryCodeGen(resolvedMetadataCacheExpr: string,\n                                    compMeta: CompileDirectiveMetadata, styleExpr: SourceExpression,\n                                    parsedTemplate: TemplateAst[], pipes: CompilePipeMetadata[],\n                                    targetDeclarations: string[]): string {\n    var changeDetectorsExprs = this._cdCompiler.compileComponentCodeGen(\n        compMeta.type, compMeta.changeDetection, parsedTemplate);\n    var protoViewExprs = this._protoViewCompiler.compileProtoViewCodeGen(\n        new Expression(resolvedMetadataCacheExpr), compMeta, parsedTemplate, pipes);\n    var viewFactoryExpr = this._viewCompiler.compileComponentCodeGen(\n        compMeta, parsedTemplate, styleExpr, protoViewExprs.protoViews, changeDetectorsExprs,\n        codeGenComponentViewFactoryName);\n\n    addAll(changeDetectorsExprs.declarations, targetDeclarations);\n    addAll(protoViewExprs.declarations, targetDeclarations);\n    addAll(viewFactoryExpr.declarations, targetDeclarations);\n\n    return viewFactoryExpr.expression;\n  }\n}\n\nexport class NormalizedComponentWithViewDirectives {\n  constructor(public component: CompileDirectiveMetadata,\n              public directives: CompileDirectiveMetadata[], public pipes: CompilePipeMetadata[]) {}\n}\n\nclass CompiledTemplate {\n  viewFactory: Function = null;\n  init(viewFactory: Function) { this.viewFactory = viewFactory; }\n}\n\nfunction assertComponent(meta: CompileDirectiveMetadata) {\n  if (!meta.isComponent) {\n    throw new BaseException(`Could not compile '${meta.type.name}' because it is not a component.`);\n  }\n}\n\nfunction templateModuleUrl(moduleUrl: string): string {\n  var urlWithoutSuffix = moduleUrl.substring(0, moduleUrl.length - MODULE_SUFFIX.length);\n  return `${urlWithoutSuffix}.template${MODULE_SUFFIX}`;\n}\n\n\nfunction codeGenHostViewFactoryName(type: CompileTypeMetadata): string {\n  return `hostViewFactory_${type.name}`;\n}\n\nfunction codeGenComponentViewFactoryName(nestedCompType: CompileDirectiveMetadata): string {\n  return `${moduleRef(templateModuleUrl(nestedCompType.type.moduleUrl))}viewFactory_${nestedCompType.type.name}0`;\n}\n\nfunction mergeStringMaps(maps: Array<{[key: string]: any}>): {[key: string]: any} {\n  var result = {};\n  maps.forEach(\n      (map) => { StringMapWrapper.forEach(map, (value, key) => { result[key] = value; }); });\n  return result;\n}\n\nfunction removeDuplicates(items: CompileMetadataWithType[]): CompileMetadataWithType[] {\n  let res = [];\n  items.forEach(item => {\n    let hasMatch =\n        res.filter(r => r.type.name == item.type.name && r.type.moduleUrl == item.type.moduleUrl &&\n                        r.type.runtime == item.type.runtime)\n            .length > 0;\n    if (!hasMatch) {\n      res.push(item);\n    }\n  });\n  return res;\n}\n\nclass DirectiveCollector implements TemplateAstVisitor {\n  static findUsedDirectives(parsedTemplate: TemplateAst[]): DirectiveCollector {\n    var collector = new DirectiveCollector();\n    templateVisitAll(collector, parsedTemplate);\n    return collector;\n  }\n\n  directives: CompileDirectiveMetadata[] = [];\n  components: CompileDirectiveMetadata[] = [];\n\n  visitBoundText(ast: BoundTextAst, context: any): any { return null; }\n  visitText(ast: TextAst, context: any): any { return null; }\n\n  visitNgContent(ast: NgContentAst, context: any): any { return null; }\n\n  visitElement(ast: ElementAst, context: any): any {\n    templateVisitAll(this, ast.directives);\n    templateVisitAll(this, ast.children);\n    return null;\n  }\n\n  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any {\n    templateVisitAll(this, ast.directives);\n    templateVisitAll(this, ast.children);\n    return null;\n  }\n  visitVariable(ast: VariableAst, ctx: any): any { return null; }\n  visitAttr(ast: AttrAst, attrNameAndValues: {[key: string]: string}): any { return null; }\n  visitDirective(ast: DirectiveAst, ctx: any): any {\n    if (ast.directive.isComponent) {\n      this.components.push(ast.directive);\n    }\n    this.directives.push(ast.directive);\n    return null;\n  }\n  visitEvent(ast: BoundEventAst, eventTargetAndNames: Map<string, BoundEventAst>): any {\n    return null;\n  }\n  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any { return null; }\n  visitElementProperty(ast: BoundElementPropertyAst, context: any): any { return null; }\n}\n\n\nfunction filterPipes(template: TemplateAst[],\n                     allPipes: CompilePipeMetadata[]): CompilePipeMetadata[] {\n  var visitor = new PipeVisitor();\n  templateVisitAll(visitor, template);\n  return allPipes.filter((pipeMeta) => SetWrapper.has(visitor.collector.pipes, pipeMeta.name));\n}\n\nclass PipeVisitor implements TemplateAstVisitor {\n  collector: PipeCollector = new PipeCollector();\n\n  visitBoundText(ast: BoundTextAst, context: any): any {\n    ast.value.visit(this.collector);\n    return null;\n  }\n  visitText(ast: TextAst, context: any): any { return null; }\n\n  visitNgContent(ast: NgContentAst, context: any): any { return null; }\n\n  visitElement(ast: ElementAst, context: any): any {\n    templateVisitAll(this, ast.inputs);\n    templateVisitAll(this, ast.outputs);\n    templateVisitAll(this, ast.directives);\n    templateVisitAll(this, ast.children);\n    return null;\n  }\n\n  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any {\n    templateVisitAll(this, ast.outputs);\n    templateVisitAll(this, ast.directives);\n    templateVisitAll(this, ast.children);\n    return null;\n  }\n  visitVariable(ast: VariableAst, ctx: any): any { return null; }\n  visitAttr(ast: AttrAst, attrNameAndValues: {[key: string]: string}): any { return null; }\n  visitDirective(ast: DirectiveAst, ctx: any): any {\n    templateVisitAll(this, ast.inputs);\n    templateVisitAll(this, ast.hostEvents);\n    templateVisitAll(this, ast.hostProperties);\n    return null;\n  }\n  visitEvent(ast: BoundEventAst, eventTargetAndNames: Map<string, BoundEventAst>): any {\n    ast.handler.visit(this.collector);\n    return null;\n  }\n  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any {\n    ast.value.visit(this.collector);\n    return null;\n  }\n  visitElementProperty(ast: BoundElementPropertyAst, context: any): any {\n    ast.value.visit(this.collector);\n    return null;\n  }\n}\n"]}