@angular/compiler-cli 8.0.3 → 8.1.0-beta.0

package/ngcc/src/packages/entry_point_finder.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/packages/entry_point_finder", ["require", "exports", "tslib", "canonical-path", "fs", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/ngcc/src/packages/entry_point"], factory);
+        define("@angular/compiler-cli/ngcc/src/packages/entry_point_finder", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/ngcc/src/packages/entry_point"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -17,12 +17,11 @@
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var path = require("canonical-path");
-    var fs = require("fs");
     var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
     var entry_point_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point");
     var EntryPointFinder = /** @class */ (function () {
-        function EntryPointFinder(logger, resolver) {
+        function EntryPointFinder(fs, logger, resolver) {
+            this.fs = fs;
             this.logger = logger;
             this.resolver = resolver;
         }
@@ -30,13 +29,45 @@
          * Search the given directory, and sub-directories, for Angular package entry points.
          * @param sourceDirectory An absolute path to the directory to search for entry points.
          */
-        EntryPointFinder.prototype.findEntryPoints = function (sourceDirectory, targetEntryPointPath) {
-            var unsortedEntryPoints = this.walkDirectoryForEntryPoints(sourceDirectory);
+        EntryPointFinder.prototype.findEntryPoints = function (sourceDirectory, targetEntryPointPath, pathMappings) {
+            var _this = this;
+            var basePaths = this.getBasePaths(sourceDirectory, pathMappings);
+            var unsortedEntryPoints = basePaths.reduce(function (entryPoints, basePath) { return entryPoints.concat(_this.walkDirectoryForEntryPoints(basePath)); }, []);
             var targetEntryPoint = targetEntryPointPath ?
                 unsortedEntryPoints.find(function (entryPoint) { return entryPoint.path === targetEntryPointPath; }) :
                 undefined;
             return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints, targetEntryPoint);
         };
+        /**
+         * Extract all the base-paths that we need to search for entry-points.
+         *
+         * This always contains the standard base-path (`sourceDirectory`).
+         * But it also parses the `paths` mappings object to guess additional base-paths.
+         *
+         * For example:
+         *
+         * ```
+         * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})
+         * > ['/node_modules', '/dist/lib']
+         * ```
+         *
+         * Notice that `'/dist'` is not included as there is no `'*'` path,
+         * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.
+         *
+         * @param sourceDirectory The standard base-path (e.g. node_modules).
+         * @param pathMappings Path mapping configuration, from which to extract additional base-paths.
+         */
+        EntryPointFinder.prototype.getBasePaths = function (sourceDirectory, pathMappings) {
+            var basePaths = [sourceDirectory];
+            if (pathMappings) {
+                var baseUrl_1 = path_1.AbsoluteFsPath.resolve(pathMappings.baseUrl);
+                values(pathMappings.paths).forEach(function (paths) { return paths.forEach(function (path) {
+                    basePaths.push(path_1.AbsoluteFsPath.join(baseUrl_1, extractPathPrefix(path)));
+                }); });
+            }
+            basePaths.sort(); // Get the paths in order with the shorter ones first.
+            return basePaths.filter(removeDeeperPaths);
+        };
         /**
          * Look for entry points that need to be compiled, starting at the source directory.
          * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.
@@ -45,28 +76,29 @@
         EntryPointFinder.prototype.walkDirectoryForEntryPoints = function (sourceDirectory) {
             var _this = this;
             var entryPoints = [];
-            fs.readdirSync(sourceDirectory)
+            this.fs
+                .readdir(sourceDirectory)
                 // Not interested in hidden files
                 .filter(function (p) { return !p.startsWith('.'); })
                 // Ignore node_modules
                 .filter(function (p) { return p !== 'node_modules'; })
                 // Only interested in directories (and only those that are not symlinks)
                 .filter(function (p) {
-                var stat = fs.lstatSync(path.resolve(sourceDirectory, p));
+                var stat = _this.fs.lstat(path_1.AbsoluteFsPath.resolve(sourceDirectory, p));
                 return stat.isDirectory() && !stat.isSymbolicLink();
             })
                 .forEach(function (p) {
                 // Either the directory is a potential package or a namespace containing packages (e.g
                 // `@angular`).
-                var packagePath = path_1.AbsoluteFsPath.from(path.join(sourceDirectory, p));
+                var packagePath = path_1.AbsoluteFsPath.join(sourceDirectory, p);
                 if (p.startsWith('@')) {
                     entryPoints.push.apply(entryPoints, tslib_1.__spread(_this.walkDirectoryForEntryPoints(packagePath)));
                 }
                 else {
                     entryPoints.push.apply(entryPoints, tslib_1.__spread(_this.getEntryPointsForPackage(packagePath)));
                     // Also check for any nested node_modules in this package
-                    var nestedNodeModulesPath = path_1.AbsoluteFsPath.from(path.resolve(packagePath, 'node_modules'));
-                    if (fs.existsSync(nestedNodeModulesPath)) {
+                    var nestedNodeModulesPath = path_1.AbsoluteFsPath.join(packagePath, 'node_modules');
+                    if (_this.fs.exists(nestedNodeModulesPath)) {
                         entryPoints.push.apply(entryPoints, tslib_1.__spread(_this.walkDirectoryForEntryPoints(nestedNodeModulesPath)));
                     }
                 }
@@ -82,13 +114,13 @@
             var _this = this;
             var entryPoints = [];
             // Try to get an entry point from the top level package directory
-            var topLevelEntryPoint = entry_point_1.getEntryPointInfo(this.logger, packagePath, packagePath);
+            var topLevelEntryPoint = entry_point_1.getEntryPointInfo(this.fs, this.logger, packagePath, packagePath);
             if (topLevelEntryPoint !== null) {
                 entryPoints.push(topLevelEntryPoint);
             }
             // Now search all the directories of this package for possible entry points
             this.walkDirectory(packagePath, function (subdir) {
-                var subEntryPoint = entry_point_1.getEntryPointInfo(_this.logger, packagePath, subdir);
+                var subEntryPoint = entry_point_1.getEntryPointInfo(_this.fs, _this.logger, packagePath, subdir);
                 if (subEntryPoint !== null) {
                     entryPoints.push(subEntryPoint);
                 }
@@ -103,19 +135,19 @@
          */
         EntryPointFinder.prototype.walkDirectory = function (dir, fn) {
             var _this = this;
-            return fs
-                .readdirSync(dir)
+            return this.fs
+                .readdir(dir)
                 // Not interested in hidden files
                 .filter(function (p) { return !p.startsWith('.'); })
                 // Ignore node_modules
                 .filter(function (p) { return p !== 'node_modules'; })
                 // Only interested in directories (and only those that are not symlinks)
                 .filter(function (p) {
-                var stat = fs.lstatSync(path.resolve(dir, p));
+                var stat = _this.fs.lstat(path_1.AbsoluteFsPath.resolve(dir, p));
                 return stat.isDirectory() && !stat.isSymbolicLink();
             })
                 .forEach(function (subDir) {
-                var resolvedSubDir = path_1.AbsoluteFsPath.from(path.resolve(dir, subDir));
+                var resolvedSubDir = path_1.AbsoluteFsPath.resolve(dir, subDir);
                 fn(resolvedSubDir);
                 _this.walkDirectory(resolvedSubDir, fn);
             });
@@ -123,5 +155,35 @@
         return EntryPointFinder;
     }());
     exports.EntryPointFinder = EntryPointFinder;
+    /**
+     * Extract everything in the `path` up to the first `*`.
+     * @param path The path to parse.
+     * @returns The extracted prefix.
+     */
+    function extractPathPrefix(path) {
+        return path.split('*', 1)[0];
+    }
+    /**
+     * A filter function that removes paths that are already covered by higher paths.
+     *
+     * @param value The current path.
+     * @param index The index of the current path.
+     * @param array The array of paths (sorted alphabetically).
+     * @returns true if this path is not already covered by a previous path.
+     */
+    function removeDeeperPaths(value, index, array) {
+        for (var i = 0; i < index; i++) {
+            if (value.startsWith(array[i]))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Extract all the values (not keys) from an object.
+     * @param obj The object to process.
+     */
+    function values(obj) {
+        return Object.keys(obj).map(function (key) { return obj[key]; });
+    }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/entry_point_finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as path from 'canonical-path';\nimport * as fs from 'fs';\n\nimport {AbsoluteFsPath} from '../../../src/ngtsc/path';\nimport {Logger} from '../logging/logger';\n\nimport {DependencyResolver, SortedEntryPointsInfo} from './dependency_resolver';\nimport {EntryPoint, getEntryPointInfo} from './entry_point';\n\n\nexport class EntryPointFinder {\n  constructor(private logger: Logger, private resolver: DependencyResolver) {}\n  /**\n   * Search the given directory, and sub-directories, for Angular package entry points.\n   * @param sourceDirectory An absolute path to the directory to search for entry points.\n   */\n  findEntryPoints(sourceDirectory: AbsoluteFsPath, targetEntryPointPath?: AbsoluteFsPath):\n      SortedEntryPointsInfo {\n    const unsortedEntryPoints = this.walkDirectoryForEntryPoints(sourceDirectory);\n    const targetEntryPoint = targetEntryPointPath ?\n        unsortedEntryPoints.find(entryPoint => entryPoint.path === targetEntryPointPath) :\n        undefined;\n    return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints, targetEntryPoint);\n  }\n\n  /**\n   * Look for entry points that need to be compiled, starting at the source directory.\n   * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.\n   * @param sourceDirectory An absolute path to the root directory where searching begins.\n   */\n  private walkDirectoryForEntryPoints(sourceDirectory: AbsoluteFsPath): EntryPoint[] {\n    const entryPoints: EntryPoint[] = [];\n    fs.readdirSync(sourceDirectory)\n        // Not interested in hidden files\n        .filter(p => !p.startsWith('.'))\n        // Ignore node_modules\n        .filter(p => p !== 'node_modules')\n        // Only interested in directories (and only those that are not symlinks)\n        .filter(p => {\n          const stat = fs.lstatSync(path.resolve(sourceDirectory, p));\n          return stat.isDirectory() && !stat.isSymbolicLink();\n        })\n        .forEach(p => {\n          // Either the directory is a potential package or a namespace containing packages (e.g\n          // `@angular`).\n          const packagePath = AbsoluteFsPath.from(path.join(sourceDirectory, p));\n          if (p.startsWith('@')) {\n            entryPoints.push(...this.walkDirectoryForEntryPoints(packagePath));\n          } else {\n            entryPoints.push(...this.getEntryPointsForPackage(packagePath));\n\n            // Also check for any nested node_modules in this package\n            const nestedNodeModulesPath =\n                AbsoluteFsPath.from(path.resolve(packagePath, 'node_modules'));\n            if (fs.existsSync(nestedNodeModulesPath)) {\n              entryPoints.push(...this.walkDirectoryForEntryPoints(nestedNodeModulesPath));\n            }\n          }\n        });\n    return entryPoints;\n  }\n\n  /**\n   * Recurse the folder structure looking for all the entry points\n   * @param packagePath The absolute path to an npm package that may contain entry points\n   * @returns An array of entry points that were discovered.\n   */\n  private getEntryPointsForPackage(packagePath: AbsoluteFsPath): EntryPoint[] {\n    const entryPoints: EntryPoint[] = [];\n\n    // Try to get an entry point from the top level package directory\n    const topLevelEntryPoint = getEntryPointInfo(this.logger, packagePath, packagePath);\n    if (topLevelEntryPoint !== null) {\n      entryPoints.push(topLevelEntryPoint);\n    }\n\n    // Now search all the directories of this package for possible entry points\n    this.walkDirectory(packagePath, subdir => {\n      const subEntryPoint = getEntryPointInfo(this.logger, packagePath, subdir);\n      if (subEntryPoint !== null) {\n        entryPoints.push(subEntryPoint);\n      }\n    });\n\n    return entryPoints;\n  }\n\n  /**\n   * Recursively walk a directory and its sub-directories, applying a given\n   * function to each directory.\n   * @param dir the directory to recursively walk.\n   * @param fn the function to apply to each directory.\n   */\n  private walkDirectory(dir: AbsoluteFsPath, fn: (dir: AbsoluteFsPath) => void) {\n    return fs\n        .readdirSync(dir)\n        // Not interested in hidden files\n        .filter(p => !p.startsWith('.'))\n        // Ignore node_modules\n        .filter(p => p !== 'node_modules')\n        // Only interested in directories (and only those that are not symlinks)\n        .filter(p => {\n          const stat = fs.lstatSync(path.resolve(dir, p));\n          return stat.isDirectory() && !stat.isSymbolicLink();\n        })\n        .forEach(subDir => {\n          const resolvedSubDir = AbsoluteFsPath.from(path.resolve(dir, subDir));\n          fn(resolvedSubDir);\n          this.walkDirectory(resolvedSubDir, fn);\n        });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/entry_point_finder.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,6DAAuD;IAKvD,mFAA4D;IAE5D;QACE,0BACY,EAAc,EAAU,MAAc,EAAU,QAA4B;YAA5E,OAAE,GAAF,EAAE,CAAY;YAAU,WAAM,GAAN,MAAM,CAAQ;YAAU,aAAQ,GAAR,QAAQ,CAAoB;QAAG,CAAC;QAC5F;;;WAGG;QACH,0CAAe,GAAf,UACI,eAA+B,EAAE,oBAAqC,EACtE,YAA2B;YAF/B,iBAWC;YARC,IAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;YACnE,IAAM,mBAAmB,GAAG,SAAS,CAAC,MAAM,CACxC,UAAC,WAAW,EAAE,QAAQ,IAAK,OAAA,WAAW,CAAC,MAAM,CAAC,KAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,EAA9D,CAA8D,EACzF,EAAE,CAAC,CAAC;YACR,IAAM,gBAAgB,GAAG,oBAAoB,CAAC,CAAC;gBAC3C,mBAAmB,CAAC,IAAI,CAAC,UAAA,UAAU,IAAI,OAAA,UAAU,CAAC,IAAI,KAAK,oBAAoB,EAAxC,CAAwC,CAAC,CAAC,CAAC;gBAClF,SAAS,CAAC;YACd,OAAO,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC,mBAAmB,EAAE,gBAAgB,CAAC,CAAC;QAC1F,CAAC;QAED;;;;;;;;;;;;;;;;;;WAkBG;QACK,uCAAY,GAApB,UAAqB,eAA+B,EAAE,YAA2B;YAE/E,IAAM,SAAS,GAAG,CAAC,eAAe,CAAC,CAAC;YACpC,IAAI,YAAY,EAAE;gBAChB,IAAM,SAAO,GAAG,qBAAc,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;gBAC7D,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,OAAO,CAAC,UAAA,IAAI;oBAC5D,SAAS,CAAC,IAAI,CAAC,qBAAc,CAAC,IAAI,CAAC,SAAO,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACxE,CAAC,CAAC,EAF0C,CAE1C,CAAC,CAAC;aACL;YACD,SAAS,CAAC,IAAI,EAAE,CAAC,CAAE,sDAAsD;YACzE,OAAO,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAC7C,CAAC;QAED;;;;WAIG;QACK,sDAA2B,GAAnC,UAAoC,eAA+B;YAAnE,iBA8BC;YA7BC,IAAM,WAAW,GAAiB,EAAE,CAAC;YACrC,IAAI,CAAC,EAAE;iBACF,OAAO,CAAC,eAAe,CAAC;gBACzB,iCAAiC;iBAChC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAlB,CAAkB,CAAC;gBAChC,sBAAsB;iBACrB,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,KAAK,cAAc,EAApB,CAAoB,CAAC;gBAClC,wEAAwE;iBACvE,MAAM,CAAC,UAAA,CAAC;gBACP,IAAM,IAAI,GAAG,KAAI,CAAC,EAAE,CAAC,KAAK,CAAC,qBAAc,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvE,OAAO,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACtD,CAAC,CAAC;iBACD,OAAO,CAAC,UAAA,CAAC;gBACR,sFAAsF;gBACtF,eAAe;gBACf,IAAM,WAAW,GAAG,qBAAc,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;gBAC5D,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;oBACrB,WAAW,CAAC,IAAI,OAAhB,WAAW,mBAAS,KAAI,CAAC,2BAA2B,CAAC,WAAW,CAAC,GAAE;iBACpE;qBAAM;oBACL,WAAW,CAAC,IAAI,OAAhB,WAAW,mBAAS,KAAI,CAAC,wBAAwB,CAAC,WAAW,CAAC,GAAE;oBAEhE,yDAAyD;oBACzD,IAAM,qBAAqB,GAAG,qBAAc,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;oBAC/E,IAAI,KAAI,CAAC,EAAE,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE;wBACzC,WAAW,CAAC,IAAI,OAAhB,WAAW,mBAAS,KAAI,CAAC,2BAA2B,CAAC,qBAAqB,CAAC,GAAE;qBAC9E;iBACF;YACH,CAAC,CAAC,CAAC;YACP,OAAO,WAAW,CAAC;QACrB,CAAC;QAED;;;;WAIG;QACK,mDAAwB,GAAhC,UAAiC,WAA2B;YAA5D,iBAkBC;YAjBC,IAAM,WAAW,GAAiB,EAAE,CAAC;YAErC,iEAAiE;YACjE,IAAM,kBAAkB,GAAG,+BAAiB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;YAC7F,IAAI,kBAAkB,KAAK,IAAI,EAAE;gBAC/B,WAAW,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;aACtC;YAED,2EAA2E;YAC3E,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,UAAA,MAAM;gBACpC,IAAM,aAAa,GAAG,+BAAiB,CAAC,KAAI,CAAC,EAAE,EAAE,KAAI,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;gBACnF,IAAI,aAAa,KAAK,IAAI,EAAE;oBAC1B,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;iBACjC;YACH,CAAC,CAAC,CAAC;YAEH,OAAO,WAAW,CAAC;QACrB,CAAC;QAED;;;;;WAKG;QACK,wCAAa,GAArB,UAAsB,GAAmB,EAAE,EAAiC;YAA5E,iBAiBC;YAhBC,OAAO,IAAI,CAAC,EAAE;iBACT,OAAO,CAAC,GAAG,CAAC;gBACb,iCAAiC;iBAChC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAlB,CAAkB,CAAC;gBAChC,sBAAsB;iBACrB,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,KAAK,cAAc,EAApB,CAAoB,CAAC;gBAClC,wEAAwE;iBACvE,MAAM,CAAC,UAAA,CAAC;gBACP,IAAM,IAAI,GAAG,KAAI,CAAC,EAAE,CAAC,KAAK,CAAC,qBAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC3D,OAAO,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACtD,CAAC,CAAC;iBACD,OAAO,CAAC,UAAA,MAAM;gBACb,IAAM,cAAc,GAAG,qBAAc,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC3D,EAAE,CAAC,cAAc,CAAC,CAAC;gBACnB,KAAI,CAAC,aAAa,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACT,CAAC;QACH,uBAAC;IAAD,CAAC,AA1ID,IA0IC;IA1IY,4CAAgB;IA4I7B;;;;OAIG;IACH,SAAS,iBAAiB,CAAC,IAAY;QACrC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,iBAAiB,CAAC,KAAqB,EAAE,KAAa,EAAE,KAAuB;QACtF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;YAC9B,IAAI,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAAE,OAAO,KAAK,CAAC;SAC9C;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,SAAS,MAAM,CAAI,GAAuB;QACxC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,CAAC,EAAR,CAAQ,CAAC,CAAC;IAC/C,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AbsoluteFsPath} from '../../../src/ngtsc/path';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {FileSystem} from '../file_system/file_system';\nimport {Logger} from '../logging/logger';\nimport {PathMappings} from '../utils';\nimport {EntryPoint, getEntryPointInfo} from './entry_point';\n\nexport class EntryPointFinder {\n  constructor(\n      private fs: FileSystem, private logger: Logger, private resolver: DependencyResolver) {}\n  /**\n   * Search the given directory, and sub-directories, for Angular package entry points.\n   * @param sourceDirectory An absolute path to the directory to search for entry points.\n   */\n  findEntryPoints(\n      sourceDirectory: AbsoluteFsPath, targetEntryPointPath?: AbsoluteFsPath,\n      pathMappings?: PathMappings): SortedEntryPointsInfo {\n    const basePaths = this.getBasePaths(sourceDirectory, pathMappings);\n    const unsortedEntryPoints = basePaths.reduce<EntryPoint[]>(\n        (entryPoints, basePath) => entryPoints.concat(this.walkDirectoryForEntryPoints(basePath)),\n        []);\n    const targetEntryPoint = targetEntryPointPath ?\n        unsortedEntryPoints.find(entryPoint => entryPoint.path === targetEntryPointPath) :\n        undefined;\n    return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints, targetEntryPoint);\n  }\n\n  /**\n   * Extract all the base-paths that we need to search for entry-points.\n   *\n   * This always contains the standard base-path (`sourceDirectory`).\n   * But it also parses the `paths` mappings object to guess additional base-paths.\n   *\n   * For example:\n   *\n   * ```\n   * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})\n   * > ['/node_modules', '/dist/lib']\n   * ```\n   *\n   * Notice that `'/dist'` is not included as there is no `'*'` path,\n   * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.\n   *\n   * @param sourceDirectory The standard base-path (e.g. node_modules).\n   * @param pathMappings Path mapping configuration, from which to extract additional base-paths.\n   */\n  private getBasePaths(sourceDirectory: AbsoluteFsPath, pathMappings?: PathMappings):\n      AbsoluteFsPath[] {\n    const basePaths = [sourceDirectory];\n    if (pathMappings) {\n      const baseUrl = AbsoluteFsPath.resolve(pathMappings.baseUrl);\n      values(pathMappings.paths).forEach(paths => paths.forEach(path => {\n        basePaths.push(AbsoluteFsPath.join(baseUrl, extractPathPrefix(path)));\n      }));\n    }\n    basePaths.sort();  // Get the paths in order with the shorter ones first.\n    return basePaths.filter(removeDeeperPaths);\n  }\n\n  /**\n   * Look for entry points that need to be compiled, starting at the source directory.\n   * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.\n   * @param sourceDirectory An absolute path to the root directory where searching begins.\n   */\n  private walkDirectoryForEntryPoints(sourceDirectory: AbsoluteFsPath): EntryPoint[] {\n    const entryPoints: EntryPoint[] = [];\n    this.fs\n        .readdir(sourceDirectory)\n        // Not interested in hidden files\n        .filter(p => !p.startsWith('.'))\n        // Ignore node_modules\n        .filter(p => p !== 'node_modules')\n        // Only interested in directories (and only those that are not symlinks)\n        .filter(p => {\n          const stat = this.fs.lstat(AbsoluteFsPath.resolve(sourceDirectory, p));\n          return stat.isDirectory() && !stat.isSymbolicLink();\n        })\n        .forEach(p => {\n          // Either the directory is a potential package or a namespace containing packages (e.g\n          // `@angular`).\n          const packagePath = AbsoluteFsPath.join(sourceDirectory, p);\n          if (p.startsWith('@')) {\n            entryPoints.push(...this.walkDirectoryForEntryPoints(packagePath));\n          } else {\n            entryPoints.push(...this.getEntryPointsForPackage(packagePath));\n\n            // Also check for any nested node_modules in this package\n            const nestedNodeModulesPath = AbsoluteFsPath.join(packagePath, 'node_modules');\n            if (this.fs.exists(nestedNodeModulesPath)) {\n              entryPoints.push(...this.walkDirectoryForEntryPoints(nestedNodeModulesPath));\n            }\n          }\n        });\n    return entryPoints;\n  }\n\n  /**\n   * Recurse the folder structure looking for all the entry points\n   * @param packagePath The absolute path to an npm package that may contain entry points\n   * @returns An array of entry points that were discovered.\n   */\n  private getEntryPointsForPackage(packagePath: AbsoluteFsPath): EntryPoint[] {\n    const entryPoints: EntryPoint[] = [];\n\n    // Try to get an entry point from the top level package directory\n    const topLevelEntryPoint = getEntryPointInfo(this.fs, this.logger, packagePath, packagePath);\n    if (topLevelEntryPoint !== null) {\n      entryPoints.push(topLevelEntryPoint);\n    }\n\n    // Now search all the directories of this package for possible entry points\n    this.walkDirectory(packagePath, subdir => {\n      const subEntryPoint = getEntryPointInfo(this.fs, this.logger, packagePath, subdir);\n      if (subEntryPoint !== null) {\n        entryPoints.push(subEntryPoint);\n      }\n    });\n\n    return entryPoints;\n  }\n\n  /**\n   * Recursively walk a directory and its sub-directories, applying a given\n   * function to each directory.\n   * @param dir the directory to recursively walk.\n   * @param fn the function to apply to each directory.\n   */\n  private walkDirectory(dir: AbsoluteFsPath, fn: (dir: AbsoluteFsPath) => void) {\n    return this.fs\n        .readdir(dir)\n        // Not interested in hidden files\n        .filter(p => !p.startsWith('.'))\n        // Ignore node_modules\n        .filter(p => p !== 'node_modules')\n        // Only interested in directories (and only those that are not symlinks)\n        .filter(p => {\n          const stat = this.fs.lstat(AbsoluteFsPath.resolve(dir, p));\n          return stat.isDirectory() && !stat.isSymbolicLink();\n        })\n        .forEach(subDir => {\n          const resolvedSubDir = AbsoluteFsPath.resolve(dir, subDir);\n          fn(resolvedSubDir);\n          this.walkDirectory(resolvedSubDir, fn);\n        });\n  }\n}\n\n/**\n * Extract everything in the `path` up to the first `*`.\n * @param path The path to parse.\n * @returns The extracted prefix.\n */\nfunction extractPathPrefix(path: string) {\n  return path.split('*', 1)[0];\n}\n\n/**\n * A filter function that removes paths that are already covered by higher paths.\n *\n * @param value The current path.\n * @param index The index of the current path.\n * @param array The array of paths (sorted alphabetically).\n * @returns true if this path is not already covered by a previous path.\n */\nfunction removeDeeperPaths(value: AbsoluteFsPath, index: number, array: AbsoluteFsPath[]) {\n  for (let i = 0; i < index; i++) {\n    if (value.startsWith(array[i])) return false;\n  }\n  return true;\n}\n\n/**\n * Extract all the values (not keys) from an object.\n * @param obj The object to process.\n */\nfunction values<T>(obj: {[key: string]: T}): T[] {\n  return Object.keys(obj).map(key => obj[key]);\n}\n"]}

package/ngcc/src/packages/ngcc_compiler_host.d.ts

@@ -0,0 +1,31 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/packages/ngcc_compiler_host" />
+import * as ts from 'typescript';
+import { FileSystem } from '../file_system/file_system';
+export declare class NgccCompilerHost implements ts.CompilerHost {
+    protected fs: FileSystem;
+    protected options: ts.CompilerOptions;
+    private _caseSensitive;
+    constructor(fs: FileSystem, options: ts.CompilerOptions);
+    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile | undefined;
+    getDefaultLibFileName(options: ts.CompilerOptions): string;
+    getDefaultLibLocation(): string;
+    writeFile(fileName: string, data: string): void;
+    getCurrentDirectory(): string;
+    getCanonicalFileName(fileName: string): string;
+    useCaseSensitiveFileNames(): boolean;
+    getNewLine(): string;
+    fileExists(fileName: string): boolean;
+    readFile(fileName: string): string | undefined;
+}
+/**
+ * Represents a compiler host that resolves a module import as a JavaScript source file if
+ * available, instead of the .d.ts typings file that would have been resolved by TypeScript. This
+ * is necessary for packages that have their typings in the same directory as the sources, which
+ * would otherwise let TypeScript prefer the .d.ts file instead of the JavaScript source file.
+ */
+export declare class NgccSourcesCompilerHost extends NgccCompilerHost {
+    protected entryPointPath: string;
+    private cache;
+    constructor(fs: FileSystem, options: ts.CompilerOptions, entryPointPath: string);
+    resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames?: string[], redirectedReference?: ts.ResolvedProjectReference): Array<ts.ResolvedModule | undefined>;
+}

package/ngcc/src/packages/ngcc_compiler_host.js

@@ -0,0 +1,108 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/ngcc/src/packages/ngcc_compiler_host", ["require", "exports", "tslib", "os", "typescript", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/ngcc/src/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var os = require("os");
+    var ts = require("typescript");
+    var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/utils");
+    var NgccCompilerHost = /** @class */ (function () {
+        function NgccCompilerHost(fs, options) {
+            this.fs = fs;
+            this.options = options;
+            this._caseSensitive = this.fs.exists(path_1.AbsoluteFsPath.fromUnchecked(__filename.toUpperCase()));
+        }
+        NgccCompilerHost.prototype.getSourceFile = function (fileName, languageVersion) {
+            var text = this.readFile(fileName);
+            return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion) : undefined;
+        };
+        NgccCompilerHost.prototype.getDefaultLibFileName = function (options) {
+            return this.getDefaultLibLocation() + '/' + ts.getDefaultLibFileName(options);
+        };
+        NgccCompilerHost.prototype.getDefaultLibLocation = function () {
+            var nodeLibPath = path_1.AbsoluteFsPath.from(require.resolve('typescript'));
+            return path_1.AbsoluteFsPath.join(nodeLibPath, '..');
+        };
+        NgccCompilerHost.prototype.writeFile = function (fileName, data) {
+            this.fs.writeFile(path_1.AbsoluteFsPath.fromUnchecked(fileName), data);
+        };
+        NgccCompilerHost.prototype.getCurrentDirectory = function () { return this.fs.pwd(); };
+        NgccCompilerHost.prototype.getCanonicalFileName = function (fileName) {
+            return this.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+        };
+        NgccCompilerHost.prototype.useCaseSensitiveFileNames = function () { return this._caseSensitive; };
+        NgccCompilerHost.prototype.getNewLine = function () {
+            switch (this.options.newLine) {
+                case ts.NewLineKind.CarriageReturnLineFeed:
+                    return '\r\n';
+                case ts.NewLineKind.LineFeed:
+                    return '\n';
+                default:
+                    return os.EOL;
+            }
+        };
+        NgccCompilerHost.prototype.fileExists = function (fileName) {
+            return this.fs.exists(path_1.AbsoluteFsPath.fromUnchecked(fileName));
+        };
+        NgccCompilerHost.prototype.readFile = function (fileName) {
+            if (!this.fileExists(fileName)) {
+                return undefined;
+            }
+            return this.fs.readFile(path_1.AbsoluteFsPath.fromUnchecked(fileName));
+        };
+        return NgccCompilerHost;
+    }());
+    exports.NgccCompilerHost = NgccCompilerHost;
+    /**
+     * Represents a compiler host that resolves a module import as a JavaScript source file if
+     * available, instead of the .d.ts typings file that would have been resolved by TypeScript. This
+     * is necessary for packages that have their typings in the same directory as the sources, which
+     * would otherwise let TypeScript prefer the .d.ts file instead of the JavaScript source file.
+     */
+    var NgccSourcesCompilerHost = /** @class */ (function (_super) {
+        tslib_1.__extends(NgccSourcesCompilerHost, _super);
+        function NgccSourcesCompilerHost(fs, options, entryPointPath) {
+            var _this = _super.call(this, fs, options) || this;
+            _this.entryPointPath = entryPointPath;
+            _this.cache = ts.createModuleResolutionCache(_this.getCurrentDirectory(), function (file) { return _this.getCanonicalFileName(file); });
+            return _this;
+        }
+        NgccSourcesCompilerHost.prototype.resolveModuleNames = function (moduleNames, containingFile, reusedNames, redirectedReference) {
+            var _this = this;
+            return moduleNames.map(function (moduleName) {
+                var resolvedModule = ts.resolveModuleName(moduleName, containingFile, _this.options, _this, _this.cache, redirectedReference).resolvedModule;
+                // If the module request originated from a relative import in a JavaScript source file,
+                // TypeScript may have resolved the module to its .d.ts declaration file if the .js source
+                // file was in the same directory. This is undesirable, as we need to have the actual
+                // JavaScript being present in the program. This logic recognizes this scenario and rewrites
+                // the resolved .d.ts declaration file to its .js counterpart, if it exists.
+                if (resolvedModule !== undefined && resolvedModule.extension === ts.Extension.Dts &&
+                    containingFile.endsWith('.js') && utils_1.isRelativePath(moduleName)) {
+                    var jsFile = resolvedModule.resolvedFileName.replace(/\.d\.ts$/, '.js');
+                    if (_this.fileExists(jsFile)) {
+                        return tslib_1.__assign({}, resolvedModule, { resolvedFileName: jsFile, extension: ts.Extension.Js });
+                    }
+                }
+                return resolvedModule;
+            });
+        };
+        return NgccSourcesCompilerHost;
+    }(NgccCompilerHost));
+    exports.NgccSourcesCompilerHost = NgccSourcesCompilerHost;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngcc_compiler_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/ngcc_compiler_host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as os from 'os';\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath} from '../../../src/ngtsc/path';\nimport {FileSystem} from '../file_system/file_system';\nimport {isRelativePath} from '../utils';\n\nexport class NgccCompilerHost implements ts.CompilerHost {\n  private _caseSensitive = this.fs.exists(AbsoluteFsPath.fromUnchecked(__filename.toUpperCase()));\n\n  constructor(protected fs: FileSystem, protected options: ts.CompilerOptions) {}\n\n  getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile|undefined {\n    const text = this.readFile(fileName);\n    return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion) : undefined;\n  }\n\n  getDefaultLibFileName(options: ts.CompilerOptions): string {\n    return this.getDefaultLibLocation() + '/' + ts.getDefaultLibFileName(options);\n  }\n\n  getDefaultLibLocation(): string {\n    const nodeLibPath = AbsoluteFsPath.from(require.resolve('typescript'));\n    return AbsoluteFsPath.join(nodeLibPath, '..');\n  }\n\n  writeFile(fileName: string, data: string): void {\n    this.fs.writeFile(AbsoluteFsPath.fromUnchecked(fileName), data);\n  }\n\n  getCurrentDirectory(): string { return this.fs.pwd(); }\n\n  getCanonicalFileName(fileName: string): string {\n    return this.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();\n  }\n\n  useCaseSensitiveFileNames(): boolean { return this._caseSensitive; }\n\n  getNewLine(): string {\n    switch (this.options.newLine) {\n      case ts.NewLineKind.CarriageReturnLineFeed:\n        return '\\r\\n';\n      case ts.NewLineKind.LineFeed:\n        return '\\n';\n      default:\n        return os.EOL;\n    }\n  }\n\n  fileExists(fileName: string): boolean {\n    return this.fs.exists(AbsoluteFsPath.fromUnchecked(fileName));\n  }\n\n  readFile(fileName: string): string|undefined {\n    if (!this.fileExists(fileName)) {\n      return undefined;\n    }\n    return this.fs.readFile(AbsoluteFsPath.fromUnchecked(fileName));\n  }\n}\n\n/**\n * Represents a compiler host that resolves a module import as a JavaScript source file if\n * available, instead of the .d.ts typings file that would have been resolved by TypeScript. This\n * is necessary for packages that have their typings in the same directory as the sources, which\n * would otherwise let TypeScript prefer the .d.ts file instead of the JavaScript source file.\n */\nexport class NgccSourcesCompilerHost extends NgccCompilerHost {\n  private cache = ts.createModuleResolutionCache(\n      this.getCurrentDirectory(), file => this.getCanonicalFileName(file));\n\n  constructor(fs: FileSystem, options: ts.CompilerOptions, protected entryPointPath: string) {\n    super(fs, options);\n  }\n\n  resolveModuleNames(\n      moduleNames: string[], containingFile: string, reusedNames?: string[],\n      redirectedReference?: ts.ResolvedProjectReference): Array<ts.ResolvedModule|undefined> {\n    return moduleNames.map(moduleName => {\n      const {resolvedModule} = ts.resolveModuleName(\n          moduleName, containingFile, this.options, this, this.cache, redirectedReference);\n\n      // If the module request originated from a relative import in a JavaScript source file,\n      // TypeScript may have resolved the module to its .d.ts declaration file if the .js source\n      // file was in the same directory. This is undesirable, as we need to have the actual\n      // JavaScript being present in the program. This logic recognizes this scenario and rewrites\n      // the resolved .d.ts declaration file to its .js counterpart, if it exists.\n      if (resolvedModule !== undefined && resolvedModule.extension === ts.Extension.Dts &&\n          containingFile.endsWith('.js') && isRelativePath(moduleName)) {\n        const jsFile = resolvedModule.resolvedFileName.replace(/\\.d\\.ts$/, '.js');\n        if (this.fileExists(jsFile)) {\n          return {...resolvedModule, resolvedFileName: jsFile, extension: ts.Extension.Js};\n        }\n      }\n      return resolvedModule;\n    });\n  }\n}\n"]}

package/ngcc/src/packages/transformer.d.ts

@@ -11,9 +11,11 @@ import { CompiledFile } from '../analysis/decoration_analyzer';
 import { ModuleWithProvidersAnalyses } from '../analysis/module_with_providers_analyzer';
 import { ExportInfo } from '../analysis/private_declarations_analyzer';
 import { SwitchMarkerAnalyses } from '../analysis/switch_marker_analyzer';
+import { FileSystem } from '../file_system/file_system';
 import { NgccReflectionHost } from '../host/ngcc_host';
 import { Logger } from '../logging/logger';
-import { FileInfo, Renderer } from '../rendering/renderer';
+import { RenderingFormatter } from '../rendering/rendering_formatter';
+import { FileToWrite } from '../rendering/utils';
 import { EntryPointBundle } from './entry_point_bundle';
 /**
  * A Package is stored in a directory on disk and that directory can contain one or more package
@@ -37,17 +39,17 @@ import { EntryPointBundle } from './entry_point_bundle';
  * - Some formats may contain multiple "modules" in a single file.
  */
 export declare class Transformer {
+    private fs;
     private logger;
-    private sourcePath;
-    constructor(logger: Logger, sourcePath: string);
+    constructor(fs: FileSystem, logger: Logger);
     /**
      * Transform the source (and typings) files of a bundle.
      * @param bundle the bundle to transform.
      * @returns information about the files that were transformed.
      */
-    transform(bundle: EntryPointBundle): FileInfo[];
+    transform(bundle: EntryPointBundle): FileToWrite[];
     getHost(isCore: boolean, bundle: EntryPointBundle): NgccReflectionHost;
-    getRenderer(host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle): Renderer;
+    getRenderingFormatter(host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle): RenderingFormatter;
     analyzeProgram(reflectionHost: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle): ProgramAnalyses;
 }
 interface ProgramAnalyses {

package/ngcc/src/packages/transformer.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/packages/transformer", ["require", "exports", "@angular/compiler-cli/ngcc/src/analysis/decoration_analyzer", "@angular/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer", "@angular/compiler-cli/ngcc/src/analysis/ngcc_references_registry", "@angular/compiler-cli/ngcc/src/analysis/private_declarations_analyzer", "@angular/compiler-cli/ngcc/src/analysis/switch_marker_analyzer", "@angular/compiler-cli/ngcc/src/host/esm2015_host", "@angular/compiler-cli/ngcc/src/host/esm5_host", "@angular/compiler-cli/ngcc/src/rendering/esm5_renderer", "@angular/compiler-cli/ngcc/src/rendering/esm_renderer"], factory);
+        define("@angular/compiler-cli/ngcc/src/packages/transformer", ["require", "exports", "@angular/compiler-cli/ngcc/src/analysis/decoration_analyzer", "@angular/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer", "@angular/compiler-cli/ngcc/src/analysis/ngcc_references_registry", "@angular/compiler-cli/ngcc/src/analysis/private_declarations_analyzer", "@angular/compiler-cli/ngcc/src/analysis/switch_marker_analyzer", "@angular/compiler-cli/ngcc/src/host/commonjs_host", "@angular/compiler-cli/ngcc/src/host/esm2015_host", "@angular/compiler-cli/ngcc/src/host/esm5_host", "@angular/compiler-cli/ngcc/src/host/umd_host", "@angular/compiler-cli/ngcc/src/rendering/commonjs_rendering_formatter", "@angular/compiler-cli/ngcc/src/rendering/dts_renderer", "@angular/compiler-cli/ngcc/src/rendering/esm5_rendering_formatter", "@angular/compiler-cli/ngcc/src/rendering/esm_rendering_formatter", "@angular/compiler-cli/ngcc/src/rendering/renderer", "@angular/compiler-cli/ngcc/src/rendering/umd_rendering_formatter"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -14,10 +14,16 @@
     var ngcc_references_registry_1 = require("@angular/compiler-cli/ngcc/src/analysis/ngcc_references_registry");
     var private_declarations_analyzer_1 = require("@angular/compiler-cli/ngcc/src/analysis/private_declarations_analyzer");
     var switch_marker_analyzer_1 = require("@angular/compiler-cli/ngcc/src/analysis/switch_marker_analyzer");
+    var commonjs_host_1 = require("@angular/compiler-cli/ngcc/src/host/commonjs_host");
     var esm2015_host_1 = require("@angular/compiler-cli/ngcc/src/host/esm2015_host");
     var esm5_host_1 = require("@angular/compiler-cli/ngcc/src/host/esm5_host");
-    var esm5_renderer_1 = require("@angular/compiler-cli/ngcc/src/rendering/esm5_renderer");
-    var esm_renderer_1 = require("@angular/compiler-cli/ngcc/src/rendering/esm_renderer");
+    var umd_host_1 = require("@angular/compiler-cli/ngcc/src/host/umd_host");
+    var commonjs_rendering_formatter_1 = require("@angular/compiler-cli/ngcc/src/rendering/commonjs_rendering_formatter");
+    var dts_renderer_1 = require("@angular/compiler-cli/ngcc/src/rendering/dts_renderer");
+    var esm5_rendering_formatter_1 = require("@angular/compiler-cli/ngcc/src/rendering/esm5_rendering_formatter");
+    var esm_rendering_formatter_1 = require("@angular/compiler-cli/ngcc/src/rendering/esm_rendering_formatter");
+    var renderer_1 = require("@angular/compiler-cli/ngcc/src/rendering/renderer");
+    var umd_rendering_formatter_1 = require("@angular/compiler-cli/ngcc/src/rendering/umd_rendering_formatter");
     /**
      * A Package is stored in a directory on disk and that directory can contain one or more package
      * formats - e.g. fesm2015, UMD, etc. Additionally, each package provides typings (`.d.ts` files).
@@ -40,9 +46,9 @@
      * - Some formats may contain multiple "modules" in a single file.
      */
     var Transformer = /** @class */ (function () {
-        function Transformer(logger, sourcePath) {
+        function Transformer(fs, logger) {
+            this.fs = fs;
             this.logger = logger;
-            this.sourcePath = sourcePath;
         }
         /**
          * Transform the source (and typings) files of a bundle.
@@ -55,8 +61,15 @@
             // Parse and analyze the files.
             var _a = this.analyzeProgram(reflectionHost, isCore, bundle), decorationAnalyses = _a.decorationAnalyses, switchMarkerAnalyses = _a.switchMarkerAnalyses, privateDeclarationsAnalyses = _a.privateDeclarationsAnalyses, moduleWithProvidersAnalyses = _a.moduleWithProvidersAnalyses;
             // Transform the source files and source maps.
-            var renderer = this.getRenderer(reflectionHost, isCore, bundle);
-            var renderedFiles = renderer.renderProgram(decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses);
+            var srcFormatter = this.getRenderingFormatter(reflectionHost, isCore, bundle);
+            var renderer = new renderer_1.Renderer(srcFormatter, this.fs, this.logger, reflectionHost, isCore, bundle);
+            var renderedFiles = renderer.renderProgram(decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses);
+            if (bundle.dts) {
+                var dtsFormatter = new esm_rendering_formatter_1.EsmRenderingFormatter(reflectionHost, isCore);
+                var dtsRenderer = new dts_renderer_1.DtsRenderer(dtsFormatter, this.fs, this.logger, reflectionHost, isCore, bundle);
+                var renderedDtsFiles = dtsRenderer.renderProgram(decorationAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses);
+                renderedFiles = renderedFiles.concat(renderedDtsFiles);
+            }
             return renderedFiles;
         };
         Transformer.prototype.getHost = function (isCore, bundle) {
@@ -66,16 +79,27 @@
                     return new esm2015_host_1.Esm2015ReflectionHost(this.logger, isCore, typeChecker, bundle.dts);
                 case 'esm5':
                     return new esm5_host_1.Esm5ReflectionHost(this.logger, isCore, typeChecker, bundle.dts);
+                case 'umd':
+                    return new umd_host_1.UmdReflectionHost(this.logger, isCore, bundle.src.program, bundle.src.host, bundle.dts);
+                case 'commonjs':
+                    return new commonjs_host_1.CommonJsReflectionHost(this.logger, isCore, bundle.src.program, bundle.src.host, bundle.dts);
                 default:
                     throw new Error("Reflection host for \"" + bundle.format + "\" not yet implemented.");
             }
         };
-        Transformer.prototype.getRenderer = function (host, isCore, bundle) {
+        Transformer.prototype.getRenderingFormatter = function (host, isCore, bundle) {
             switch (bundle.format) {
                 case 'esm2015':
-                    return new esm_renderer_1.EsmRenderer(this.logger, host, isCore, bundle, this.sourcePath);
+                    return new esm_rendering_formatter_1.EsmRenderingFormatter(host, isCore);
                 case 'esm5':
-                    return new esm5_renderer_1.Esm5Renderer(this.logger, host, isCore, bundle, this.sourcePath);
+                    return new esm5_rendering_formatter_1.Esm5RenderingFormatter(host, isCore);
+                case 'umd':
+                    if (!(host instanceof umd_host_1.UmdReflectionHost)) {
+                        throw new Error('UmdRenderer requires a UmdReflectionHost');
+                    }
+                    return new umd_rendering_formatter_1.UmdRenderingFormatter(host, isCore);
+                case 'commonjs':
+                    return new commonjs_rendering_formatter_1.CommonJsRenderingFormatter(host, isCore);
                 default:
                     throw new Error("Renderer for \"" + bundle.format + "\" not yet implemented.");
             }
@@ -85,7 +109,7 @@
             var referencesRegistry = new ngcc_references_registry_1.NgccReferencesRegistry(reflectionHost);
             var switchMarkerAnalyzer = new switch_marker_analyzer_1.SwitchMarkerAnalyzer(reflectionHost);
             var switchMarkerAnalyses = switchMarkerAnalyzer.analyzeProgram(bundle.src.program);
-            var decorationAnalyzer = new decoration_analyzer_1.DecorationAnalyzer(bundle.src.program, bundle.src.options, bundle.src.host, typeChecker, reflectionHost, referencesRegistry, bundle.rootDirs, isCore);
+            var decorationAnalyzer = new decoration_analyzer_1.DecorationAnalyzer(this.fs, bundle.src.program, bundle.src.options, bundle.src.host, typeChecker, reflectionHost, referencesRegistry, bundle.rootDirs, isCore);
             var decorationAnalyses = decorationAnalyzer.analyzeProgram();
             var moduleWithProvidersAnalyzer = bundle.dts && new module_with_providers_analyzer_1.ModuleWithProvidersAnalyzer(reflectionHost, referencesRegistry);
             var moduleWithProvidersAnalyses = moduleWithProvidersAnalyzer &&
@@ -99,4 +123,4 @@
     }());
     exports.Transformer = Transformer;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transformer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/transformer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {CompiledFile, DecorationAnalyzer} from '../analysis/decoration_analyzer';\nimport {ModuleWithProvidersAnalyses, ModuleWithProvidersAnalyzer} from '../analysis/module_with_providers_analyzer';\nimport {NgccReferencesRegistry} from '../analysis/ngcc_references_registry';\nimport {ExportInfo, PrivateDeclarationsAnalyzer} from '../analysis/private_declarations_analyzer';\nimport {SwitchMarkerAnalyses, SwitchMarkerAnalyzer} from '../analysis/switch_marker_analyzer';\nimport {Esm2015ReflectionHost} from '../host/esm2015_host';\nimport {Esm5ReflectionHost} from '../host/esm5_host';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {Logger} from '../logging/logger';\nimport {Esm5Renderer} from '../rendering/esm5_renderer';\nimport {EsmRenderer} from '../rendering/esm_renderer';\nimport {FileInfo, Renderer} from '../rendering/renderer';\n\nimport {EntryPointBundle} from './entry_point_bundle';\n\n\n\n/**\n * A Package is stored in a directory on disk and that directory can contain one or more package\n * formats - e.g. fesm2015, UMD, etc. Additionally, each package provides typings (`.d.ts` files).\n *\n * Each of these formats exposes one or more entry points, which are source files that need to be\n * parsed to identify the decorated exported classes that need to be analyzed and compiled by one or\n * more `DecoratorHandler` objects.\n *\n * Each entry point to a package is identified by a `package.json` which contains properties that\n * indicate what formatted bundles are accessible via this end-point.\n *\n * Each bundle is identified by a root `SourceFile` that can be parsed and analyzed to\n * identify classes that need to be transformed; and then finally rendered and written to disk.\n *\n * Along with the source files, the corresponding source maps (either inline or external) and\n * `.d.ts` files are transformed accordingly.\n *\n * - Flat file packages have all the classes in a single file.\n * - Other packages may re-export classes from other non-entry point files.\n * - Some formats may contain multiple \"modules\" in a single file.\n */\nexport class Transformer {\n  constructor(private logger: Logger, private sourcePath: string) {}\n\n  /**\n   * Transform the source (and typings) files of a bundle.\n   * @param bundle the bundle to transform.\n   * @returns information about the files that were transformed.\n   */\n  transform(bundle: EntryPointBundle): FileInfo[] {\n    const isCore = bundle.isCore;\n    const reflectionHost = this.getHost(isCore, bundle);\n\n    // Parse and analyze the files.\n    const {decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,\n           moduleWithProvidersAnalyses} = this.analyzeProgram(reflectionHost, isCore, bundle);\n\n    // Transform the source files and source maps.\n    const renderer = this.getRenderer(reflectionHost, isCore, bundle);\n    const renderedFiles = renderer.renderProgram(\n        decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,\n        moduleWithProvidersAnalyses);\n\n    return renderedFiles;\n  }\n\n  getHost(isCore: boolean, bundle: EntryPointBundle): NgccReflectionHost {\n    const typeChecker = bundle.src.program.getTypeChecker();\n    switch (bundle.format) {\n      case 'esm2015':\n        return new Esm2015ReflectionHost(this.logger, isCore, typeChecker, bundle.dts);\n      case 'esm5':\n        return new Esm5ReflectionHost(this.logger, isCore, typeChecker, bundle.dts);\n      default:\n        throw new Error(`Reflection host for \"${bundle.format}\" not yet implemented.`);\n    }\n  }\n\n  getRenderer(host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle): Renderer {\n    switch (bundle.format) {\n      case 'esm2015':\n        return new EsmRenderer(this.logger, host, isCore, bundle, this.sourcePath);\n      case 'esm5':\n        return new Esm5Renderer(this.logger, host, isCore, bundle, this.sourcePath);\n      default:\n        throw new Error(`Renderer for \"${bundle.format}\" not yet implemented.`);\n    }\n  }\n\n  analyzeProgram(reflectionHost: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle):\n      ProgramAnalyses {\n    const typeChecker = bundle.src.program.getTypeChecker();\n    const referencesRegistry = new NgccReferencesRegistry(reflectionHost);\n\n    const switchMarkerAnalyzer = new SwitchMarkerAnalyzer(reflectionHost);\n    const switchMarkerAnalyses = switchMarkerAnalyzer.analyzeProgram(bundle.src.program);\n\n    const decorationAnalyzer = new DecorationAnalyzer(\n        bundle.src.program, bundle.src.options, bundle.src.host, typeChecker, reflectionHost,\n        referencesRegistry, bundle.rootDirs, isCore);\n    const decorationAnalyses = decorationAnalyzer.analyzeProgram();\n\n    const moduleWithProvidersAnalyzer =\n        bundle.dts && new ModuleWithProvidersAnalyzer(reflectionHost, referencesRegistry);\n    const moduleWithProvidersAnalyses = moduleWithProvidersAnalyzer &&\n        moduleWithProvidersAnalyzer.analyzeProgram(bundle.src.program);\n\n    const privateDeclarationsAnalyzer =\n        new PrivateDeclarationsAnalyzer(reflectionHost, referencesRegistry);\n    const privateDeclarationsAnalyses =\n        privateDeclarationsAnalyzer.analyzeProgram(bundle.src.program);\n\n    return {decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,\n            moduleWithProvidersAnalyses};\n  }\n}\n\n\ninterface ProgramAnalyses {\n  decorationAnalyses: Map<ts.SourceFile, CompiledFile>;\n  switchMarkerAnalyses: SwitchMarkerAnalyses;\n  privateDeclarationsAnalyses: ExportInfo[];\n  moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses|null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transformer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/transformer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {CompiledFile, DecorationAnalyzer} from '../analysis/decoration_analyzer';\nimport {ModuleWithProvidersAnalyses, ModuleWithProvidersAnalyzer} from '../analysis/module_with_providers_analyzer';\nimport {NgccReferencesRegistry} from '../analysis/ngcc_references_registry';\nimport {ExportInfo, PrivateDeclarationsAnalyzer} from '../analysis/private_declarations_analyzer';\nimport {SwitchMarkerAnalyses, SwitchMarkerAnalyzer} from '../analysis/switch_marker_analyzer';\nimport {FileSystem} from '../file_system/file_system';\nimport {CommonJsReflectionHost} from '../host/commonjs_host';\nimport {Esm2015ReflectionHost} from '../host/esm2015_host';\nimport {Esm5ReflectionHost} from '../host/esm5_host';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {UmdReflectionHost} from '../host/umd_host';\nimport {Logger} from '../logging/logger';\nimport {CommonJsRenderingFormatter} from '../rendering/commonjs_rendering_formatter';\nimport {DtsRenderer} from '../rendering/dts_renderer';\nimport {Esm5RenderingFormatter} from '../rendering/esm5_rendering_formatter';\nimport {EsmRenderingFormatter} from '../rendering/esm_rendering_formatter';\nimport {Renderer} from '../rendering/renderer';\nimport {RenderingFormatter} from '../rendering/rendering_formatter';\nimport {UmdRenderingFormatter} from '../rendering/umd_rendering_formatter';\nimport {FileToWrite} from '../rendering/utils';\n\nimport {EntryPointBundle} from './entry_point_bundle';\n\n\n\n/**\n * A Package is stored in a directory on disk and that directory can contain one or more package\n * formats - e.g. fesm2015, UMD, etc. Additionally, each package provides typings (`.d.ts` files).\n *\n * Each of these formats exposes one or more entry points, which are source files that need to be\n * parsed to identify the decorated exported classes that need to be analyzed and compiled by one or\n * more `DecoratorHandler` objects.\n *\n * Each entry point to a package is identified by a `package.json` which contains properties that\n * indicate what formatted bundles are accessible via this end-point.\n *\n * Each bundle is identified by a root `SourceFile` that can be parsed and analyzed to\n * identify classes that need to be transformed; and then finally rendered and written to disk.\n *\n * Along with the source files, the corresponding source maps (either inline or external) and\n * `.d.ts` files are transformed accordingly.\n *\n * - Flat file packages have all the classes in a single file.\n * - Other packages may re-export classes from other non-entry point files.\n * - Some formats may contain multiple \"modules\" in a single file.\n */\nexport class Transformer {\n  constructor(private fs: FileSystem, private logger: Logger) {}\n\n  /**\n   * Transform the source (and typings) files of a bundle.\n   * @param bundle the bundle to transform.\n   * @returns information about the files that were transformed.\n   */\n  transform(bundle: EntryPointBundle): FileToWrite[] {\n    const isCore = bundle.isCore;\n    const reflectionHost = this.getHost(isCore, bundle);\n\n    // Parse and analyze the files.\n    const {decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,\n           moduleWithProvidersAnalyses} = this.analyzeProgram(reflectionHost, isCore, bundle);\n\n    // Transform the source files and source maps.\n    const srcFormatter = this.getRenderingFormatter(reflectionHost, isCore, bundle);\n\n    const renderer =\n        new Renderer(srcFormatter, this.fs, this.logger, reflectionHost, isCore, bundle);\n    let renderedFiles = renderer.renderProgram(\n        decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses);\n\n    if (bundle.dts) {\n      const dtsFormatter = new EsmRenderingFormatter(reflectionHost, isCore);\n      const dtsRenderer =\n          new DtsRenderer(dtsFormatter, this.fs, this.logger, reflectionHost, isCore, bundle);\n      const renderedDtsFiles = dtsRenderer.renderProgram(\n          decorationAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses);\n      renderedFiles = renderedFiles.concat(renderedDtsFiles);\n    }\n\n    return renderedFiles;\n  }\n\n  getHost(isCore: boolean, bundle: EntryPointBundle): NgccReflectionHost {\n    const typeChecker = bundle.src.program.getTypeChecker();\n    switch (bundle.format) {\n      case 'esm2015':\n        return new Esm2015ReflectionHost(this.logger, isCore, typeChecker, bundle.dts);\n      case 'esm5':\n        return new Esm5ReflectionHost(this.logger, isCore, typeChecker, bundle.dts);\n      case 'umd':\n        return new UmdReflectionHost(\n            this.logger, isCore, bundle.src.program, bundle.src.host, bundle.dts);\n      case 'commonjs':\n        return new CommonJsReflectionHost(\n            this.logger, isCore, bundle.src.program, bundle.src.host, bundle.dts);\n      default:\n        throw new Error(`Reflection host for \"${bundle.format}\" not yet implemented.`);\n    }\n  }\n\n  getRenderingFormatter(host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle):\n      RenderingFormatter {\n    switch (bundle.format) {\n      case 'esm2015':\n        return new EsmRenderingFormatter(host, isCore);\n      case 'esm5':\n        return new Esm5RenderingFormatter(host, isCore);\n      case 'umd':\n        if (!(host instanceof UmdReflectionHost)) {\n          throw new Error('UmdRenderer requires a UmdReflectionHost');\n        }\n        return new UmdRenderingFormatter(host, isCore);\n      case 'commonjs':\n        return new CommonJsRenderingFormatter(host, isCore);\n      default:\n        throw new Error(`Renderer for \"${bundle.format}\" not yet implemented.`);\n    }\n  }\n\n  analyzeProgram(reflectionHost: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle):\n      ProgramAnalyses {\n    const typeChecker = bundle.src.program.getTypeChecker();\n    const referencesRegistry = new NgccReferencesRegistry(reflectionHost);\n\n    const switchMarkerAnalyzer = new SwitchMarkerAnalyzer(reflectionHost);\n    const switchMarkerAnalyses = switchMarkerAnalyzer.analyzeProgram(bundle.src.program);\n\n    const decorationAnalyzer = new DecorationAnalyzer(\n        this.fs, bundle.src.program, bundle.src.options, bundle.src.host, typeChecker,\n        reflectionHost, referencesRegistry, bundle.rootDirs, isCore);\n    const decorationAnalyses = decorationAnalyzer.analyzeProgram();\n\n    const moduleWithProvidersAnalyzer =\n        bundle.dts && new ModuleWithProvidersAnalyzer(reflectionHost, referencesRegistry);\n    const moduleWithProvidersAnalyses = moduleWithProvidersAnalyzer &&\n        moduleWithProvidersAnalyzer.analyzeProgram(bundle.src.program);\n\n    const privateDeclarationsAnalyzer =\n        new PrivateDeclarationsAnalyzer(reflectionHost, referencesRegistry);\n    const privateDeclarationsAnalyses =\n        privateDeclarationsAnalyzer.analyzeProgram(bundle.src.program);\n\n    return {decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,\n            moduleWithProvidersAnalyses};\n  }\n}\n\n\ninterface ProgramAnalyses {\n  decorationAnalyses: Map<ts.SourceFile, CompiledFile>;\n  switchMarkerAnalyses: SwitchMarkerAnalyses;\n  privateDeclarationsAnalyses: ExportInfo[];\n  moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses|null;\n}\n"]}