@angular/compiler-cli 9.1.0 → 9.1.4

package/ngcc/src/execution/create_compile_function.js

@@ -0,0 +1,74 @@
+(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/create_compile_function", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngtsc/diagnostics", "@angular/compiler-cli/ngcc/src/packages/entry_point", "@angular/compiler-cli/ngcc/src/packages/entry_point_bundle", "@angular/compiler-cli/ngcc/src/writing/in_place_file_writer", "@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var ts = require("typescript");
+    var diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics");
+    var entry_point_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point");
+    var entry_point_bundle_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point_bundle");
+    var in_place_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/in_place_file_writer");
+    var new_entry_point_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer");
+    /**
+     * The function for creating the `compile()` function.
+     */
+    function getCreateCompileFn(fileSystem, logger, pkgJsonUpdater, createNewEntryPointFormats, errorOnFailedEntryPoint, enableI18nLegacyMessageIdFormat, tsConfig, pathMappings) {
+        return function (onTaskCompleted) {
+            var fileWriter = getFileWriter(fileSystem, logger, pkgJsonUpdater, createNewEntryPointFormats, errorOnFailedEntryPoint);
+            var Transformer = require('../packages/transformer').Transformer;
+            var transformer = new Transformer(fileSystem, logger, tsConfig);
+            return function (task) {
+                var entryPoint = task.entryPoint, formatProperty = task.formatProperty, formatPropertiesToMarkAsProcessed = task.formatPropertiesToMarkAsProcessed, processDts = task.processDts;
+                var isCore = entryPoint.name === '@angular/core'; // Are we compiling the Angular core?
+                var packageJson = entryPoint.packageJson;
+                var formatPath = packageJson[formatProperty];
+                var format = entry_point_1.getEntryPointFormat(fileSystem, entryPoint, formatProperty);
+                // All properties listed in `propertiesToProcess` are guaranteed to point to a format-path
+                // (i.e. they are defined in `entryPoint.packageJson`). Furthermore, they are also guaranteed
+                // to be among `SUPPORTED_FORMAT_PROPERTIES`.
+                // Based on the above, `formatPath` should always be defined and `getEntryPointFormat()`
+                // should always return a format here (and not `undefined`).
+                if (!formatPath || !format) {
+                    // This should never happen.
+                    throw new Error("Invariant violated: No format-path or format for " + entryPoint.path + " : " +
+                        (formatProperty + " (formatPath: " + formatPath + " | format: " + format + ")"));
+                }
+                var bundle = entry_point_bundle_1.makeEntryPointBundle(fileSystem, entryPoint, formatPath, isCore, format, processDts, pathMappings, true, enableI18nLegacyMessageIdFormat);
+                logger.info("Compiling " + entryPoint.name + " : " + formatProperty + " as " + format);
+                var result = transformer.transform(bundle);
+                if (result.success) {
+                    if (result.diagnostics.length > 0) {
+                        logger.warn(diagnostics_1.replaceTsWithNgInErrors(ts.formatDiagnosticsWithColorAndContext(result.diagnostics, bundle.src.host)));
+                    }
+                    fileWriter.writeBundle(bundle, result.transformedFiles, formatPropertiesToMarkAsProcessed);
+                    logger.debug("  Successfully compiled " + entryPoint.name + " : " + formatProperty);
+                    onTaskCompleted(task, 0 /* Processed */, null);
+                }
+                else {
+                    var errors = diagnostics_1.replaceTsWithNgInErrors(ts.formatDiagnosticsWithColorAndContext(result.diagnostics, bundle.src.host));
+                    onTaskCompleted(task, 1 /* Failed */, "compilation errors:\n" + errors);
+                }
+            };
+        };
+    }
+    exports.getCreateCompileFn = getCreateCompileFn;
+    function getFileWriter(fs, logger, pkgJsonUpdater, createNewEntryPointFormats, errorOnFailedEntryPoint) {
+        return createNewEntryPointFormats ?
+            new new_entry_point_file_writer_1.NewEntryPointFileWriter(fs, logger, errorOnFailedEntryPoint, pkgJsonUpdater) :
+            new in_place_file_writer_1.InPlaceFileWriter(fs, logger, errorOnFailedEntryPoint);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create_compile_function.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/execution/create_compile_function.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {replaceTsWithNgInErrors} from '../../../src/ngtsc/diagnostics';\nimport {FileSystem} from '../../../src/ngtsc/file_system';\nimport {ParsedConfiguration} from '../../../src/perform_compile';\nimport {Logger} from '../logging/logger';\nimport {PathMappings} from '../ngcc_options';\nimport {getEntryPointFormat} from '../packages/entry_point';\nimport {makeEntryPointBundle} from '../packages/entry_point_bundle';\nimport {FileWriter} from '../writing/file_writer';\nimport {InPlaceFileWriter} from '../writing/in_place_file_writer';\nimport {NewEntryPointFileWriter} from '../writing/new_entry_point_file_writer';\nimport {PackageJsonUpdater} from '../writing/package_json_updater';\n\nimport {CreateCompileFn} from './api';\nimport {Task, TaskProcessingOutcome} from './tasks/api';\n\n/**\n * The function for creating the `compile()` function.\n */\nexport function getCreateCompileFn(\n    fileSystem: FileSystem, logger: Logger, pkgJsonUpdater: PackageJsonUpdater,\n    createNewEntryPointFormats: boolean, errorOnFailedEntryPoint: boolean,\n    enableI18nLegacyMessageIdFormat: boolean, tsConfig: ParsedConfiguration|null,\n    pathMappings: PathMappings|undefined): CreateCompileFn {\n  return onTaskCompleted => {\n    const fileWriter = getFileWriter(\n        fileSystem, logger, pkgJsonUpdater, createNewEntryPointFormats, errorOnFailedEntryPoint);\n    const {Transformer} = require('../packages/transformer');\n    const transformer = new Transformer(fileSystem, logger, tsConfig);\n\n    return (task: Task) => {\n      const {entryPoint, formatProperty, formatPropertiesToMarkAsProcessed, processDts} = task;\n\n      const isCore = entryPoint.name === '@angular/core';  // Are we compiling the Angular core?\n      const packageJson = entryPoint.packageJson;\n      const formatPath = packageJson[formatProperty];\n      const format = getEntryPointFormat(fileSystem, entryPoint, formatProperty);\n\n      // All properties listed in `propertiesToProcess` are guaranteed to point to a format-path\n      // (i.e. they are defined in `entryPoint.packageJson`). Furthermore, they are also guaranteed\n      // to be among `SUPPORTED_FORMAT_PROPERTIES`.\n      // Based on the above, `formatPath` should always be defined and `getEntryPointFormat()`\n      // should always return a format here (and not `undefined`).\n      if (!formatPath || !format) {\n        // This should never happen.\n        throw new Error(\n            `Invariant violated: No format-path or format for ${entryPoint.path} : ` +\n            `${formatProperty} (formatPath: ${formatPath} | format: ${format})`);\n      }\n\n      const bundle = makeEntryPointBundle(\n          fileSystem, entryPoint, formatPath, isCore, format, processDts, pathMappings, true,\n          enableI18nLegacyMessageIdFormat);\n\n      logger.info(`Compiling ${entryPoint.name} : ${formatProperty} as ${format}`);\n\n      const result = transformer.transform(bundle);\n      if (result.success) {\n        if (result.diagnostics.length > 0) {\n          logger.warn(replaceTsWithNgInErrors(\n              ts.formatDiagnosticsWithColorAndContext(result.diagnostics, bundle.src.host)));\n        }\n        fileWriter.writeBundle(bundle, result.transformedFiles, formatPropertiesToMarkAsProcessed);\n\n        logger.debug(`  Successfully compiled ${entryPoint.name} : ${formatProperty}`);\n\n        onTaskCompleted(task, TaskProcessingOutcome.Processed, null);\n      } else {\n        const errors = replaceTsWithNgInErrors(\n            ts.formatDiagnosticsWithColorAndContext(result.diagnostics, bundle.src.host));\n        onTaskCompleted(task, TaskProcessingOutcome.Failed, `compilation errors:\\n${errors}`);\n      }\n    };\n  };\n}\n\nfunction getFileWriter(\n    fs: FileSystem, logger: Logger, pkgJsonUpdater: PackageJsonUpdater,\n    createNewEntryPointFormats: boolean, errorOnFailedEntryPoint: boolean): FileWriter {\n  return createNewEntryPointFormats ?\n      new NewEntryPointFileWriter(fs, logger, errorOnFailedEntryPoint, pkgJsonUpdater) :\n      new InPlaceFileWriter(fs, logger, errorOnFailedEntryPoint);\n}\n"]}

package/ngcc/src/execution/single_process_executor.js

@@ -87,4 +87,4 @@
     }(SingleProcessorExecutorBase));
     exports.SingleProcessExecutorAsync = SingleProcessExecutorAsync;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xlX3Byb2Nlc3NfZXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9zcmMvZXhlY3V0aW9uL3NpbmdsZV9wcm9jZXNzX2V4ZWN1dG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7OztJQVNIO1FBQ0UscUNBQ1ksTUFBYyxFQUFVLDJCQUF3RDtZQUFoRixXQUFNLEdBQU4sTUFBTSxDQUFRO1lBQVUsZ0NBQTJCLEdBQTNCLDJCQUEyQixDQUE2QjtRQUFHLENBQUM7UUFFaEcsK0NBQVMsR0FBVCxVQUFVLGtCQUF3QyxFQUFFLGVBQWdDO1lBRWxGLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLHFCQUFtQixJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksTUFBRyxDQUFDLENBQUM7WUFFL0QsSUFBTSxTQUFTLEdBQUcsa0JBQWtCLEVBQUUsQ0FBQztZQUN2QyxJQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsMkJBQTJCLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDcEUsSUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1lBRWpELHFCQUFxQjtZQUNyQixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1lBQ3pDLElBQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUU3QixPQUFPLENBQUMsU0FBUyxDQUFDLGlCQUFpQixFQUFFO2dCQUNuQyxJQUFNLElBQUksR0FBRyxTQUFTLENBQUMsV0FBVyxFQUFJLENBQUM7Z0JBQ3ZDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDZCxTQUFTLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDbkM7WUFFRCxJQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLFNBQVMsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO1lBQzdELElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLHdCQUFzQixRQUFRLE9BQUksQ0FBQyxDQUFDO1FBQ3hELENBQUM7UUFDSCxrQ0FBQztJQUFELENBQUMsQUF6QkQsSUF5QkM7SUF6QnFCLGtFQUEyQjtJQTJCakQ7O09BRUc7SUFDSDtRQUErQyxxREFBMkI7UUFDeEUsbUNBQ0ksTUFBYyxFQUFVLFFBQW9CLEVBQzVDLDJCQUF3RDtZQUY1RCxZQUdFLGtCQUFNLE1BQU0sRUFBRSwyQkFBMkIsQ0FBQyxTQUMzQztZQUgyQixjQUFRLEdBQVIsUUFBUSxDQUFZOztRQUdoRCxDQUFDO1FBQ0QsMkNBQU8sR0FBUCxVQUFRLGtCQUF3QyxFQUFFLGVBQWdDO1lBQWxGLGlCQUVDO1lBREMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsY0FBTSxPQUFBLEtBQUksQ0FBQyxTQUFTLENBQUMsa0JBQWtCLEVBQUUsZUFBZSxDQUFDLEVBQW5ELENBQW1ELENBQUMsQ0FBQztRQUNoRixDQUFDO1FBQ0gsZ0NBQUM7SUFBRCxDQUFDLEFBVEQsQ0FBK0MsMkJBQTJCLEdBU3pFO0lBVFksOERBQXlCO0lBV3RDOztPQUVHO0lBQ0g7UUFBZ0Qsc0RBQTJCO1FBQ3pFLG9DQUNJLE1BQWMsRUFBVSxRQUFxQixFQUM3QywyQkFBd0Q7WUFGNUQsWUFHRSxrQkFBTSxNQUFNLEVBQUUsMkJBQTJCLENBQUMsU0FDM0M7WUFIMkIsY0FBUSxHQUFSLFFBQVEsQ0FBYTs7UUFHakQsQ0FBQztRQUNLLDRDQUFPLEdBQWIsVUFBYyxrQkFBd0MsRUFBRSxlQUFnQzs7Ozs7Z0NBRXRGLHFCQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDO2dDQUFXLHNCQUFBLElBQUksQ0FBQyxTQUFTLENBQUMsa0JBQWtCLEVBQUUsZUFBZSxDQUFDLEVBQUE7cUNBQUEsQ0FBQyxFQUFBOzs0QkFBeEYsU0FBd0YsQ0FBQzs7Ozs7U0FDMUY7UUFDSCxpQ0FBQztJQUFELENBQUMsQUFWRCxDQUFnRCwyQkFBMkIsR0FVMUU7SUFWWSxnRUFBMEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7QXN5bmNMb2NrZXJ9IGZyb20gJy4uL2xvY2tpbmcvYXN5bmNfbG9ja2VyJztcbmltcG9ydCB7U3luY0xvY2tlcn0gZnJvbSAnLi4vbG9ja2luZy9zeW5jX2xvY2tlcic7XG5pbXBvcnQge0xvZ2dlcn0gZnJvbSAnLi4vbG9nZ2luZy9sb2dnZXInO1xuXG5pbXBvcnQge0FuYWx5emVFbnRyeVBvaW50c0ZuLCBDcmVhdGVDb21waWxlRm4sIEV4ZWN1dG9yfSBmcm9tICcuL2FwaSc7XG5pbXBvcnQge0NyZWF0ZVRhc2tDb21wbGV0ZWRDYWxsYmFja30gZnJvbSAnLi90YXNrcy9hcGknO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2luZ2xlUHJvY2Vzc29yRXhlY3V0b3JCYXNlIHtcbiAgY29uc3RydWN0b3IoXG4gICAgICBwcml2YXRlIGxvZ2dlcjogTG9nZ2VyLCBwcml2YXRlIGNyZWF0ZVRhc2tDb21wbGV0ZWRDYWxsYmFjazogQ3JlYXRlVGFza0NvbXBsZXRlZENhbGxiYWNrKSB7fVxuXG4gIGRvRXhlY3V0ZShhbmFseXplRW50cnlQb2ludHM6IEFuYWx5emVFbnRyeVBvaW50c0ZuLCBjcmVhdGVDb21waWxlRm46IENyZWF0ZUNvbXBpbGVGbik6XG4gICAgICB2b2lkfFByb21pc2U8dm9pZD4ge1xuICAgIHRoaXMubG9nZ2VyLmRlYnVnKGBSdW5uaW5nIG5nY2Mgb24gJHt0aGlzLmNvbnN0cnVjdG9yLm5hbWV9LmApO1xuXG4gICAgY29uc3QgdGFza1F1ZXVlID0gYW5hbHl6ZUVudHJ5UG9pbnRzKCk7XG4gICAgY29uc3Qgb25UYXNrQ29tcGxldGVkID0gdGhpcy5jcmVhdGVUYXNrQ29tcGxldGVkQ2FsbGJhY2sodGFza1F1ZXVlKTtcbiAgICBjb25zdCBjb21waWxlID0gY3JlYXRlQ29tcGlsZUZuKG9uVGFza0NvbXBsZXRlZCk7XG5cbiAgICAvLyBQcm9jZXNzIGFsbCB0YXNrcy5cbiAgICB0aGlzLmxvZ2dlci5kZWJ1ZygnUHJvY2Vzc2luZyB0YXNrcy4uLicpO1xuICAgIGNvbnN0IHN0YXJ0VGltZSA9IERhdGUubm93KCk7XG5cbiAgICB3aGlsZSAoIXRhc2tRdWV1ZS5hbGxUYXNrc0NvbXBsZXRlZCkge1xuICAgICAgY29uc3QgdGFzayA9IHRhc2tRdWV1ZS5nZXROZXh0VGFzaygpICE7XG4gICAgICBjb21waWxlKHRhc2spO1xuICAgICAgdGFza1F1ZXVlLm1hcmtUYXNrQ29tcGxldGVkKHRhc2spO1xuICAgIH1cblxuICAgIGNvbnN0IGR1cmF0aW9uID0gTWF0aC5yb3VuZCgoRGF0ZS5ub3coKSAtIHN0YXJ0VGltZSkgLyAxMDAwKTtcbiAgICB0aGlzLmxvZ2dlci5kZWJ1ZyhgUHJvY2Vzc2VkIHRhc2tzIGluICR7ZHVyYXRpb259cy5gKTtcbiAgfVxufVxuXG4vKipcbiAqIEFuIGBFeGVjdXRvcmAgdGhhdCBwcm9jZXNzZXMgYWxsIHRhc2tzIHNlcmlhbGx5IGFuZCBjb21wbGV0ZXMgc3luY2hyb25vdXNseS5cbiAqL1xuZXhwb3J0IGNsYXNzIFNpbmdsZVByb2Nlc3NFeGVjdXRvclN5bmMgZXh0ZW5kcyBTaW5nbGVQcm9jZXNzb3JFeGVjdXRvckJhc2UgaW1wbGVtZW50cyBFeGVjdXRvciB7XG4gIGNvbnN0cnVjdG9yKFxuICAgICAgbG9nZ2VyOiBMb2dnZXIsIHByaXZhdGUgbG9ja0ZpbGU6IFN5bmNMb2NrZXIsXG4gICAgICBjcmVhdGVUYXNrQ29tcGxldGVkQ2FsbGJhY2s6IENyZWF0ZVRhc2tDb21wbGV0ZWRDYWxsYmFjaykge1xuICAgIHN1cGVyKGxvZ2dlciwgY3JlYXRlVGFza0NvbXBsZXRlZENhbGxiYWNrKTtcbiAgfVxuICBleGVjdXRlKGFuYWx5emVFbnRyeVBvaW50czogQW5hbHl6ZUVudHJ5UG9pbnRzRm4sIGNyZWF0ZUNvbXBpbGVGbjogQ3JlYXRlQ29tcGlsZUZuKTogdm9pZCB7XG4gICAgdGhpcy5sb2NrRmlsZS5sb2NrKCgpID0+IHRoaXMuZG9FeGVjdXRlKGFuYWx5emVFbnRyeVBvaW50cywgY3JlYXRlQ29tcGlsZUZuKSk7XG4gIH1cbn1cblxuLyoqXG4gKiBBbiBgRXhlY3V0b3JgIHRoYXQgcHJvY2Vzc2VzIGFsbCB0YXNrcyBzZXJpYWxseSwgYnV0IHN0aWxsIGNvbXBsZXRlcyBhc3luY2hyb25vdXNseS5cbiAqL1xuZXhwb3J0IGNsYXNzIFNpbmdsZVByb2Nlc3NFeGVjdXRvckFzeW5jIGV4dGVuZHMgU2luZ2xlUHJvY2Vzc29yRXhlY3V0b3JCYXNlIGltcGxlbWVudHMgRXhlY3V0b3Ige1xuICBjb25zdHJ1Y3RvcihcbiAgICAgIGxvZ2dlcjogTG9nZ2VyLCBwcml2YXRlIGxvY2tGaWxlOiBBc3luY0xvY2tlcixcbiAgICAgIGNyZWF0ZVRhc2tDb21wbGV0ZWRDYWxsYmFjazogQ3JlYXRlVGFza0NvbXBsZXRlZENhbGxiYWNrKSB7XG4gICAgc3VwZXIobG9nZ2VyLCBjcmVhdGVUYXNrQ29tcGxldGVkQ2FsbGJhY2spO1xuICB9XG4gIGFzeW5jIGV4ZWN1dGUoYW5hbHl6ZUVudHJ5UG9pbnRzOiBBbmFseXplRW50cnlQb2ludHNGbiwgY3JlYXRlQ29tcGlsZUZuOiBDcmVhdGVDb21waWxlRm4pOlxuICAgICAgUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgdGhpcy5sb2NrRmlsZS5sb2NrKGFzeW5jKCkgPT4gdGhpcy5kb0V4ZWN1dGUoYW5hbHl6ZUVudHJ5UG9pbnRzLCBjcmVhdGVDb21waWxlRm4pKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/ngcc/src/execution/tasks/completion.js

@@ -79,4 +79,4 @@
     }
     exports.createLogErrorHandler = createLogErrorHandler;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/execution/tasks/queues/base_task_queue.js

@@ -109,4 +109,4 @@
     }());
     exports.BaseTaskQueue = BaseTaskQueue;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/execution/tasks/queues/parallel_task_queue.js

@@ -83,4 +83,4 @@
     }(base_task_queue_1.BaseTaskQueue));
     exports.ParallelTaskQueue = ParallelTaskQueue;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/execution/tasks/utils.js

@@ -12,9 +12,7 @@
     var tslib_1 = require("tslib");
     var api_1 = require("@angular/compiler-cli/ngcc/src/execution/tasks/api");
     /** Stringify a task for debugging purposes. */
-    exports.stringifyTask = function (task) {
-        return "{entryPoint: " + task.entryPoint.name + ", formatProperty: " + task.formatProperty + ", processDts: " + task.processDts + "}";
-    };
+    exports.stringifyTask = function (task) { return "{entryPoint: " + task.entryPoint.name + ", formatProperty: " + task.formatProperty + ", processDts: " + task.processDts + "}"; };
     /**
      * Compute a mapping of tasks to the tasks that are dependent on them (if any).
      *
@@ -161,4 +159,4 @@
     }
     exports.sortTasksByPriority = sortTasksByPriority;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/ngcc/src/execution/tasks/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 {DepGraph} from 'dependency-graph';\nimport {EntryPoint} from '../../packages/entry_point';\nimport {PartiallyOrderedTasks, Task, TaskDependencies} from './api';\n\n/** Stringify a task for debugging purposes. */\nexport const stringifyTask = (task: Task): string =>\n    `{entryPoint: ${task.entryPoint.name}, formatProperty: ${task.formatProperty}, processDts: ${task.processDts}}`;\n\n/**\n * Compute a mapping of tasks to the tasks that are dependent on them (if any).\n *\n * Task A can depend upon task B, if either:\n *\n * * A and B have the same entry-point _and_ B is generating the typings for that entry-point\n *   (i.e. has `processDts: true`).\n * * A's entry-point depends on B's entry-point _and_ B is also generating typings.\n *\n * NOTE: If a task is not generating typings, then it cannot affect anything which depends on its\n *       entry-point, regardless of the dependency graph. To put this another way, only the task\n *       which produces the typings for a dependency needs to have been completed.\n *\n * As a performance optimization, we take into account the fact that `tasks` are sorted in such a\n * way that a task can only depend on earlier tasks (i.e. dependencies always come before\n * dependents in the list of tasks).\n *\n * @param tasks A (partially ordered) list of tasks.\n * @param graph The dependency graph between entry-points.\n * @return A map from each task to those tasks directly dependent upon it.\n */\nexport function computeTaskDependencies(\n    tasks: PartiallyOrderedTasks, graph: DepGraph<EntryPoint>): TaskDependencies {\n  const dependencies = new TaskDependencies();\n  const candidateDependencies = new Map<string, Task>();\n\n  tasks.forEach(task => {\n    const entryPointPath = task.entryPoint.path;\n\n    // Find the earlier tasks (`candidateDependencies`) that this task depends upon.\n    const deps = graph.dependenciesOf(entryPointPath);\n    const taskDependencies = deps.filter(dep => candidateDependencies.has(dep))\n                                 .map(dep => candidateDependencies.get(dep) !);\n\n    // If this task has dependencies, add it to the dependencies and dependents maps.\n    if (taskDependencies.length > 0) {\n      for (const dependency of taskDependencies) {\n        const taskDependents = getDependentsSet(dependencies, dependency);\n        taskDependents.add(task);\n      }\n    }\n\n    if (task.processDts) {\n      // SANITY CHECK:\n      // There should only be one task per entry-point that generates typings (and thus can be a\n      // dependency of other tasks), so the following should theoretically never happen, but check\n      // just in case.\n      if (candidateDependencies.has(entryPointPath)) {\n        const otherTask = candidateDependencies.get(entryPointPath) !;\n        throw new Error(\n            'Invariant violated: Multiple tasks are assigned generating typings for ' +\n            `'${entryPointPath}':\\n  - ${stringifyTask(otherTask)}\\n  - ${stringifyTask(task)}`);\n      }\n      // This task can potentially be a dependency (i.e. it generates typings), so add it to the\n      // list of candidate dependencies for subsequent tasks.\n      candidateDependencies.set(entryPointPath, task);\n    } else {\n      // This task is not generating typings so we need to add it to the dependents of the task that\n      // does generate typings, if that exists\n      if (candidateDependencies.has(entryPointPath)) {\n        const typingsTask = candidateDependencies.get(entryPointPath) !;\n        const typingsTaskDependents = getDependentsSet(dependencies, typingsTask);\n        typingsTaskDependents.add(task);\n      }\n    }\n  });\n\n  return dependencies;\n}\n\nexport function getDependentsSet(map: TaskDependencies, task: Task): Set<Task> {\n  if (!map.has(task)) {\n    map.set(task, new Set());\n  }\n  return map.get(task) !;\n}\n\n/**\n * Invert the given mapping of Task dependencies.\n *\n * @param dependencies The mapping of tasks to the tasks that depend upon them.\n * @returns A mapping of tasks to the tasks that they depend upon.\n */\nexport function getBlockedTasks(dependencies: TaskDependencies): Map<Task, Set<Task>> {\n  const blockedTasks = new Map<Task, Set<Task>>();\n  for (const [dependency, dependents] of dependencies) {\n    for (const dependent of dependents) {\n      const dependentSet = getDependentsSet(blockedTasks, dependent);\n      dependentSet.add(dependency);\n    }\n  }\n  return blockedTasks;\n}\n\n/**\n * Sort a list of tasks by priority.\n *\n * Priority is determined by the number of other tasks that a task is (transitively) blocking:\n * The more tasks a task is blocking the higher its priority is, because processing it will\n * potentially unblock more tasks.\n *\n * To keep the behavior predictable, if two tasks block the same number of other tasks, their\n * relative order in the original `tasks` lists is preserved.\n *\n * @param tasks A (partially ordered) list of tasks.\n * @param dependencies The mapping of tasks to the tasks that depend upon them.\n * @return The list of tasks sorted by priority.\n */\nexport function sortTasksByPriority(\n    tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks {\n  const priorityPerTask = new Map<Task, [number, number]>();\n  const computePriority = (task: Task, idx: number):\n      [number, number] => [dependencies.has(task) ? dependencies.get(task) !.size : 0, idx];\n\n  tasks.forEach((task, i) => priorityPerTask.set(task, computePriority(task, i)));\n\n  return tasks.slice().sort((task1, task2) => {\n    const [p1, idx1] = priorityPerTask.get(task1) !;\n    const [p2, idx2] = priorityPerTask.get(task2) !;\n\n    return (p2 - p1) || (idx1 - idx2);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/ngcc/src/execution/tasks/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 {DepGraph} from 'dependency-graph';\nimport {EntryPoint} from '../../packages/entry_point';\nimport {PartiallyOrderedTasks, Task, TaskDependencies} from './api';\n\n/** Stringify a task for debugging purposes. */\nexport const stringifyTask = (task: Task): string => `{entryPoint: ${\n    task.entryPoint.name}, formatProperty: ${task.formatProperty}, processDts: ${task.processDts}}`;\n\n/**\n * Compute a mapping of tasks to the tasks that are dependent on them (if any).\n *\n * Task A can depend upon task B, if either:\n *\n * * A and B have the same entry-point _and_ B is generating the typings for that entry-point\n *   (i.e. has `processDts: true`).\n * * A's entry-point depends on B's entry-point _and_ B is also generating typings.\n *\n * NOTE: If a task is not generating typings, then it cannot affect anything which depends on its\n *       entry-point, regardless of the dependency graph. To put this another way, only the task\n *       which produces the typings for a dependency needs to have been completed.\n *\n * As a performance optimization, we take into account the fact that `tasks` are sorted in such a\n * way that a task can only depend on earlier tasks (i.e. dependencies always come before\n * dependents in the list of tasks).\n *\n * @param tasks A (partially ordered) list of tasks.\n * @param graph The dependency graph between entry-points.\n * @return A map from each task to those tasks directly dependent upon it.\n */\nexport function computeTaskDependencies(\n    tasks: PartiallyOrderedTasks, graph: DepGraph<EntryPoint>): TaskDependencies {\n  const dependencies = new TaskDependencies();\n  const candidateDependencies = new Map<string, Task>();\n\n  tasks.forEach(task => {\n    const entryPointPath = task.entryPoint.path;\n\n    // Find the earlier tasks (`candidateDependencies`) that this task depends upon.\n    const deps = graph.dependenciesOf(entryPointPath);\n    const taskDependencies = deps.filter(dep => candidateDependencies.has(dep))\n                                 .map(dep => candidateDependencies.get(dep)!);\n\n    // If this task has dependencies, add it to the dependencies and dependents maps.\n    if (taskDependencies.length > 0) {\n      for (const dependency of taskDependencies) {\n        const taskDependents = getDependentsSet(dependencies, dependency);\n        taskDependents.add(task);\n      }\n    }\n\n    if (task.processDts) {\n      // SANITY CHECK:\n      // There should only be one task per entry-point that generates typings (and thus can be a\n      // dependency of other tasks), so the following should theoretically never happen, but check\n      // just in case.\n      if (candidateDependencies.has(entryPointPath)) {\n        const otherTask = candidateDependencies.get(entryPointPath)!;\n        throw new Error(\n            'Invariant violated: Multiple tasks are assigned generating typings for ' +\n            `'${entryPointPath}':\\n  - ${stringifyTask(otherTask)}\\n  - ${stringifyTask(task)}`);\n      }\n      // This task can potentially be a dependency (i.e. it generates typings), so add it to the\n      // list of candidate dependencies for subsequent tasks.\n      candidateDependencies.set(entryPointPath, task);\n    } else {\n      // This task is not generating typings so we need to add it to the dependents of the task that\n      // does generate typings, if that exists\n      if (candidateDependencies.has(entryPointPath)) {\n        const typingsTask = candidateDependencies.get(entryPointPath)!;\n        const typingsTaskDependents = getDependentsSet(dependencies, typingsTask);\n        typingsTaskDependents.add(task);\n      }\n    }\n  });\n\n  return dependencies;\n}\n\nexport function getDependentsSet(map: TaskDependencies, task: Task): Set<Task> {\n  if (!map.has(task)) {\n    map.set(task, new Set());\n  }\n  return map.get(task)!;\n}\n\n/**\n * Invert the given mapping of Task dependencies.\n *\n * @param dependencies The mapping of tasks to the tasks that depend upon them.\n * @returns A mapping of tasks to the tasks that they depend upon.\n */\nexport function getBlockedTasks(dependencies: TaskDependencies): Map<Task, Set<Task>> {\n  const blockedTasks = new Map<Task, Set<Task>>();\n  for (const [dependency, dependents] of dependencies) {\n    for (const dependent of dependents) {\n      const dependentSet = getDependentsSet(blockedTasks, dependent);\n      dependentSet.add(dependency);\n    }\n  }\n  return blockedTasks;\n}\n\n/**\n * Sort a list of tasks by priority.\n *\n * Priority is determined by the number of other tasks that a task is (transitively) blocking:\n * The more tasks a task is blocking the higher its priority is, because processing it will\n * potentially unblock more tasks.\n *\n * To keep the behavior predictable, if two tasks block the same number of other tasks, their\n * relative order in the original `tasks` lists is preserved.\n *\n * @param tasks A (partially ordered) list of tasks.\n * @param dependencies The mapping of tasks to the tasks that depend upon them.\n * @return The list of tasks sorted by priority.\n */\nexport function sortTasksByPriority(\n    tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks {\n  const priorityPerTask = new Map<Task, [number, number]>();\n  const computePriority = (task: Task, idx: number):\n      [number, number] => [dependencies.has(task) ? dependencies.get(task)!.size : 0, idx];\n\n  tasks.forEach((task, i) => priorityPerTask.set(task, computePriority(task, i)));\n\n  return tasks.slice().sort((task1, task2) => {\n    const [p1, idx1] = priorityPerTask.get(task1)!;\n    const [p2, idx2] = priorityPerTask.get(task2)!;\n\n    return (p2 - p1) || (idx1 - idx2);\n  });\n}\n"]}

package/ngcc/src/host/commonjs_host.js

@@ -167,7 +167,10 @@
             var reexports = [];
             importedExports.forEach(function (decl, name) {
                 if (decl.node !== null) {
-                    reexports.push({ name: name, declaration: { node: decl.node, known: null, viaModule: viaModule } });
+                    reexports.push({
+                        name: name,
+                        declaration: { node: decl.node, known: null, viaModule: viaModule, identity: decl.identity }
+                    });
                 }
                 else {
                     reexports.push({ name: name, declaration: { node: null, known: null, expression: decl.expression, viaModule: viaModule } });
@@ -191,7 +194,7 @@
                 return null;
             }
             var viaModule = !importInfo.from.startsWith('.') ? importInfo.from : null;
-            return { node: importedFile, known: utils_1.getTsHelperFnFromIdentifier(id), viaModule: viaModule };
+            return { node: importedFile, known: utils_1.getTsHelperFnFromIdentifier(id), viaModule: viaModule, identity: null };
         };
         CommonJsReflectionHost.prototype.resolveModuleName = function (moduleName, containingFile) {
             if (this.compilerHost.resolveModuleNames) {
@@ -208,4 +211,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, getTsHelperFnFromIdentifier, 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 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: getTsHelperFnFromIdentifier(id), 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';\n\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, getTsHelperFnFromIdentifier, isDefined, stripExtension} from '../utils';\n\nimport {ExportDeclaration, ExportStatement, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall, ReexportStatement, RequireCall} 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 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({\n          name,\n          declaration: {node: decl.node, known: null, viaModule, identity: decl.identity}\n        });\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: getTsHelperFnFromIdentifier(id), viaModule, identity: null};\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/commonjs_umd_utils.js

@@ -106,4 +106,4 @@
     }
     exports.isRequireCall = isRequireCall;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs_umd_utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/commonjs_umd_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 */\n\nimport * as ts from 'typescript';\nimport {Declaration} from '../../../src/ngtsc/reflection';\n\n\nexport interface ExportDeclaration {\n  name: string;\n  declaration: Declaration;\n}\n\nexport interface ExportStatement extends ts.ExpressionStatement {\n  expression: ts.BinaryExpression&{left: ts.PropertyAccessExpression & {expression: ts.Identifier}};\n}\n\n/**\n * A CommonJS or UMD re-export statement.\n *\n * In CommonJS/UMD, re-export statements can have several forms (depending, for example, on whether\n * the TypeScript helpers are imported or emitted inline). The expression can have one of the\n * following forms:\n * - `__export(firstArg)`\n * - `__exportStar(firstArg)`\n * - `tslib.__export(firstArg, exports)`\n * - `tslib.__exportStar(firstArg, exports)`\n *\n * In all cases, we only care about `firstApp`, which is the first argument of the re-export call\n * expression and can be either a `require('...')` call or an identifier (initialized via a\n * `require('...')` call).\n */\nexport interface ReexportStatement extends ts.ExpressionStatement { expression: ts.CallExpression; }\n\nexport interface RequireCall extends ts.CallExpression {\n  arguments: ts.CallExpression['arguments']&[ts.StringLiteral];\n}\n\n\n/**\n * Return the \"namespace\" of the specified `ts.Identifier` if the identifier is the RHS of a\n * property access expression, i.e. an expression of the form `<namespace>.<id>` (in which case a\n * `ts.Identifier` corresponding to `<namespace>` will be returned). Otherwise return `null`.\n */\nexport function findNamespaceOfIdentifier(id: ts.Identifier): ts.Identifier|null {\n  return id.parent && ts.isPropertyAccessExpression(id.parent) &&\n          ts.isIdentifier(id.parent.expression) ?\n      id.parent.expression :\n      null;\n}\n\n/**\n * Return the `RequireCall` that is used to initialize the specified `ts.Identifier`, if the\n * specified indentifier was indeed initialized with a require call in a declaration of the form:\n * `var <id> = require('...')`\n */\nexport function findRequireCallReference(id: ts.Identifier, checker: ts.TypeChecker): RequireCall|\n    null {\n  const symbol = checker.getSymbolAtLocation(id) || null;\n  const declaration = symbol && symbol.valueDeclaration;\n  const initializer =\n      declaration && ts.isVariableDeclaration(declaration) && declaration.initializer || null;\n  return initializer && isRequireCall(initializer) ? initializer : null;\n}\n\n/**\n * Check whether the specified `ts.Statement` is an export statement, i.e. an expression statement\n * of the form: `export.<foo> = <bar>`\n */\nexport function isExportStatement(stmt: ts.Statement): stmt is ExportStatement {\n  return ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression) &&\n      (stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) &&\n      ts.isPropertyAccessExpression(stmt.expression.left) &&\n      ts.isIdentifier(stmt.expression.left.expression) &&\n      stmt.expression.left.expression.text === 'exports';\n}\n\n/**\n * Check whether the specified `ts.Statement` is a re-export statement, i.e. an expression statement\n * of one of the following forms:\n * - `__export(<foo>)`\n * - `__exportStar(<foo>)`\n * - `tslib.__export(<foo>, exports)`\n * - `tslib.__exportStar(<foo>, exports)`\n */\nexport function isReexportStatement(stmt: ts.Statement): stmt is ReexportStatement {\n  // Ensure it is a call expression statement.\n  if (!ts.isExpressionStatement(stmt) || !ts.isCallExpression(stmt.expression)) {\n    return false;\n  }\n\n  // Get the called function identifier.\n  // NOTE: Currently, it seems that `__export()` is used when emitting helpers inline and\n  //       `__exportStar()` when importing them\n  //       ([source](https://github.com/microsoft/TypeScript/blob/d7c83f023/src/compiler/transformers/module/module.ts#L1796-L1797)).\n  //       So, theoretically, we only care about the formats `__export(<foo>)` and\n  //       `tslib.__exportStar(<foo>, exports)`.\n  //       The current implementation accepts the other two formats (`__exportStar(...)` and\n  //       `tslib.__export(...)`) as well to be more future-proof (given that it is unlikely that\n  //       they will introduce false positives).\n  let fnName: string|null = null;\n  if (ts.isIdentifier(stmt.expression.expression)) {\n    // Statement of the form `someFn(...)`.\n    fnName = stmt.expression.expression.text;\n  } else if (\n      ts.isPropertyAccessExpression(stmt.expression.expression) &&\n      ts.isIdentifier(stmt.expression.expression.name)) {\n    // Statement of the form `tslib.someFn(...)`.\n    fnName = stmt.expression.expression.name.text;\n  }\n\n  // Ensure the called function is either `__export()` or `__exportStar()`.\n  if ((fnName !== '__export') && (fnName !== '__exportStar')) {\n    return false;\n  }\n\n  // Ensure there is at least one argument.\n  // (The first argument is the exported thing and there will be a second `exports` argument in the\n  // case of imported helpers).\n  return stmt.expression.arguments.length > 0;\n}\n\n/**\n * Check whether the specified `ts.Node` represents a `require()` call, i.e. an call expression of\n * the form: `require('<foo>')`\n */\nexport function isRequireCall(node: ts.Node): node is RequireCall {\n  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&\n      node.expression.text === 'require' && node.arguments.length === 1 &&\n      ts.isStringLiteral(node.arguments[0]);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs_umd_utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/commonjs_umd_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 */\n\nimport * as ts from 'typescript';\nimport {Declaration} from '../../../src/ngtsc/reflection';\n\n\nexport interface ExportDeclaration {\n  name: string;\n  declaration: Declaration;\n}\n\nexport interface ExportStatement extends ts.ExpressionStatement {\n  expression: ts.BinaryExpression&{\n    left: ts.PropertyAccessExpression &\n        {\n          expression: ts.Identifier\n        }\n  };\n}\n\n/**\n * A CommonJS or UMD re-export statement.\n *\n * In CommonJS/UMD, re-export statements can have several forms (depending, for example, on whether\n * the TypeScript helpers are imported or emitted inline). The expression can have one of the\n * following forms:\n * - `__export(firstArg)`\n * - `__exportStar(firstArg)`\n * - `tslib.__export(firstArg, exports)`\n * - `tslib.__exportStar(firstArg, exports)`\n *\n * In all cases, we only care about `firstApp`, which is the first argument of the re-export call\n * expression and can be either a `require('...')` call or an identifier (initialized via a\n * `require('...')` call).\n */\nexport interface ReexportStatement extends ts.ExpressionStatement {\n  expression: ts.CallExpression;\n}\n\nexport interface RequireCall extends ts.CallExpression {\n  arguments: ts.CallExpression['arguments']&[ts.StringLiteral];\n}\n\n\n/**\n * Return the \"namespace\" of the specified `ts.Identifier` if the identifier is the RHS of a\n * property access expression, i.e. an expression of the form `<namespace>.<id>` (in which case a\n * `ts.Identifier` corresponding to `<namespace>` will be returned). Otherwise return `null`.\n */\nexport function findNamespaceOfIdentifier(id: ts.Identifier): ts.Identifier|null {\n  return id.parent && ts.isPropertyAccessExpression(id.parent) &&\n          ts.isIdentifier(id.parent.expression) ?\n      id.parent.expression :\n      null;\n}\n\n/**\n * Return the `RequireCall` that is used to initialize the specified `ts.Identifier`, if the\n * specified indentifier was indeed initialized with a require call in a declaration of the form:\n * `var <id> = require('...')`\n */\nexport function findRequireCallReference(id: ts.Identifier, checker: ts.TypeChecker): RequireCall|\n    null {\n  const symbol = checker.getSymbolAtLocation(id) || null;\n  const declaration = symbol && symbol.valueDeclaration;\n  const initializer =\n      declaration && ts.isVariableDeclaration(declaration) && declaration.initializer || null;\n  return initializer && isRequireCall(initializer) ? initializer : null;\n}\n\n/**\n * Check whether the specified `ts.Statement` is an export statement, i.e. an expression statement\n * of the form: `export.<foo> = <bar>`\n */\nexport function isExportStatement(stmt: ts.Statement): stmt is ExportStatement {\n  return ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression) &&\n      (stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) &&\n      ts.isPropertyAccessExpression(stmt.expression.left) &&\n      ts.isIdentifier(stmt.expression.left.expression) &&\n      stmt.expression.left.expression.text === 'exports';\n}\n\n/**\n * Check whether the specified `ts.Statement` is a re-export statement, i.e. an expression statement\n * of one of the following forms:\n * - `__export(<foo>)`\n * - `__exportStar(<foo>)`\n * - `tslib.__export(<foo>, exports)`\n * - `tslib.__exportStar(<foo>, exports)`\n */\nexport function isReexportStatement(stmt: ts.Statement): stmt is ReexportStatement {\n  // Ensure it is a call expression statement.\n  if (!ts.isExpressionStatement(stmt) || !ts.isCallExpression(stmt.expression)) {\n    return false;\n  }\n\n  // Get the called function identifier.\n  // NOTE: Currently, it seems that `__export()` is used when emitting helpers inline and\n  //       `__exportStar()` when importing them\n  //       ([source](https://github.com/microsoft/TypeScript/blob/d7c83f023/src/compiler/transformers/module/module.ts#L1796-L1797)).\n  //       So, theoretically, we only care about the formats `__export(<foo>)` and\n  //       `tslib.__exportStar(<foo>, exports)`.\n  //       The current implementation accepts the other two formats (`__exportStar(...)` and\n  //       `tslib.__export(...)`) as well to be more future-proof (given that it is unlikely that\n  //       they will introduce false positives).\n  let fnName: string|null = null;\n  if (ts.isIdentifier(stmt.expression.expression)) {\n    // Statement of the form `someFn(...)`.\n    fnName = stmt.expression.expression.text;\n  } else if (\n      ts.isPropertyAccessExpression(stmt.expression.expression) &&\n      ts.isIdentifier(stmt.expression.expression.name)) {\n    // Statement of the form `tslib.someFn(...)`.\n    fnName = stmt.expression.expression.name.text;\n  }\n\n  // Ensure the called function is either `__export()` or `__exportStar()`.\n  if ((fnName !== '__export') && (fnName !== '__exportStar')) {\n    return false;\n  }\n\n  // Ensure there is at least one argument.\n  // (The first argument is the exported thing and there will be a second `exports` argument in the\n  // case of imported helpers).\n  return stmt.expression.arguments.length > 0;\n}\n\n/**\n * Check whether the specified `ts.Node` represents a `require()` call, i.e. an call expression of\n * the form: `require('<foo>')`\n */\nexport function isRequireCall(node: ts.Node): node is RequireCall {\n  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&\n      node.expression.text === 'require' && node.arguments.length === 1 &&\n      ts.isStringLiteral(node.arguments[0]);\n}\n"]}

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

@@ -41,4 +41,7 @@ export declare class DelegatingReflectionHost implements NgccReflectionHost {
     getModuleWithProvidersFunctions(sf: ts.SourceFile): ModuleWithProvidersFunction[];
     getSwitchableDeclarations(module: ts.Node): SwitchableVariableDeclaration[];
     getEndOfClass(classSymbol: NgccClassSymbol): ts.Node;
+    detectKnownDeclaration(decl: null): null;
+    detectKnownDeclaration<T extends Declaration>(decl: T): T;
+    detectKnownDeclaration<T extends Declaration>(decl: T | null): T | null;
 }