@angular/compiler-cli 9.1.3 → 9.1.7

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

@@ -9,9 +9,9 @@
 import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
 import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
 import { Logger } from '../logging/logger';
-import { PathMappings } from '../ngcc_options';
 import { NgccConfiguration } from '../packages/configuration';
 import { EntryPointJsonProperty } from '../packages/entry_point';
+import { PathMappings } from '../path_mappings';
 import { EntryPointFinder } from './interface';
 /**
  * An EntryPointFinder that starts from a target entry-point and only finds
@@ -31,23 +31,30 @@ export declare class TargetedEntryPointFinder implements EntryPointFinder {
     private unprocessedPaths;
     private unsortedEntryPoints;
     private basePaths;
+    private getBasePaths;
     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;
+    private computePackagePath;
     /**
-     * Search down to the `entryPointPath` from each `basePath` for the first `package.json` that we
-     * come to. This is the path to the entry-point's containing package. For example if `basePath` is
-     * `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists `/a/b/c/d/package.json` and
-     * `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
+     * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that
+     * we come to. This is the path to the entry-point's containing package. For example if
+     * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists
+     * `/a/b/c/d/package.json` and `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
      *
      * To account for nested `node_modules` we actually start the search at the last `node_modules` in
-     * the `entryPointPath` that is below the `basePath`. E.g. if `basePath` is `/a/b/c` and
-     * `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
+     * the `entryPointPath` that is below the `containingPath`. E.g. if `containingPath` is `/a/b/c`
+     * and `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
      * `/a/b/c/d/node_modules`.
      */
-    private computePackagePath;
+    private computePackagePathFromContainingPath;
+    /**
+     * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory
+     * that we can use as a potential starting point for computing the package path.
+     */
+    private computePackagePathFromNearestNodeModules;
     /**
      * Split the given `path` into path segments using an FS independent algorithm.
      * @param path The path to split.

package/ngcc/src/entry_point_finder/targeted_entry_point_finder.js

@@ -39,8 +39,14 @@
             this.pathMappings = pathMappings;
             this.unprocessedPaths = [];
             this.unsortedEntryPoints = new Map();
-            this.basePaths = utils_1.getBasePaths(this.logger, this.basePath, this.pathMappings);
+            this.basePaths = null;
         }
+        TargetedEntryPointFinder.prototype.getBasePaths = function () {
+            if (this.basePaths === null) {
+                this.basePaths = utils_1.getBasePaths(this.logger, this.basePath, this.pathMappings);
+            }
+            return this.basePaths;
+        };
         TargetedEntryPointFinder.prototype.findEntryPoints = function () {
             var _this = this;
             this.unprocessedPaths = [this.targetPath];
@@ -111,58 +117,25 @@
             }
             return entryPoint;
         };
-        /**
-         * Search down to the `entryPointPath` from each `basePath` for the first `package.json` that we
-         * come to. This is the path to the entry-point's containing package. For example if `basePath` is
-         * `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists `/a/b/c/d/package.json` and
-         * `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
-         *
-         * To account for nested `node_modules` we actually start the search at the last `node_modules` in
-         * the `entryPointPath` that is below the `basePath`. E.g. if `basePath` is `/a/b/c` and
-         * `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
-         * `/a/b/c/d/node_modules`.
-         */
         TargetedEntryPointFinder.prototype.computePackagePath = function (entryPointPath) {
-            var e_2, _a, e_3, _b;
+            var e_2, _a;
+            // First try the main basePath, to avoid having to compute the other basePaths from the paths
+            // mappings, which can be computationally intensive.
+            if (entryPointPath.startsWith(this.basePath)) {
+                var packagePath = this.computePackagePathFromContainingPath(entryPointPath, this.basePath);
+                if (packagePath !== null) {
+                    return packagePath;
+                }
+            }
             try {
-                for (var _c = tslib_1.__values(this.basePaths), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var basePath = _d.value;
+                // The main `basePath` didn't work out so now we try the `basePaths` computed from the paths
+                // mappings in `tsconfig.json`.
+                for (var _b = tslib_1.__values(this.getBasePaths()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var basePath = _c.value;
                     if (entryPointPath.startsWith(basePath)) {
-                        var packagePath_1 = basePath;
-                        var segments = this.splitPath(file_system_1.relative(basePath, entryPointPath));
-                        var nodeModulesIndex = segments.lastIndexOf(file_system_1.relativeFrom('node_modules'));
-                        // If there are no `node_modules` in the relative path between the `basePath` and the
-                        // `entryPointPath` then just try the `basePath` as the `packagePath`.
-                        // (This can be the case with path-mapped entry-points.)
-                        if (nodeModulesIndex === -1) {
-                            if (this.fs.exists(file_system_1.join(packagePath_1, 'package.json'))) {
-                                return packagePath_1;
-                            }
-                        }
-                        // Start the search at the deepest nested `node_modules` folder that is below the `basePath`
-                        // but above the `entryPointPath`, if there are any.
-                        while (nodeModulesIndex >= 0) {
-                            packagePath_1 = file_system_1.join(packagePath_1, segments.shift());
-                            nodeModulesIndex--;
-                        }
-                        try {
-                            // Note that we start at the folder below the current candidate `packagePath` because the
-                            // initial candidate `packagePath` is either a `node_modules` folder or the `basePath` with
-                            // no `package.json`.
-                            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_1 = file_system_1.join(packagePath_1, segment);
-                                if (this.fs.exists(file_system_1.join(packagePath_1, 'package.json'))) {
-                                    return packagePath_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_3) throw e_3.error; }
+                        var packagePath = this.computePackagePathFromContainingPath(entryPointPath, basePath);
+                        if (packagePath !== null) {
+                            return packagePath;
                         }
                         // If we got here then we couldn't find a `packagePath` for the current `basePath`.
                         // Since `basePath`s are guaranteed not to be a sub-directory of each other then no other
@@ -174,12 +147,71 @@
             catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
                 finally { if (e_2) throw e_2.error; }
             }
-            // We couldn't find a `packagePath` using `basePaths` so try to find the nearest `node_modules`
-            // that contains the `entryPointPath`, if there is one, and use it as a `basePath`.
+            // Finally, if we couldn't find a `packagePath` using `basePaths` then try to find the nearest
+            // `node_modules` that contains the `entryPointPath`, if there is one, and use it as a
+            // `basePath`.
+            return this.computePackagePathFromNearestNodeModules(entryPointPath);
+        };
+        /**
+         * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that
+         * we come to. This is the path to the entry-point's containing package. For example if
+         * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists
+         * `/a/b/c/d/package.json` and `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
+         *
+         * To account for nested `node_modules` we actually start the search at the last `node_modules` in
+         * the `entryPointPath` that is below the `containingPath`. E.g. if `containingPath` is `/a/b/c`
+         * and `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
+         * `/a/b/c/d/node_modules`.
+         */
+        TargetedEntryPointFinder.prototype.computePackagePathFromContainingPath = function (entryPointPath, containingPath) {
+            var e_3, _a;
+            var packagePath = containingPath;
+            var segments = this.splitPath(file_system_1.relative(containingPath, entryPointPath));
+            var nodeModulesIndex = segments.lastIndexOf(file_system_1.relativeFrom('node_modules'));
+            // If there are no `node_modules` in the relative path between the `basePath` and the
+            // `entryPointPath` then just try the `basePath` as the `packagePath`.
+            // (This can be the case with path-mapped entry-points.)
+            if (nodeModulesIndex === -1) {
+                if (this.fs.exists(file_system_1.join(packagePath, 'package.json'))) {
+                    return packagePath;
+                }
+            }
+            // Start the search at the deepest nested `node_modules` folder that is below the `basePath`
+            // but above the `entryPointPath`, if there are any.
+            while (nodeModulesIndex >= 0) {
+                packagePath = file_system_1.join(packagePath, segments.shift());
+                nodeModulesIndex--;
+            }
+            try {
+                // Note that we start at the folder below the current candidate `packagePath` because the
+                // initial candidate `packagePath` is either a `node_modules` folder or the `basePath` with
+                // no `package.json`.
+                for (var segments_1 = 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'))) {
+                        return packagePath;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return null;
+        };
+        /**
+         * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory
+         * that we can use as a potential starting point for computing the package path.
+         */
+        TargetedEntryPointFinder.prototype.computePackagePathFromNearestNodeModules = function (entryPointPath) {
             var packagePath = entryPointPath;
             var scopedPackagePath = packagePath;
             var containerPath = this.fs.dirname(packagePath);
@@ -222,4 +254,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, join, PathSegment, relative, relativeFrom} from '../../../src/ngtsc/file_system';\nimport {EntryPointWithDependencies} from '../dependencies/dependency_host';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {Logger} from '../logging/logger';\nimport {PathMappings} from '../ngcc_options';\nimport {hasBeenProcessed} from '../packages/build_marker';\nimport {NgccConfiguration} from '../packages/configuration';\nimport {EntryPoint, EntryPointJsonProperty, getEntryPointInfo, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from '../packages/entry_point';\n\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, EntryPointWithDependencies>();\n  private basePaths = getBasePaths(this.logger, 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?.entryPoint);\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      return;\n    }\n    const entryPointWithDeps = this.resolver.getEntryPointWithDependencies(entryPoint);\n    this.unsortedEntryPoints.set(entryPoint.path, entryPointWithDeps);\n    entryPointWithDeps.depInfo.dependencies.forEach(dep => {\n      if (!this.unsortedEntryPoints.has(dep)) {\n        this.unprocessedPaths.push(dep);\n      }\n    });\n  }\n\n  private getEntryPoint(entryPointPath: AbsoluteFsPath): EntryPoint|null {\n    const packagePath = this.computePackagePath(entryPointPath);\n    const entryPoint =\n        getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);\n    if (entryPoint === NO_ENTRY_POINT || entryPoint === INCOMPATIBLE_ENTRY_POINT) {\n      return null;\n    }\n    return entryPoint;\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        let nodeModulesIndex = segments.lastIndexOf(relativeFrom('node_modules'));\n\n        // If there are no `node_modules` in the relative path between the `basePath` and the\n        // `entryPointPath` then just try the `basePath` as the `packagePath`.\n        // (This can be the case with path-mapped entry-points.)\n        if (nodeModulesIndex === -1) {\n          if (this.fs.exists(join(packagePath, 'package.json'))) {\n            return packagePath;\n          }\n        }\n\n        // Start the search at the deepest nested `node_modules` folder that is below the `basePath`\n        // but above the `entryPointPath`, if there are any.\n        while (nodeModulesIndex >= 0) {\n          packagePath = join(packagePath, segments.shift()!);\n          nodeModulesIndex--;\n        }\n\n        // Note that we start at the folder below the current candidate `packagePath` because the\n        // initial candidate `packagePath` is either a `node_modules` folder or the `basePath` with\n        // no `package.json`.\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`.\n        // Since `basePath`s are guaranteed not to be a sub-directory of each other then no other\n        // `basePath` will match either.\n        break;\n      }\n    }\n\n    // We couldn't find a `packagePath` using `basePaths` so try to find the nearest `node_modules`\n    // that contains the `entryPointPath`, if there is one, and use it as a `basePath`.\n    let packagePath = entryPointPath;\n    let scopedPackagePath = packagePath;\n    let containerPath = this.fs.dirname(packagePath);\n    while (!this.fs.isRoot(containerPath) && !containerPath.endsWith('node_modules')) {\n      scopedPackagePath = packagePath;\n      packagePath = containerPath;\n      containerPath = this.fs.dirname(containerPath);\n    }\n\n    if (this.fs.exists(join(packagePath, 'package.json'))) {\n      // The directory directly below `node_modules` is a package - use it\n      return packagePath;\n    } else if (\n        this.fs.basename(packagePath).startsWith('@') &&\n        this.fs.exists(join(scopedPackagePath, 'package.json'))) {\n      // The directory directly below the `node_modules` is a scope and the directory directly\n      // below that is a scoped package - use it\n      return scopedPackagePath;\n    } else {\n      // If we get here then none of the `basePaths` contained the `entryPointPath` and the\n      // `entryPointPath` contains no `node_modules` that contains a package or a scoped\n      // package. All we can do is assume that this entry-point is a primary entry-point to a\n      // 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, join, PathSegment, relative, relativeFrom} from '../../../src/ngtsc/file_system';\nimport {EntryPointWithDependencies} from '../dependencies/dependency_host';\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, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from '../packages/entry_point';\nimport {PathMappings} from '../path_mappings';\n\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, EntryPointWithDependencies>();\n  private basePaths: AbsoluteFsPath[]|null = null;\n  private getBasePaths() {\n    if (this.basePaths === null) {\n      this.basePaths = getBasePaths(this.logger, this.basePath, this.pathMappings);\n    }\n    return this.basePaths;\n  }\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?.entryPoint);\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      return;\n    }\n    const entryPointWithDeps = this.resolver.getEntryPointWithDependencies(entryPoint);\n    this.unsortedEntryPoints.set(entryPoint.path, entryPointWithDeps);\n    entryPointWithDeps.depInfo.dependencies.forEach(dep => {\n      if (!this.unsortedEntryPoints.has(dep)) {\n        this.unprocessedPaths.push(dep);\n      }\n    });\n  }\n\n  private getEntryPoint(entryPointPath: AbsoluteFsPath): EntryPoint|null {\n    const packagePath = this.computePackagePath(entryPointPath);\n    const entryPoint =\n        getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);\n    if (entryPoint === NO_ENTRY_POINT || entryPoint === INCOMPATIBLE_ENTRY_POINT) {\n      return null;\n    }\n    return entryPoint;\n  }\n\n  private computePackagePath(entryPointPath: AbsoluteFsPath): AbsoluteFsPath {\n    // First try the main basePath, to avoid having to compute the other basePaths from the paths\n    // mappings, which can be computationally intensive.\n    if (entryPointPath.startsWith(this.basePath)) {\n      const packagePath = this.computePackagePathFromContainingPath(entryPointPath, this.basePath);\n      if (packagePath !== null) {\n        return packagePath;\n      }\n    }\n\n    // The main `basePath` didn't work out so now we try the `basePaths` computed from the paths\n    // mappings in `tsconfig.json`.\n    for (const basePath of this.getBasePaths()) {\n      if (entryPointPath.startsWith(basePath)) {\n        const packagePath = this.computePackagePathFromContainingPath(entryPointPath, basePath);\n        if (packagePath !== null) {\n          return packagePath;\n        }\n        // If we got here then we couldn't find a `packagePath` for the current `basePath`.\n        // Since `basePath`s are guaranteed not to be a sub-directory of each other then no other\n        // `basePath` will match either.\n        break;\n      }\n    }\n\n    // Finally, if we couldn't find a `packagePath` using `basePaths` then try to find the nearest\n    // `node_modules` that contains the `entryPointPath`, if there is one, and use it as a\n    // `basePath`.\n    return this.computePackagePathFromNearestNodeModules(entryPointPath);\n  }\n\n  /**\n   * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that\n   * we come to. This is the path to the entry-point's containing package. For example if\n   * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists\n   * `/a/b/c/d/package.json` and `/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 `containingPath`. E.g. if `containingPath` is `/a/b/c`\n   * and `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 computePackagePathFromContainingPath(\n      entryPointPath: AbsoluteFsPath, containingPath: AbsoluteFsPath): AbsoluteFsPath|null {\n    let packagePath = containingPath;\n    const segments = this.splitPath(relative(containingPath, entryPointPath));\n    let nodeModulesIndex = segments.lastIndexOf(relativeFrom('node_modules'));\n\n    // If there are no `node_modules` in the relative path between the `basePath` and the\n    // `entryPointPath` then just try the `basePath` as the `packagePath`.\n    // (This can be the case with path-mapped entry-points.)\n    if (nodeModulesIndex === -1) {\n      if (this.fs.exists(join(packagePath, 'package.json'))) {\n        return packagePath;\n      }\n    }\n\n    // Start the search at the deepest nested `node_modules` folder that is below the `basePath`\n    // but above the `entryPointPath`, if there are any.\n    while (nodeModulesIndex >= 0) {\n      packagePath = join(packagePath, segments.shift()!);\n      nodeModulesIndex--;\n    }\n\n    // Note that we start at the folder below the current candidate `packagePath` because the\n    // initial candidate `packagePath` is either a `node_modules` folder or the `basePath` with\n    // no `package.json`.\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    return null;\n  }\n\n  /**\n   * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory\n   * that we can use as a potential starting point for computing the package path.\n   */\n  private computePackagePathFromNearestNodeModules(entryPointPath: AbsoluteFsPath): AbsoluteFsPath {\n    let packagePath = entryPointPath;\n    let scopedPackagePath = packagePath;\n    let containerPath = this.fs.dirname(packagePath);\n    while (!this.fs.isRoot(containerPath) && !containerPath.endsWith('node_modules')) {\n      scopedPackagePath = packagePath;\n      packagePath = containerPath;\n      containerPath = this.fs.dirname(containerPath);\n    }\n\n    if (this.fs.exists(join(packagePath, 'package.json'))) {\n      // The directory directly below `node_modules` is a package - use it\n      return packagePath;\n    } else if (\n        this.fs.basename(packagePath).startsWith('@') &&\n        this.fs.exists(join(scopedPackagePath, 'package.json'))) {\n      // The directory directly below the `node_modules` is a scope and the directory directly\n      // below that is a scoped package - use it\n      return scopedPackagePath;\n    } else {\n      // If we get here then none of the `basePaths` contained the `entryPointPath` and the\n      // `entryPointPath` contains no `node_modules` that contains a package or a scoped\n      // package. All we can do is assume that this entry-point is a primary entry-point to a\n      // 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/entry_point_finder/utils.d.ts

@@ -8,7 +8,7 @@
  */
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { Logger } from '../logging/logger';
-import { PathMappings } from '../ngcc_options';
+import { PathMappings } from '../path_mappings';
 /**
  * Extract all the base-paths that we need to search for entry-points.
  *
@@ -37,3 +37,12 @@ export declare function getBasePaths(logger: Logger, sourceDirectory: AbsoluteFs
  * @returns The result of calling `task`.
  */
 export declare function trackDuration<T = void>(task: () => T extends Promise<unknown> ? never : T, log: (duration: number) => void): T;
+/**
+ * Remove paths that are contained by other paths.
+ *
+ * For example:
+ * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.
+ * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not
+ * one of the base paths.)
+ */
+export declare function dedupePaths(paths: AbsoluteFsPath[]): AbsoluteFsPath[];

package/ngcc/src/entry_point_finder/utils.js

@@ -4,11 +4,12 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/entry_point_finder/utils", ["require", "exports", "@angular/compiler-cli/src/ngtsc/file_system"], factory);
+        define("@angular/compiler-cli/ngcc/src/entry_point_finder/utils", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -61,8 +62,7 @@
                 }
             }); });
         }
-        basePaths.sort().reverse(); // Get the paths in order with the longer ones first.
-        var dedupedBasePaths = basePaths.filter(removeContainedPaths);
+        var dedupedBasePaths = dedupePaths(basePaths);
         // We want to ensure that the `sourceDirectory` is included when it is a node_modules folder.
         // Otherwise our entry-point finding algorithm would fail to walk that folder.
         if (fs.basename(sourceDirectory) === 'node_modules' &&
@@ -80,30 +80,6 @@
     function extractPathPrefix(path) {
         return path.split('*', 1)[0];
     }
-    /**
-     * A filter function that removes paths that are contained by other paths.
-     *
-     * For example:
-     * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.
-     * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not
-     * one of the base paths.)
-     *
-     * @param value The current path.
-     * @param index The index of the current path.
-     * @param array The array of paths (sorted in reverse alphabetical order).
-     * @returns true if this path is not contained by another path.
-     */
-    function removeContainedPaths(value, index, array) {
-        // We only need to check the following paths since the `array` is sorted in reverse alphabetic
-        // order.
-        for (var i = index + 1; i < array.length; i++) {
-            // We need to use `relative().startsWith()` rather than a simple `startsWith()` to ensure we
-            // don't assume that `a/b` contains `a/b-2`.
-            if (!file_system_1.relative(array[i], value).startsWith('..'))
-                return false;
-        }
-        return true;
-    }
     /**
      * Run a task and track how long it takes.
      *
@@ -119,5 +95,79 @@
         return result;
     }
     exports.trackDuration = trackDuration;
+    /**
+     * Remove paths that are contained by other paths.
+     *
+     * For example:
+     * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.
+     * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not
+     * one of the base paths.)
+     */
+    function dedupePaths(paths) {
+        var e_1, _a;
+        var root = { children: new Map() };
+        try {
+            for (var paths_1 = tslib_1.__values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+                var path = paths_1_1.value;
+                addPath(root, path);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return flattenTree(root);
+    }
+    exports.dedupePaths = dedupePaths;
+    /**
+     * Add a path (defined by the `segments`) to the current `node` in the tree.
+     */
+    function addPath(root, path) {
+        var node = root;
+        if (!file_system_1.isRoot(path)) {
+            var segments = path.split('/');
+            for (var index = 0; index < segments.length; index++) {
+                if (isLeaf(node)) {
+                    // We hit a leaf so don't bother processing any more of the path
+                    return;
+                }
+                // This is not the end of the path continue to process the rest of this path.
+                var next = segments[index];
+                if (!node.children.has(next)) {
+                    node.children.set(next, { children: new Map() });
+                }
+                node = node.children.get(next);
+            }
+        }
+        // This path has finished so convert this node to a leaf
+        convertToLeaf(node, path);
+    }
+    /**
+     * Flatten the tree of nodes back into an array of absolute paths
+     */
+    function flattenTree(root) {
+        var paths = [];
+        var nodes = [root];
+        for (var index = 0; index < nodes.length; index++) {
+            var node = nodes[index];
+            if (isLeaf(node)) {
+                // We found a leaf so store the currentPath
+                paths.push(node.path);
+            }
+            else {
+                node.children.forEach(function (value) { return nodes.push(value); });
+            }
+        }
+        return paths;
+    }
+    function isLeaf(node) {
+        return node.path !== undefined;
+    }
+    function convertToLeaf(node, path) {
+        node.path = path;
+    }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/utils.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, getFileSystem, relative, resolve} from '../../../src/ngtsc/file_system';\nimport {Logger} from '../logging/logger';\nimport {PathMappings} from '../ngcc_options';\n\n/**\n * Extract all the base-paths that we need to search for entry-points.\n *\n * This always contains the standard base-path (`sourceDirectory`).\n * But it also parses the `paths` mappings object to guess additional base-paths.\n *\n * For example:\n *\n * ```\n * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})\n * > ['/node_modules', '/dist/lib']\n * ```\n *\n * Notice that `'/dist'` is not included as there is no `'*'` path,\n * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.\n *\n * @param sourceDirectory The standard base-path (e.g. node_modules).\n * @param pathMappings Path mapping configuration, from which to extract additional base-paths.\n */\nexport function getBasePaths(\n    logger: Logger, sourceDirectory: AbsoluteFsPath,\n    pathMappings: PathMappings|undefined): AbsoluteFsPath[] {\n  const fs = getFileSystem();\n  const basePaths = [sourceDirectory];\n  if (pathMappings) {\n    const baseUrl = resolve(pathMappings.baseUrl);\n    if (fs.isRoot(baseUrl)) {\n      logger.warn(\n          `The provided pathMappings baseUrl is the root path ${baseUrl}.\\n` +\n          `This is likely to mess up how ngcc finds entry-points and is probably not correct.\\n` +\n          `Please check your path mappings configuration such as in the tsconfig.json file.`);\n    }\n    Object.values(pathMappings.paths).forEach(paths => paths.forEach(path => {\n      // We only want base paths that exist and are not files\n      let basePath = fs.resolve(baseUrl, extractPathPrefix(path));\n      if (fs.exists(basePath) && fs.stat(basePath).isFile()) {\n        basePath = fs.dirname(basePath);\n      }\n      if (fs.exists(basePath)) {\n        basePaths.push(basePath);\n      } else {\n        logger.debug(\n            `The basePath \"${basePath}\" computed from baseUrl \"${baseUrl}\" and path mapping \"${\n                path}\" does not exist in the file-system.\\n` +\n            `It will not be scanned for entry-points.`);\n      }\n    }));\n  }\n  basePaths.sort().reverse();  // Get the paths in order with the longer ones first.\n  const dedupedBasePaths = basePaths.filter(removeContainedPaths);\n\n  // We want to ensure that the `sourceDirectory` is included when it is a node_modules folder.\n  // Otherwise our entry-point finding algorithm would fail to walk that folder.\n  if (fs.basename(sourceDirectory) === 'node_modules' &&\n      !dedupedBasePaths.includes(sourceDirectory)) {\n    dedupedBasePaths.unshift(sourceDirectory);\n  }\n\n  return dedupedBasePaths;\n}\n\n/**\n * Extract everything in the `path` up to the first `*`.\n * @param path The path to parse.\n * @returns The extracted prefix.\n */\nfunction extractPathPrefix(path: string) {\n  return path.split('*', 1)[0];\n}\n\n/**\n * A filter function that removes paths that are contained by other paths.\n *\n * For example:\n * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.\n * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not\n * one of the base paths.)\n *\n * @param value The current path.\n * @param index The index of the current path.\n * @param array The array of paths (sorted in reverse alphabetical order).\n * @returns true if this path is not contained by another path.\n */\nfunction removeContainedPaths(value: AbsoluteFsPath, index: number, array: AbsoluteFsPath[]) {\n  // We only need to check the following paths since the `array` is sorted in reverse alphabetic\n  // order.\n  for (let i = index + 1; i < array.length; i++) {\n    // We need to use `relative().startsWith()` rather than a simple `startsWith()` to ensure we\n    // don't assume that `a/b` contains `a/b-2`.\n    if (!relative(array[i], value).startsWith('..')) return false;\n  }\n  return true;\n}\n\n/**\n * Run a task and track how long it takes.\n *\n * @param task The task whose duration we are tracking\n * @param log The function to call with the duration of the task\n * @returns The result of calling `task`.\n */\nexport function trackDuration<T = void>(task: () => T extends Promise<unknown>? never : T,\n                                                              log: (duration: number) => void): T {\n  const startTime = Date.now();\n  const result = task();\n  const duration = Math.round((Date.now() - startTime) / 100) / 10;\n  log(duration);\n  return result;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/utils.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, getFileSystem, isRoot, resolve} from '../../../src/ngtsc/file_system';\nimport {Logger} from '../logging/logger';\nimport {PathMappings} from '../path_mappings';\n\n/**\n * Extract all the base-paths that we need to search for entry-points.\n *\n * This always contains the standard base-path (`sourceDirectory`).\n * But it also parses the `paths` mappings object to guess additional base-paths.\n *\n * For example:\n *\n * ```\n * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})\n * > ['/node_modules', '/dist/lib']\n * ```\n *\n * Notice that `'/dist'` is not included as there is no `'*'` path,\n * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.\n *\n * @param sourceDirectory The standard base-path (e.g. node_modules).\n * @param pathMappings Path mapping configuration, from which to extract additional base-paths.\n */\nexport function getBasePaths(\n    logger: Logger, sourceDirectory: AbsoluteFsPath,\n    pathMappings: PathMappings|undefined): AbsoluteFsPath[] {\n  const fs = getFileSystem();\n  const basePaths = [sourceDirectory];\n  if (pathMappings) {\n    const baseUrl = resolve(pathMappings.baseUrl);\n    if (fs.isRoot(baseUrl)) {\n      logger.warn(\n          `The provided pathMappings baseUrl is the root path ${baseUrl}.\\n` +\n          `This is likely to mess up how ngcc finds entry-points and is probably not correct.\\n` +\n          `Please check your path mappings configuration such as in the tsconfig.json file.`);\n    }\n    Object.values(pathMappings.paths).forEach(paths => paths.forEach(path => {\n      // We only want base paths that exist and are not files\n      let basePath = fs.resolve(baseUrl, extractPathPrefix(path));\n      if (fs.exists(basePath) && fs.stat(basePath).isFile()) {\n        basePath = fs.dirname(basePath);\n      }\n      if (fs.exists(basePath)) {\n        basePaths.push(basePath);\n      } else {\n        logger.debug(\n            `The basePath \"${basePath}\" computed from baseUrl \"${baseUrl}\" and path mapping \"${\n                path}\" does not exist in the file-system.\\n` +\n            `It will not be scanned for entry-points.`);\n      }\n    }));\n  }\n\n  const dedupedBasePaths = dedupePaths(basePaths);\n\n  // We want to ensure that the `sourceDirectory` is included when it is a node_modules folder.\n  // Otherwise our entry-point finding algorithm would fail to walk that folder.\n  if (fs.basename(sourceDirectory) === 'node_modules' &&\n      !dedupedBasePaths.includes(sourceDirectory)) {\n    dedupedBasePaths.unshift(sourceDirectory);\n  }\n\n  return dedupedBasePaths;\n}\n\n/**\n * Extract everything in the `path` up to the first `*`.\n * @param path The path to parse.\n * @returns The extracted prefix.\n */\nfunction extractPathPrefix(path: string) {\n  return path.split('*', 1)[0];\n}\n\n/**\n * Run a task and track how long it takes.\n *\n * @param task The task whose duration we are tracking\n * @param log The function to call with the duration of the task\n * @returns The result of calling `task`.\n */\nexport function trackDuration<T = void>(task: () => T extends Promise<unknown>? never : T,\n                                                              log: (duration: number) => void): T {\n  const startTime = Date.now();\n  const result = task();\n  const duration = Math.round((Date.now() - startTime) / 100) / 10;\n  log(duration);\n  return result;\n}\n\n/**\n * Remove paths that are contained by other paths.\n *\n * For example:\n * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.\n * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not\n * one of the base paths.)\n */\nexport function dedupePaths(paths: AbsoluteFsPath[]): AbsoluteFsPath[] {\n  const root: Node = {children: new Map()};\n  for (const path of paths) {\n    addPath(root, path);\n  }\n  return flattenTree(root);\n}\n\n/**\n * Add a path (defined by the `segments`) to the current `node` in the tree.\n */\nfunction addPath(root: Node, path: AbsoluteFsPath): void {\n  let node = root;\n  if (!isRoot(path)) {\n    const segments = path.split('/');\n    for (let index = 0; index < segments.length; index++) {\n      if (isLeaf(node)) {\n        // We hit a leaf so don't bother processing any more of the path\n        return;\n      }\n      // This is not the end of the path continue to process the rest of this path.\n      const next = segments[index];\n      if (!node.children.has(next)) {\n        node.children.set(next, {children: new Map()});\n      }\n      node = node.children.get(next)!;\n    }\n  }\n  // This path has finished so convert this node to a leaf\n  convertToLeaf(node, path);\n}\n\n/**\n * Flatten the tree of nodes back into an array of absolute paths\n */\nfunction flattenTree(root: Node): AbsoluteFsPath[] {\n  const paths: AbsoluteFsPath[] = [];\n  const nodes: Node[] = [root];\n  for (let index = 0; index < nodes.length; index++) {\n    const node = nodes[index];\n    if (isLeaf(node)) {\n      // We found a leaf so store the currentPath\n      paths.push(node.path);\n    } else {\n      node.children.forEach(value => nodes.push(value));\n    }\n  }\n  return paths;\n}\n\nfunction isLeaf(node: Node): node is Leaf {\n  return node.path !== undefined;\n}\n\nfunction convertToLeaf(node: Node, path: AbsoluteFsPath) {\n  node.path = path;\n}\n\ninterface Node {\n  children: Map<string, Node>;\n  path?: AbsoluteFsPath;\n}\n\ntype Leaf = Required<Node>;\n"]}

package/ngcc/src/execution/api.d.ts

@@ -6,6 +6,7 @@
  * 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 { FileToWrite } from '../rendering/utils';
 import { Task, TaskCompletedCallback, TaskQueue } from './tasks/api';
 /**
  * The type of the function that analyzes entry-points and creates the list of tasks.
@@ -15,9 +16,9 @@ import { Task, TaskCompletedCallback, TaskQueue } from './tasks/api';
  */
 export declare type AnalyzeEntryPointsFn = () => TaskQueue;
 /** The type of the function that can process/compile a task. */
-export declare type CompileFn = (task: Task) => void;
+export declare type CompileFn<T> = (task: Task) => void | T;
 /** The type of the function that creates the `CompileFn` function used to process tasks. */
-export declare type CreateCompileFn = (onTaskCompleted: TaskCompletedCallback) => CompileFn;
+export declare type CreateCompileFn = <T extends void | Promise<void>>(beforeWritingFiles: (transformedFiles: FileToWrite[]) => T, onTaskCompleted: TaskCompletedCallback) => CompileFn<T>;
 /**
  * A class that orchestrates and executes the required work (i.e. analyzes the entry-points,
  * processes the resulting tasks, does book-keeping and validates the final outcome).

package/ngcc/src/execution/api.js

@@ -10,4 +10,4 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL25nY2Mvc3JjL2V4ZWN1dGlvbi9hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7VGFzaywgVGFza0NvbXBsZXRlZENhbGxiYWNrLCBUYXNrUXVldWV9IGZyb20gJy4vdGFza3MvYXBpJztcblxuLyoqXG4gKiBUaGUgdHlwZSBvZiB0aGUgZnVuY3Rpb24gdGhhdCBhbmFseXplcyBlbnRyeS1wb2ludHMgYW5kIGNyZWF0ZXMgdGhlIGxpc3Qgb2YgdGFza3MuXG4gKlxuICogQHJldHVybiBBIGxpc3Qgb2YgdGFza3MgdGhhdCBuZWVkIHRvIGJlIGV4ZWN1dGVkIGluIG9yZGVyIHRvIHByb2Nlc3MgdGhlIG5lY2Vzc2FyeSBmb3JtYXRcbiAqICAgICAgICAgcHJvcGVydGllcyBmb3IgYWxsIGVudHJ5LXBvaW50cy5cbiAqL1xuZXhwb3J0IHR5cGUgQW5hbHl6ZUVudHJ5UG9pbnRzRm4gPSAoKSA9PiBUYXNrUXVldWU7XG5cbi8qKiBUaGUgdHlwZSBvZiB0aGUgZnVuY3Rpb24gdGhhdCBjYW4gcHJvY2Vzcy9jb21waWxlIGEgdGFzay4gKi9cbmV4cG9ydCB0eXBlIENvbXBpbGVGbiA9ICh0YXNrOiBUYXNrKSA9PiB2b2lkO1xuXG4vKiogVGhlIHR5cGUgb2YgdGhlIGZ1bmN0aW9uIHRoYXQgY3JlYXRlcyB0aGUgYENvbXBpbGVGbmAgZnVuY3Rpb24gdXNlZCB0byBwcm9jZXNzIHRhc2tzLiAqL1xuZXhwb3J0IHR5cGUgQ3JlYXRlQ29tcGlsZUZuID0gKG9uVGFza0NvbXBsZXRlZDogVGFza0NvbXBsZXRlZENhbGxiYWNrKSA9PiBDb21waWxlRm47XG5cbi8qKlxuICogQSBjbGFzcyB0aGF0IG9yY2hlc3RyYXRlcyBhbmQgZXhlY3V0ZXMgdGhlIHJlcXVpcmVkIHdvcmsgKGkuZS4gYW5hbHl6ZXMgdGhlIGVudHJ5LXBvaW50cyxcbiAqIHByb2Nlc3NlcyB0aGUgcmVzdWx0aW5nIHRhc2tzLCBkb2VzIGJvb2sta2VlcGluZyBhbmQgdmFsaWRhdGVzIHRoZSBmaW5hbCBvdXRjb21lKS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFeGVjdXRvciB7XG4gIGV4ZWN1dGUoYW5hbHl6ZUVudHJ5UG9pbnRzOiBBbmFseXplRW50cnlQb2ludHNGbiwgY3JlYXRlQ29tcGlsZUZuOiBDcmVhdGVDb21waWxlRm4pOlxuICAgICAgdm9pZHxQcm9taXNlPHZvaWQ+O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -31,6 +31,11 @@ export interface TaskCompletedMessage extends JsonObject {
     outcome: TaskProcessingOutcome;
     message: string | null;
 }
+/** A message listing the paths to transformed files about to be written to disk. */
+export interface TransformedFilesMessage extends JsonObject {
+    type: 'transformed-files';
+    files: AbsoluteFsPath[];
+}
 /** A message requesting the update of a `package.json` file. */
 export interface UpdatePackageJsonMessage extends JsonObject {
     type: 'update-package-json';
@@ -38,6 +43,6 @@ export interface UpdatePackageJsonMessage extends JsonObject {
     changes: PackageJsonChange[];
 }
 /** The type of messages sent from cluster workers to the cluster master. */
-export declare type MessageFromWorker = ErrorMessage | TaskCompletedMessage | UpdatePackageJsonMessage;
+export declare type MessageFromWorker = ErrorMessage | TaskCompletedMessage | TransformedFilesMessage | UpdatePackageJsonMessage;
 /** The type of messages sent from the cluster master to cluster workers. */
 export declare type MessageToWorker = ProcessTaskMessage;

package/ngcc/src/execution/cluster/api.js

@@ -17,4 +17,4 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -9,6 +9,7 @@
 import { FileSystem } from '../../../../src/ngtsc/file_system';
 import { AsyncLocker } from '../../locking/async_locker';
 import { Logger } from '../../logging/logger';
+import { FileWriter } from '../../writing/file_writer';
 import { PackageJsonUpdater } from '../../writing/package_json_updater';
 import { AnalyzeEntryPointsFn, CreateCompileFn, Executor } from '../api';
 import { CreateTaskCompletedCallback } from '../tasks/api';
@@ -20,9 +21,10 @@ export declare class ClusterExecutor implements Executor {
     private workerCount;
     private fileSystem;
     private logger;
+    private fileWriter;
     private pkgJsonUpdater;
     private lockFile;
     private createTaskCompletedCallback;
-    constructor(workerCount: number, fileSystem: FileSystem, logger: Logger, pkgJsonUpdater: PackageJsonUpdater, lockFile: AsyncLocker, createTaskCompletedCallback: CreateTaskCompletedCallback);
+    constructor(workerCount: number, fileSystem: FileSystem, logger: Logger, fileWriter: FileWriter, pkgJsonUpdater: PackageJsonUpdater, lockFile: AsyncLocker, createTaskCompletedCallback: CreateTaskCompletedCallback);
     execute(analyzeEntryPoints: AnalyzeEntryPointsFn, _createCompileFn: CreateCompileFn): Promise<void>;
 }