feat(@ngtools/webpack): compile a module map for commonjs bundles

Author: FrozenPandaz

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

@@ -435,15 +435,12 @@ function _diagnoseDeps(reasons: ModuleReason[], plugin: AotPlugin, checked: Set<
 }
 
 
-export function _replaceExport(plugin: AotPlugin, refactor: TypeScriptFileRefactor) {
-  if (!plugin.replaceExport) {
-    return;
-  }
-
+export function _getModuleExports(plugin: AotPlugin,
+                                  refactor: TypeScriptFileRefactor): ts.Identifier[] {
   const exports = refactor
     .findAstNodes(refactor.sourceFile, ts.SyntaxKind.ExportDeclaration, true);
 
-  exports
+  return exports
     .filter(node => {
 
       const identifiers = refactor.findAstNodes(node, ts.SyntaxKind.Identifier, false);
@@ -452,7 +449,15 @@ export function _replaceExport(plugin: AotPlugin, refactor: TypeScriptFileRefact
         .filter(node => node.getText() === plugin.entryModule.className);
 
       return identifiers.length > 0;
-    })
+    }) as ts.Identifier[];
+}
+
+
+export function _replaceExport(plugin: AotPlugin, refactor: TypeScriptFileRefactor) {
+  if (!plugin.replaceExport) {
+    return;
+  }
+  _getModuleExports(plugin, refactor)
     .forEach(node => {
       const factoryPath = _getNgFactoryPath(plugin, refactor);
       const factoryClassName = plugin.entryModule.className + 'NgFactory';
@@ -462,6 +467,40 @@ export function _replaceExport(plugin: AotPlugin, refactor: TypeScriptFileRefact
 }
 
 
+export function _exportModuleMap(plugin: AotPlugin, refactor: TypeScriptFileRefactor) {
+  if (!plugin.replaceExport) {
+    return;
+  }
+
+  const dirName = path.normalize(path.dirname(refactor.fileName));
+  const classNameAppend = plugin.skipCodeGeneration ? '' : 'NgFactory';
+  const modulePathAppend = plugin.skipCodeGeneration ? '' : '.ngfactory';
+
+  _getModuleExports(plugin, refactor)
+    .forEach(node => {
+      const jsonContent: string = Object.keys(plugin.discoveredLazyRoutes)
+        .map((routeKey, index: number) => {
+          let [lazyRouteKey, moduleName] = routeKey.split('#');
+
+          if (!lazyRouteKey || !moduleName) {
+            throw new Error(`${routeKey} was not a proper loadChildren string`);
+          }
+
+          moduleName += classNameAppend;
+          lazyRouteKey += modulePathAppend;
+
+          const modulePath = plugin.lazyRoutes[lazyRouteKey];
+          const relativePath = path.relative(dirName, modulePath).replace(/\\/g, '/');
+          refactor.prependBefore(node, `import * as __lazy_${index}__ from './${relativePath}'`);
+          return `"${routeKey}": __lazy_${index}__.${moduleName}`;
+        })
+        .join();
+
+      refactor.appendAfter(node, `export const moduleMap = {${jsonContent}};`);
+    });
+}
+
+
 // Super simple TS transpiler loader for testing / isolated usage. does not type check!
 export function ngcLoader(this: LoaderContext & { _compilation: any }, source: string | null) {
   const cb = this.async();
@@ -492,11 +531,13 @@ export function ngcLoader(this: LoaderContext & { _compilation: any }, source: s
           return Promise.resolve()
             .then(() => _removeDecorators(refactor))
             .then(() => _refactorBootstrap(plugin, refactor))
-            .then(() => _replaceExport(plugin, refactor));
+            .then(() => _replaceExport(plugin, refactor))
+            .then(() => _exportModuleMap(plugin, refactor));
         } else {
           return Promise.resolve()
             .then(() => _replaceResources(refactor))
-            .then(() => _removeModuleId(refactor));
+            .then(() => _removeModuleId(refactor))
+            .then(() => _exportModuleMap(plugin, refactor));
         }
       })
       .then(() => {

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

@@ -50,6 +50,7 @@ export class AotPlugin implements Tapable {
   private _rootFilePath: string[];
   private _compilerHost: WebpackCompilerHost;
   private _resourceLoader: WebpackResourceLoader;
+  private _discoveredLazyRoutes: LazyRouteMap;
   private _lazyRoutes: LazyRouteMap = Object.create(null);
   private _tsConfigPath: string;
   private _entryModule: string;
@@ -97,6 +98,8 @@ export class AotPlugin implements Tapable {
   get i18nFormat() { return this._i18nFormat; }
   get locale() { return this._locale; }
   get firstRun() { return this._firstRun; }
+  get lazyRoutes() { return this._lazyRoutes; }
+  get discoveredLazyRoutes() { return this._discoveredLazyRoutes; }
 
   private _setupOptions(options: AotPluginOptions) {
     // Fill in the missing options.
@@ -516,14 +519,14 @@ export class AotPlugin implements Tapable {
       .then(() => {
         // We need to run the `listLazyRoutes` the first time because it also navigates libraries
         // and other things that we might miss using the findLazyRoutesInAst.
-        let discoveredLazyRoutes: LazyRouteMap = this.firstRun
+        this._discoveredLazyRoutes = this.firstRun
           ? this._getLazyRoutesFromNgtools()
           : this._findLazyRoutesInAst();
 
         // Process the lazy routes discovered.
-        Object.keys(discoveredLazyRoutes)
+        Object.keys(this.discoveredLazyRoutes)
           .forEach(k => {
-            const lazyRoute = discoveredLazyRoutes[k];
+            const lazyRoute = this.discoveredLazyRoutes[k];
             k = k.split('#')[0];
             if (lazyRoute === null) {
               return;

tests/e2e/tests/packages/webpack/server.ts

@@ -24,6 +24,8 @@ export default function(skipCleaning: () => void) {
       '--config', 'webpack.commonjs.config.js'))
     .then(() => expectFileToMatch('dist/app.main.js',
       /__webpack_exports__, "AppModuleNgFactory"/))
+    .then(() => expectFileToMatch('dist/app.main.js',
+      /var moduleMap = { ".\/lazy\.module#LazyModule": /))
     .then(() => exec(normalize('node'), 'index.js'))
     .then(() => expectFileToMatch('dist/index.html',
       new RegExp('<a ng-reflect-router-link="lazy" href="/lazy">lazy</a>')))