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

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

@@ -26,22 +26,27 @@
      * asynchronously.
      */
     var ClusterExecutor = /** @class */ (function () {
-        function ClusterExecutor(workerCount, logger, pkgJsonUpdater) {
+        function ClusterExecutor(workerCount, logger, pkgJsonUpdater, lockFile) {
             this.workerCount = workerCount;
             this.logger = logger;
             this.pkgJsonUpdater = pkgJsonUpdater;
+            this.lockFile = lockFile;
         }
         ClusterExecutor.prototype.execute = function (analyzeEntryPoints, createCompileFn) {
             return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var master, worker;
+                var worker;
+                var _this = this;
                 return tslib_1.__generator(this, function (_a) {
                     if (cluster.isMaster) {
-                        this.logger.debug("Running ngcc on " + this.constructor.name + " (using " + this.workerCount + " worker processes).");
-                        master = new master_1.ClusterMaster(this.workerCount, this.logger, this.pkgJsonUpdater, analyzeEntryPoints);
-                        return [2 /*return*/, master.run()];
+                        // This process is the cluster master.
+                        return [2 /*return*/, this.lockFile.lock(function () {
+                                _this.logger.debug("Running ngcc on " + _this.constructor.name + " (using " + _this.workerCount + " worker processes).");
+                                var master = new master_1.ClusterMaster(_this.workerCount, _this.logger, _this.pkgJsonUpdater, analyzeEntryPoints);
+                                return master.run();
+                            })];
                     }
                     else {
-                        worker = new worker_1.ClusterWorker(createCompileFn);
+                        worker = new worker_1.ClusterWorker(this.logger, createCompileFn);
                         return [2 /*return*/, worker.run()];
                     }
                     return [2 /*return*/];
@@ -52,4 +57,4 @@
     }());
     exports.ClusterExecutor = ClusterExecutor;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -54,7 +54,8 @@
                         if (propPath.length === 0) {
                             throw new Error("Missing property path for writing value to '" + packageJsonPath + "'.");
                         }
-                        package_json_updater_1.applyChange(preExistingParsedJson, propPath, value);
+                        // No need to take property positioning into account for in-memory representations.
+                        package_json_updater_1.applyChange(preExistingParsedJson, propPath, value, 'unimportant');
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -75,4 +76,4 @@
     }());
     exports.ClusterPackageJsonUpdater = ClusterPackageJsonUpdater;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -6,13 +6,15 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/ngcc/src/execution/cluster/worker" />
+import { Logger } from '../../logging/logger';
 import { CreateCompileFn } from '../api';
 /**
  * A cluster worker is responsible for processing one task (i.e. one format property for a specific
  * entry-point) at a time and reporting results back to the cluster master.
  */
 export declare class ClusterWorker {
+    private logger;
     private compile;
-    constructor(createCompileFn: CreateCompileFn);
+    constructor(logger: Logger, createCompileFn: CreateCompileFn);
     run(): Promise<void>;
 }

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

@@ -11,25 +11,27 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/execution/cluster/worker", ["require", "exports", "cluster", "@angular/compiler-cli/ngcc/src/execution/cluster/utils"], factory);
+        define("@angular/compiler-cli/ngcc/src/execution/cluster/worker", ["require", "exports", "cluster", "@angular/compiler-cli/ngcc/src/execution/utils", "@angular/compiler-cli/ngcc/src/execution/cluster/utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     /// <reference types="node" />
     var cluster = require("cluster");
-    var utils_1 = require("@angular/compiler-cli/ngcc/src/execution/cluster/utils");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/execution/utils");
+    var utils_2 = require("@angular/compiler-cli/ngcc/src/execution/cluster/utils");
     /**
      * A cluster worker is responsible for processing one task (i.e. one format property for a specific
      * entry-point) at a time and reporting results back to the cluster master.
      */
     var ClusterWorker = /** @class */ (function () {
-        function ClusterWorker(createCompileFn) {
+        function ClusterWorker(logger, createCompileFn) {
+            this.logger = logger;
             if (cluster.isMaster) {
                 throw new Error('Tried to instantiate `ClusterWorker` on the master process.');
             }
             this.compile =
-                createCompileFn(function (_task, outcome) { return utils_1.sendMessageToMaster({ type: 'task-completed', outcome: outcome }); });
+                createCompileFn(function (_task, outcome) { return utils_2.sendMessageToMaster({ type: 'task-completed', outcome: outcome }); });
         }
         ClusterWorker.prototype.run = function () {
             var _this = this;
@@ -38,13 +40,14 @@
                 try {
                     switch (msg.type) {
                         case 'process-task':
+                            _this.logger.debug("[Worker #" + cluster.worker.id + "] Processing task: " + utils_1.stringifyTask(msg.task));
                             return _this.compile(msg.task);
                         default:
-                            throw new Error("Invalid message received on worker #" + cluster.worker.id + ": " + JSON.stringify(msg));
+                            throw new Error("[Worker #" + cluster.worker.id + "] Invalid message received: " + JSON.stringify(msg));
                     }
                 }
                 catch (err) {
-                    utils_1.sendMessageToMaster({
+                    utils_2.sendMessageToMaster({
                         type: 'error',
                         error: (err instanceof Error) ? (err.stack || err.message) : err,
                     });
@@ -57,4 +60,4 @@
     }());
     exports.ClusterWorker = ClusterWorker;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,43 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/execution/lock_file" />
+import { FileSystem } from '../../../src/ngtsc/file_system';
+/**
+ * The LockFile is used to prevent more than one instance of ngcc executing at the same time.
+ *
+ * When ngcc starts executing, it creates a file in the `compiler-cli/ngcc` folder. If it finds one
+ * is already there then it fails with a suitable error message.
+ * When ngcc completes executing, it removes the file so that future ngcc executions can start.
+ */
+export declare class LockFile {
+    private fs;
+    lockFilePath: import("@angular/compiler-cli/src/ngtsc/file_system/src/types").BrandedPath<"AbsoluteFsPath">;
+    constructor(fs: FileSystem);
+    /**
+     * Run a function guarded by the lock file.
+     *
+     * Note that T can be a Promise. If so, we run the `remove()` call in the promise's `finally`
+     * handler. Otherwise we run the `remove()` call in the `try...finally` block.
+     *
+     * @param fn The function to run.
+     */
+    lock<T>(fn: () => T): T;
+    /**
+     * Write a lock file to disk, or error if there is already one there.
+     */
+    protected create(): void;
+    /**
+     * Remove the lock file from disk.
+     */
+    protected remove(): void;
+    protected addSignalHandlers(): void;
+    protected removeSignalHandlers(): void;
+    /**
+     * This handle needs to be defined as a property rather than a method
+     * so that it can be passed around as a bound function.
+     */
+    protected signalHandler: () => void;
+    /**
+     * This function wraps `process.exit()` which makes it easier to manage in unit tests,
+     * since it is not possible to mock out `process.exit()` when it is called from signal handlers.
+     */
+    protected exit(code: number): void;
+}

package/ngcc/src/execution/lock_file.js

@@ -0,0 +1,129 @@
+(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/execution/lock_file", ["require", "exports", "process"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var process = require("process");
+    /**
+     * The LockFile is used to prevent more than one instance of ngcc executing at the same time.
+     *
+     * When ngcc starts executing, it creates a file in the `compiler-cli/ngcc` folder. If it finds one
+     * is already there then it fails with a suitable error message.
+     * When ngcc completes executing, it removes the file so that future ngcc executions can start.
+     */
+    var LockFile = /** @class */ (function () {
+        function LockFile(fs) {
+            var _this = this;
+            this.fs = fs;
+            this.lockFilePath = this.fs.resolve(require.resolve('@angular/compiler-cli/ngcc'), '../__ngcc_lock_file__');
+            /**
+             * This handle needs to be defined as a property rather than a method
+             * so that it can be passed around as a bound function.
+             */
+            this.signalHandler = function () {
+                _this.remove();
+                _this.exit(1);
+            };
+        }
+        /**
+         * Run a function guarded by the lock file.
+         *
+         * Note that T can be a Promise. If so, we run the `remove()` call in the promise's `finally`
+         * handler. Otherwise we run the `remove()` call in the `try...finally` block.
+         *
+         * @param fn The function to run.
+         */
+        LockFile.prototype.lock = function (fn) {
+            var _this = this;
+            var isAsync = false;
+            this.create();
+            try {
+                var result = fn();
+                if (result instanceof Promise) {
+                    isAsync = true;
+                    // The cast is necessary because TS cannot deduce that T is now a promise here.
+                    return result.finally(function () { return _this.remove(); });
+                }
+                else {
+                    return result;
+                }
+            }
+            finally {
+                if (!isAsync) {
+                    this.remove();
+                }
+            }
+        };
+        /**
+         * Write a lock file to disk, or error if there is already one there.
+         */
+        LockFile.prototype.create = function () {
+            try {
+                this.addSignalHandlers();
+                // To avoid race conditions, we check for existence of the lockfile
+                // by actually trying to create it exclusively
+                this.fs.writeFile(this.lockFilePath, process.pid.toString(), /* exclusive */ true);
+            }
+            catch (e) {
+                this.removeSignalHandlers();
+                if (e.code !== 'EEXIST') {
+                    throw e;
+                }
+                // The lockfile already exists so raise a helpful error.
+                // It is feasible that the lockfile was removed between the previous check for existence
+                // and this file-read. If so then we still error but as gracefully as possible.
+                var pid = void 0;
+                try {
+                    pid = this.fs.readFile(this.lockFilePath);
+                }
+                catch (_a) {
+                    pid = '{unknown}';
+                }
+                throw new Error("ngcc is already running at process with id " + pid + ".\n" +
+                    "If you are running multiple builds in parallel then you should pre-process your node_modules via the command line ngcc tool before starting the builds;\n" +
+                    "See https://v9.angular.io/guide/ivy#speeding-up-ngcc-compilation.\n" +
+                    ("(If you are sure no ngcc process is running then you should delete the lockfile at " + this.lockFilePath + ".)"));
+            }
+        };
+        /**
+         * Remove the lock file from disk.
+         */
+        LockFile.prototype.remove = function () {
+            this.removeSignalHandlers();
+            if (this.fs.exists(this.lockFilePath)) {
+                this.fs.removeFile(this.lockFilePath);
+            }
+        };
+        LockFile.prototype.addSignalHandlers = function () {
+            process.once('SIGINT', this.signalHandler);
+            process.once('SIGHUP', this.signalHandler);
+        };
+        LockFile.prototype.removeSignalHandlers = function () {
+            process.removeListener('SIGINT', this.signalHandler);
+            process.removeListener('SIGHUP', this.signalHandler);
+        };
+        /**
+         * This function wraps `process.exit()` which makes it easier to manage in unit tests,
+         * since it is not possible to mock out `process.exit()` when it is called from signal handlers.
+         */
+        LockFile.prototype.exit = function (code) {
+            process.exit(code);
+        };
+        return LockFile;
+    }());
+    exports.LockFile = LockFile;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lock_file.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/execution/lock_file.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA;;;;;;OAMG;IACH,iCAAmC;IAGnC;;;;;;OAMG;IACH;QAIE,kBAAoB,EAAc;YAAlC,iBAAsC;YAAlB,OAAE,GAAF,EAAE,CAAY;YAHlC,iBAAY,GACR,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,4BAA4B,CAAC,EAAE,uBAAuB,CAAC,CAAC;YAoF5F;;;eAGG;YACO,kBAAa,GACnB;gBACE,KAAI,CAAC,MAAM,EAAE,CAAC;gBACd,KAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,CAAC,CAAA;QA1FgC,CAAC;QAEtC;;;;;;;WAOG;QACH,uBAAI,GAAJ,UAAQ,EAAW;YAAnB,iBAiBC;YAhBC,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,IAAI;gBACF,IAAM,MAAM,GAAG,EAAE,EAAE,CAAC;gBACpB,IAAI,MAAM,YAAY,OAAO,EAAE;oBAC7B,OAAO,GAAG,IAAI,CAAC;oBACf,+EAA+E;oBAC/E,OAAO,MAAM,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,MAAM,EAAE,EAAb,CAAa,CAAiB,CAAC;iBAC5D;qBAAM;oBACL,OAAO,MAAM,CAAC;iBACf;aACF;oBAAS;gBACR,IAAI,CAAC,OAAO,EAAE;oBACZ,IAAI,CAAC,MAAM,EAAE,CAAC;iBACf;aACF;QACH,CAAC;QAED;;WAEG;QACO,yBAAM,GAAhB;YACE,IAAI;gBACF,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACzB,mEAAmE;gBACnE,8CAA8C;gBAC9C,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;aACpF;YAAC,OAAO,CAAC,EAAE;gBACV,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC5B,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE;oBACvB,MAAM,CAAC,CAAC;iBACT;gBAED,wDAAwD;gBACxD,wFAAwF;gBACxF,+EAA+E;gBAC/E,IAAI,GAAG,SAAQ,CAAC;gBAChB,IAAI;oBACF,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;iBAC3C;gBAAC,WAAM;oBACN,GAAG,GAAG,WAAW,CAAC;iBACnB;gBAED,MAAM,IAAI,KAAK,CACX,gDAA8C,GAAG,QAAK;oBACtD,2JAA2J;oBAC3J,qEAAqE;qBACrE,wFAAsF,IAAI,CAAC,YAAY,OAAI,CAAA,CAAC,CAAC;aAClH;QACH,CAAC;QAED;;WAEG;QACO,yBAAM,GAAhB;YACE,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;gBACrC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;aACvC;QACH,CAAC;QAES,oCAAiB,GAA3B;YACE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YAC3C,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC7C,CAAC;QAES,uCAAoB,GAA9B;YACE,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YACrD,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACvD,CAAC;QAYD;;;WAGG;QACO,uBAAI,GAAd,UAAe,IAAY;YACzB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;QACH,eAAC;IAAD,CAAC,AAvGD,IAuGC;IAvGY,4BAAQ","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 process from 'process';\nimport {FileSystem} from '../../../src/ngtsc/file_system';\n\n/**\n * The LockFile is used to prevent more than one instance of ngcc executing at the same time.\n *\n * When ngcc starts executing, it creates a file in the `compiler-cli/ngcc` folder. If it finds one\n * is already there then it fails with a suitable error message.\n * When ngcc completes executing, it removes the file so that future ngcc executions can start.\n */\nexport class LockFile {\n  lockFilePath =\n      this.fs.resolve(require.resolve('@angular/compiler-cli/ngcc'), '../__ngcc_lock_file__');\n\n  constructor(private fs: FileSystem) {}\n\n  /**\n   * Run a function guarded by the lock file.\n   *\n   * Note that T can be a Promise. If so, we run the `remove()` call in the promise's `finally`\n   * handler. Otherwise we run the `remove()` call in the `try...finally` block.\n   *\n   * @param fn The function to run.\n   */\n  lock<T>(fn: () => T): T {\n    let isAsync = false;\n    this.create();\n    try {\n      const result = fn();\n      if (result instanceof Promise) {\n        isAsync = true;\n        // The cast is necessary because TS cannot deduce that T is now a promise here.\n        return result.finally(() => this.remove()) as unknown as T;\n      } else {\n        return result;\n      }\n    } finally {\n      if (!isAsync) {\n        this.remove();\n      }\n    }\n  }\n\n  /**\n   * Write a lock file to disk, or error if there is already one there.\n   */\n  protected create() {\n    try {\n      this.addSignalHandlers();\n      // To avoid race conditions, we check for existence of the lockfile\n      // by actually trying to create it exclusively\n      this.fs.writeFile(this.lockFilePath, process.pid.toString(), /* exclusive */ true);\n    } catch (e) {\n      this.removeSignalHandlers();\n      if (e.code !== 'EEXIST') {\n        throw e;\n      }\n\n      // The lockfile already exists so raise a helpful error.\n      // It is feasible that the lockfile was removed between the previous check for existence\n      // and this file-read. If so then we still error but as gracefully as possible.\n      let pid: string;\n      try {\n        pid = this.fs.readFile(this.lockFilePath);\n      } catch {\n        pid = '{unknown}';\n      }\n\n      throw new Error(\n          `ngcc is already running at process with id ${pid}.\\n` +\n          `If you are running multiple builds in parallel then you should pre-process your node_modules via the command line ngcc tool before starting the builds;\\n` +\n          `See https://v9.angular.io/guide/ivy#speeding-up-ngcc-compilation.\\n` +\n          `(If you are sure no ngcc process is running then you should delete the lockfile at ${this.lockFilePath}.)`);\n    }\n  }\n\n  /**\n   * Remove the lock file from disk.\n   */\n  protected remove() {\n    this.removeSignalHandlers();\n    if (this.fs.exists(this.lockFilePath)) {\n      this.fs.removeFile(this.lockFilePath);\n    }\n  }\n\n  protected addSignalHandlers() {\n    process.once('SIGINT', this.signalHandler);\n    process.once('SIGHUP', this.signalHandler);\n  }\n\n  protected removeSignalHandlers() {\n    process.removeListener('SIGINT', this.signalHandler);\n    process.removeListener('SIGHUP', this.signalHandler);\n  }\n\n  /**\n   * This handle needs to be defined as a property rather than a method\n   * so that it can be passed around as a bound function.\n   */\n  protected signalHandler =\n      () => {\n        this.remove();\n        this.exit(1);\n      }\n\n  /**\n   * This function wraps `process.exit()` which makes it easier to manage in unit tests,\n   * since it is not possible to mock out `process.exit()` when it is called from signal handlers.\n   */\n  protected exit(code: number): void {\n    process.exit(code);\n  }\n}\n"]}

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

@@ -9,13 +9,15 @@
 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 all tasks serially and completes synchronously.
  */
 export declare class SingleProcessExecutor implements Executor {
     private logger;
     private pkgJsonUpdater;
-    constructor(logger: Logger, pkgJsonUpdater: PackageJsonUpdater);
+    private lockFile;
+    constructor(logger: Logger, pkgJsonUpdater: PackageJsonUpdater, lockFile: LockFile);
     execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): void;
 }
 /**

package/ngcc/src/execution/single_process_executor.js

@@ -22,25 +22,28 @@
      * An `Executor` that processes all tasks serially and completes synchronously.
      */
     var SingleProcessExecutor = /** @class */ (function () {
-        function SingleProcessExecutor(logger, pkgJsonUpdater) {
+        function SingleProcessExecutor(logger, pkgJsonUpdater, lockFile) {
             this.logger = logger;
             this.pkgJsonUpdater = pkgJsonUpdater;
+            this.lockFile = lockFile;
         }
         SingleProcessExecutor.prototype.execute = function (analyzeEntryPoints, createCompileFn) {
             var _this = this;
-            this.logger.debug("Running ngcc on " + this.constructor.name + ".");
-            var taskQueue = analyzeEntryPoints();
-            var compile = createCompileFn(function (task, outcome) { return utils_1.onTaskCompleted(_this.pkgJsonUpdater, task, outcome); });
-            // Process all tasks.
-            this.logger.debug('Processing tasks...');
-            var startTime = Date.now();
-            while (!taskQueue.allTasksCompleted) {
-                var task = taskQueue.getNextTask();
-                compile(task);
-                taskQueue.markTaskCompleted(task);
-            }
-            var duration = Math.round((Date.now() - startTime) / 1000);
-            this.logger.debug("Processed tasks in " + duration + "s.");
+            this.lockFile.lock(function () {
+                _this.logger.debug("Running ngcc on " + _this.constructor.name + ".");
+                var taskQueue = analyzeEntryPoints();
+                var compile = createCompileFn(function (task, outcome) { return utils_1.onTaskCompleted(_this.pkgJsonUpdater, task, outcome); });
+                // Process all tasks.
+                _this.logger.debug('Processing tasks...');
+                var startTime = Date.now();
+                while (!taskQueue.allTasksCompleted) {
+                    var task = taskQueue.getNextTask();
+                    compile(task);
+                    taskQueue.markTaskCompleted(task);
+                }
+                var duration = Math.round((Date.now() - startTime) / 1000);
+                _this.logger.debug("Processed tasks in " + duration + "s.");
+            });
         };
         return SingleProcessExecutor;
     }());
@@ -68,4 +71,4 @@
     }(SingleProcessExecutor));
     exports.AsyncSingleProcessExecutor = AsyncSingleProcessExecutor;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xlX3Byb2Nlc3NfZXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9zcmMvZXhlY3V0aW9uL3NpbmdsZV9wcm9jZXNzX2V4ZWN1dG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7OztJQU9ILHdFQUF3QztJQUd4Qzs7T0FFRztJQUNIO1FBQ0UsK0JBQ1ksTUFBYyxFQUFVLGNBQWtDLEVBQzFELFFBQWtCO1lBRGxCLFdBQU0sR0FBTixNQUFNLENBQVE7WUFBVSxtQkFBYyxHQUFkLGNBQWMsQ0FBb0I7WUFDMUQsYUFBUSxHQUFSLFFBQVEsQ0FBVTtRQUFHLENBQUM7UUFFbEMsdUNBQU8sR0FBUCxVQUFRLGtCQUF3QyxFQUFFLGVBQWdDO1lBQWxGLGlCQXFCQztZQXBCQyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQztnQkFDakIsS0FBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMscUJBQW1CLEtBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxNQUFHLENBQUMsQ0FBQztnQkFFL0QsSUFBTSxTQUFTLEdBQUcsa0JBQWtCLEVBQUUsQ0FBQztnQkFDdkMsSUFBTSxPQUFPLEdBQ1QsZUFBZSxDQUFDLFVBQUMsSUFBSSxFQUFFLE9BQU8sSUFBSyxPQUFBLHVCQUFlLENBQUMsS0FBSSxDQUFDLGNBQWMsRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLEVBQW5ELENBQW1ELENBQUMsQ0FBQztnQkFFNUYscUJBQXFCO2dCQUNyQixLQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO2dCQUN6QyxJQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7Z0JBRTdCLE9BQU8sQ0FBQyxTQUFTLENBQUMsaUJBQWlCLEVBQUU7b0JBQ25DLElBQU0sSUFBSSxHQUFHLFNBQVMsQ0FBQyxXQUFXLEVBQUksQ0FBQztvQkFDdkMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO29CQUNkLFNBQVMsQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsQ0FBQztpQkFDbkM7Z0JBRUQsSUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxTQUFTLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztnQkFDN0QsS0FBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsd0JBQXNCLFFBQVEsT0FBSSxDQUFDLENBQUM7WUFDeEQsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBQ0gsNEJBQUM7SUFBRCxDQUFDLEFBM0JELElBMkJDO0lBM0JZLHNEQUFxQjtJQTZCbEM7O09BRUc7SUFDSDtRQUFnRCxzREFBcUI7UUFBckU7O1FBSUEsQ0FBQztRQUhPLDRDQUFPLEdBQWI7WUFBYyxjQUF3QztpQkFBeEMsVUFBd0MsRUFBeEMscUJBQXdDLEVBQXhDLElBQXdDO2dCQUF4Qyx5QkFBd0M7Ozs7b0JBQ3BELHNCQUFPLGlCQUFNLE9BQU8sOEJBQUksSUFBSSxJQUFFOzs7U0FDL0I7UUFDSCxpQ0FBQztJQUFELENBQUMsQUFKRCxDQUFnRCxxQkFBcUIsR0FJcEU7SUFKWSxnRUFBMEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7TG9nZ2VyfSBmcm9tICcuLi9sb2dnaW5nL2xvZ2dlcic7XG5pbXBvcnQge1BhY2thZ2VKc29uVXBkYXRlcn0gZnJvbSAnLi4vd3JpdGluZy9wYWNrYWdlX2pzb25fdXBkYXRlcic7XG5cbmltcG9ydCB7QW5hbHl6ZUVudHJ5UG9pbnRzRm4sIENyZWF0ZUNvbXBpbGVGbiwgRXhlY3V0b3J9IGZyb20gJy4vYXBpJztcbmltcG9ydCB7TG9ja0ZpbGV9IGZyb20gJy4vbG9ja19maWxlJztcbmltcG9ydCB7b25UYXNrQ29tcGxldGVkfSBmcm9tICcuL3V0aWxzJztcblxuXG4vKipcbiAqIEFuIGBFeGVjdXRvcmAgdGhhdCBwcm9jZXNzZXMgYWxsIHRhc2tzIHNlcmlhbGx5IGFuZCBjb21wbGV0ZXMgc3luY2hyb25vdXNseS5cbiAqL1xuZXhwb3J0IGNsYXNzIFNpbmdsZVByb2Nlc3NFeGVjdXRvciBpbXBsZW1lbnRzIEV4ZWN1dG9yIHtcbiAgY29uc3RydWN0b3IoXG4gICAgICBwcml2YXRlIGxvZ2dlcjogTG9nZ2VyLCBwcml2YXRlIHBrZ0pzb25VcGRhdGVyOiBQYWNrYWdlSnNvblVwZGF0ZXIsXG4gICAgICBwcml2YXRlIGxvY2tGaWxlOiBMb2NrRmlsZSkge31cblxuICBleGVjdXRlKGFuYWx5emVFbnRyeVBvaW50czogQW5hbHl6ZUVudHJ5UG9pbnRzRm4sIGNyZWF0ZUNvbXBpbGVGbjogQ3JlYXRlQ29tcGlsZUZuKTogdm9pZCB7XG4gICAgdGhpcy5sb2NrRmlsZS5sb2NrKCgpID0+IHtcbiAgICAgIHRoaXMubG9nZ2VyLmRlYnVnKGBSdW5uaW5nIG5nY2Mgb24gJHt0aGlzLmNvbnN0cnVjdG9yLm5hbWV9LmApO1xuXG4gICAgICBjb25zdCB0YXNrUXVldWUgPSBhbmFseXplRW50cnlQb2ludHMoKTtcbiAgICAgIGNvbnN0IGNvbXBpbGUgPVxuICAgICAgICAgIGNyZWF0ZUNvbXBpbGVGbigodGFzaywgb3V0Y29tZSkgPT4gb25UYXNrQ29tcGxldGVkKHRoaXMucGtnSnNvblVwZGF0ZXIsIHRhc2ssIG91dGNvbWUpKTtcblxuICAgICAgLy8gUHJvY2VzcyBhbGwgdGFza3MuXG4gICAgICB0aGlzLmxvZ2dlci5kZWJ1ZygnUHJvY2Vzc2luZyB0YXNrcy4uLicpO1xuICAgICAgY29uc3Qgc3RhcnRUaW1lID0gRGF0ZS5ub3coKTtcblxuICAgICAgd2hpbGUgKCF0YXNrUXVldWUuYWxsVGFza3NDb21wbGV0ZWQpIHtcbiAgICAgICAgY29uc3QgdGFzayA9IHRhc2tRdWV1ZS5nZXROZXh0VGFzaygpICE7XG4gICAgICAgIGNvbXBpbGUodGFzayk7XG4gICAgICAgIHRhc2tRdWV1ZS5tYXJrVGFza0NvbXBsZXRlZCh0YXNrKTtcbiAgICAgIH1cblxuICAgICAgY29uc3QgZHVyYXRpb24gPSBNYXRoLnJvdW5kKChEYXRlLm5vdygpIC0gc3RhcnRUaW1lKSAvIDEwMDApO1xuICAgICAgdGhpcy5sb2dnZXIuZGVidWcoYFByb2Nlc3NlZCB0YXNrcyBpbiAke2R1cmF0aW9ufXMuYCk7XG4gICAgfSk7XG4gIH1cbn1cblxuLyoqXG4gKiBBbiBgRXhlY3V0b3JgIHRoYXQgcHJvY2Vzc2VzIGFsbCB0YXNrcyBzZXJpYWxseSwgYnV0IHN0aWxsIGNvbXBsZXRlcyBhc3luY2hyb25vdXNseS5cbiAqL1xuZXhwb3J0IGNsYXNzIEFzeW5jU2luZ2xlUHJvY2Vzc0V4ZWN1dG9yIGV4dGVuZHMgU2luZ2xlUHJvY2Vzc0V4ZWN1dG9yIHtcbiAgYXN5bmMgZXhlY3V0ZSguLi5hcmdzOiBQYXJhbWV0ZXJzPEV4ZWN1dG9yWydleGVjdXRlJ10+KTogUHJvbWlzZTx2b2lkPiB7XG4gICAgcmV0dXJuIHN1cGVyLmV4ZWN1dGUoLi4uYXJncyk7XG4gIH1cbn1cbiJdfQ==

package/ngcc/src/execution/task_selection/base_task_queue.d.ts

@@ -12,7 +12,7 @@ import { PartiallyOrderedTasks, Task, TaskQueue } from '../api';
  */
 export declare abstract class BaseTaskQueue implements TaskQueue {
     protected tasks: PartiallyOrderedTasks;
-    readonly allTasksCompleted: boolean;
+    get allTasksCompleted(): boolean;
     protected inProgressTasks: Set<Task>;
     constructor(tasks: PartiallyOrderedTasks);
     abstract getNextTask(): Task | null;

package/ngcc/src/host/commonjs_host.d.ts

@@ -10,18 +10,18 @@ import * as ts from 'typescript';
 import { Declaration, Import } from '../../../src/ngtsc/reflection';
 import { Logger } from '../logging/logger';
 import { BundleProgram } from '../packages/bundle_program';
+import { FactoryMap } from '../utils';
 import { Esm5ReflectionHost } from './esm5_host';
 import { NgccClassSymbol } from './ngcc_host';
 export declare class CommonJsReflectionHost extends Esm5ReflectionHost {
+    protected commonJsExports: FactoryMap<ts.SourceFile, Map<string, Declaration<ts.Declaration>> | null>;
+    protected topLevelHelperCalls: FactoryMap<string, FactoryMap<ts.SourceFile, ts.CallExpression[]>>;
     protected program: ts.Program;
     protected compilerHost: ts.CompilerHost;
-    protected commonJsExports: Map<ts.SourceFile, Map<string, Declaration<ts.Declaration>> | null>;
-    protected topLevelHelperCalls: Map<string, Map<ts.SourceFile, ts.CallExpression[]>>;
-    constructor(logger: Logger, isCore: boolean, program: ts.Program, compilerHost: ts.CompilerHost, dts?: BundleProgram | null);
+    constructor(logger: Logger, isCore: boolean, src: BundleProgram, dts?: BundleProgram | null);
     getImportOfIdentifier(id: ts.Identifier): Import | null;
     getDeclarationOfIdentifier(id: ts.Identifier): Declaration | null;
     getExportsOfModule(module: ts.Node): Map<string, Declaration> | null;
-    getCommonJsExports(sourceFile: ts.SourceFile): Map<string, Declaration> | null;
     /**
      * Search statements related to the given class for calls to the specified helper.
      *
@@ -31,7 +31,8 @@ export declare class CommonJsReflectionHost extends Esm5ReflectionHost {
      * no helpers are found.
      *
      * @param classSymbol the class whose helper calls we are interested in.
-     * @param helperName the name of the helper (e.g. `__decorate`) whose calls we are interested in.
+     * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested
+     * in.
      * @returns an array of nodes of calls to the helper with the given name.
      */
     protected getHelperCallsForClass(classSymbol: NgccClassSymbol, helperNames: string[]): ts.CallExpression[];
@@ -54,16 +55,3 @@ export declare class CommonJsReflectionHost extends Esm5ReflectionHost {
     private getCommonJsImportedDeclaration;
     private resolveModuleName;
 }
-declare type CommonJsExportStatement = ts.ExpressionStatement & {
-    expression: ts.BinaryExpression & {
-        left: ts.PropertyAccessExpression & {
-            expression: ts.Identifier;
-        };
-    };
-};
-export declare function isCommonJsExportStatement(s: ts.Statement): s is CommonJsExportStatement;
-export declare type RequireCall = ts.CallExpression & {
-    arguments: [ts.StringLiteral];
-};
-export declare function isRequireCall(node: ts.Node): node is RequireCall;
-export {};