chore(compiler): refactoring for offline compiler cli

- pass a baseUrl for asset resolution from static symbols - fixes in StaticReflector to work with a path-aware host see angular#7483
rmshea · Apr 29, 2016 · c493d88 · c493d88
1 parent 8bf6ef6
commit c493d88
Show file tree

Hide file tree

Showing 11 changed files with 357 additions and 280 deletions.
diff --git a/modules/angular2/src/compiler/compile_metadata.ts b/modules/angular2/src/compiler/compile_metadata.ts
@@ -468,20 +468,24 @@ export class CompileTemplateMetadata {
   styles: string[];
   styleUrls: string[];
   ngContentSelectors: string[];
-  constructor({encapsulation, template, templateUrl, styles, styleUrls, ngContentSelectors}: {
+  baseUrl: string;
+  constructor({encapsulation, template, templateUrl, styles, styleUrls, ngContentSelectors,
+               baseUrl}: {
     encapsulation?: ViewEncapsulation,
     template?: string,
     templateUrl?: string,
     styles?: string[],
     styleUrls?: string[],
-    ngContentSelectors?: string[]
+    ngContentSelectors?: string[],
+    baseUrl?: string
   } = {}) {
     this.encapsulation = isPresent(encapsulation) ? encapsulation : ViewEncapsulation.Emulated;
     this.template = template;
     this.templateUrl = templateUrl;
     this.styles = isPresent(styles) ? styles : [];
     this.styleUrls = isPresent(styleUrls) ? styleUrls : [];
     this.ngContentSelectors = isPresent(ngContentSelectors) ? ngContentSelectors : [];
+    this.baseUrl = baseUrl;
   }
 
   static fromJson(data: {[key: string]: any}): CompileTemplateMetadata {
@@ -493,7 +497,8 @@ export class CompileTemplateMetadata {
       templateUrl: data['templateUrl'],
       styles: data['styles'],
       styleUrls: data['styleUrls'],
-      ngContentSelectors: data['ngContentSelectors']
+      ngContentSelectors: data['ngContentSelectors'],
+      baseUrl: data['baseUrl']
     });
   }
 
@@ -505,7 +510,8 @@ export class CompileTemplateMetadata {
       'templateUrl': this.templateUrl,
       'styles': this.styles,
       'styleUrls': this.styleUrls,
-      'ngContentSelectors': this.ngContentSelectors
+      'ngContentSelectors': this.ngContentSelectors,
+      'baseUrl': this.baseUrl
     };
   }
 }

diff --git a/modules/angular2/src/compiler/directive_normalizer.ts b/modules/angular2/src/compiler/directive_normalizer.ts
@@ -66,9 +66,9 @@ export class DirectiveNormalizer {
                     template: CompileTemplateMetadata): Promise<CompileTemplateMetadata> {
     if (isPresent(template.template)) {
       return PromiseWrapper.resolve(this.normalizeLoadedTemplate(
-          directiveType, template, template.template, directiveType.moduleUrl));
+          directiveType, template, template.template, template.baseUrl));
     } else if (isPresent(template.templateUrl)) {
-      var sourceAbsUrl = this._urlResolver.resolve(directiveType.moduleUrl, template.templateUrl);
+      var sourceAbsUrl = this._urlResolver.resolve(template.baseUrl, template.templateUrl);
       return this._xhr.get(sourceAbsUrl)
           .then(templateContent => this.normalizeLoadedTemplate(directiveType, template,
                                                                 templateContent, sourceAbsUrl));
@@ -93,7 +93,7 @@ export class DirectiveNormalizer {
         visitor.styleUrls.filter(isStyleUrlResolvable)
             .map(url => this._urlResolver.resolve(templateAbsUrl, url))
             .concat(templateMeta.styleUrls.filter(isStyleUrlResolvable)
-                        .map(url => this._urlResolver.resolve(directiveType.moduleUrl, url)));
+                        .map(url => this._urlResolver.resolve(templateMeta.baseUrl, url)));
 
     var allResolvedStyles = allStyles.map(style => {
       var styleWithImports = extractStyleUrls(this._urlResolver, templateAbsUrl, style);

diff --git a/modules/angular2/src/compiler/metadata_resolver.ts b/modules/angular2/src/compiler/metadata_resolver.ts
@@ -76,23 +76,22 @@ export class CompileMetadataResolver {
     var meta = this._directiveCache.get(directiveType);
     if (isBlank(meta)) {
       var dirMeta = this._directiveResolver.resolve(directiveType);
-      var moduleUrl = staticTypeModuleUrl(directiveType);
       var templateMeta = null;
       var changeDetectionStrategy = null;
       var viewProviders = [];
 
       if (dirMeta instanceof md.ComponentMetadata) {
         assertArrayOfStrings('styles', dirMeta.styles);
         var cmpMeta = <md.ComponentMetadata>dirMeta;
-        moduleUrl = calcModuleUrl(this._reflector, directiveType, cmpMeta);
         var viewMeta = this._viewResolver.resolve(directiveType);
         assertArrayOfStrings('styles', viewMeta.styles);
         templateMeta = new cpl.CompileTemplateMetadata({
           encapsulation: viewMeta.encapsulation,
           template: viewMeta.template,
           templateUrl: viewMeta.templateUrl,
           styles: viewMeta.styles,
-          styleUrls: viewMeta.styleUrls
+          styleUrls: viewMeta.styleUrls,
+          baseUrl: calcTemplateBaseUrl(this._reflector, directiveType, cmpMeta)
         });
         changeDetectionStrategy = cmpMeta.changeDetection;
         if (isPresent(dirMeta.viewProviders)) {
@@ -114,7 +113,7 @@ export class CompileMetadataResolver {
         selector: dirMeta.selector,
         exportAs: dirMeta.exportAs,
         isComponent: isPresent(templateMeta),
-        type: this.getTypeMetadata(directiveType, moduleUrl),
+        type: this.getTypeMetadata(directiveType, staticTypeModuleUrl(directiveType)),
         template: templateMeta,
         changeDetection: changeDetectionStrategy,
         inputs: dirMeta.inputs,
@@ -399,14 +398,19 @@ function staticTypeModuleUrl(value: any): string {
   return isStaticType(value) ? value['moduleId'] : null;
 }
 
-function calcModuleUrl(reflector: ReflectorReader, type: Type,
-                       cmpMetadata: md.ComponentMetadata): string {
-  var moduleId = cmpMetadata.moduleId;
-  if (isPresent(moduleId)) {
+
+function calcTemplateBaseUrl(reflector: ReflectorReader, type: any,
+                             cmpMetadata: md.ComponentMetadata): string {
+  if (isStaticType(type)) {
+    return type['filePath'];
+  }
+
+  if (isPresent(cmpMetadata.moduleId)) {
+    var moduleId = cmpMetadata.moduleId;
     var scheme = getUrlScheme(moduleId);
     return isPresent(scheme) && scheme.length > 0 ? moduleId :
                                                     `package:${moduleId}${MODULE_SUFFIX}`;
-  } else {
-    return reflector.importUri(type);
   }
+
+  return reflector.importUri(type);
 }