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

package/ngcc/src/dependencies/commonjs_dependency_host.js

@@ -0,0 +1,133 @@
+(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/commonjs_dependency_host", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/ngcc/src/host/commonjs_host", "@angular/compiler-cli/ngcc/src/dependencies/module_resolver"], 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 ts = require("typescript");
+    var commonjs_host_1 = require("@angular/compiler-cli/ngcc/src/host/commonjs_host");
+    var module_resolver_1 = require("@angular/compiler-cli/ngcc/src/dependencies/module_resolver");
+    /**
+     * Helper functions for computing dependencies.
+     */
+    var CommonJsDependencyHost = /** @class */ (function () {
+        function CommonJsDependencyHost(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.
+         */
+        CommonJsDependencyHost.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.
+         */
+        CommonJsDependencyHost.prototype.recursivelyFindDependencies = function (file, dependencies, missing, deepImports, alreadySeen) {
+            var e_1, _a, e_2, _b;
+            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);
+            try {
+                for (var _c = tslib_1.__values(sf.statements), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var statement = _d.value;
+                    var declarations = ts.isVariableStatement(statement) ? statement.declarationList.declarations : [];
+                    try {
+                        for (var declarations_1 = tslib_1.__values(declarations), declarations_1_1 = declarations_1.next(); !declarations_1_1.done; declarations_1_1 = declarations_1.next()) {
+                            var declaration = declarations_1_1.value;
+                            if (declaration.initializer && commonjs_host_1.isRequireCall(declaration.initializer)) {
+                                var importPath = declaration.initializer.arguments[0].text;
+                                var resolvedModule = this.moduleResolver.resolveModuleImport(importPath, 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(importPath);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (declarations_1_1 && !declarations_1_1.done && (_b = declarations_1.return)) _b.call(declarations_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        /**
+         * 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.
+         */
+        CommonJsDependencyHost.prototype.hasRequireCalls = function (source) { return /require\(['"]/.test(source); };
+        return CommonJsDependencyHost;
+    }());
+    exports.CommonJsDependencyHost = CommonJsDependencyHost;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs_dependency_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/commonjs_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 {isRequireCall} from '../host/commonjs_host';\n\nimport {DependencyHost, DependencyInfo} from './dependency_host';\nimport {ModuleResolver, ResolvedDeepImport, ResolvedRelativeModule} from './module_resolver';\n\n/**\n * Helper functions for computing dependencies.\n */\nexport class CommonJsDependencyHost 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<AbsoluteFsPath>, 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\n    for (const statement of sf.statements) {\n      const declarations =\n          ts.isVariableStatement(statement) ? statement.declarationList.declarations : [];\n      for (const declaration of declarations) {\n        if (declaration.initializer && isRequireCall(declaration.initializer)) {\n          const importPath = declaration.initializer.arguments[0].text;\n          const resolvedModule = this.moduleResolver.resolveModuleImport(importPath, 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(importPath);\n          }\n        }\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"]}

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

@@ -0,0 +1,17 @@
+/**
+ * @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/dependency_host" />
+import { AbsoluteFsPath, PathSegment } from '../../../src/ngtsc/path';
+export interface DependencyHost {
+    findDependencies(entryPointPath: AbsoluteFsPath): DependencyInfo;
+}
+export interface DependencyInfo {
+    dependencies: Set<AbsoluteFsPath>;
+    missing: Set<AbsoluteFsPath | PathSegment>;
+    deepImports: Set<AbsoluteFsPath>;
+}

package/ngcc/src/dependencies/dependency_host.js

@@ -0,0 +1,20 @@
+/**
+ * @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/dependency_host", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwZW5kZW5jeV9ob3N0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL25nY2Mvc3JjL2RlcGVuZGVuY2llcy9kZXBlbmRlbmN5X2hvc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0Fic29sdXRlRnNQYXRoLCBQYXRoU2VnbWVudH0gZnJvbSAnLi4vLi4vLi4vc3JjL25ndHNjL3BhdGgnO1xuXG5leHBvcnQgaW50ZXJmYWNlIERlcGVuZGVuY3lIb3N0IHtcbiAgZmluZERlcGVuZGVuY2llcyhlbnRyeVBvaW50UGF0aDogQWJzb2x1dGVGc1BhdGgpOiBEZXBlbmRlbmN5SW5mbztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEZXBlbmRlbmN5SW5mbyB7XG4gIGRlcGVuZGVuY2llczogU2V0PEFic29sdXRlRnNQYXRoPjtcbiAgbWlzc2luZzogU2V0PEFic29sdXRlRnNQYXRofFBhdGhTZWdtZW50PjtcbiAgZGVlcEltcG9ydHM6IFNldDxBYnNvbHV0ZUZzUGF0aD47XG59XG4iXX0=

package/ngcc/src/{packages → dependencies}/dependency_resolver.d.ts

@@ -5,10 +5,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
  */
-/// <amd-module name="@angular/compiler-cli/ngcc/src/packages/dependency_resolver" />
+/// <amd-module name="@angular/compiler-cli/ngcc/src/dependencies/dependency_resolver" />
+import { FileSystem } from '../file_system/file_system';
 import { Logger } from '../logging/logger';
+import { EntryPoint, EntryPointFormat } from '../packages/entry_point';
 import { DependencyHost } from './dependency_host';
-import { EntryPoint } from './entry_point';
 /**
  * Holds information about entry points that are removed because
  * they have dependencies that are missing (directly or transitively).
@@ -39,6 +40,10 @@ export interface IgnoredDependency {
     entryPoint: EntryPoint;
     dependencyPath: string;
 }
+export interface DependencyDiagnostics {
+    invalidEntryPoints: InvalidEntryPoint[];
+    ignoredDependencies: IgnoredDependency[];
+}
 /**
  * A list of entry-points, sorted by their dependencies.
  *
@@ -48,18 +53,17 @@ export interface IgnoredDependency {
  * Some entry points or their dependencies may be have been ignored. These are captured for
  * diagnostic purposes in `invalidEntryPoints` and `ignoredDependencies` respectively.
  */
-export interface SortedEntryPointsInfo {
+export interface SortedEntryPointsInfo extends DependencyDiagnostics {
     entryPoints: EntryPoint[];
-    invalidEntryPoints: InvalidEntryPoint[];
-    ignoredDependencies: IgnoredDependency[];
 }
 /**
  * A class that resolves dependencies between entry-points.
  */
 export declare class DependencyResolver {
+    private fs;
     private logger;
-    private host;
-    constructor(logger: Logger, host: DependencyHost);
+    private hosts;
+    constructor(fs: FileSystem, logger: Logger, hosts: Partial<Record<EntryPointFormat, DependencyHost>>);
     /**
      * Sort the array of entry points so that the dependant entry points always come later than
      * their dependencies in the array.
@@ -74,5 +78,6 @@ export declare class DependencyResolver {
      * The graph only holds entry-points that ngcc cares about and whose dependencies
      * (direct and transitive) all exist.
      */
-    private createDependencyInfo;
+    private computeDependencyGraph;
+    private getEntryPointFormatInfo;
 }

package/ngcc/src/dependencies/dependency_resolver.js

@@ -0,0 +1,138 @@
+/**
+ * @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/dependency_resolver", ["require", "exports", "tslib", "dependency-graph", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/ngcc/src/packages/entry_point"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var dependency_graph_1 = require("dependency-graph");
+    var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
+    var entry_point_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point");
+    /**
+     * A class that resolves dependencies between entry-points.
+     */
+    var DependencyResolver = /** @class */ (function () {
+        function DependencyResolver(fs, logger, hosts) {
+            this.fs = fs;
+            this.logger = logger;
+            this.hosts = hosts;
+        }
+        /**
+         * Sort the array of entry points so that the dependant entry points always come later than
+         * their dependencies in the array.
+         * @param entryPoints An array entry points to sort.
+         * @param target If provided, only return entry-points depended on by this entry-point.
+         * @returns the result of sorting the entry points by dependency.
+         */
+        DependencyResolver.prototype.sortEntryPointsByDependency = function (entryPoints, target) {
+            var _a = this.computeDependencyGraph(entryPoints), invalidEntryPoints = _a.invalidEntryPoints, ignoredDependencies = _a.ignoredDependencies, graph = _a.graph;
+            var sortedEntryPointNodes;
+            if (target) {
+                if (target.compiledByAngular) {
+                    sortedEntryPointNodes = graph.dependenciesOf(target.path);
+                    sortedEntryPointNodes.push(target.path);
+                }
+                else {
+                    sortedEntryPointNodes = [];
+                }
+            }
+            else {
+                sortedEntryPointNodes = graph.overallOrder();
+            }
+            return {
+                entryPoints: sortedEntryPointNodes.map(function (path) { return graph.getNodeData(path); }),
+                invalidEntryPoints: invalidEntryPoints,
+                ignoredDependencies: ignoredDependencies,
+            };
+        };
+        /**
+         * Computes a dependency graph of the given entry-points.
+         *
+         * The graph only holds entry-points that ngcc cares about and whose dependencies
+         * (direct and transitive) all exist.
+         */
+        DependencyResolver.prototype.computeDependencyGraph = function (entryPoints) {
+            var _this = this;
+            var invalidEntryPoints = [];
+            var ignoredDependencies = [];
+            var graph = new dependency_graph_1.DepGraph();
+            var angularEntryPoints = entryPoints.filter(function (entryPoint) { return entryPoint.compiledByAngular; });
+            // Add the Angular compiled entry points to the graph as nodes
+            angularEntryPoints.forEach(function (entryPoint) { return graph.addNode(entryPoint.path, entryPoint); });
+            // Now add the dependencies between them
+            angularEntryPoints.forEach(function (entryPoint) {
+                var formatInfo = _this.getEntryPointFormatInfo(entryPoint);
+                var host = _this.hosts[formatInfo.format];
+                if (!host) {
+                    throw new Error("Could not find a suitable format for computing dependencies of entry-point: '" + entryPoint.path + "'.");
+                }
+                var _a = host.findDependencies(formatInfo.path), dependencies = _a.dependencies, missing = _a.missing, deepImports = _a.deepImports;
+                if (missing.size > 0) {
+                    // This entry point has dependencies that are missing
+                    // so remove it from the graph.
+                    removeNodes(entryPoint, Array.from(missing));
+                }
+                else {
+                    dependencies.forEach(function (dependencyPath) {
+                        if (graph.hasNode(dependencyPath)) {
+                            if (graph.hasNode(entryPoint.path)) {
+                                // The entry-point is still valid (i.e. has no missing dependencies) and
+                                // the dependency maps to an entry point that exists in the graph so add it
+                                graph.addDependency(entryPoint.path, dependencyPath);
+                            }
+                        }
+                        else if (invalidEntryPoints.some(function (i) { return i.entryPoint.path === dependencyPath; })) {
+                            // The dependency path maps to an entry-point that was previously removed
+                            // from the graph, so remove this entry-point as well.
+                            removeNodes(entryPoint, [dependencyPath]);
+                        }
+                        else {
+                            // The dependency path points to a package that ngcc does not care about.
+                            ignoredDependencies.push({ entryPoint: entryPoint, dependencyPath: dependencyPath });
+                        }
+                    });
+                }
+                if (deepImports.size) {
+                    var imports = Array.from(deepImports).map(function (i) { return "'" + i + "'"; }).join(', ');
+                    _this.logger.warn("Entry point '" + entryPoint.name + "' contains deep imports into " + imports + ". " +
+                        "This is probably not a problem, but may cause the compilation of entry points to be out of order.");
+                }
+            });
+            return { invalidEntryPoints: invalidEntryPoints, ignoredDependencies: ignoredDependencies, graph: graph };
+            function removeNodes(entryPoint, missingDependencies) {
+                var nodesToRemove = tslib_1.__spread([entryPoint.path], graph.dependantsOf(entryPoint.path));
+                nodesToRemove.forEach(function (node) {
+                    invalidEntryPoints.push({ entryPoint: graph.getNodeData(node), missingDependencies: missingDependencies });
+                    graph.removeNode(node);
+                });
+            }
+        };
+        DependencyResolver.prototype.getEntryPointFormatInfo = function (entryPoint) {
+            var properties = Object.keys(entryPoint.packageJson);
+            for (var i = 0; i < properties.length; i++) {
+                var property = properties[i];
+                var format = entry_point_1.getEntryPointFormat(this.fs, entryPoint, property);
+                if (format === 'esm2015' || format === 'esm5' || format === 'umd' || format === 'commonjs') {
+                    var formatPath = entryPoint.packageJson[property];
+                    return { format: format, path: path_1.AbsoluteFsPath.resolve(entryPoint.path, formatPath) };
+                }
+            }
+            throw new Error("There is no appropriate source code format in '" + entryPoint.path + "' entry-point.");
+        };
+        return DependencyResolver;
+    }());
+    exports.DependencyResolver = DependencyResolver;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency_resolver.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/dependency_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 {DepGraph} from 'dependency-graph';\nimport {AbsoluteFsPath} from '../../../src/ngtsc/path';\nimport {FileSystem} from '../file_system/file_system';\nimport {Logger} from '../logging/logger';\nimport {EntryPoint, EntryPointFormat, EntryPointJsonProperty, getEntryPointFormat} from '../packages/entry_point';\nimport {DependencyHost} from './dependency_host';\n\n/**\n * Holds information about entry points that are removed because\n * they have dependencies that are missing (directly or transitively).\n *\n * This might not be an error, because such an entry point might not actually be used\n * in the application. If it is used then the `ngc` application compilation would\n * fail also, so we don't need ngcc to catch this.\n *\n * For example, consider an application that uses the `@angular/router` package.\n * This package includes an entry-point called `@angular/router/upgrade`, which has a dependency\n * on the `@angular/upgrade` package.\n * If the application never uses code from `@angular/router/upgrade` then there is no need for\n * `@angular/upgrade` to be installed.\n * In this case the ngcc tool should just ignore the `@angular/router/upgrade` end-point.\n */\nexport interface InvalidEntryPoint {\n  entryPoint: EntryPoint;\n  missingDependencies: string[];\n}\n\n/**\n * Holds information about dependencies of an entry-point that do not need to be processed\n * by the ngcc tool.\n *\n * For example, the `rxjs` package does not contain any Angular decorators that need to be\n * compiled and so this can be safely ignored by ngcc.\n */\nexport interface IgnoredDependency {\n  entryPoint: EntryPoint;\n  dependencyPath: string;\n}\n\nexport interface DependencyDiagnostics {\n  invalidEntryPoints: InvalidEntryPoint[];\n  ignoredDependencies: IgnoredDependency[];\n}\n\n/**\n * A list of entry-points, sorted by their dependencies.\n *\n * The `entryPoints` array will be ordered so that no entry point depends upon an entry point that\n * appears later in the array.\n *\n * Some entry points or their dependencies may be have been ignored. These are captured for\n * diagnostic purposes in `invalidEntryPoints` and `ignoredDependencies` respectively.\n */\nexport interface SortedEntryPointsInfo extends DependencyDiagnostics { entryPoints: EntryPoint[]; }\n\n/**\n * A class that resolves dependencies between entry-points.\n */\nexport class DependencyResolver {\n  constructor(\n      private fs: FileSystem, private logger: Logger,\n      private hosts: Partial<Record<EntryPointFormat, DependencyHost>>) {}\n  /**\n   * Sort the array of entry points so that the dependant entry points always come later than\n   * their dependencies in the array.\n   * @param entryPoints An array entry points to sort.\n   * @param target If provided, only return entry-points depended on by this entry-point.\n   * @returns the result of sorting the entry points by dependency.\n   */\n  sortEntryPointsByDependency(entryPoints: EntryPoint[], target?: EntryPoint):\n      SortedEntryPointsInfo {\n    const {invalidEntryPoints, ignoredDependencies, graph} =\n        this.computeDependencyGraph(entryPoints);\n\n    let sortedEntryPointNodes: string[];\n    if (target) {\n      if (target.compiledByAngular) {\n        sortedEntryPointNodes = graph.dependenciesOf(target.path);\n        sortedEntryPointNodes.push(target.path);\n      } else {\n        sortedEntryPointNodes = [];\n      }\n    } else {\n      sortedEntryPointNodes = graph.overallOrder();\n    }\n\n    return {\n      entryPoints: sortedEntryPointNodes.map(path => graph.getNodeData(path)),\n      invalidEntryPoints,\n      ignoredDependencies,\n    };\n  }\n\n  /**\n   * Computes a dependency graph of the given entry-points.\n   *\n   * The graph only holds entry-points that ngcc cares about and whose dependencies\n   * (direct and transitive) all exist.\n   */\n  private computeDependencyGraph(entryPoints: EntryPoint[]): DependencyGraph {\n    const invalidEntryPoints: InvalidEntryPoint[] = [];\n    const ignoredDependencies: IgnoredDependency[] = [];\n    const graph = new DepGraph<EntryPoint>();\n\n    const angularEntryPoints = entryPoints.filter(entryPoint => entryPoint.compiledByAngular);\n\n    // Add the Angular compiled entry points to the graph as nodes\n    angularEntryPoints.forEach(entryPoint => graph.addNode(entryPoint.path, entryPoint));\n\n    // Now add the dependencies between them\n    angularEntryPoints.forEach(entryPoint => {\n      const formatInfo = this.getEntryPointFormatInfo(entryPoint);\n      const host = this.hosts[formatInfo.format];\n      if (!host) {\n        throw new Error(\n            `Could not find a suitable format for computing dependencies of entry-point: '${entryPoint.path}'.`);\n      }\n      const {dependencies, missing, deepImports} = host.findDependencies(formatInfo.path);\n\n      if (missing.size > 0) {\n        // This entry point has dependencies that are missing\n        // so remove it from the graph.\n        removeNodes(entryPoint, Array.from(missing));\n      } else {\n        dependencies.forEach(dependencyPath => {\n          if (graph.hasNode(dependencyPath)) {\n            if (graph.hasNode(entryPoint.path)) {\n              // The entry-point is still valid (i.e. has no missing dependencies) and\n              // the dependency maps to an entry point that exists in the graph so add it\n              graph.addDependency(entryPoint.path, dependencyPath);\n            }\n          } else if (invalidEntryPoints.some(i => i.entryPoint.path === dependencyPath)) {\n            // The dependency path maps to an entry-point that was previously removed\n            // from the graph, so remove this entry-point as well.\n            removeNodes(entryPoint, [dependencyPath]);\n          } else {\n            // The dependency path points to a package that ngcc does not care about.\n            ignoredDependencies.push({entryPoint, dependencyPath});\n          }\n        });\n      }\n\n      if (deepImports.size) {\n        const imports = Array.from(deepImports).map(i => `'${i}'`).join(', ');\n        this.logger.warn(\n            `Entry point '${entryPoint.name}' contains deep imports into ${imports}. ` +\n            `This is probably not a problem, but may cause the compilation of entry points to be out of order.`);\n      }\n    });\n\n    return {invalidEntryPoints, ignoredDependencies, graph};\n\n    function removeNodes(entryPoint: EntryPoint, missingDependencies: string[]) {\n      const nodesToRemove = [entryPoint.path, ...graph.dependantsOf(entryPoint.path)];\n      nodesToRemove.forEach(node => {\n        invalidEntryPoints.push({entryPoint: graph.getNodeData(node), missingDependencies});\n        graph.removeNode(node);\n      });\n    }\n  }\n\n  private getEntryPointFormatInfo(entryPoint: EntryPoint):\n      {format: EntryPointFormat, path: AbsoluteFsPath} {\n    const properties = Object.keys(entryPoint.packageJson);\n    for (let i = 0; i < properties.length; i++) {\n      const property = properties[i] as EntryPointJsonProperty;\n      const format = getEntryPointFormat(this.fs, entryPoint, property);\n\n      if (format === 'esm2015' || format === 'esm5' || format === 'umd' || format === 'commonjs') {\n        const formatPath = entryPoint.packageJson[property] !;\n        return {format, path: AbsoluteFsPath.resolve(entryPoint.path, formatPath)};\n      }\n    }\n    throw new Error(\n        `There is no appropriate source code format in '${entryPoint.path}' entry-point.`);\n  }\n}\n\ninterface DependencyGraph extends DependencyDiagnostics {\n  graph: DepGraph<EntryPoint>;\n}\n"]}

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

@@ -0,0 +1,62 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_host" />
+/**
+ * @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
+ */
+import * as ts from 'typescript';
+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 EsmDependencyHost 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 the given statement is an import with a string literal module specifier.
+     * @param stmt the statement node to check.
+     * @returns true if the statement is an import with a string literal module specifier.
+     */
+    isStringImportOrReexport(stmt: ts.Statement): stmt is ts.ImportDeclaration & {
+        moduleSpecifier: ts.StringLiteral;
+    };
+    /**
+     * 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 import or re-export statements
+     * in this file, true otherwise.
+     */
+    hasImportOrReexportStatements(source: string): boolean;
+}

package/ngcc/src/dependencies/esm_dependency_host.js

@@ -0,0 +1,122 @@
+(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/esm_dependency_host", ["require", "exports", "typescript", "@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 module_resolver_1 = require("@angular/compiler-cli/ngcc/src/dependencies/module_resolver");
+    /**
+     * Helper functions for computing dependencies.
+     */
+    var EsmDependencyHost = /** @class */ (function () {
+        function EsmDependencyHost(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.
+         */
+        EsmDependencyHost.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.
+         */
+        EsmDependencyHost.prototype.recursivelyFindDependencies = function (file, dependencies, missing, deepImports, alreadySeen) {
+            var _this = this;
+            var fromContents = this.fs.readFile(file);
+            if (!this.hasImportOrReexportStatements(fromContents)) {
+                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);
+            sf.statements
+                // filter out statements that are not imports or reexports
+                .filter(this.isStringImportOrReexport)
+                // Grab the id of the module that is being imported
+                .map(function (stmt) { return stmt.moduleSpecifier.text; })
+                // Resolve this module id into an absolute path
+                .forEach(function (importPath) {
+                var resolvedModule = _this.moduleResolver.resolveModuleImport(importPath, 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(importPath);
+                }
+            });
+        };
+        /**
+         * Check whether the given statement is an import with a string literal module specifier.
+         * @param stmt the statement node to check.
+         * @returns true if the statement is an import with a string literal module specifier.
+         */
+        EsmDependencyHost.prototype.isStringImportOrReexport = function (stmt) {
+            return ts.isImportDeclaration(stmt) ||
+                ts.isExportDeclaration(stmt) && !!stmt.moduleSpecifier &&
+                    ts.isStringLiteral(stmt.moduleSpecifier);
+        };
+        /**
+         * 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 import or re-export statements
+         * in this file, true otherwise.
+         */
+        EsmDependencyHost.prototype.hasImportOrReexportStatements = function (source) {
+            return /(import|export)\s.+from/.test(source);
+        };
+        return EsmDependencyHost;
+    }());
+    exports.EsmDependencyHost = EsmDependencyHost;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esm_dependency_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/esm_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 {DependencyHost, DependencyInfo} from './dependency_host';\nimport {ModuleResolver, ResolvedDeepImport, ResolvedRelativeModule} from './module_resolver';\n\n\n/**\n * Helper functions for computing dependencies.\n */\nexport class EsmDependencyHost 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.hasImportOrReexportStatements(fromContents)) {\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    sf.statements\n        // filter out statements that are not imports or reexports\n        .filter(this.isStringImportOrReexport)\n        // Grab the id of the module that is being imported\n        .map(stmt => stmt.moduleSpecifier.text)\n        // Resolve this module id into an absolute path\n        .forEach(importPath => {\n          const resolvedModule = this.moduleResolver.resolveModuleImport(importPath, 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(importPath);\n          }\n        });\n  }\n\n  /**\n   * Check whether the given statement is an import with a string literal module specifier.\n   * @param stmt the statement node to check.\n   * @returns true if the statement is an import with a string literal module specifier.\n   */\n  isStringImportOrReexport(stmt: ts.Statement): stmt is ts.ImportDeclaration&\n      {moduleSpecifier: ts.StringLiteral} {\n    return ts.isImportDeclaration(stmt) ||\n        ts.isExportDeclaration(stmt) && !!stmt.moduleSpecifier &&\n        ts.isStringLiteral(stmt.moduleSpecifier);\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 import or re-export statements\n   * in this file, true otherwise.\n   */\n  hasImportOrReexportStatements(source: string): boolean {\n    return /(import|export)\\s.+from/.test(source);\n  }\n}\n"]}