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

package/ngcc/src/dependencies/module_resolver.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/ngcc/src/dependencies/module_resolver" />
+import { AbsoluteFsPath } from '../../../src/ngtsc/path';
+import { FileSystem } from '../file_system/file_system';
+import { PathMappings } from '../utils';
+/**
+ * This is a very cut-down implementation of the TypeScript module resolution strategy.
+ *
+ * It is specific to the needs of ngcc and is not intended to be a drop-in replacement
+ * for the TS module resolver. It is used to compute the dependencies between entry-points
+ * that may be compiled by ngcc.
+ *
+ * The algorithm only finds `.js` files for internal/relative imports and paths to
+ * the folder containing the `package.json` of the entry-point for external imports.
+ *
+ * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`
+ * configuration properties, as provided in a `ts.CompilerOptions` object.
+ */
+export declare class ModuleResolver {
+    private fs;
+    private relativeExtensions;
+    private pathMappings;
+    constructor(fs: FileSystem, pathMappings?: PathMappings, relativeExtensions?: string[]);
+    /**
+     * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.
+     * @param moduleName The name of the import to resolve.
+     * @param fromPath The path to the file containing the import.
+     * @returns A path to the resolved module or null if missing.
+     * Specifically:
+     *  * the absolute path to the package.json of an external module
+     *  * a JavaScript file of an internal module
+     *  * null if none exists.
+     */
+    resolveModuleImport(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule | null;
+    /**
+     * Convert the `pathMappings` into a collection of `PathMapper` functions.
+     */
+    private processPathMappings;
+    /**
+     * Try to resolve a module name, as a relative path, from the `fromPath`.
+     *
+     * As it is relative, it only looks for files that end in one of the `relativeExtensions`.
+     * For example: `${moduleName}.js` or `${moduleName}/index.js`.
+     * If neither of these files exist then the method returns `null`.
+     */
+    private resolveAsRelativePath;
+    /**
+     * Try to resolve the `moduleName`, by applying the computed `pathMappings` and
+     * then trying to resolve the mapped path as a relative or external import.
+     *
+     * Whether the mapped path is relative is defined as it being "below the `fromPath`" and not
+     * containing `node_modules`.
+     *
+     * If the mapped path is not relative but does not resolve to an external entry-point, then we
+     * check whether it would have resolved to a relative path, in which case it is marked as a
+     * "deep-import".
+     */
+    private resolveByPathMappings;
+    /**
+     * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`
+     * folders up the tree for a matching `.../node_modules/${moduleName}`.
+     *
+     * If a folder is found but the path does not contain a `package.json` then it is marked as a
+     * "deep-import".
+     */
+    private resolveAsEntryPoint;
+    /**
+     * Attempt to resolve a `path` to a file by appending the provided `postFixes`
+     * to the `path` and checking if the file exists on disk.
+     * @returns An absolute path to the first matching existing file, or `null` if none exist.
+     */
+    private resolvePath;
+    /**
+     * Can we consider the given path as an entry-point to a package?
+     *
+     * This is achieved by checking for the existence of `${modulePath}/package.json`.
+     */
+    private isEntryPoint;
+    /**
+     * Apply the `pathMappers` to the `moduleName` and return all the possible
+     * paths that match.
+     *
+     * The mapped path is computed for each template in `mapping.templates` by
+     * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the
+     * `template.prefix` and `template.postfix` strings.
+     */
+    private findMappedPaths;
+    /**
+     * Attempt to find a mapped path for the given `path` and a `mapping`.
+     *
+     * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with
+     * `matcher.postfix`.
+     *
+     * @returns the wildcard segment of a matched `path`, or `null` if no match.
+     */
+    private matchMapping;
+    /**
+     * Compute the candidate paths from the given mapping's templates using the matched
+     * string.
+     */
+    private computeMappedTemplates;
+    /**
+     * Search up the folder tree for the first folder that contains `package.json`
+     * or `null` if none is found.
+     */
+    private findPackagePath;
+}
+/** The result of resolving an import to a module. */
+export declare type ResolvedModule = ResolvedExternalModule | ResolvedRelativeModule | ResolvedDeepImport;
+/**
+ * A module that is external to the package doing the importing.
+ * In this case we capture the folder containing the entry-point.
+ */
+export declare class ResolvedExternalModule {
+    entryPointPath: AbsoluteFsPath;
+    constructor(entryPointPath: AbsoluteFsPath);
+}
+/**
+ * A module that is relative to the module doing the importing, and so internal to the
+ * source module's package.
+ */
+export declare class ResolvedRelativeModule {
+    modulePath: AbsoluteFsPath;
+    constructor(modulePath: AbsoluteFsPath);
+}
+/**
+ * A module that is external to the package doing the importing but pointing to a
+ * module that is deep inside a package, rather than to an entry-point of the package.
+ */
+export declare class ResolvedDeepImport {
+    importPath: AbsoluteFsPath;
+    constructor(importPath: AbsoluteFsPath);
+}

package/ngcc/src/dependencies/module_resolver.js

@@ -0,0 +1,297 @@
+/**
+ * @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
+ */
+(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/dependencies/module_resolver", ["require", "exports", "tslib", "@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");
+    var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/utils");
+    /**
+     * This is a very cut-down implementation of the TypeScript module resolution strategy.
+     *
+     * It is specific to the needs of ngcc and is not intended to be a drop-in replacement
+     * for the TS module resolver. It is used to compute the dependencies between entry-points
+     * that may be compiled by ngcc.
+     *
+     * The algorithm only finds `.js` files for internal/relative imports and paths to
+     * the folder containing the `package.json` of the entry-point for external imports.
+     *
+     * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`
+     * configuration properties, as provided in a `ts.CompilerOptions` object.
+     */
+    var ModuleResolver = /** @class */ (function () {
+        function ModuleResolver(fs, pathMappings, relativeExtensions) {
+            if (relativeExtensions === void 0) { relativeExtensions = [
+                '.js', '/index.js'
+            ]; }
+            this.fs = fs;
+            this.relativeExtensions = relativeExtensions;
+            this.pathMappings = pathMappings ? this.processPathMappings(pathMappings) : [];
+        }
+        /**
+         * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.
+         * @param moduleName The name of the import to resolve.
+         * @param fromPath The path to the file containing the import.
+         * @returns A path to the resolved module or null if missing.
+         * Specifically:
+         *  * the absolute path to the package.json of an external module
+         *  * a JavaScript file of an internal module
+         *  * null if none exists.
+         */
+        ModuleResolver.prototype.resolveModuleImport = function (moduleName, fromPath) {
+            if (utils_1.isRelativePath(moduleName)) {
+                return this.resolveAsRelativePath(moduleName, fromPath);
+            }
+            else {
+                return this.pathMappings.length && this.resolveByPathMappings(moduleName, fromPath) ||
+                    this.resolveAsEntryPoint(moduleName, fromPath);
+            }
+        };
+        /**
+         * Convert the `pathMappings` into a collection of `PathMapper` functions.
+         */
+        ModuleResolver.prototype.processPathMappings = function (pathMappings) {
+            var baseUrl = path_1.AbsoluteFsPath.from(pathMappings.baseUrl);
+            return Object.keys(pathMappings.paths).map(function (pathPattern) {
+                var matcher = splitOnStar(pathPattern);
+                var templates = pathMappings.paths[pathPattern].map(splitOnStar);
+                return { matcher: matcher, templates: templates, baseUrl: baseUrl };
+            });
+        };
+        /**
+         * Try to resolve a module name, as a relative path, from the `fromPath`.
+         *
+         * As it is relative, it only looks for files that end in one of the `relativeExtensions`.
+         * For example: `${moduleName}.js` or `${moduleName}/index.js`.
+         * If neither of these files exist then the method returns `null`.
+         */
+        ModuleResolver.prototype.resolveAsRelativePath = function (moduleName, fromPath) {
+            var resolvedPath = this.resolvePath(path_1.AbsoluteFsPath.resolve(path_1.AbsoluteFsPath.dirname(fromPath), moduleName), this.relativeExtensions);
+            return resolvedPath && new ResolvedRelativeModule(resolvedPath);
+        };
+        /**
+         * Try to resolve the `moduleName`, by applying the computed `pathMappings` and
+         * then trying to resolve the mapped path as a relative or external import.
+         *
+         * Whether the mapped path is relative is defined as it being "below the `fromPath`" and not
+         * containing `node_modules`.
+         *
+         * If the mapped path is not relative but does not resolve to an external entry-point, then we
+         * check whether it would have resolved to a relative path, in which case it is marked as a
+         * "deep-import".
+         */
+        ModuleResolver.prototype.resolveByPathMappings = function (moduleName, fromPath) {
+            var e_1, _a;
+            var mappedPaths = this.findMappedPaths(moduleName);
+            if (mappedPaths.length > 0) {
+                var packagePath = this.findPackagePath(fromPath);
+                if (packagePath !== null) {
+                    try {
+                        for (var mappedPaths_1 = tslib_1.__values(mappedPaths), mappedPaths_1_1 = mappedPaths_1.next(); !mappedPaths_1_1.done; mappedPaths_1_1 = mappedPaths_1.next()) {
+                            var mappedPath = mappedPaths_1_1.value;
+                            var isRelative = mappedPath.startsWith(packagePath) && !mappedPath.includes('node_modules');
+                            if (isRelative) {
+                                return this.resolveAsRelativePath(mappedPath, fromPath);
+                            }
+                            else if (this.isEntryPoint(mappedPath)) {
+                                return new ResolvedExternalModule(mappedPath);
+                            }
+                            else if (this.resolveAsRelativePath(mappedPath, fromPath)) {
+                                return new ResolvedDeepImport(mappedPath);
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (mappedPaths_1_1 && !mappedPaths_1_1.done && (_a = mappedPaths_1.return)) _a.call(mappedPaths_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }
+            return null;
+        };
+        /**
+         * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`
+         * folders up the tree for a matching `.../node_modules/${moduleName}`.
+         *
+         * If a folder is found but the path does not contain a `package.json` then it is marked as a
+         * "deep-import".
+         */
+        ModuleResolver.prototype.resolveAsEntryPoint = function (moduleName, fromPath) {
+            var folder = fromPath;
+            while (!path_1.AbsoluteFsPath.isRoot(folder)) {
+                folder = path_1.AbsoluteFsPath.dirname(folder);
+                if (folder.endsWith('node_modules')) {
+                    // Skip up if the folder already ends in node_modules
+                    folder = path_1.AbsoluteFsPath.dirname(folder);
+                }
+                var modulePath = path_1.AbsoluteFsPath.resolve(folder, 'node_modules', moduleName);
+                if (this.isEntryPoint(modulePath)) {
+                    return new ResolvedExternalModule(modulePath);
+                }
+                else if (this.resolveAsRelativePath(modulePath, fromPath)) {
+                    return new ResolvedDeepImport(modulePath);
+                }
+            }
+            return null;
+        };
+        /**
+         * Attempt to resolve a `path` to a file by appending the provided `postFixes`
+         * to the `path` and checking if the file exists on disk.
+         * @returns An absolute path to the first matching existing file, or `null` if none exist.
+         */
+        ModuleResolver.prototype.resolvePath = function (path, postFixes) {
+            var e_2, _a;
+            try {
+                for (var postFixes_1 = tslib_1.__values(postFixes), postFixes_1_1 = postFixes_1.next(); !postFixes_1_1.done; postFixes_1_1 = postFixes_1.next()) {
+                    var postFix = postFixes_1_1.value;
+                    var testPath = path_1.AbsoluteFsPath.fromUnchecked(path + postFix);
+                    if (this.fs.exists(testPath)) {
+                        return testPath;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (postFixes_1_1 && !postFixes_1_1.done && (_a = postFixes_1.return)) _a.call(postFixes_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return null;
+        };
+        /**
+         * Can we consider the given path as an entry-point to a package?
+         *
+         * This is achieved by checking for the existence of `${modulePath}/package.json`.
+         */
+        ModuleResolver.prototype.isEntryPoint = function (modulePath) {
+            return this.fs.exists(path_1.AbsoluteFsPath.join(modulePath, 'package.json'));
+        };
+        /**
+         * Apply the `pathMappers` to the `moduleName` and return all the possible
+         * paths that match.
+         *
+         * The mapped path is computed for each template in `mapping.templates` by
+         * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the
+         * `template.prefix` and `template.postfix` strings.
+         */
+        ModuleResolver.prototype.findMappedPaths = function (moduleName) {
+            var _this = this;
+            var matches = this.pathMappings.map(function (mapping) { return _this.matchMapping(moduleName, mapping); });
+            var bestMapping;
+            var bestMatch;
+            for (var index = 0; index < this.pathMappings.length; index++) {
+                var mapping = this.pathMappings[index];
+                var match = matches[index];
+                if (match !== null) {
+                    // If this mapping had no wildcard then this must be a complete match.
+                    if (!mapping.matcher.hasWildcard) {
+                        bestMatch = match;
+                        bestMapping = mapping;
+                        break;
+                    }
+                    // The best matched mapping is the one with the longest prefix.
+                    if (!bestMapping || mapping.matcher.prefix > bestMapping.matcher.prefix) {
+                        bestMatch = match;
+                        bestMapping = mapping;
+                    }
+                }
+            }
+            return (bestMapping && bestMatch) ? this.computeMappedTemplates(bestMapping, bestMatch) : [];
+        };
+        /**
+         * Attempt to find a mapped path for the given `path` and a `mapping`.
+         *
+         * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with
+         * `matcher.postfix`.
+         *
+         * @returns the wildcard segment of a matched `path`, or `null` if no match.
+         */
+        ModuleResolver.prototype.matchMapping = function (path, mapping) {
+            var _a = mapping.matcher, prefix = _a.prefix, postfix = _a.postfix, hasWildcard = _a.hasWildcard;
+            if (path.startsWith(prefix) && path.endsWith(postfix)) {
+                return hasWildcard ? path.substring(prefix.length, path.length - postfix.length) : '';
+            }
+            return null;
+        };
+        /**
+         * Compute the candidate paths from the given mapping's templates using the matched
+         * string.
+         */
+        ModuleResolver.prototype.computeMappedTemplates = function (mapping, match) {
+            return mapping.templates.map(function (template) {
+                return path_1.AbsoluteFsPath.resolve(mapping.baseUrl, template.prefix + match + template.postfix);
+            });
+        };
+        /**
+         * Search up the folder tree for the first folder that contains `package.json`
+         * or `null` if none is found.
+         */
+        ModuleResolver.prototype.findPackagePath = function (path) {
+            var folder = path;
+            while (!path_1.AbsoluteFsPath.isRoot(folder)) {
+                folder = path_1.AbsoluteFsPath.dirname(folder);
+                if (this.fs.exists(path_1.AbsoluteFsPath.join(folder, 'package.json'))) {
+                    return folder;
+                }
+            }
+            return null;
+        };
+        return ModuleResolver;
+    }());
+    exports.ModuleResolver = ModuleResolver;
+    /**
+     * A module that is external to the package doing the importing.
+     * In this case we capture the folder containing the entry-point.
+     */
+    var ResolvedExternalModule = /** @class */ (function () {
+        function ResolvedExternalModule(entryPointPath) {
+            this.entryPointPath = entryPointPath;
+        }
+        return ResolvedExternalModule;
+    }());
+    exports.ResolvedExternalModule = ResolvedExternalModule;
+    /**
+     * A module that is relative to the module doing the importing, and so internal to the
+     * source module's package.
+     */
+    var ResolvedRelativeModule = /** @class */ (function () {
+        function ResolvedRelativeModule(modulePath) {
+            this.modulePath = modulePath;
+        }
+        return ResolvedRelativeModule;
+    }());
+    exports.ResolvedRelativeModule = ResolvedRelativeModule;
+    /**
+     * A module that is external to the package doing the importing but pointing to a
+     * module that is deep inside a package, rather than to an entry-point of the package.
+     */
+    var ResolvedDeepImport = /** @class */ (function () {
+        function ResolvedDeepImport(importPath) {
+            this.importPath = importPath;
+        }
+        return ResolvedDeepImport;
+    }());
+    exports.ResolvedDeepImport = ResolvedDeepImport;
+    function splitOnStar(str) {
+        var _a = tslib_1.__read(str.split('*', 2), 2), prefix = _a[0], postfix = _a[1];
+        return { prefix: prefix, postfix: postfix || '', hasWildcard: postfix !== undefined };
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_resolver.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/module_resolver.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 */\n\nimport {AbsoluteFsPath} from '../../../src/ngtsc/path';\nimport {FileSystem} from '../file_system/file_system';\nimport {PathMappings, isRelativePath} from '../utils';\n\n/**\n * This is a very cut-down implementation of the TypeScript module resolution strategy.\n *\n * It is specific to the needs of ngcc and is not intended to be a drop-in replacement\n * for the TS module resolver. It is used to compute the dependencies between entry-points\n * that may be compiled by ngcc.\n *\n * The algorithm only finds `.js` files for internal/relative imports and paths to\n * the folder containing the `package.json` of the entry-point for external imports.\n *\n * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`\n * configuration properties, as provided in a `ts.CompilerOptions` object.\n */\nexport class ModuleResolver {\n  private pathMappings: ProcessedPathMapping[];\n\n  constructor(private fs: FileSystem, pathMappings?: PathMappings, private relativeExtensions = [\n    '.js', '/index.js'\n  ]) {\n    this.pathMappings = pathMappings ? this.processPathMappings(pathMappings) : [];\n  }\n\n  /**\n   * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.\n   * @param moduleName The name of the import to resolve.\n   * @param fromPath The path to the file containing the import.\n   * @returns A path to the resolved module or null if missing.\n   * Specifically:\n   *  * the absolute path to the package.json of an external module\n   *  * a JavaScript file of an internal module\n   *  * null if none exists.\n   */\n  resolveModuleImport(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    if (isRelativePath(moduleName)) {\n      return this.resolveAsRelativePath(moduleName, fromPath);\n    } else {\n      return this.pathMappings.length && this.resolveByPathMappings(moduleName, fromPath) ||\n          this.resolveAsEntryPoint(moduleName, fromPath);\n    }\n  }\n\n  /**\n   * Convert the `pathMappings` into a collection of `PathMapper` functions.\n   */\n  private processPathMappings(pathMappings: PathMappings): ProcessedPathMapping[] {\n    const baseUrl = AbsoluteFsPath.from(pathMappings.baseUrl);\n    return Object.keys(pathMappings.paths).map(pathPattern => {\n      const matcher = splitOnStar(pathPattern);\n      const templates = pathMappings.paths[pathPattern].map(splitOnStar);\n      return {matcher, templates, baseUrl};\n    });\n  }\n\n  /**\n   * Try to resolve a module name, as a relative path, from the `fromPath`.\n   *\n   * As it is relative, it only looks for files that end in one of the `relativeExtensions`.\n   * For example: `${moduleName}.js` or `${moduleName}/index.js`.\n   * If neither of these files exist then the method returns `null`.\n   */\n  private resolveAsRelativePath(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const resolvedPath = this.resolvePath(\n        AbsoluteFsPath.resolve(AbsoluteFsPath.dirname(fromPath), moduleName),\n        this.relativeExtensions);\n    return resolvedPath && new ResolvedRelativeModule(resolvedPath);\n  }\n\n  /**\n   * Try to resolve the `moduleName`, by applying the computed `pathMappings` and\n   * then trying to resolve the mapped path as a relative or external import.\n   *\n   * Whether the mapped path is relative is defined as it being \"below the `fromPath`\" and not\n   * containing `node_modules`.\n   *\n   * If the mapped path is not relative but does not resolve to an external entry-point, then we\n   * check whether it would have resolved to a relative path, in which case it is marked as a\n   * \"deep-import\".\n   */\n  private resolveByPathMappings(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const mappedPaths = this.findMappedPaths(moduleName);\n    if (mappedPaths.length > 0) {\n      const packagePath = this.findPackagePath(fromPath);\n      if (packagePath !== null) {\n        for (const mappedPath of mappedPaths) {\n          const isRelative =\n              mappedPath.startsWith(packagePath) && !mappedPath.includes('node_modules');\n          if (isRelative) {\n            return this.resolveAsRelativePath(mappedPath, fromPath);\n          } else if (this.isEntryPoint(mappedPath)) {\n            return new ResolvedExternalModule(mappedPath);\n          } else if (this.resolveAsRelativePath(mappedPath, fromPath)) {\n            return new ResolvedDeepImport(mappedPath);\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`\n   * folders up the tree for a matching `.../node_modules/${moduleName}`.\n   *\n   * If a folder is found but the path does not contain a `package.json` then it is marked as a\n   * \"deep-import\".\n   */\n  private resolveAsEntryPoint(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    let folder = fromPath;\n    while (!AbsoluteFsPath.isRoot(folder)) {\n      folder = AbsoluteFsPath.dirname(folder);\n      if (folder.endsWith('node_modules')) {\n        // Skip up if the folder already ends in node_modules\n        folder = AbsoluteFsPath.dirname(folder);\n      }\n      const modulePath = AbsoluteFsPath.resolve(folder, 'node_modules', moduleName);\n      if (this.isEntryPoint(modulePath)) {\n        return new ResolvedExternalModule(modulePath);\n      } else if (this.resolveAsRelativePath(modulePath, fromPath)) {\n        return new ResolvedDeepImport(modulePath);\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Attempt to resolve a `path` to a file by appending the provided `postFixes`\n   * to the `path` and checking if the file exists on disk.\n   * @returns An absolute path to the first matching existing file, or `null` if none exist.\n   */\n  private resolvePath(path: AbsoluteFsPath, postFixes: string[]): AbsoluteFsPath|null {\n    for (const postFix of postFixes) {\n      const testPath = AbsoluteFsPath.fromUnchecked(path + postFix);\n      if (this.fs.exists(testPath)) {\n        return testPath;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Can we consider the given path as an entry-point to a package?\n   *\n   * This is achieved by checking for the existence of `${modulePath}/package.json`.\n   */\n  private isEntryPoint(modulePath: AbsoluteFsPath): boolean {\n    return this.fs.exists(AbsoluteFsPath.join(modulePath, 'package.json'));\n  }\n\n  /**\n   * Apply the `pathMappers` to the `moduleName` and return all the possible\n   * paths that match.\n   *\n   * The mapped path is computed for each template in `mapping.templates` by\n   * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the\n   * `template.prefix` and `template.postfix` strings.\n   */\n  private findMappedPaths(moduleName: string): AbsoluteFsPath[] {\n    const matches = this.pathMappings.map(mapping => this.matchMapping(moduleName, mapping));\n\n    let bestMapping: ProcessedPathMapping|undefined;\n    let bestMatch: string|undefined;\n\n    for (let index = 0; index < this.pathMappings.length; index++) {\n      const mapping = this.pathMappings[index];\n      const match = matches[index];\n      if (match !== null) {\n        // If this mapping had no wildcard then this must be a complete match.\n        if (!mapping.matcher.hasWildcard) {\n          bestMatch = match;\n          bestMapping = mapping;\n          break;\n        }\n        // The best matched mapping is the one with the longest prefix.\n        if (!bestMapping || mapping.matcher.prefix > bestMapping.matcher.prefix) {\n          bestMatch = match;\n          bestMapping = mapping;\n        }\n      }\n    }\n\n    return (bestMapping && bestMatch) ? this.computeMappedTemplates(bestMapping, bestMatch) : [];\n  }\n\n  /**\n   * Attempt to find a mapped path for the given `path` and a `mapping`.\n   *\n   * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with\n   * `matcher.postfix`.\n   *\n   * @returns the wildcard segment of a matched `path`, or `null` if no match.\n   */\n  private matchMapping(path: string, mapping: ProcessedPathMapping): string|null {\n    const {prefix, postfix, hasWildcard} = mapping.matcher;\n    if (path.startsWith(prefix) && path.endsWith(postfix)) {\n      return hasWildcard ? path.substring(prefix.length, path.length - postfix.length) : '';\n    }\n    return null;\n  }\n\n  /**\n   * Compute the candidate paths from the given mapping's templates using the matched\n   * string.\n   */\n  private computeMappedTemplates(mapping: ProcessedPathMapping, match: string) {\n    return mapping.templates.map(\n        template =>\n            AbsoluteFsPath.resolve(mapping.baseUrl, template.prefix + match + template.postfix));\n  }\n\n  /**\n   * Search up the folder tree for the first folder that contains `package.json`\n   * or `null` if none is found.\n   */\n  private findPackagePath(path: AbsoluteFsPath): AbsoluteFsPath|null {\n    let folder = path;\n    while (!AbsoluteFsPath.isRoot(folder)) {\n      folder = AbsoluteFsPath.dirname(folder);\n      if (this.fs.exists(AbsoluteFsPath.join(folder, 'package.json'))) {\n        return folder;\n      }\n    }\n    return null;\n  }\n}\n\n/** The result of resolving an import to a module. */\nexport type ResolvedModule = ResolvedExternalModule | ResolvedRelativeModule | ResolvedDeepImport;\n\n/**\n * A module that is external to the package doing the importing.\n * In this case we capture the folder containing the entry-point.\n */\nexport class ResolvedExternalModule {\n  constructor(public entryPointPath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is relative to the module doing the importing, and so internal to the\n * source module's package.\n */\nexport class ResolvedRelativeModule {\n  constructor(public modulePath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is external to the package doing the importing but pointing to a\n * module that is deep inside a package, rather than to an entry-point of the package.\n */\nexport class ResolvedDeepImport {\n  constructor(public importPath: AbsoluteFsPath) {}\n}\n\nfunction splitOnStar(str: string): PathMappingPattern {\n  const [prefix, postfix] = str.split('*', 2);\n  return {prefix, postfix: postfix || '', hasWildcard: postfix !== undefined};\n}\n\ninterface ProcessedPathMapping {\n  baseUrl: AbsoluteFsPath;\n  matcher: PathMappingPattern;\n  templates: PathMappingPattern[];\n}\n\ninterface PathMappingPattern {\n  prefix: string;\n  postfix: string;\n  hasWildcard: boolean;\n}\n"]}

package/ngcc/src/dependencies/umd_dependency_host.d.ts

@@ -0,0 +1,46 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/dependencies/umd_dependency_host" />
+import { AbsoluteFsPath } from '../../../src/ngtsc/path';
+import { FileSystem } from '../file_system/file_system';
+import { DependencyHost, DependencyInfo } from './dependency_host';
+import { ModuleResolver } from './module_resolver';
+/**
+ * Helper functions for computing dependencies.
+ */
+export declare class UmdDependencyHost implements DependencyHost {
+    private fs;
+    private moduleResolver;
+    constructor(fs: FileSystem, moduleResolver: ModuleResolver);
+    /**
+     * Find all the dependencies for the entry-point at the given path.
+     *
+     * @param entryPointPath The absolute path to the JavaScript file that represents an entry-point.
+     * @returns Information about the dependencies of the entry-point, including those that were
+     * missing or deep imports into other entry-points.
+     */
+    findDependencies(entryPointPath: AbsoluteFsPath): DependencyInfo;
+    /**
+     * Compute the dependencies of the given file.
+     *
+     * @param file An absolute path to the file whose dependencies we want to get.
+     * @param dependencies A set that will have the absolute paths of resolved entry points added to
+     * it.
+     * @param missing A set that will have the dependencies that could not be found added to it.
+     * @param deepImports A set that will have the import paths that exist but cannot be mapped to
+     * entry-points, i.e. deep-imports.
+     * @param alreadySeen A set that is used to track internal dependencies to prevent getting stuck
+     * in a
+     * circular dependency loop.
+     */
+    private recursivelyFindDependencies;
+    /**
+     * Check whether a source file needs to be parsed for imports.
+     * This is a performance short-circuit, which saves us from creating
+     * a TypeScript AST unnecessarily.
+     *
+     * @param source The content of the source file to check.
+     *
+     * @returns false if there are definitely no require calls
+     * in this file, true otherwise.
+     */
+    hasRequireCalls(source: string): boolean;
+}

package/ngcc/src/dependencies/umd_dependency_host.js

@@ -0,0 +1,114 @@
+(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/dependencies/umd_dependency_host", ["require", "exports", "typescript", "@angular/compiler-cli/ngcc/src/host/umd_host", "@angular/compiler-cli/ngcc/src/dependencies/module_resolver"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @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 ts = require("typescript");
+    var umd_host_1 = require("@angular/compiler-cli/ngcc/src/host/umd_host");
+    var module_resolver_1 = require("@angular/compiler-cli/ngcc/src/dependencies/module_resolver");
+    /**
+     * Helper functions for computing dependencies.
+     */
+    var UmdDependencyHost = /** @class */ (function () {
+        function UmdDependencyHost(fs, moduleResolver) {
+            this.fs = fs;
+            this.moduleResolver = moduleResolver;
+        }
+        /**
+         * Find all the dependencies for the entry-point at the given path.
+         *
+         * @param entryPointPath The absolute path to the JavaScript file that represents an entry-point.
+         * @returns Information about the dependencies of the entry-point, including those that were
+         * missing or deep imports into other entry-points.
+         */
+        UmdDependencyHost.prototype.findDependencies = function (entryPointPath) {
+            var dependencies = new Set();
+            var missing = new Set();
+            var deepImports = new Set();
+            var alreadySeen = new Set();
+            this.recursivelyFindDependencies(entryPointPath, dependencies, missing, deepImports, alreadySeen);
+            return { dependencies: dependencies, missing: missing, deepImports: deepImports };
+        };
+        /**
+         * Compute the dependencies of the given file.
+         *
+         * @param file An absolute path to the file whose dependencies we want to get.
+         * @param dependencies A set that will have the absolute paths of resolved entry points added to
+         * it.
+         * @param missing A set that will have the dependencies that could not be found added to it.
+         * @param deepImports A set that will have the import paths that exist but cannot be mapped to
+         * entry-points, i.e. deep-imports.
+         * @param alreadySeen A set that is used to track internal dependencies to prevent getting stuck
+         * in a
+         * circular dependency loop.
+         */
+        UmdDependencyHost.prototype.recursivelyFindDependencies = function (file, dependencies, missing, deepImports, alreadySeen) {
+            var _this = this;
+            var fromContents = this.fs.readFile(file);
+            if (!this.hasRequireCalls(fromContents)) {
+                // Avoid parsing the source file as there are no require calls.
+                return;
+            }
+            // Parse the source into a TypeScript AST and then walk it looking for imports and re-exports.
+            var sf = ts.createSourceFile(file, fromContents, ts.ScriptTarget.ES2015, false, ts.ScriptKind.JS);
+            if (sf.statements.length !== 1) {
+                return;
+            }
+            var umdModule = umd_host_1.parseStatementForUmdModule(sf.statements[0]);
+            var umdImports = umdModule && umd_host_1.getImportsOfUmdModule(umdModule);
+            if (umdImports === null) {
+                return;
+            }
+            umdImports.forEach(function (umdImport) {
+                var resolvedModule = _this.moduleResolver.resolveModuleImport(umdImport.path, file);
+                if (resolvedModule) {
+                    if (resolvedModule instanceof module_resolver_1.ResolvedRelativeModule) {
+                        var internalDependency = resolvedModule.modulePath;
+                        if (!alreadySeen.has(internalDependency)) {
+                            alreadySeen.add(internalDependency);
+                            _this.recursivelyFindDependencies(internalDependency, dependencies, missing, deepImports, alreadySeen);
+                        }
+                    }
+                    else {
+                        if (resolvedModule instanceof module_resolver_1.ResolvedDeepImport) {
+                            deepImports.add(resolvedModule.importPath);
+                        }
+                        else {
+                            dependencies.add(resolvedModule.entryPointPath);
+                        }
+                    }
+                }
+                else {
+                    missing.add(umdImport.path);
+                }
+            });
+        };
+        /**
+         * Check whether a source file needs to be parsed for imports.
+         * This is a performance short-circuit, which saves us from creating
+         * a TypeScript AST unnecessarily.
+         *
+         * @param source The content of the source file to check.
+         *
+         * @returns false if there are definitely no require calls
+         * in this file, true otherwise.
+         */
+        UmdDependencyHost.prototype.hasRequireCalls = function (source) { return /require\(['"]/.test(source); };
+        return UmdDependencyHost;
+    }());
+    exports.UmdDependencyHost = UmdDependencyHost;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"umd_dependency_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/umd_dependency_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 ts from 'typescript';\n\nimport {AbsoluteFsPath, PathSegment} from '../../../src/ngtsc/path';\nimport {FileSystem} from '../file_system/file_system';\nimport {getImportsOfUmdModule, parseStatementForUmdModule} from '../host/umd_host';\n\nimport {DependencyHost, DependencyInfo} from './dependency_host';\nimport {ModuleResolver, ResolvedDeepImport, ResolvedRelativeModule} from './module_resolver';\n\n\n\n/**\n * Helper functions for computing dependencies.\n */\nexport class UmdDependencyHost implements DependencyHost {\n  constructor(private fs: FileSystem, private moduleResolver: ModuleResolver) {}\n\n  /**\n   * Find all the dependencies for the entry-point at the given path.\n   *\n   * @param entryPointPath The absolute path to the JavaScript file that represents an entry-point.\n   * @returns Information about the dependencies of the entry-point, including those that were\n   * missing or deep imports into other entry-points.\n   */\n  findDependencies(entryPointPath: AbsoluteFsPath): DependencyInfo {\n    const dependencies = new Set<AbsoluteFsPath>();\n    const missing = new Set<AbsoluteFsPath|PathSegment>();\n    const deepImports = new Set<AbsoluteFsPath>();\n    const alreadySeen = new Set<AbsoluteFsPath>();\n    this.recursivelyFindDependencies(\n        entryPointPath, dependencies, missing, deepImports, alreadySeen);\n    return {dependencies, missing, deepImports};\n  }\n\n  /**\n   * Compute the dependencies of the given file.\n   *\n   * @param file An absolute path to the file whose dependencies we want to get.\n   * @param dependencies A set that will have the absolute paths of resolved entry points added to\n   * it.\n   * @param missing A set that will have the dependencies that could not be found added to it.\n   * @param deepImports A set that will have the import paths that exist but cannot be mapped to\n   * entry-points, i.e. deep-imports.\n   * @param alreadySeen A set that is used to track internal dependencies to prevent getting stuck\n   * in a\n   * circular dependency loop.\n   */\n  private recursivelyFindDependencies(\n      file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>,\n      deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void {\n    const fromContents = this.fs.readFile(file);\n    if (!this.hasRequireCalls(fromContents)) {\n      // Avoid parsing the source file as there are no require calls.\n      return;\n    }\n\n    // Parse the source into a TypeScript AST and then walk it looking for imports and re-exports.\n    const sf =\n        ts.createSourceFile(file, fromContents, ts.ScriptTarget.ES2015, false, ts.ScriptKind.JS);\n    if (sf.statements.length !== 1) {\n      return;\n    }\n\n    const umdModule = parseStatementForUmdModule(sf.statements[0]);\n    const umdImports = umdModule && getImportsOfUmdModule(umdModule);\n    if (umdImports === null) {\n      return;\n    }\n\n    umdImports.forEach(umdImport => {\n      const resolvedModule = this.moduleResolver.resolveModuleImport(umdImport.path, file);\n      if (resolvedModule) {\n        if (resolvedModule instanceof ResolvedRelativeModule) {\n          const internalDependency = resolvedModule.modulePath;\n          if (!alreadySeen.has(internalDependency)) {\n            alreadySeen.add(internalDependency);\n            this.recursivelyFindDependencies(\n                internalDependency, dependencies, missing, deepImports, alreadySeen);\n          }\n        } else {\n          if (resolvedModule instanceof ResolvedDeepImport) {\n            deepImports.add(resolvedModule.importPath);\n          } else {\n            dependencies.add(resolvedModule.entryPointPath);\n          }\n        }\n      } else {\n        missing.add(umdImport.path);\n      }\n    });\n  }\n\n  /**\n   * Check whether a source file needs to be parsed for imports.\n   * This is a performance short-circuit, which saves us from creating\n   * a TypeScript AST unnecessarily.\n   *\n   * @param source The content of the source file to check.\n   *\n   * @returns false if there are definitely no require calls\n   * in this file, true otherwise.\n   */\n  hasRequireCalls(source: string): boolean { return /require\\(['\"]/.test(source); }\n}\n"]}