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

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/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":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as 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,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

package/ngcc/src/host/commonjs_host.js

@@ -143,6 +143,7 @@
                     name: name,
                     declaration: {
                         node: null,
+                        known: null,
                         expression: exportExpression,
                         viaModule: null,
                     },
@@ -170,10 +171,10 @@
             var reexports = [];
             importedExports.forEach(function (decl, name) {
                 if (decl.node !== null) {
-                    reexports.push({ name: name, declaration: { node: decl.node, viaModule: viaModule } });
+                    reexports.push({ name: name, declaration: { node: decl.node, known: null, viaModule: viaModule } });
                 }
                 else {
-                    reexports.push({ name: name, declaration: { node: null, expression: decl.expression, viaModule: viaModule } });
+                    reexports.push({ name: name, declaration: { node: null, known: null, expression: decl.expression, viaModule: viaModule } });
                 }
             });
             return reexports;
@@ -194,7 +195,7 @@
                 return null;
             }
             var viaModule = !importInfo.from.startsWith('.') ? importInfo.from : null;
-            return { node: importedFile, viaModule: viaModule };
+            return { node: importedFile, known: null, viaModule: viaModule };
         };
         CommonJsReflectionHost.prototype.resolveModuleName = function (moduleName, containingFile) {
             if (this.compilerHost.resolveModuleNames) {
@@ -211,4 +212,4 @@
     }(esm5_host_1.Esm5ReflectionHost));
     exports.CommonJsReflectionHost = CommonJsReflectionHost;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/commonjs_host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\nimport {absoluteFrom} from '../../../src/ngtsc/file_system';\nimport {Declaration, Import} from '../../../src/ngtsc/reflection';\nimport {Logger} from '../logging/logger';\nimport {BundleProgram} from '../packages/bundle_program';\nimport {FactoryMap, isDefined, stripExtension} from '../utils';\n\nimport {ExportDeclaration, ExportStatement, ReexportStatement, RequireCall, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall} from './commonjs_umd_utils';\nimport {Esm5ReflectionHost} from './esm5_host';\nimport {NgccClassSymbol} from './ngcc_host';\n\nexport class CommonJsReflectionHost extends Esm5ReflectionHost {\n  protected commonJsExports = new FactoryMap<ts.SourceFile, Map<string, Declaration>|null>(\n      sf => this.computeExportsOfCommonJsModule(sf));\n  protected topLevelHelperCalls =\n      new FactoryMap<string, FactoryMap<ts.SourceFile, ts.CallExpression[]>>(\n          helperName => new FactoryMap<ts.SourceFile, ts.CallExpression[]>(\n              sf => sf.statements.map(stmt => this.getHelperCall(stmt, [helperName]))\n                        .filter(isDefined)));\n  protected program: ts.Program;\n  protected compilerHost: ts.CompilerHost;\n  constructor(logger: Logger, isCore: boolean, src: BundleProgram, dts: BundleProgram|null = null) {\n    super(logger, isCore, src, dts);\n    this.program = src.program;\n    this.compilerHost = src.host;\n  }\n\n  getImportOfIdentifier(id: ts.Identifier): Import|null {\n    const superImport = super.getImportOfIdentifier(id);\n    if (superImport !== null) {\n      return superImport;\n    }\n\n    const requireCall = this.findCommonJsImport(id);\n    if (requireCall === null) {\n      return null;\n    }\n    return {from: requireCall.arguments[0].text, name: id.text};\n  }\n\n  getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {\n    return this.getCommonJsImportedDeclaration(id) || super.getDeclarationOfIdentifier(id);\n  }\n\n  getExportsOfModule(module: ts.Node): Map<string, Declaration>|null {\n    return super.getExportsOfModule(module) || this.commonJsExports.get(module.getSourceFile());\n  }\n\n  /**\n   * Search statements related to the given class for calls to the specified helper.\n   *\n   * In CommonJS these helper calls can be outside the class's IIFE at the top level of the\n   * source file. Searching the top level statements for helpers can be expensive, so we\n   * try to get helpers from the IIFE first and only fall back on searching the top level if\n   * no helpers are found.\n   *\n   * @param classSymbol the class whose helper calls we are interested in.\n   * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested\n   * in.\n   * @returns an array of nodes of calls to the helper with the given name.\n   */\n  protected getHelperCallsForClass(classSymbol: NgccClassSymbol, helperNames: string[]):\n      ts.CallExpression[] {\n    const esm5HelperCalls = super.getHelperCallsForClass(classSymbol, helperNames);\n    if (esm5HelperCalls.length > 0) {\n      return esm5HelperCalls;\n    } else {\n      const sourceFile = classSymbol.declaration.valueDeclaration.getSourceFile();\n      return this.getTopLevelHelperCalls(sourceFile, helperNames);\n    }\n  }\n\n  /**\n   * Find all the helper calls at the top level of a source file.\n   *\n   * We cache the helper calls per source file so that we don't have to keep parsing the code for\n   * each class in a file.\n   *\n   * @param sourceFile the source who may contain helper calls.\n   * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested\n   * in.\n   * @returns an array of nodes of calls to the helper with the given name.\n   */\n  private getTopLevelHelperCalls(sourceFile: ts.SourceFile, helperNames: string[]):\n      ts.CallExpression[] {\n    const calls: ts.CallExpression[] = [];\n    helperNames.forEach(helperName => {\n      const helperCallsMap = this.topLevelHelperCalls.get(helperName);\n      calls.push(...helperCallsMap.get(sourceFile));\n    });\n    return calls;\n  }\n\n  private computeExportsOfCommonJsModule(sourceFile: ts.SourceFile): Map<string, Declaration> {\n    const moduleMap = new Map<string, Declaration>();\n    for (const statement of this.getModuleStatements(sourceFile)) {\n      if (isExportStatement(statement)) {\n        const exportDeclaration = this.extractCommonJsExportDeclaration(statement);\n        moduleMap.set(exportDeclaration.name, exportDeclaration.declaration);\n      } else if (isReexportStatement(statement)) {\n        const reexports = this.extractCommonJsReexports(statement, sourceFile);\n        for (const reexport of reexports) {\n          moduleMap.set(reexport.name, reexport.declaration);\n        }\n      }\n    }\n    return moduleMap;\n  }\n\n  private extractCommonJsExportDeclaration(statement: ExportStatement): ExportDeclaration {\n    const exportExpression = statement.expression.right;\n    const declaration = this.getDeclarationOfExpression(exportExpression);\n    const name = statement.expression.left.name.text;\n    if (declaration !== null) {\n      return {name, declaration};\n    } else {\n      return {\n        name,\n        declaration: {\n          node: null,\n          expression: exportExpression,\n          viaModule: null,\n        },\n      };\n    }\n  }\n\n  private extractCommonJsReexports(statement: ReexportStatement, containingFile: ts.SourceFile):\n      ExportDeclaration[] {\n    const reexportArg = statement.expression.arguments[0];\n\n    const requireCall = isRequireCall(reexportArg) ?\n        reexportArg :\n        ts.isIdentifier(reexportArg) ? findRequireCallReference(reexportArg, this.checker) : null;\n    if (requireCall === null) {\n      return [];\n    }\n\n    const importPath = requireCall.arguments[0].text;\n    const importedFile = this.resolveModuleName(importPath, containingFile);\n    if (importedFile === undefined) {\n      return [];\n    }\n\n    const importedExports = this.getExportsOfModule(importedFile);\n    if (importedExports === null) {\n      return [];\n    }\n\n    const viaModule = stripExtension(importedFile.fileName);\n    const reexports: ExportDeclaration[] = [];\n    importedExports.forEach((decl, name) => {\n      if (decl.node !== null) {\n        reexports.push({name, declaration: {node: decl.node, viaModule}});\n      } else {\n        reexports.push({name, declaration: {node: null, expression: decl.expression, viaModule}});\n      }\n    });\n    return reexports;\n  }\n\n  private findCommonJsImport(id: ts.Identifier): RequireCall|null {\n    // Is `id` a namespaced property access, e.g. `Directive` in `core.Directive`?\n    // If so capture the symbol of the namespace, e.g. `core`.\n    const nsIdentifier = findNamespaceOfIdentifier(id);\n    return nsIdentifier && findRequireCallReference(nsIdentifier, this.checker);\n  }\n\n  private getCommonJsImportedDeclaration(id: ts.Identifier): Declaration|null {\n    const importInfo = this.getImportOfIdentifier(id);\n    if (importInfo === null) {\n      return null;\n    }\n\n    const importedFile = this.resolveModuleName(importInfo.from, id.getSourceFile());\n    if (importedFile === undefined) {\n      return null;\n    }\n\n    const viaModule = !importInfo.from.startsWith('.') ? importInfo.from : null;\n    return {node: importedFile, viaModule};\n  }\n\n  private resolveModuleName(moduleName: string, containingFile: ts.SourceFile): ts.SourceFile\n      |undefined {\n    if (this.compilerHost.resolveModuleNames) {\n      const moduleInfo = this.compilerHost.resolveModuleNames(\n          [moduleName], containingFile.fileName, undefined, undefined,\n          this.program.getCompilerOptions())[0];\n      return moduleInfo && this.program.getSourceFile(absoluteFrom(moduleInfo.resolvedFileName));\n    } else {\n      const moduleInfo = ts.resolveModuleName(\n          moduleName, containingFile.fileName, this.program.getCompilerOptions(),\n          this.compilerHost);\n      return moduleInfo.resolvedModule &&\n          this.program.getSourceFile(absoluteFrom(moduleInfo.resolvedModule.resolvedFileName));\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/commonjs_host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\nimport {absoluteFrom} from '../../../src/ngtsc/file_system';\nimport {Declaration, Import} from '../../../src/ngtsc/reflection';\nimport {Logger} from '../logging/logger';\nimport {BundleProgram} from '../packages/bundle_program';\nimport {FactoryMap, isDefined, stripExtension} from '../utils';\n\nimport {ExportDeclaration, ExportStatement, ReexportStatement, RequireCall, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall} from './commonjs_umd_utils';\nimport {Esm5ReflectionHost} from './esm5_host';\nimport {NgccClassSymbol} from './ngcc_host';\n\nexport class CommonJsReflectionHost extends Esm5ReflectionHost {\n  protected commonJsExports = new FactoryMap<ts.SourceFile, Map<string, Declaration>|null>(\n      sf => this.computeExportsOfCommonJsModule(sf));\n  protected topLevelHelperCalls =\n      new FactoryMap<string, FactoryMap<ts.SourceFile, ts.CallExpression[]>>(\n          helperName => new FactoryMap<ts.SourceFile, ts.CallExpression[]>(\n              sf => sf.statements.map(stmt => this.getHelperCall(stmt, [helperName]))\n                        .filter(isDefined)));\n  protected program: ts.Program;\n  protected compilerHost: ts.CompilerHost;\n  constructor(logger: Logger, isCore: boolean, src: BundleProgram, dts: BundleProgram|null = null) {\n    super(logger, isCore, src, dts);\n    this.program = src.program;\n    this.compilerHost = src.host;\n  }\n\n  getImportOfIdentifier(id: ts.Identifier): Import|null {\n    const superImport = super.getImportOfIdentifier(id);\n    if (superImport !== null) {\n      return superImport;\n    }\n\n    const requireCall = this.findCommonJsImport(id);\n    if (requireCall === null) {\n      return null;\n    }\n    return {from: requireCall.arguments[0].text, name: id.text};\n  }\n\n  getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {\n    return this.getCommonJsImportedDeclaration(id) || super.getDeclarationOfIdentifier(id);\n  }\n\n  getExportsOfModule(module: ts.Node): Map<string, Declaration>|null {\n    return super.getExportsOfModule(module) || this.commonJsExports.get(module.getSourceFile());\n  }\n\n  /**\n   * Search statements related to the given class for calls to the specified helper.\n   *\n   * In CommonJS these helper calls can be outside the class's IIFE at the top level of the\n   * source file. Searching the top level statements for helpers can be expensive, so we\n   * try to get helpers from the IIFE first and only fall back on searching the top level if\n   * no helpers are found.\n   *\n   * @param classSymbol the class whose helper calls we are interested in.\n   * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested\n   * in.\n   * @returns an array of nodes of calls to the helper with the given name.\n   */\n  protected getHelperCallsForClass(classSymbol: NgccClassSymbol, helperNames: string[]):\n      ts.CallExpression[] {\n    const esm5HelperCalls = super.getHelperCallsForClass(classSymbol, helperNames);\n    if (esm5HelperCalls.length > 0) {\n      return esm5HelperCalls;\n    } else {\n      const sourceFile = classSymbol.declaration.valueDeclaration.getSourceFile();\n      return this.getTopLevelHelperCalls(sourceFile, helperNames);\n    }\n  }\n\n  /**\n   * Find all the helper calls at the top level of a source file.\n   *\n   * We cache the helper calls per source file so that we don't have to keep parsing the code for\n   * each class in a file.\n   *\n   * @param sourceFile the source who may contain helper calls.\n   * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested\n   * in.\n   * @returns an array of nodes of calls to the helper with the given name.\n   */\n  private getTopLevelHelperCalls(sourceFile: ts.SourceFile, helperNames: string[]):\n      ts.CallExpression[] {\n    const calls: ts.CallExpression[] = [];\n    helperNames.forEach(helperName => {\n      const helperCallsMap = this.topLevelHelperCalls.get(helperName);\n      calls.push(...helperCallsMap.get(sourceFile));\n    });\n    return calls;\n  }\n\n  private computeExportsOfCommonJsModule(sourceFile: ts.SourceFile): Map<string, Declaration> {\n    const moduleMap = new Map<string, Declaration>();\n    for (const statement of this.getModuleStatements(sourceFile)) {\n      if (isExportStatement(statement)) {\n        const exportDeclaration = this.extractCommonJsExportDeclaration(statement);\n        moduleMap.set(exportDeclaration.name, exportDeclaration.declaration);\n      } else if (isReexportStatement(statement)) {\n        const reexports = this.extractCommonJsReexports(statement, sourceFile);\n        for (const reexport of reexports) {\n          moduleMap.set(reexport.name, reexport.declaration);\n        }\n      }\n    }\n    return moduleMap;\n  }\n\n  private extractCommonJsExportDeclaration(statement: ExportStatement): ExportDeclaration {\n    const exportExpression = statement.expression.right;\n    const declaration = this.getDeclarationOfExpression(exportExpression);\n    const name = statement.expression.left.name.text;\n    if (declaration !== null) {\n      return {name, declaration};\n    } else {\n      return {\n        name,\n        declaration: {\n          node: null,\n          known: null,\n          expression: exportExpression,\n          viaModule: null,\n        },\n      };\n    }\n  }\n\n  private extractCommonJsReexports(statement: ReexportStatement, containingFile: ts.SourceFile):\n      ExportDeclaration[] {\n    const reexportArg = statement.expression.arguments[0];\n\n    const requireCall = isRequireCall(reexportArg) ?\n        reexportArg :\n        ts.isIdentifier(reexportArg) ? findRequireCallReference(reexportArg, this.checker) : null;\n    if (requireCall === null) {\n      return [];\n    }\n\n    const importPath = requireCall.arguments[0].text;\n    const importedFile = this.resolveModuleName(importPath, containingFile);\n    if (importedFile === undefined) {\n      return [];\n    }\n\n    const importedExports = this.getExportsOfModule(importedFile);\n    if (importedExports === null) {\n      return [];\n    }\n\n    const viaModule = stripExtension(importedFile.fileName);\n    const reexports: ExportDeclaration[] = [];\n    importedExports.forEach((decl, name) => {\n      if (decl.node !== null) {\n        reexports.push({name, declaration: {node: decl.node, known: null, viaModule}});\n      } else {\n        reexports.push(\n            {name, declaration: {node: null, known: null, expression: decl.expression, viaModule}});\n      }\n    });\n    return reexports;\n  }\n\n  private findCommonJsImport(id: ts.Identifier): RequireCall|null {\n    // Is `id` a namespaced property access, e.g. `Directive` in `core.Directive`?\n    // If so capture the symbol of the namespace, e.g. `core`.\n    const nsIdentifier = findNamespaceOfIdentifier(id);\n    return nsIdentifier && findRequireCallReference(nsIdentifier, this.checker);\n  }\n\n  private getCommonJsImportedDeclaration(id: ts.Identifier): Declaration|null {\n    const importInfo = this.getImportOfIdentifier(id);\n    if (importInfo === null) {\n      return null;\n    }\n\n    const importedFile = this.resolveModuleName(importInfo.from, id.getSourceFile());\n    if (importedFile === undefined) {\n      return null;\n    }\n\n    const viaModule = !importInfo.from.startsWith('.') ? importInfo.from : null;\n    return {node: importedFile, known: null, viaModule};\n  }\n\n  private resolveModuleName(moduleName: string, containingFile: ts.SourceFile): ts.SourceFile\n      |undefined {\n    if (this.compilerHost.resolveModuleNames) {\n      const moduleInfo = this.compilerHost.resolveModuleNames(\n          [moduleName], containingFile.fileName, undefined, undefined,\n          this.program.getCompilerOptions())[0];\n      return moduleInfo && this.program.getSourceFile(absoluteFrom(moduleInfo.resolvedFileName));\n    } else {\n      const moduleInfo = ts.resolveModuleName(\n          moduleName, containingFile.fileName, this.program.getCompilerOptions(),\n          this.compilerHost);\n      return moduleInfo.resolvedModule &&\n          this.program.getSourceFile(absoluteFrom(moduleInfo.resolvedModule.resolvedFileName));\n    }\n  }\n}\n"]}

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

@@ -48,7 +48,7 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
     protected src: BundleProgram;
     protected dts: BundleProgram | null;
     /**
-     * A mapping from source declarations typings declarations, which are both publicly exported.
+     * A mapping from source declarations to typings declarations, which are both publicly exported.
      *
      * There should be one entry for every public export visible from the root file of the source
      * tree. Note that by definition the key and value declarations will not be in the same TS
@@ -606,6 +606,8 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      */
     protected parseForModuleWithProviders(name: string, node: ts.Node | null, implementation?: ts.Node | null, container?: ts.Declaration | null): ModuleWithProvidersFunction | null;
     protected getDeclarationOfExpression(expression: ts.Expression): Declaration | null;
+    /** Checks if the specified declaration resolves to the known JavaScript global `Object`. */
+    protected isJavaScriptObjectDeclaration(decl: Declaration): boolean;
 }
 export declare type ParamInfo = {
     decorators: Decorator[] | null;