@angular/compiler-cli 9.0.0-rc.6 → 9.0.0

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

@@ -0,0 +1,21 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/dependencies/dts_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 { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
+import { PathMappings } from '../utils';
+import { EsmDependencyHost } from './esm_dependency_host';
+/**
+ * Helper functions for computing dependencies via typings files.
+ */
+export declare class DtsDependencyHost extends EsmDependencyHost {
+    constructor(fs: FileSystem, pathMappings?: PathMappings);
+    /**
+     * Attempts to process the `importPath` directly and also inside `@types/...`.
+     */
+    protected processImport(importPath: string, file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): boolean;
+}

package/ngcc/src/dependencies/dts_dependency_host.js

@@ -0,0 +1,34 @@
+(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/dts_dependency_host", ["require", "exports", "tslib", "@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_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");
+    var esm_dependency_host_1 = require("@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_host");
+    var module_resolver_1 = require("@angular/compiler-cli/ngcc/src/dependencies/module_resolver");
+    /**
+     * Helper functions for computing dependencies via typings files.
+     */
+    var DtsDependencyHost = /** @class */ (function (_super) {
+        tslib_1.__extends(DtsDependencyHost, _super);
+        function DtsDependencyHost(fs, pathMappings) {
+            return _super.call(this, fs, new module_resolver_1.ModuleResolver(fs, pathMappings, ['', '.d.ts', '/index.d.ts', '.js', '/index.js'])) || this;
+        }
+        /**
+         * Attempts to process the `importPath` directly and also inside `@types/...`.
+         */
+        DtsDependencyHost.prototype.processImport = function (importPath, file, dependencies, missing, deepImports, alreadySeen) {
+            return _super.prototype.processImport.call(this, importPath, file, dependencies, missing, deepImports, alreadySeen) ||
+                _super.prototype.processImport.call(this, "@types/" + importPath, file, dependencies, missing, deepImports, alreadySeen);
+        };
+        return DtsDependencyHost;
+    }(esm_dependency_host_1.EsmDependencyHost));
+    exports.DtsDependencyHost = DtsDependencyHost;
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -25,7 +25,14 @@ export declare class EsmDependencyHost extends DependencyHostBase {
      * @param alreadySeen A set that is used to track internal dependencies to prevent getting stuck
      * in a circular dependency loop.
      */
-    protected recursivelyFindDependencies(file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void;
+    protected recursivelyCollectDependencies(file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void;
+    /**
+     * Resolve the given `importPath` from `file` and add it to the appropriate set.
+     *
+     * @returns `true` if the import was resolved (to an entry-point, a local import, or a
+     * deep-import).
+     */
+    protected processImport(importPath: string, file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): boolean;
 }
 /**
  * Check whether a source file needs to be parsed for imports.

package/ngcc/src/dependencies/esm_dependency_host.js

@@ -40,7 +40,7 @@
          * @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) {
+        EsmDependencyHost.prototype.recursivelyCollectDependencies = function (file, dependencies, missing, deepImports, alreadySeen) {
             var _this = this;
             var fromContents = this.fs.readFile(file);
             if (!hasImportOrReexportStatements(fromContents)) {
@@ -54,31 +54,39 @@
                 .filter(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 {
+                var resolved = _this.processImport(importPath, file, dependencies, missing, deepImports, alreadySeen);
+                if (!resolved) {
                     missing.add(importPath);
                 }
             });
         };
+        /**
+         * Resolve the given `importPath` from `file` and add it to the appropriate set.
+         *
+         * @returns `true` if the import was resolved (to an entry-point, a local import, or a
+         * deep-import).
+         */
+        EsmDependencyHost.prototype.processImport = function (importPath, file, dependencies, missing, deepImports, alreadySeen) {
+            var resolvedModule = this.moduleResolver.resolveModuleImport(importPath, file);
+            if (resolvedModule === null) {
+                return false;
+            }
+            if (resolvedModule instanceof module_resolver_1.ResolvedRelativeModule) {
+                var internalDependency = resolvedModule.modulePath;
+                if (!alreadySeen.has(internalDependency)) {
+                    alreadySeen.add(internalDependency);
+                    this.recursivelyCollectDependencies(internalDependency, dependencies, missing, deepImports, alreadySeen);
+                }
+            }
+            else if (resolvedModule instanceof module_resolver_1.ResolvedDeepImport) {
+                deepImports.add(resolvedModule.importPath);
+            }
+            else {
+                dependencies.add(resolvedModule.entryPointPath);
+            }
+            return true;
+        };
         return EsmDependencyHost;
     }(dependency_host_1.DependencyHostBase));
     exports.EsmDependencyHost = EsmDependencyHost;
@@ -108,4 +116,4 @@
     }
     exports.isStringImportOrReexport = isStringImportOrReexport;
 });
-//# 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":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,+BAAiC;IAEjC,+FAAqD;IACrD,+FAA6E;IAE7E;;OAEG;IACH;QAAuC,6CAAkB;QAAzD;;QAsDA,CAAC;QArDC;;;;;;;;;;;WAWG;QACO,uDAA2B,GAArC,UACI,IAAoB,EAAE,YAAiC,EAAE,OAAoB,EAC7E,WAAwB,EAAE,WAAgC;YAF9D,iBAwCC;YArCC,IAAM,YAAY,GAAG,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAE5C,IAAI,CAAC,6BAA6B,CAAC,YAAY,CAAC,EAAE;gBAChD,yDAAyD;gBACzD,OAAO;aACR;YAED,8FAA8F;YAC9F,IAAM,EAAE,GACJ,EAAE,CAAC,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAC7F,EAAE,CAAC,UAAU;gBACT,0DAA0D;iBACzD,MAAM,CAAC,wBAAwB,CAAC;gBACjC,mDAAmD;iBAClD,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,eAAe,CAAC,IAAI,EAAzB,CAAyB,CAAC;gBACvC,+CAA+C;iBAC9C,OAAO,CAAC,UAAA,UAAU;gBACjB,IAAM,cAAc,GAAG,KAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;gBACjF,IAAI,cAAc,EAAE;oBAClB,IAAI,cAAc,YAAY,wCAAsB,EAAE;wBACpD,IAAM,kBAAkB,GAAG,cAAc,CAAC,UAAU,CAAC;wBACrD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE;4BACxC,WAAW,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;4BACpC,KAAI,CAAC,2BAA2B,CAC5B,kBAAkB,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;yBAC1E;qBACF;yBAAM;wBACL,IAAI,cAAc,YAAY,oCAAkB,EAAE;4BAChD,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;yBAC5C;6BAAM;4BACL,YAAY,CAAC,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;yBACjD;qBACF;iBACF;qBAAM;oBACL,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;iBACzB;YACH,CAAC,CAAC,CAAC;QACT,CAAC;QACH,wBAAC;IAAD,CAAC,AAtDD,CAAuC,oCAAkB,GAsDxD;IAtDY,8CAAiB;IAwD9B;;;;;;;;;OASG;IACH,SAAgB,6BAA6B,CAAC,MAAc;QAC1D,OAAO,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IAFD,sEAEC;IAGD;;;;OAIG;IACH,SAAgB,wBAAwB,CAAC,IAAkB;QAEzD,OAAO,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAC/B,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe;gBACtD,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/C,CAAC;IALD,4DAKC","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';\nimport {AbsoluteFsPath} from '../../../src/ngtsc/file_system';\nimport {DependencyHostBase} from './dependency_host';\nimport {ResolvedDeepImport, ResolvedRelativeModule} from './module_resolver';\n\n/**\n * Helper functions for computing dependencies.\n */\nexport class EsmDependencyHost extends DependencyHostBase {\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 circular dependency loop.\n   */\n  protected 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\n    if (!hasImportOrReexportStatements(fromContents)) {\n      // Avoid parsing the source file as there are no imports.\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(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/**\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 */\nexport function hasImportOrReexportStatements(source: string): boolean {\n  return /(import|export)\\s.+from/.test(source);\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 */\nexport function 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"]}
+//# 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":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,+BAAiC;IAEjC,+FAAqD;IACrD,+FAA6E;IAE7E;;OAEG;IACH;QAAuC,6CAAkB;QAAzD;;QAmEA,CAAC;QAlEC;;;;;;;;;;;WAWG;QACO,0DAA8B,GAAxC,UACI,IAAoB,EAAE,YAAiC,EAAE,OAAoB,EAC7E,WAAwB,EAAE,WAAgC;YAF9D,iBAyBC;YAtBC,IAAM,YAAY,GAAG,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAE5C,IAAI,CAAC,6BAA6B,CAAC,YAAY,CAAC,EAAE;gBAChD,yDAAyD;gBACzD,OAAO;aACR;YAED,8FAA8F;YAC9F,IAAM,EAAE,GACJ,EAAE,CAAC,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAC7F,EAAE,CAAC,UAAU;gBACT,0DAA0D;iBACzD,MAAM,CAAC,wBAAwB,CAAC;gBACjC,mDAAmD;iBAClD,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,eAAe,CAAC,IAAI,EAAzB,CAAyB,CAAC;iBACtC,OAAO,CAAC,UAAA,UAAU;gBACjB,IAAM,QAAQ,GACV,KAAI,CAAC,aAAa,CAAC,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;gBAC1F,IAAI,CAAC,QAAQ,EAAE;oBACb,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;iBACzB;YACH,CAAC,CAAC,CAAC;QACT,CAAC;QAED;;;;;WAKG;QACO,yCAAa,GAAvB,UACI,UAAkB,EAAE,IAAoB,EAAE,YAAiC,EAC3E,OAAoB,EAAE,WAAwB,EAAE,WAAgC;YAClF,IAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YACjF,IAAI,cAAc,KAAK,IAAI,EAAE;gBAC3B,OAAO,KAAK,CAAC;aACd;YACD,IAAI,cAAc,YAAY,wCAAsB,EAAE;gBACpD,IAAM,kBAAkB,GAAG,cAAc,CAAC,UAAU,CAAC;gBACrD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE;oBACxC,WAAW,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;oBACpC,IAAI,CAAC,8BAA8B,CAC/B,kBAAkB,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;iBAC1E;aACF;iBAAM,IAAI,cAAc,YAAY,oCAAkB,EAAE;gBACvD,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;aAC5C;iBAAM;gBACL,YAAY,CAAC,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;aACjD;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACH,wBAAC;IAAD,CAAC,AAnED,CAAuC,oCAAkB,GAmExD;IAnEY,8CAAiB;IAqE9B;;;;;;;;;OASG;IACH,SAAgB,6BAA6B,CAAC,MAAc;QAC1D,OAAO,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IAFD,sEAEC;IAGD;;;;OAIG;IACH,SAAgB,wBAAwB,CAAC,IAAkB;QAEzD,OAAO,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAC/B,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe;gBACtD,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/C,CAAC;IALD,4DAKC","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';\nimport {AbsoluteFsPath} from '../../../src/ngtsc/file_system';\nimport {DependencyHostBase} from './dependency_host';\nimport {ResolvedDeepImport, ResolvedRelativeModule} from './module_resolver';\n\n/**\n * Helper functions for computing dependencies.\n */\nexport class EsmDependencyHost extends DependencyHostBase {\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 circular dependency loop.\n   */\n  protected recursivelyCollectDependencies(\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\n    if (!hasImportOrReexportStatements(fromContents)) {\n      // Avoid parsing the source file as there are no imports.\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(isStringImportOrReexport)\n        // Grab the id of the module that is being imported\n        .map(stmt => stmt.moduleSpecifier.text)\n        .forEach(importPath => {\n          const resolved =\n              this.processImport(importPath, file, dependencies, missing, deepImports, alreadySeen);\n          if (!resolved) {\n            missing.add(importPath);\n          }\n        });\n  }\n\n  /**\n   * Resolve the given `importPath` from `file` and add it to the appropriate set.\n   *\n   * @returns `true` if the import was resolved (to an entry-point, a local import, or a\n   * deep-import).\n   */\n  protected processImport(\n      importPath: string, file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>,\n      missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): boolean {\n    const resolvedModule = this.moduleResolver.resolveModuleImport(importPath, file);\n    if (resolvedModule === null) {\n      return false;\n    }\n    if (resolvedModule instanceof ResolvedRelativeModule) {\n      const internalDependency = resolvedModule.modulePath;\n      if (!alreadySeen.has(internalDependency)) {\n        alreadySeen.add(internalDependency);\n        this.recursivelyCollectDependencies(\n            internalDependency, dependencies, missing, deepImports, alreadySeen);\n      }\n    } else if (resolvedModule instanceof ResolvedDeepImport) {\n      deepImports.add(resolvedModule.importPath);\n    } else {\n      dependencies.add(resolvedModule.entryPointPath);\n    }\n    return true;\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 import or re-export statements\n * in this file, true otherwise.\n */\nexport function hasImportOrReexportStatements(source: string): boolean {\n  return /(import|export)\\s.+from/.test(source);\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 */\nexport function 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"]}

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

@@ -23,7 +23,7 @@ import { PathMappings } from '../utils';
  */
 export declare class ModuleResolver {
     private fs;
-    private relativeExtensions;
+    readonly relativeExtensions: string[];
     private pathMappings;
     constructor(fs: FileSystem, pathMappings?: PathMappings, relativeExtensions?: string[]);
     /**

package/ngcc/src/dependencies/module_resolver.js

@@ -274,4 +274,4 @@
         return to.startsWith(from) && !to.includes('node_modules');
     }
 });
-//# 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 */\nimport {AbsoluteFsPath, FileSystem, absoluteFrom, dirname, isRoot, join, resolve} from '../../../src/ngtsc/file_system';\nimport {PathMappings, isRelativePath, resolveFileWithPostfixes} 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 = absoluteFrom(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 = resolveFileWithPostfixes(\n        this.fs, resolve(dirname(fromPath), moduleName), 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          if (this.isEntryPoint(mappedPath)) {\n            return new ResolvedExternalModule(mappedPath);\n          }\n          const nonEntryPointImport = this.resolveAsRelativePath(mappedPath, fromPath);\n          if (nonEntryPointImport !== null) {\n            return isRelativeImport(packagePath, mappedPath) ? nonEntryPointImport :\n                                                               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 (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (folder.endsWith('node_modules')) {\n        // Skip up if the folder already ends in node_modules\n        folder = dirname(folder);\n      }\n      const modulePath = 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  /**\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(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 !== undefined && bestMatch !== undefined) ?\n        this.computeMappedTemplates(bestMapping, bestMatch) :\n        [];\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 (hasWildcard) {\n      return (path.startsWith(prefix) && path.endsWith(postfix)) ?\n          path.substring(prefix.length, path.length - postfix.length) :\n          null;\n    } else {\n      return (path === prefix) ? '' : null;\n    }\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 => 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 (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (this.fs.exists(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\nfunction isRelativeImport(from: AbsoluteFsPath, to: AbsoluteFsPath) {\n  return to.startsWith(from) && !to.includes('node_modules');\n}\n"]}
+//# 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 */\nimport {AbsoluteFsPath, FileSystem, absoluteFrom, dirname, isRoot, join, resolve} from '../../../src/ngtsc/file_system';\nimport {PathMappings, isRelativePath, resolveFileWithPostfixes} 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, readonly 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 = absoluteFrom(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 = resolveFileWithPostfixes(\n        this.fs, resolve(dirname(fromPath), moduleName), 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          if (this.isEntryPoint(mappedPath)) {\n            return new ResolvedExternalModule(mappedPath);\n          }\n          const nonEntryPointImport = this.resolveAsRelativePath(mappedPath, fromPath);\n          if (nonEntryPointImport !== null) {\n            return isRelativeImport(packagePath, mappedPath) ? nonEntryPointImport :\n                                                               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 (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (folder.endsWith('node_modules')) {\n        // Skip up if the folder already ends in node_modules\n        folder = dirname(folder);\n      }\n      const modulePath = 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  /**\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(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 !== undefined && bestMatch !== undefined) ?\n        this.computeMappedTemplates(bestMapping, bestMatch) :\n        [];\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 (hasWildcard) {\n      return (path.startsWith(prefix) && path.endsWith(postfix)) ?\n          path.substring(prefix.length, path.length - postfix.length) :\n          null;\n    } else {\n      return (path === prefix) ? '' : null;\n    }\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 => 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 (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (this.fs.exists(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\nfunction isRelativeImport(from: AbsoluteFsPath, to: AbsoluteFsPath) {\n  return to.startsWith(from) && !to.includes('node_modules');\n}\n"]}

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

@@ -17,7 +17,7 @@ export declare class UmdDependencyHost extends DependencyHostBase {
      * @param alreadySeen A set that is used to track internal dependencies to prevent getting stuck
      * in a circular dependency loop.
      */
-    protected recursivelyFindDependencies(file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void;
+    protected recursivelyCollectDependencies(file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void;
     /**
      * Check whether a source file needs to be parsed for imports.
      * This is a performance short-circuit, which saves us from creating

package/ngcc/src/dependencies/umd_dependency_host.js

@@ -41,7 +41,7 @@
          * @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) {
+        UmdDependencyHost.prototype.recursivelyCollectDependencies = function (file, dependencies, missing, deepImports, alreadySeen) {
             var _this = this;
             var fromContents = this.fs.readFile(file);
             if (!this.hasRequireCalls(fromContents)) {
@@ -65,7 +65,7 @@
                         var internalDependency = resolvedModule.modulePath;
                         if (!alreadySeen.has(internalDependency)) {
                             alreadySeen.add(internalDependency);
-                            _this.recursivelyFindDependencies(internalDependency, dependencies, missing, deepImports, alreadySeen);
+                            _this.recursivelyCollectDependencies(internalDependency, dependencies, missing, deepImports, alreadySeen);
                         }
                     }
                     else {
@@ -97,4 +97,4 @@
     }(dependency_host_1.DependencyHostBase));
     exports.UmdDependencyHost = UmdDependencyHost;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW1kX2RlcGVuZGVuY3lfaG9zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9uZ2NjL3NyYy9kZXBlbmRlbmNpZXMvdW1kX2RlcGVuZGVuY3lfaG9zdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7SUFBQTs7Ozs7O09BTUc7SUFDSCwrQkFBaUM7SUFFakMseUVBQW1GO0lBQ25GLCtGQUFxRDtJQUNyRCwrRkFBNkU7SUFFN0U7O09BRUc7SUFDSDtRQUF1Qyw2Q0FBa0I7UUFBekQ7O1FBdUVBLENBQUM7UUF0RUM7Ozs7Ozs7Ozs7O1dBV0c7UUFDTyx1REFBMkIsR0FBckMsVUFDSSxJQUFvQixFQUFFLFlBQWlDLEVBQUUsT0FBb0IsRUFDN0UsV0FBd0IsRUFBRSxXQUFnQztZQUY5RCxpQkE2Q0M7WUExQ0MsSUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7WUFFNUMsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsWUFBWSxDQUFDLEVBQUU7Z0JBQ3ZDLHlEQUF5RDtnQkFDekQsT0FBTzthQUNSO1lBRUQsOEZBQThGO1lBQzlGLElBQU0sRUFBRSxHQUNKLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsWUFBWSxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBRTdGLElBQUksRUFBRSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO2dCQUM5QixPQUFPO2FBQ1I7WUFFRCxJQUFNLFNBQVMsR0FBRyxxQ0FBMEIsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDL0QsSUFBTSxVQUFVLEdBQUcsU0FBUyxJQUFJLGdDQUFxQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ2pFLElBQUksVUFBVSxLQUFLLElBQUksRUFBRTtnQkFDdkIsT0FBTzthQUNSO1lBRUQsVUFBVSxDQUFDLE9BQU8sQ0FBQyxVQUFBLFNBQVM7Z0JBQzFCLElBQU0sY0FBYyxHQUFHLEtBQUksQ0FBQyxjQUFjLENBQUMsbUJBQW1CLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDckYsSUFBSSxjQUFjLEVBQUU7b0JBQ2xCLElBQUksY0FBYyxZQUFZLHdDQUFzQixFQUFFO3dCQUNwRCxJQUFNLGtCQUFrQixHQUFHLGNBQWMsQ0FBQyxVQUFVLENBQUM7d0JBQ3JELElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLGtCQUFrQixDQUFDLEVBQUU7NEJBQ3hDLFdBQVcsQ0FBQyxHQUFHLENBQUMsa0JBQWtCLENBQUMsQ0FBQzs0QkFDcEMsS0FBSSxDQUFDLDJCQUEyQixDQUM1QixrQkFBa0IsRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLFdBQVcsRUFBRSxXQUFXLENBQUMsQ0FBQzt5QkFDMUU7cUJBQ0Y7eUJBQU07d0JBQ0wsSUFBSSxjQUFjLFlBQVksb0NBQWtCLEVBQUU7NEJBQ2hELFdBQVcsQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO3lCQUM1Qzs2QkFBTTs0QkFDTCxZQUFZLENBQUMsR0FBRyxDQUFDLGNBQWMsQ0FBQyxjQUFjLENBQUMsQ0FBQzt5QkFDakQ7cUJBQ0Y7aUJBQ0Y7cUJBQU07b0JBQ0wsT0FBTyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7aUJBQzdCO1lBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBRUQ7Ozs7Ozs7OztXQVNHO1FBQ0ssMkNBQWUsR0FBdkIsVUFBd0IsTUFBYyxJQUFhLE9BQU8sZUFBZSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDM0Ysd0JBQUM7SUFBRCxDQUFDLEFBdkVELENBQXVDLG9DQUFrQixHQXVFeEQ7SUF2RVksOENBQWlCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5pbXBvcnQge0Fic29sdXRlRnNQYXRofSBmcm9tICcuLi8uLi8uLi9zcmMvbmd0c2MvZmlsZV9zeXN0ZW0nO1xuaW1wb3J0IHtnZXRJbXBvcnRzT2ZVbWRNb2R1bGUsIHBhcnNlU3RhdGVtZW50Rm9yVW1kTW9kdWxlfSBmcm9tICcuLi9ob3N0L3VtZF9ob3N0JztcbmltcG9ydCB7RGVwZW5kZW5jeUhvc3RCYXNlfSBmcm9tICcuL2RlcGVuZGVuY3lfaG9zdCc7XG5pbXBvcnQge1Jlc29sdmVkRGVlcEltcG9ydCwgUmVzb2x2ZWRSZWxhdGl2ZU1vZHVsZX0gZnJvbSAnLi9tb2R1bGVfcmVzb2x2ZXInO1xuXG4vKipcbiAqIEhlbHBlciBmdW5jdGlvbnMgZm9yIGNvbXB1dGluZyBkZXBlbmRlbmNpZXMuXG4gKi9cbmV4cG9ydCBjbGFzcyBVbWREZXBlbmRlbmN5SG9zdCBleHRlbmRzIERlcGVuZGVuY3lIb3N0QmFzZSB7XG4gIC8qKlxuICAgKiBDb21wdXRlIHRoZSBkZXBlbmRlbmNpZXMgb2YgdGhlIGdpdmVuIGZpbGUuXG4gICAqXG4gICAqIEBwYXJhbSBmaWxlIEFuIGFic29sdXRlIHBhdGggdG8gdGhlIGZpbGUgd2hvc2UgZGVwZW5kZW5jaWVzIHdlIHdhbnQgdG8gZ2V0LlxuICAgKiBAcGFyYW0gZGVwZW5kZW5jaWVzIEEgc2V0IHRoYXQgd2lsbCBoYXZlIHRoZSBhYnNvbHV0ZSBwYXRocyBvZiByZXNvbHZlZCBlbnRyeSBwb2ludHMgYWRkZWQgdG9cbiAgICogaXQuXG4gICAqIEBwYXJhbSBtaXNzaW5nIEEgc2V0IHRoYXQgd2lsbCBoYXZlIHRoZSBkZXBlbmRlbmNpZXMgdGhhdCBjb3VsZCBub3QgYmUgZm91bmQgYWRkZWQgdG8gaXQuXG4gICAqIEBwYXJhbSBkZWVwSW1wb3J0cyBBIHNldCB0aGF0IHdpbGwgaGF2ZSB0aGUgaW1wb3J0IHBhdGhzIHRoYXQgZXhpc3QgYnV0IGNhbm5vdCBiZSBtYXBwZWQgdG9cbiAgICogZW50cnktcG9pbnRzLCBpLmUuIGRlZXAtaW1wb3J0cy5cbiAgICogQHBhcmFtIGFscmVhZHlTZWVuIEEgc2V0IHRoYXQgaXMgdXNlZCB0byB0cmFjayBpbnRlcm5hbCBkZXBlbmRlbmNpZXMgdG8gcHJldmVudCBnZXR0aW5nIHN0dWNrXG4gICAqIGluIGEgY2lyY3VsYXIgZGVwZW5kZW5jeSBsb29wLlxuICAgKi9cbiAgcHJvdGVjdGVkIHJlY3Vyc2l2ZWx5RmluZERlcGVuZGVuY2llcyhcbiAgICAgIGZpbGU6IEFic29sdXRlRnNQYXRoLCBkZXBlbmRlbmNpZXM6IFNldDxBYnNvbHV0ZUZzUGF0aD4sIG1pc3Npbmc6IFNldDxzdHJpbmc+LFxuICAgICAgZGVlcEltcG9ydHM6IFNldDxzdHJpbmc+LCBhbHJlYWR5U2VlbjogU2V0PEFic29sdXRlRnNQYXRoPik6IHZvaWQge1xuICAgIGNvbnN0IGZyb21Db250ZW50cyA9IHRoaXMuZnMucmVhZEZpbGUoZmlsZSk7XG5cbiAgICBpZiAoIXRoaXMuaGFzUmVxdWlyZUNhbGxzKGZyb21Db250ZW50cykpIHtcbiAgICAgIC8vIEF2b2lkIHBhcnNpbmcgdGhlIHNvdXJjZSBmaWxlIGFzIHRoZXJlIGFyZSBubyBpbXBvcnRzLlxuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIC8vIFBhcnNlIHRoZSBzb3VyY2UgaW50byBhIFR5cGVTY3JpcHQgQVNUIGFuZCB0aGVuIHdhbGsgaXQgbG9va2luZyBmb3IgaW1wb3J0cyBhbmQgcmUtZXhwb3J0cy5cbiAgICBjb25zdCBzZiA9XG4gICAgICAgIHRzLmNyZWF0ZVNvdXJjZUZpbGUoZmlsZSwgZnJvbUNvbnRlbnRzLCB0cy5TY3JpcHRUYXJnZXQuRVMyMDE1LCBmYWxzZSwgdHMuU2NyaXB0S2luZC5KUyk7XG5cbiAgICBpZiAoc2Yuc3RhdGVtZW50cy5sZW5ndGggIT09IDEpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zdCB1bWRNb2R1bGUgPSBwYXJzZVN0YXRlbWVudEZvclVtZE1vZHVsZShzZi5zdGF0ZW1lbnRzWzBdKTtcbiAgICBjb25zdCB1bWRJbXBvcnRzID0gdW1kTW9kdWxlICYmIGdldEltcG9ydHNPZlVtZE1vZHVsZSh1bWRNb2R1bGUpO1xuICAgIGlmICh1bWRJbXBvcnRzID09PSBudWxsKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgdW1kSW1wb3J0cy5mb3JFYWNoKHVtZEltcG9ydCA9PiB7XG4gICAgICBjb25zdCByZXNvbHZlZE1vZHVsZSA9IHRoaXMubW9kdWxlUmVzb2x2ZXIucmVzb2x2ZU1vZHVsZUltcG9ydCh1bWRJbXBvcnQucGF0aCwgZmlsZSk7XG4gICAgICBpZiAocmVzb2x2ZWRNb2R1bGUpIHtcbiAgICAgICAgaWYgKHJlc29sdmVkTW9kdWxlIGluc3RhbmNlb2YgUmVzb2x2ZWRSZWxhdGl2ZU1vZHVsZSkge1xuICAgICAgICAgIGNvbnN0IGludGVybmFsRGVwZW5kZW5jeSA9IHJlc29sdmVkTW9kdWxlLm1vZHVsZVBhdGg7XG4gICAgICAgICAgaWYgKCFhbHJlYWR5U2Vlbi5oYXMoaW50ZXJuYWxEZXBlbmRlbmN5KSkge1xuICAgICAgICAgICAgYWxyZWFkeVNlZW4uYWRkKGludGVybmFsRGVwZW5kZW5jeSk7XG4gICAgICAgICAgICB0aGlzLnJlY3Vyc2l2ZWx5RmluZERlcGVuZGVuY2llcyhcbiAgICAgICAgICAgICAgICBpbnRlcm5hbERlcGVuZGVuY3ksIGRlcGVuZGVuY2llcywgbWlzc2luZywgZGVlcEltcG9ydHMsIGFscmVhZHlTZWVuKTtcbiAgICAgICAgICB9XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgaWYgKHJlc29sdmVkTW9kdWxlIGluc3RhbmNlb2YgUmVzb2x2ZWREZWVwSW1wb3J0KSB7XG4gICAgICAgICAgICBkZWVwSW1wb3J0cy5hZGQocmVzb2x2ZWRNb2R1bGUuaW1wb3J0UGF0aCk7XG4gICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIGRlcGVuZGVuY2llcy5hZGQocmVzb2x2ZWRNb2R1bGUuZW50cnlQb2ludFBhdGgpO1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfSBlbHNlIHtcbiAgICAgICAgbWlzc2luZy5hZGQodW1kSW1wb3J0LnBhdGgpO1xuICAgICAgfVxuICAgIH0pO1xuICB9XG5cbiAgLyoqXG4gICAqIENoZWNrIHdoZXRoZXIgYSBzb3VyY2UgZmlsZSBuZWVkcyB0byBiZSBwYXJzZWQgZm9yIGltcG9ydHMuXG4gICAqIFRoaXMgaXMgYSBwZXJmb3JtYW5jZSBzaG9ydC1jaXJjdWl0LCB3aGljaCBzYXZlcyB1cyBmcm9tIGNyZWF0aW5nXG4gICAqIGEgVHlwZVNjcmlwdCBBU1QgdW5uZWNlc3NhcmlseS5cbiAgICpcbiAgICogQHBhcmFtIHNvdXJjZSBUaGUgY29udGVudCBvZiB0aGUgc291cmNlIGZpbGUgdG8gY2hlY2suXG4gICAqXG4gICAqIEByZXR1cm5zIGZhbHNlIGlmIHRoZXJlIGFyZSBkZWZpbml0ZWx5IG5vIHJlcXVpcmUgY2FsbHNcbiAgICogaW4gdGhpcyBmaWxlLCB0cnVlIG90aGVyd2lzZS5cbiAgICovXG4gIHByaXZhdGUgaGFzUmVxdWlyZUNhbGxzKHNvdXJjZTogc3RyaW5nKTogYm9vbGVhbiB7IHJldHVybiAvcmVxdWlyZVxcKFsnXCJdLy50ZXN0KHNvdXJjZSk7IH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/entry_point_finder/targeted_entry_point_finder.d.ts

@@ -10,6 +10,7 @@ import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
 import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
 import { Logger } from '../logging/logger';
 import { NgccConfiguration } from '../packages/configuration';
+import { EntryPointJsonProperty } from '../packages/entry_point';
 import { PathMappings } from '../utils';
 import { EntryPointFinder } from './interface';
 /**
@@ -32,6 +33,7 @@ export declare class TargetedEntryPointFinder implements EntryPointFinder {
     private basePaths;
     constructor(fs: FileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, basePath: AbsoluteFsPath, targetPath: AbsoluteFsPath, pathMappings: PathMappings | undefined);
     findEntryPoints(): SortedEntryPointsInfo;
+    targetNeedsProcessingOrCleaning(propertiesToConsider: EntryPointJsonProperty[], compileAllFormats: boolean): boolean;
     private processNextPath;
     private getEntryPoint;
     /**

package/ngcc/src/entry_point_finder/targeted_entry_point_finder.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/entry_point_finder/targeted_entry_point_finder", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/ngcc/src/packages/entry_point", "@angular/compiler-cli/ngcc/src/entry_point_finder/utils"], factory);
+        define("@angular/compiler-cli/ngcc/src/entry_point_finder/targeted_entry_point_finder", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/ngcc/src/packages/build_marker", "@angular/compiler-cli/ngcc/src/packages/entry_point", "@angular/compiler-cli/ngcc/src/entry_point_finder/utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -18,6 +18,7 @@
      * found in the LICENSE file at https://angular.io/license
      */
     var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    var build_marker_1 = require("@angular/compiler-cli/ngcc/src/packages/build_marker");
     var entry_point_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point");
     var utils_1 = require("@angular/compiler-cli/ngcc/src/entry_point_finder/utils");
     /**
@@ -41,12 +42,51 @@
             this.basePaths = utils_1.getBasePaths(this.basePath, this.pathMappings);
         }
         TargetedEntryPointFinder.prototype.findEntryPoints = function () {
+            var _this = this;
             this.unprocessedPaths = [this.targetPath];
             while (this.unprocessedPaths.length > 0) {
                 this.processNextPath();
             }
             var targetEntryPoint = this.unsortedEntryPoints.get(this.targetPath);
-            return this.resolver.sortEntryPointsByDependency(Array.from(this.unsortedEntryPoints.values()), targetEntryPoint);
+            var entryPoints = this.resolver.sortEntryPointsByDependency(Array.from(this.unsortedEntryPoints.values()), targetEntryPoint);
+            var invalidTarget = entryPoints.invalidEntryPoints.find(function (i) { return i.entryPoint.path === _this.targetPath; });
+            if (invalidTarget !== undefined) {
+                throw new Error("The target entry-point \"" + invalidTarget.entryPoint.name + "\" has missing dependencies:\n" +
+                    invalidTarget.missingDependencies.map(function (dep) { return " - " + dep + "\n"; }).join(''));
+            }
+            return entryPoints;
+        };
+        TargetedEntryPointFinder.prototype.targetNeedsProcessingOrCleaning = function (propertiesToConsider, compileAllFormats) {
+            var e_1, _a;
+            var entryPoint = this.getEntryPoint(this.targetPath);
+            if (entryPoint === null || !entryPoint.compiledByAngular) {
+                return false;
+            }
+            try {
+                for (var propertiesToConsider_1 = tslib_1.__values(propertiesToConsider), propertiesToConsider_1_1 = propertiesToConsider_1.next(); !propertiesToConsider_1_1.done; propertiesToConsider_1_1 = propertiesToConsider_1.next()) {
+                    var property = propertiesToConsider_1_1.value;
+                    if (entryPoint.packageJson[property]) {
+                        // Here is a property that should be processed.
+                        if (!build_marker_1.hasBeenProcessed(entryPoint.packageJson, property)) {
+                            return true;
+                        }
+                        if (!compileAllFormats) {
+                            // This property has been processed, and we only need one.
+                            return false;
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (propertiesToConsider_1_1 && !propertiesToConsider_1_1.done && (_a = propertiesToConsider_1.return)) _a.call(propertiesToConsider_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            // All `propertiesToConsider` that appear in this entry-point have been processed.
+            // In other words, there were no properties that need processing.
+            return false;
         };
         TargetedEntryPointFinder.prototype.processNextPath = function () {
             var _this = this;
@@ -78,7 +118,7 @@
          * `/a/b/c/d/node_modules`.
          */
         TargetedEntryPointFinder.prototype.computePackagePath = function (entryPointPath) {
-            var e_1, _a, e_2, _b;
+            var e_2, _a, e_3, _b;
             try {
                 for (var _c = tslib_1.__values(this.basePaths), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var basePath = _d.value;
@@ -95,7 +135,7 @@
                         try {
                             // Note that we skip the first `packagePath` and start looking from the first folder below
                             // it because that will be the `node_modules` folder.
-                            for (var segments_1 = (e_2 = void 0, tslib_1.__values(segments)), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+                            for (var segments_1 = (e_3 = void 0, tslib_1.__values(segments)), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
                                 var segment = segments_1_1.value;
                                 packagePath = file_system_1.join(packagePath, segment);
                                 if (this.fs.exists(file_system_1.join(packagePath, 'package.json'))) {
@@ -103,12 +143,12 @@
                                 }
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
                         finally {
                             try {
                                 if (segments_1_1 && !segments_1_1.done && (_b = segments_1.return)) _b.call(segments_1);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_3) throw e_3.error; }
                         }
                         // If we got here then we couldn't find a `packagePath` for the current `basePath` but since
                         // `basePath`s are guaranteed not to be a sub-directory each other then no other `basePath`
@@ -117,12 +157,12 @@
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_2) throw e_2.error; }
             }
             // If we get here then none of the `basePaths` matched the `entryPointPath`, which
             // is somewhat unexpected and means that this entry-point lives completely outside
@@ -146,4 +186,4 @@
     }());
     exports.TargetedEntryPointFinder = TargetedEntryPointFinder;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"targeted_entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/targeted_entry_point_finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AbsoluteFsPath, FileSystem, PathSegment, join, relative, relativeFrom} from '../../../src/ngtsc/file_system';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {Logger} from '../logging/logger';\nimport {NgccConfiguration} from '../packages/configuration';\nimport {EntryPoint, getEntryPointInfo} from '../packages/entry_point';\nimport {PathMappings} from '../utils';\nimport {EntryPointFinder} from './interface';\nimport {getBasePaths} from './utils';\n\n/**\n * An EntryPointFinder that starts from a target entry-point and only finds\n * entry-points that are dependencies of the target.\n *\n * This is faster than searching the entire file-system for all the entry-points,\n * and is used primarily by the CLI integration.\n */\nexport class TargetedEntryPointFinder implements EntryPointFinder {\n  private unprocessedPaths: AbsoluteFsPath[] = [];\n  private unsortedEntryPoints = new Map<AbsoluteFsPath, EntryPoint>();\n  private basePaths = getBasePaths(this.basePath, this.pathMappings);\n\n  constructor(\n      private fs: FileSystem, private config: NgccConfiguration, private logger: Logger,\n      private resolver: DependencyResolver, private basePath: AbsoluteFsPath,\n      private targetPath: AbsoluteFsPath, private pathMappings: PathMappings|undefined) {}\n\n  findEntryPoints(): SortedEntryPointsInfo {\n    this.unprocessedPaths = [this.targetPath];\n    while (this.unprocessedPaths.length > 0) {\n      this.processNextPath();\n    }\n    const targetEntryPoint = this.unsortedEntryPoints.get(this.targetPath);\n    return this.resolver.sortEntryPointsByDependency(\n        Array.from(this.unsortedEntryPoints.values()), targetEntryPoint);\n  }\n\n  private processNextPath(): void {\n    const path = this.unprocessedPaths.shift() !;\n    const entryPoint = this.getEntryPoint(path);\n    if (entryPoint !== null && entryPoint.compiledByAngular) {\n      this.unsortedEntryPoints.set(entryPoint.path, entryPoint);\n      const deps = this.resolver.getEntryPointDependencies(entryPoint);\n      deps.dependencies.forEach(dep => {\n        if (!this.unsortedEntryPoints.has(dep)) {\n          this.unprocessedPaths.push(dep);\n        }\n      });\n    }\n  }\n\n  private getEntryPoint(entryPointPath: AbsoluteFsPath): EntryPoint|null {\n    const packagePath = this.computePackagePath(entryPointPath);\n    return getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);\n  }\n\n  /**\n   * Search down to the `entryPointPath` from each `basePath` for the first `package.json` that we\n   * come to. This is the path to the entry-point's containing package. For example if `basePath` is\n   * `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists `/a/b/c/d/package.json` and\n   * `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.\n   *\n   * To account for nested `node_modules` we actually start the search at the last `node_modules` in\n   * the `entryPointPath` that is below the `basePath`. E.g. if `basePath` is `/a/b/c` and\n   * `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at\n   * `/a/b/c/d/node_modules`.\n   */\n  private computePackagePath(entryPointPath: AbsoluteFsPath): AbsoluteFsPath {\n    for (const basePath of this.basePaths) {\n      if (entryPointPath.startsWith(basePath)) {\n        let packagePath = basePath;\n        const segments = this.splitPath(relative(basePath, entryPointPath));\n\n        // Start the search at the last nested `node_modules` folder if the relative\n        // `entryPointPath` contains one or more.\n        let nodeModulesIndex = segments.lastIndexOf(relativeFrom('node_modules'));\n        while (nodeModulesIndex >= 0) {\n          packagePath = join(packagePath, segments.shift() !);\n          nodeModulesIndex--;\n        }\n\n        // Note that we skip the first `packagePath` and start looking from the first folder below\n        // it because that will be the `node_modules` folder.\n        for (const segment of segments) {\n          packagePath = join(packagePath, segment);\n          if (this.fs.exists(join(packagePath, 'package.json'))) {\n            return packagePath;\n          }\n        }\n\n        // If we got here then we couldn't find a `packagePath` for the current `basePath` but since\n        // `basePath`s are guaranteed not to be a sub-directory each other then no other `basePath`\n        // will match either.\n        break;\n      }\n    }\n    // If we get here then none of the `basePaths` matched the `entryPointPath`, which\n    // is somewhat unexpected and means that this entry-point lives completely outside\n    // any of the `basePaths`.\n    // All we can do is assume that his entry-point is a primary entry-point to a package.\n    return entryPointPath;\n  }\n\n\n  /**\n   * Split the given `path` into path segments using an FS independent algorithm.\n   * @param path The path to split.\n   */\n  private splitPath(path: PathSegment) {\n    const segments = [];\n    while (path !== '.') {\n      segments.unshift(this.fs.basename(path));\n      path = this.fs.dirname(path);\n    }\n    return segments;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"targeted_entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/targeted_entry_point_finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AbsoluteFsPath, FileSystem, PathSegment, join, relative, relativeFrom} from '../../../src/ngtsc/file_system';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {Logger} from '../logging/logger';\nimport {hasBeenProcessed} from '../packages/build_marker';\nimport {NgccConfiguration} from '../packages/configuration';\nimport {EntryPoint, EntryPointJsonProperty, getEntryPointInfo} from '../packages/entry_point';\nimport {PathMappings} from '../utils';\nimport {EntryPointFinder} from './interface';\nimport {getBasePaths} from './utils';\n\n/**\n * An EntryPointFinder that starts from a target entry-point and only finds\n * entry-points that are dependencies of the target.\n *\n * This is faster than searching the entire file-system for all the entry-points,\n * and is used primarily by the CLI integration.\n */\nexport class TargetedEntryPointFinder implements EntryPointFinder {\n  private unprocessedPaths: AbsoluteFsPath[] = [];\n  private unsortedEntryPoints = new Map<AbsoluteFsPath, EntryPoint>();\n  private basePaths = getBasePaths(this.basePath, this.pathMappings);\n\n  constructor(\n      private fs: FileSystem, private config: NgccConfiguration, private logger: Logger,\n      private resolver: DependencyResolver, private basePath: AbsoluteFsPath,\n      private targetPath: AbsoluteFsPath, private pathMappings: PathMappings|undefined) {}\n\n  findEntryPoints(): SortedEntryPointsInfo {\n    this.unprocessedPaths = [this.targetPath];\n    while (this.unprocessedPaths.length > 0) {\n      this.processNextPath();\n    }\n    const targetEntryPoint = this.unsortedEntryPoints.get(this.targetPath);\n    const entryPoints = this.resolver.sortEntryPointsByDependency(\n        Array.from(this.unsortedEntryPoints.values()), targetEntryPoint);\n\n    const invalidTarget =\n        entryPoints.invalidEntryPoints.find(i => i.entryPoint.path === this.targetPath);\n    if (invalidTarget !== undefined) {\n      throw new Error(\n          `The target entry-point \"${invalidTarget.entryPoint.name}\" has missing dependencies:\\n` +\n          invalidTarget.missingDependencies.map(dep => ` - ${dep}\\n`).join(''));\n    }\n    return entryPoints;\n  }\n\n  targetNeedsProcessingOrCleaning(\n      propertiesToConsider: EntryPointJsonProperty[], compileAllFormats: boolean): boolean {\n    const entryPoint = this.getEntryPoint(this.targetPath);\n    if (entryPoint === null || !entryPoint.compiledByAngular) {\n      return false;\n    }\n\n    for (const property of propertiesToConsider) {\n      if (entryPoint.packageJson[property]) {\n        // Here is a property that should be processed.\n        if (!hasBeenProcessed(entryPoint.packageJson, property)) {\n          return true;\n        }\n        if (!compileAllFormats) {\n          // This property has been processed, and we only need one.\n          return false;\n        }\n      }\n    }\n    // All `propertiesToConsider` that appear in this entry-point have been processed.\n    // In other words, there were no properties that need processing.\n    return false;\n  }\n\n  private processNextPath(): void {\n    const path = this.unprocessedPaths.shift() !;\n    const entryPoint = this.getEntryPoint(path);\n    if (entryPoint !== null && entryPoint.compiledByAngular) {\n      this.unsortedEntryPoints.set(entryPoint.path, entryPoint);\n      const deps = this.resolver.getEntryPointDependencies(entryPoint);\n      deps.dependencies.forEach(dep => {\n        if (!this.unsortedEntryPoints.has(dep)) {\n          this.unprocessedPaths.push(dep);\n        }\n      });\n    }\n  }\n\n  private getEntryPoint(entryPointPath: AbsoluteFsPath): EntryPoint|null {\n    const packagePath = this.computePackagePath(entryPointPath);\n    return getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);\n  }\n\n  /**\n   * Search down to the `entryPointPath` from each `basePath` for the first `package.json` that we\n   * come to. This is the path to the entry-point's containing package. For example if `basePath` is\n   * `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists `/a/b/c/d/package.json` and\n   * `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.\n   *\n   * To account for nested `node_modules` we actually start the search at the last `node_modules` in\n   * the `entryPointPath` that is below the `basePath`. E.g. if `basePath` is `/a/b/c` and\n   * `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at\n   * `/a/b/c/d/node_modules`.\n   */\n  private computePackagePath(entryPointPath: AbsoluteFsPath): AbsoluteFsPath {\n    for (const basePath of this.basePaths) {\n      if (entryPointPath.startsWith(basePath)) {\n        let packagePath = basePath;\n        const segments = this.splitPath(relative(basePath, entryPointPath));\n\n        // Start the search at the last nested `node_modules` folder if the relative\n        // `entryPointPath` contains one or more.\n        let nodeModulesIndex = segments.lastIndexOf(relativeFrom('node_modules'));\n        while (nodeModulesIndex >= 0) {\n          packagePath = join(packagePath, segments.shift() !);\n          nodeModulesIndex--;\n        }\n\n        // Note that we skip the first `packagePath` and start looking from the first folder below\n        // it because that will be the `node_modules` folder.\n        for (const segment of segments) {\n          packagePath = join(packagePath, segment);\n          if (this.fs.exists(join(packagePath, 'package.json'))) {\n            return packagePath;\n          }\n        }\n\n        // If we got here then we couldn't find a `packagePath` for the current `basePath` but since\n        // `basePath`s are guaranteed not to be a sub-directory each other then no other `basePath`\n        // will match either.\n        break;\n      }\n    }\n    // If we get here then none of the `basePaths` matched the `entryPointPath`, which\n    // is somewhat unexpected and means that this entry-point lives completely outside\n    // any of the `basePaths`.\n    // All we can do is assume that his entry-point is a primary entry-point to a package.\n    return entryPointPath;\n  }\n\n\n  /**\n   * Split the given `path` into path segments using an FS independent algorithm.\n   * @param path The path to split.\n   */\n  private splitPath(path: PathSegment) {\n    const segments = [];\n    while (path !== '.') {\n      segments.unshift(this.fs.basename(path));\n      path = this.fs.dirname(path);\n    }\n    return segments;\n  }\n}\n"]}

package/ngcc/src/execution/cluster/executor.d.ts

@@ -9,6 +9,7 @@
 import { Logger } from '../../logging/logger';
 import { PackageJsonUpdater } from '../../writing/package_json_updater';
 import { AnalyzeEntryPointsFn, CreateCompileFn, Executor } from '../api';
+import { LockFile } from '../lock_file';
 /**
  * An `Executor` that processes tasks in parallel (on multiple processes) and completes
  * asynchronously.
@@ -17,6 +18,7 @@ export declare class ClusterExecutor implements Executor {
     private workerCount;
     private logger;
     private pkgJsonUpdater;
-    constructor(workerCount: number, logger: Logger, pkgJsonUpdater: PackageJsonUpdater);
+    private lockFile;
+    constructor(workerCount: number, logger: Logger, pkgJsonUpdater: PackageJsonUpdater, lockFile: LockFile);
     execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): Promise<void>;
 }