refactor(@ngtools/webpack): simplify paths plugin logic

Author: clydin

packages/@ngtools/webpack/src/angular_compiler_plugin.ts

@@ -10,7 +10,7 @@ const treeKill = require('tree-kill');
 import { WebpackResourceLoader } from './resource_loader';
 import { WebpackCompilerHost } from './compiler_host';
 import { Tapable } from './webpack';
-import { PathsPlugin } from './paths-plugin';
+import { resolveWithPaths } from './paths-plugin';
 import { findLazyRoutes, LazyRouteMap } from './lazy_routes';
 import {
   VirtualFileSystemDecorator,
@@ -259,9 +259,6 @@ export class AngularCompilerPlugin implements Tapable {
       }
     }
 
-    // Use an identity function as all our paths are absolute already.
-    this._moduleResolutionCache = ts.createModuleResolutionCache(this._basePath, x => x);
-
     // Resolve mainPath if provided.
     if (options.mainPath) {
       this._mainPath = this._compilerHost.resolve(options.mainPath);
@@ -315,6 +312,9 @@ export class AngularCompilerPlugin implements Tapable {
           this._updateForkedTypeChecker(this._rootNames, this._getChangedCompilationFiles());
         }
 
+         // Use an identity function as all our paths are absolute already.
+        this._moduleResolutionCache = ts.createModuleResolutionCache(this._basePath, x => x);
+
         if (this._JitMode) {
           // Create the TypeScript program.
           time('AngularCompilerPlugin._createOrUpdateProgram.ts.createProgram');
@@ -617,12 +617,15 @@ export class AngularCompilerPlugin implements Tapable {
     });
 
     compiler.plugin('normal-module-factory', (nmf: any) => {
-      compiler.resolvers.normal.apply(new PathsPlugin({
-        nmf,
-        tsConfigPath: this._tsConfigPath,
-        compilerOptions: this._compilerOptions,
-        compilerHost: this._compilerHost
-      }));
+      nmf.plugin('before-resolve', (request: any, callback: any) => {
+        resolveWithPaths(
+          request,
+          callback,
+          this._compilerOptions,
+          this._compilerHost,
+          this._moduleResolutionCache,
+        );
+      });
     });
   }
 

packages/@ngtools/webpack/src/paths-plugin.ts

@@ -13,19 +13,47 @@ import {
 const ModulesInRootPlugin: new (a: string, b: string, c: string) => ResolverPlugin
   = require('enhanced-resolve/lib/ModulesInRootPlugin');
 
-export interface Mapping {
-  onlyModule: boolean;
-  alias: string;
-  aliasPattern: RegExp;
-  target: string;
-}
+export function resolveWithPaths(
+  request: NormalModuleFactoryRequest,
+  callback: Callback<NormalModuleFactoryRequest>,
+  compilerOptions: ts.CompilerOptions,
+  host: ts.CompilerHost,
+  cache?: ts.ModuleResolutionCache,
+) {
+  if (!request) {
+    callback(null, request);
+    return;
+  }
+
+  // Only work on Javascript/TypeScript issuers.
+  if (!request.contextInfo.issuer || !request.contextInfo.issuer.match(/\.[jt]s$/)) {
+    callback(null, request);
+    return;
+  }
 
+  const moduleResolver = ts.resolveModuleName(
+    request.request,
+    request.contextInfo.issuer,
+    compilerOptions,
+    host,
+    cache
+  );
+
+  let moduleFilePath = moduleResolver.resolvedModule
+                    && moduleResolver.resolvedModule.resolvedFileName;
+
+  // If TypeScript gives us a .d.ts it's probably a node module and we need to let webpack
+  // do the resolution.
+  if (moduleFilePath) {
+    moduleFilePath = moduleFilePath.replace(/\.d\.ts$/, '.js');
+    if (host.fileExists(moduleFilePath)) {
+      request.request = moduleFilePath;
+    }
+  }
 
-function escapeRegExp(str: string): string {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+  callback(null, request);
 }
 
-
 export interface PathsPluginOptions {
   nmf: NormalModuleFactory;
   tsConfigPath: string;
@@ -35,15 +63,11 @@ export interface PathsPluginOptions {
 
 export class PathsPlugin implements Tapable {
   private _nmf: NormalModuleFactory;
-  private _tsConfigPath: string;
   private _compilerOptions: ts.CompilerOptions;
   private _host: ts.CompilerHost;
 
   source: string;
   target: string;
-
-  private _mappings: Mapping[];
-
   private _absoluteBaseUrl: string;
 
   private static _loadOptionsFromTsConfig(tsConfigPath: string, host?: ts.CompilerHost):
@@ -66,12 +90,12 @@ export class PathsPlugin implements Tapable {
       // This could happen in JavaScript.
       throw new Error('tsConfigPath option is mandatory.');
     }
-    this._tsConfigPath = options.tsConfigPath;
+    const tsConfigPath = options.tsConfigPath;
 
     if (options.compilerOptions) {
       this._compilerOptions = options.compilerOptions;
     } else {
-      this._compilerOptions = PathsPlugin._loadOptionsFromTsConfig(this._tsConfigPath);
+      this._compilerOptions = PathsPlugin._loadOptionsFromTsConfig(tsConfigPath);
     }
 
     if (options.compilerHost) {
@@ -85,33 +109,9 @@ export class PathsPlugin implements Tapable {
     this.target = 'resolve';
 
     this._absoluteBaseUrl = path.resolve(
-      path.dirname(this._tsConfigPath),
+      path.dirname(tsConfigPath),
       this._compilerOptions.baseUrl || '.'
     );
-
-    this._mappings = [];
-    let paths = this._compilerOptions.paths || {};
-    Object.keys(paths).forEach(alias => {
-      let onlyModule = alias.indexOf('*') === -1;
-      let excapedAlias = escapeRegExp(alias);
-      let targets = paths[alias];
-      targets.forEach(target => {
-        let aliasPattern: RegExp;
-        if (onlyModule) {
-          aliasPattern = new RegExp(`^${excapedAlias}$`);
-        } else {
-          let withStarCapturing = excapedAlias.replace('\\*', '(.*)');
-          aliasPattern = new RegExp(`^${withStarCapturing}`);
-        }
-
-        this._mappings.push({
-          onlyModule,
-          alias,
-          aliasPattern,
-          target: target
-        });
-      });
-    });
   }
 
   apply(resolver: ResolverPlugin): void {
@@ -121,43 +121,8 @@ export class PathsPlugin implements Tapable {
       resolver.apply(new ModulesInRootPlugin('module', this._absoluteBaseUrl, 'resolve'));
     }
 
-    this._nmf.plugin('before-resolve', (request: NormalModuleFactoryRequest,
-                                        callback: Callback<any>) => {
-      // Only work on TypeScript issuers.
-      if (!request.contextInfo.issuer || !request.contextInfo.issuer.match(/\.[jt]s$/)) {
-        return callback(null, request);
-      }
-
-      for (let mapping of this._mappings) {
-        const match = request.request.match(mapping.aliasPattern);
-        if (!match) { continue; }
-        let newRequestStr = mapping.target;
-        if (!mapping.onlyModule) {
-          newRequestStr = newRequestStr.replace('*', match[1]);
-        }
-        const moduleResolver = ts.resolveModuleName(
-          request.request,
-          request.contextInfo.issuer,
-          this._compilerOptions,
-          this._host
-        );
-        let moduleFilePath = moduleResolver.resolvedModule
-                          && moduleResolver.resolvedModule.resolvedFileName;
-
-        // If TypeScript gives us a .d.ts it's probably a node module and we need to let webpack
-        // do the resolution.
-        if (moduleFilePath && moduleFilePath.endsWith('.d.ts')) {
-          moduleFilePath = moduleFilePath.replace(/\.d\.ts$/, '.js');
-          if (!this._host.fileExists(moduleFilePath)) {
-            continue;
-          }
-        }
-        if (moduleFilePath) {
-          return callback(null, Object.assign({}, request, { request: moduleFilePath }));
-        }
-      }
-
-      return callback(null, request);
+    this._nmf.plugin('before-resolve', (request, callback) => {
+      resolveWithPaths(request, callback, this._compilerOptions, this._host);
     });
   }
 }