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

package/src/ngtsc/resource/src/loader.js

@@ -0,0 +1,193 @@
+/**
+ * @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
+ */
+(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/src/ngtsc/resource/src/loader", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/util/src/typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var ts = require("typescript");
+    var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
+    var CSS_PREPROCESSOR_EXT = /(\.scss|\.sass|\.less|\.styl)$/;
+    /**
+     * `ResourceLoader` which delegates to a `CompilerHost` resource loading method.
+     */
+    var HostResourceLoader = /** @class */ (function () {
+        function HostResourceLoader(host, options) {
+            this.host = host;
+            this.options = options;
+            this.cache = new Map();
+            this.fetching = new Map();
+            this.canPreload = !!this.host.readResource;
+            this.rootDirs = typescript_1.getRootDirs(host, options);
+        }
+        /**
+         * Resolve the url of a resource relative to the file that contains the reference to it.
+         * The return value of this method can be used in the `load()` and `preload()` methods.
+         *
+         * Uses the provided CompilerHost if it supports mapping resources to filenames.
+         * Otherwise, uses a fallback mechanism that searches the module resolution candidates.
+         *
+         * @param url The, possibly relative, url of the resource.
+         * @param fromFile The path to the file that contains the URL of the resource.
+         * @returns A resolved url of resource.
+         * @throws An error if the resource cannot be resolved.
+         */
+        HostResourceLoader.prototype.resolve = function (url, fromFile) {
+            var resolvedUrl = null;
+            if (this.host.resourceNameToFileName) {
+                resolvedUrl = this.host.resourceNameToFileName(url, fromFile);
+            }
+            else {
+                resolvedUrl = this.fallbackResolve(url, fromFile);
+            }
+            if (resolvedUrl === null) {
+                throw new Error("HostResourceResolver: could not resolve " + url + " in context of " + fromFile + ")");
+            }
+            return resolvedUrl;
+        };
+        /**
+         * Preload the specified resource, asynchronously.
+         *
+         * Once the resource is loaded, its value is cached so it can be accessed synchronously via the
+         * `load()` method.
+         *
+         * @param resolvedUrl The url (resolved by a call to `resolve()`) of the resource to preload.
+         * @returns A Promise that is resolved once the resource has been loaded or `undefined` if the
+         * file has already been loaded.
+         * @throws An Error if pre-loading is not available.
+         */
+        HostResourceLoader.prototype.preload = function (resolvedUrl) {
+            var _this = this;
+            if (!this.host.readResource) {
+                throw new Error('HostResourceLoader: the CompilerHost provided does not support pre-loading resources.');
+            }
+            if (this.cache.has(resolvedUrl)) {
+                return undefined;
+            }
+            else if (this.fetching.has(resolvedUrl)) {
+                return this.fetching.get(resolvedUrl);
+            }
+            var result = this.host.readResource(resolvedUrl);
+            if (typeof result === 'string') {
+                this.cache.set(resolvedUrl, result);
+                return undefined;
+            }
+            else {
+                var fetchCompletion = result.then(function (str) {
+                    _this.fetching.delete(resolvedUrl);
+                    _this.cache.set(resolvedUrl, str);
+                });
+                this.fetching.set(resolvedUrl, fetchCompletion);
+                return fetchCompletion;
+            }
+        };
+        /**
+         * Load the resource at the given url, synchronously.
+         *
+         * The contents of the resource may have been cached by a previous call to `preload()`.
+         *
+         * @param resolvedUrl The url (resolved by a call to `resolve()`) of the resource to load.
+         * @returns The contents of the resource.
+         */
+        HostResourceLoader.prototype.load = function (resolvedUrl) {
+            if (this.cache.has(resolvedUrl)) {
+                return this.cache.get(resolvedUrl);
+            }
+            var result = this.host.readResource ? this.host.readResource(resolvedUrl) :
+                this.host.readFile(resolvedUrl);
+            if (typeof result !== 'string') {
+                throw new Error("HostResourceLoader: loader(" + resolvedUrl + ") returned a Promise");
+            }
+            this.cache.set(resolvedUrl, result);
+            return result;
+        };
+        /**
+         * Attempt to resolve `url` in the context of `fromFile`, while respecting the rootDirs
+         * option from the tsconfig. First, normalize the file name.
+         */
+        HostResourceLoader.prototype.fallbackResolve = function (url, fromFile) {
+            var e_1, _a;
+            var candidateLocations;
+            if (url.startsWith('/')) {
+                // This path is not really an absolute path, but instead the leading '/' means that it's
+                // rooted in the project rootDirs. So look for it according to the rootDirs.
+                candidateLocations = this.getRootedCandidateLocations(url);
+            }
+            else {
+                // This path is a "relative" path and can be resolved as such. To make this easier on the
+                // downstream resolver, the './' prefix is added if missing to distinguish these paths from
+                // absolute node_modules paths.
+                if (!url.startsWith('.')) {
+                    url = "./" + url;
+                }
+                candidateLocations = this.getResolvedCandidateLocations(url, fromFile);
+            }
+            try {
+                for (var candidateLocations_1 = tslib_1.__values(candidateLocations), candidateLocations_1_1 = candidateLocations_1.next(); !candidateLocations_1_1.done; candidateLocations_1_1 = candidateLocations_1.next()) {
+                    var candidate = candidateLocations_1_1.value;
+                    if (this.host.fileExists(candidate)) {
+                        return candidate;
+                    }
+                    else if (CSS_PREPROCESSOR_EXT.test(candidate)) {
+                        /**
+                         * If the user specified styleUrl points to *.scss, but the Sass compiler was run before
+                         * Angular, then the resource may have been generated as *.css. Simply try the resolution
+                         * again.
+                         */
+                        var cssFallbackUrl = candidate.replace(CSS_PREPROCESSOR_EXT, '.css');
+                        if (this.host.fileExists(cssFallbackUrl)) {
+                            return cssFallbackUrl;
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (candidateLocations_1_1 && !candidateLocations_1_1.done && (_a = candidateLocations_1.return)) _a.call(candidateLocations_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return null;
+        };
+        HostResourceLoader.prototype.getRootedCandidateLocations = function (url) {
+            // The path already starts with '/', so add a '.' to make it relative.
+            var segment = ('.' + url);
+            return this.rootDirs.map(function (rootDir) { return file_system_1.join(rootDir, segment); });
+        };
+        /**
+         * TypeScript provides utilities to resolve module names, but not resource files (which aren't
+         * a part of the ts.Program). However, TypeScript's module resolution can be used creatively
+         * to locate where resource files should be expected to exist. Since module resolution returns
+         * a list of file names that were considered, the loader can enumerate the possible locations
+         * for the file by setting up a module resolution for it that will fail.
+         */
+        HostResourceLoader.prototype.getResolvedCandidateLocations = function (url, fromFile) {
+            // clang-format off
+            var failedLookup = ts.resolveModuleName(url + '.$ngresource$', fromFile, this.options, this.host);
+            // clang-format on
+            if (failedLookup.failedLookupLocations === undefined) {
+                throw new Error("Internal error: expected to find failedLookupLocations during resolution of resource '" + url + "' in context of " + fromFile);
+            }
+            return failedLookup.failedLookupLocations
+                .filter(function (candidate) { return candidate.endsWith('.$ngresource$.ts'); })
+                .map(function (candidate) { return candidate.replace(/\.\$ngresource\$\.ts$/, ''); });
+        };
+        return HostResourceLoader;
+    }());
+    exports.HostResourceLoader = HostResourceLoader;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/resource/src/loader.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 {ResourceLoader} from '../../annotations';\nimport {ExtendedTsCompilerHost} from '../../core/api';\nimport {AbsoluteFsPath, PathSegment, join} from '../../file_system';\nimport {getRootDirs} from '../../util/src/typescript';\n\nconst CSS_PREPROCESSOR_EXT = /(\\.scss|\\.sass|\\.less|\\.styl)$/;\n\n/**\n * `ResourceLoader` which delegates to a `CompilerHost` resource loading method.\n */\nexport class HostResourceLoader implements ResourceLoader {\n  private cache = new Map<string, string>();\n  private fetching = new Map<string, Promise<void>>();\n\n  private rootDirs: AbsoluteFsPath[];\n\n  canPreload = !!this.host.readResource;\n\n  constructor(private host: ExtendedTsCompilerHost, private options: ts.CompilerOptions) {\n    this.rootDirs = getRootDirs(host, options);\n  }\n\n  /**\n   * Resolve the url of a resource relative to the file that contains the reference to it.\n   * The return value of this method can be used in the `load()` and `preload()` methods.\n   *\n   * Uses the provided CompilerHost if it supports mapping resources to filenames.\n   * Otherwise, uses a fallback mechanism that searches the module resolution candidates.\n   *\n   * @param url The, possibly relative, url of the resource.\n   * @param fromFile The path to the file that contains the URL of the resource.\n   * @returns A resolved url of resource.\n   * @throws An error if the resource cannot be resolved.\n   */\n  resolve(url: string, fromFile: string): string {\n    let resolvedUrl: string|null = null;\n    if (this.host.resourceNameToFileName) {\n      resolvedUrl = this.host.resourceNameToFileName(url, fromFile);\n    } else {\n      resolvedUrl = this.fallbackResolve(url, fromFile);\n    }\n    if (resolvedUrl === null) {\n      throw new Error(`HostResourceResolver: could not resolve ${url} in context of ${fromFile})`);\n    }\n    return resolvedUrl;\n  }\n\n  /**\n   * Preload the specified resource, asynchronously.\n   *\n   * Once the resource is loaded, its value is cached so it can be accessed synchronously via the\n   * `load()` method.\n   *\n   * @param resolvedUrl The url (resolved by a call to `resolve()`) of the resource to preload.\n   * @returns A Promise that is resolved once the resource has been loaded or `undefined` if the\n   * file has already been loaded.\n   * @throws An Error if pre-loading is not available.\n   */\n  preload(resolvedUrl: string): Promise<void>|undefined {\n    if (!this.host.readResource) {\n      throw new Error(\n          'HostResourceLoader: the CompilerHost provided does not support pre-loading resources.');\n    }\n    if (this.cache.has(resolvedUrl)) {\n      return undefined;\n    } else if (this.fetching.has(resolvedUrl)) {\n      return this.fetching.get(resolvedUrl);\n    }\n\n    const result = this.host.readResource(resolvedUrl);\n    if (typeof result === 'string') {\n      this.cache.set(resolvedUrl, result);\n      return undefined;\n    } else {\n      const fetchCompletion = result.then(str => {\n        this.fetching.delete(resolvedUrl);\n        this.cache.set(resolvedUrl, str);\n      });\n      this.fetching.set(resolvedUrl, fetchCompletion);\n      return fetchCompletion;\n    }\n  }\n\n  /**\n   * Load the resource at the given url, synchronously.\n   *\n   * The contents of the resource may have been cached by a previous call to `preload()`.\n   *\n   * @param resolvedUrl The url (resolved by a call to `resolve()`) of the resource to load.\n   * @returns The contents of the resource.\n   */\n  load(resolvedUrl: string): string {\n    if (this.cache.has(resolvedUrl)) {\n      return this.cache.get(resolvedUrl) !;\n    }\n\n    const result = this.host.readResource ? this.host.readResource(resolvedUrl) :\n                                            this.host.readFile(resolvedUrl);\n    if (typeof result !== 'string') {\n      throw new Error(`HostResourceLoader: loader(${resolvedUrl}) returned a Promise`);\n    }\n    this.cache.set(resolvedUrl, result);\n    return result;\n  }\n\n  /**\n   * Attempt to resolve `url` in the context of `fromFile`, while respecting the rootDirs\n   * option from the tsconfig. First, normalize the file name.\n   */\n  private fallbackResolve(url: string, fromFile: string): string|null {\n    let candidateLocations: string[];\n    if (url.startsWith('/')) {\n      // This path is not really an absolute path, but instead the leading '/' means that it's\n      // rooted in the project rootDirs. So look for it according to the rootDirs.\n      candidateLocations = this.getRootedCandidateLocations(url);\n    } else {\n      // This path is a \"relative\" path and can be resolved as such. To make this easier on the\n      // downstream resolver, the './' prefix is added if missing to distinguish these paths from\n      // absolute node_modules paths.\n      if (!url.startsWith('.')) {\n        url = `./${url}`;\n      }\n      candidateLocations = this.getResolvedCandidateLocations(url, fromFile);\n    }\n\n    for (const candidate of candidateLocations) {\n      if (this.host.fileExists(candidate)) {\n        return candidate;\n      } else if (CSS_PREPROCESSOR_EXT.test(candidate)) {\n        /**\n         * If the user specified styleUrl points to *.scss, but the Sass compiler was run before\n         * Angular, then the resource may have been generated as *.css. Simply try the resolution\n         * again.\n         */\n        const cssFallbackUrl = candidate.replace(CSS_PREPROCESSOR_EXT, '.css');\n        if (this.host.fileExists(cssFallbackUrl)) {\n          return cssFallbackUrl;\n        }\n      }\n    }\n    return null;\n  }\n\n  private getRootedCandidateLocations(url: string): AbsoluteFsPath[] {\n    // The path already starts with '/', so add a '.' to make it relative.\n    const segment: PathSegment = ('.' + url) as PathSegment;\n    return this.rootDirs.map(rootDir => join(rootDir, segment));\n  }\n\n  /**\n   * TypeScript provides utilities to resolve module names, but not resource files (which aren't\n   * a part of the ts.Program). However, TypeScript's module resolution can be used creatively\n   * to locate where resource files should be expected to exist. Since module resolution returns\n   * a list of file names that were considered, the loader can enumerate the possible locations\n   * for the file by setting up a module resolution for it that will fail.\n   */\n  private getResolvedCandidateLocations(url: string, fromFile: string): string[] {\n    // `failedLookupLocations` is in the name of the type ts.ResolvedModuleWithFailedLookupLocations\n    // but is marked @internal in TypeScript. See\n    // https://github.com/Microsoft/TypeScript/issues/28770.\n    type ResolvedModuleWithFailedLookupLocations =\n        ts.ResolvedModuleWithFailedLookupLocations & {failedLookupLocations: ReadonlyArray<string>};\n\n    // clang-format off\n    const failedLookup = ts.resolveModuleName(url + '.$ngresource$', fromFile, this.options, this.host) as ResolvedModuleWithFailedLookupLocations;\n    // clang-format on\n    if (failedLookup.failedLookupLocations === undefined) {\n      throw new Error(\n          `Internal error: expected to find failedLookupLocations during resolution of resource '${url}' in context of ${fromFile}`);\n    }\n\n    return failedLookup.failedLookupLocations\n        .filter(candidate => candidate.endsWith('.$ngresource$.ts'))\n        .map(candidate => candidate.replace(/\\.\\$ngresource\\$\\.ts$/, ''));\n  }\n}\n"]}

package/src/ngtsc/shims/index.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/shims" />
+export { ShimGenerator } from './src/api';
 export { FactoryGenerator, FactoryInfo, generatedFactoryTransform } from './src/factory_generator';
 export { FactoryTracker } from './src/factory_tracker';
-export { GeneratedShimsHostWrapper, ShimGenerator } from './src/host';
 export { SummaryGenerator } from './src/summary_generator';
 export { TypeCheckShimGenerator } from './src/typecheck_shim';

package/src/ngtsc/shims/index.js

@@ -11,22 +11,19 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/shims", ["require", "exports", "@angular/compiler-cli/src/ngtsc/shims/src/factory_generator", "@angular/compiler-cli/src/ngtsc/shims/src/factory_tracker", "@angular/compiler-cli/src/ngtsc/shims/src/host", "@angular/compiler-cli/src/ngtsc/shims/src/summary_generator", "@angular/compiler-cli/src/ngtsc/shims/src/typecheck_shim"], factory);
+        define("@angular/compiler-cli/src/ngtsc/shims", ["require", "exports", "@angular/compiler-cli/src/ngtsc/shims/src/factory_generator", "@angular/compiler-cli/src/ngtsc/shims/src/factory_tracker", "@angular/compiler-cli/src/ngtsc/shims/src/summary_generator", "@angular/compiler-cli/src/ngtsc/shims/src/typecheck_shim"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    /// <reference types="node" />
     var factory_generator_1 = require("@angular/compiler-cli/src/ngtsc/shims/src/factory_generator");
     exports.FactoryGenerator = factory_generator_1.FactoryGenerator;
     exports.generatedFactoryTransform = factory_generator_1.generatedFactoryTransform;
     var factory_tracker_1 = require("@angular/compiler-cli/src/ngtsc/shims/src/factory_tracker");
     exports.FactoryTracker = factory_tracker_1.FactoryTracker;
-    var host_1 = require("@angular/compiler-cli/src/ngtsc/shims/src/host");
-    exports.GeneratedShimsHostWrapper = host_1.GeneratedShimsHostWrapper;
     var summary_generator_1 = require("@angular/compiler-cli/src/ngtsc/shims/src/summary_generator");
     exports.SummaryGenerator = summary_generator_1.SummaryGenerator;
     var typecheck_shim_1 = require("@angular/compiler-cli/src/ngtsc/shims/src/typecheck_shim");
     exports.TypeCheckShimGenerator = typecheck_shim_1.TypeCheckShimGenerator;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3NoaW1zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBRUgsOEJBQThCO0lBRTlCLGlHQUFpRztJQUF6RiwrQ0FBQSxnQkFBZ0IsQ0FBQTtJQUFlLHdEQUFBLHlCQUF5QixDQUFBO0lBQ2hFLDZGQUFxRDtJQUE3QywyQ0FBQSxjQUFjLENBQUE7SUFDdEIsdUVBQW9FO0lBQTVELDJDQUFBLHlCQUF5QixDQUFBO0lBQ2pDLGlHQUF5RDtJQUFqRCwrQ0FBQSxnQkFBZ0IsQ0FBQTtJQUN4QiwyRkFBNEQ7SUFBcEQsa0RBQUEsc0JBQXNCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8vLyA8cmVmZXJlbmNlIHR5cGVzPVwibm9kZVwiIC8+XG5cbmV4cG9ydCB7RmFjdG9yeUdlbmVyYXRvciwgRmFjdG9yeUluZm8sIGdlbmVyYXRlZEZhY3RvcnlUcmFuc2Zvcm19IGZyb20gJy4vc3JjL2ZhY3RvcnlfZ2VuZXJhdG9yJztcbmV4cG9ydCB7RmFjdG9yeVRyYWNrZXJ9IGZyb20gJy4vc3JjL2ZhY3RvcnlfdHJhY2tlcic7XG5leHBvcnQge0dlbmVyYXRlZFNoaW1zSG9zdFdyYXBwZXIsIFNoaW1HZW5lcmF0b3J9IGZyb20gJy4vc3JjL2hvc3QnO1xuZXhwb3J0IHtTdW1tYXJ5R2VuZXJhdG9yfSBmcm9tICcuL3NyYy9zdW1tYXJ5X2dlbmVyYXRvcic7XG5leHBvcnQge1R5cGVDaGVja1NoaW1HZW5lcmF0b3J9IGZyb20gJy4vc3JjL3R5cGVjaGVja19zaGltJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3NoaW1zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBS0gsaUdBQWlHO0lBQXpGLCtDQUFBLGdCQUFnQixDQUFBO0lBQWUsd0RBQUEseUJBQXlCLENBQUE7SUFDaEUsNkZBQXFEO0lBQTdDLDJDQUFBLGNBQWMsQ0FBQTtJQUN0QixpR0FBeUQ7SUFBakQsK0NBQUEsZ0JBQWdCLENBQUE7SUFDeEIsMkZBQTREO0lBQXBELGtEQUFBLHNCQUFzQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vLy8gPHJlZmVyZW5jZSB0eXBlcz1cIm5vZGVcIiAvPlxuXG5leHBvcnQge1NoaW1HZW5lcmF0b3J9IGZyb20gJy4vc3JjL2FwaSc7XG5leHBvcnQge0ZhY3RvcnlHZW5lcmF0b3IsIEZhY3RvcnlJbmZvLCBnZW5lcmF0ZWRGYWN0b3J5VHJhbnNmb3JtfSBmcm9tICcuL3NyYy9mYWN0b3J5X2dlbmVyYXRvcic7XG5leHBvcnQge0ZhY3RvcnlUcmFja2VyfSBmcm9tICcuL3NyYy9mYWN0b3J5X3RyYWNrZXInO1xuZXhwb3J0IHtTdW1tYXJ5R2VuZXJhdG9yfSBmcm9tICcuL3NyYy9zdW1tYXJ5X2dlbmVyYXRvcic7XG5leHBvcnQge1R5cGVDaGVja1NoaW1HZW5lcmF0b3J9IGZyb20gJy4vc3JjL3R5cGVjaGVja19zaGltJztcbiJdfQ==

package/src/ngtsc/shims/src/api.d.ts

@@ -0,0 +1,25 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/shims/src/api" />
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { AbsoluteFsPath } from '../../file_system';
+export interface ShimGenerator {
+    /**
+     * Returns `true` if this generator is intended to handle the given file.
+     */
+    recognize(fileName: AbsoluteFsPath): boolean;
+    /**
+     * Generate a shim's `ts.SourceFile` for the given original file.
+     *
+     * `readFile` is a function which allows the generator to look up the contents of existing source
+     * files. It returns null if the requested file doesn't exist.
+     *
+     * If `generate` returns null, then the shim generator declines to generate the file after all.
+     */
+    generate(genFileName: AbsoluteFsPath, readFile: (fileName: string) => ts.SourceFile | null): ts.SourceFile | null;
+}

package/src/ngtsc/shims/src/api.js

@@ -0,0 +1,13 @@
+(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/src/ngtsc/shims/src/api", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ3RzYy9zaGltcy9zcmMvYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQgKiBhcyB0cyBmcm9tICd0eXBlc2NyaXB0JztcbmltcG9ydCB7QWJzb2x1dGVGc1BhdGh9IGZyb20gJy4uLy4uL2ZpbGVfc3lzdGVtJztcblxuZXhwb3J0IGludGVyZmFjZSBTaGltR2VuZXJhdG9yIHtcbiAgLyoqXG4gICAqIFJldHVybnMgYHRydWVgIGlmIHRoaXMgZ2VuZXJhdG9yIGlzIGludGVuZGVkIHRvIGhhbmRsZSB0aGUgZ2l2ZW4gZmlsZS5cbiAgICovXG4gIHJlY29nbml6ZShmaWxlTmFtZTogQWJzb2x1dGVGc1BhdGgpOiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBHZW5lcmF0ZSBhIHNoaW0ncyBgdHMuU291cmNlRmlsZWAgZm9yIHRoZSBnaXZlbiBvcmlnaW5hbCBmaWxlLlxuICAgKlxuICAgKiBgcmVhZEZpbGVgIGlzIGEgZnVuY3Rpb24gd2hpY2ggYWxsb3dzIHRoZSBnZW5lcmF0b3IgdG8gbG9vayB1cCB0aGUgY29udGVudHMgb2YgZXhpc3Rpbmcgc291cmNlXG4gICAqIGZpbGVzLiBJdCByZXR1cm5zIG51bGwgaWYgdGhlIHJlcXVlc3RlZCBmaWxlIGRvZXNuJ3QgZXhpc3QuXG4gICAqXG4gICAqIElmIGBnZW5lcmF0ZWAgcmV0dXJucyBudWxsLCB0aGVuIHRoZSBzaGltIGdlbmVyYXRvciBkZWNsaW5lcyB0byBnZW5lcmF0ZSB0aGUgZmlsZSBhZnRlciBhbGwuXG4gICAqL1xuICBnZW5lcmF0ZShnZW5GaWxlTmFtZTogQWJzb2x1dGVGc1BhdGgsIHJlYWRGaWxlOiAoZmlsZU5hbWU6IHN0cmluZykgPT4gdHMuU291cmNlRmlsZSB8IG51bGwpOlxuICAgICAgdHMuU291cmNlRmlsZXxudWxsO1xufSJdfQ==

package/src/ngtsc/shims/src/factory_generator.d.ts

@@ -9,7 +9,7 @@
 import * as ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { ImportRewriter } from '../../imports';
-import { ShimGenerator } from './host';
+import { ShimGenerator } from './api';
 /**
  * Generates ts.SourceFiles which contain variable declarations for NgFactories for every exported
  * class of an input ts.SourceFile.

package/src/ngtsc/shims/src/factory_generator.js

@@ -232,4 +232,4 @@
         return file;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory_generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/shims/src/factory_generator.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 ts from 'typescript';\n\nimport {AbsoluteFsPath, absoluteFrom, basename} from '../../file_system';\nimport {ImportRewriter} from '../../imports';\nimport {isNonDeclarationTsPath} from '../../util/src/typescript';\n\nimport {ShimGenerator} from './host';\nimport {generatedModuleName} from './util';\n\nconst TS_DTS_SUFFIX = /(\\.d)?\\.ts$/;\nconst STRIP_NG_FACTORY = /(.*)NgFactory$/;\n\n/**\n * Generates ts.SourceFiles which contain variable declarations for NgFactories for every exported\n * class of an input ts.SourceFile.\n */\nexport class FactoryGenerator implements ShimGenerator {\n  private constructor(private map: Map<string, string>) {}\n\n  get factoryFileMap(): Map<string, string> { return this.map; }\n\n  recognize(fileName: AbsoluteFsPath): boolean { return this.map.has(fileName); }\n\n  generate(genFilePath: AbsoluteFsPath, readFile: (fileName: string) => ts.SourceFile | null):\n      ts.SourceFile|null {\n    const originalPath = this.map.get(genFilePath) !;\n    const original = readFile(originalPath);\n    if (original === null) {\n      return null;\n    }\n\n    const relativePathToSource = './' + basename(original.fileName).replace(TS_DTS_SUFFIX, '');\n    // Collect a list of classes that need to have factory types emitted for them. This list is\n    // overly broad as at this point the ts.TypeChecker hasn't been created, and can't be used to\n    // semantically understand which decorated types are actually decorated with Angular decorators.\n    //\n    // The exports generated here are pruned in the factory transform during emit.\n    const symbolNames = original\n                            .statements\n                            // Pick out top level class declarations...\n                            .filter(ts.isClassDeclaration)\n                            // which are named, exported, and have decorators.\n                            .filter(\n                                decl => isExported(decl) && decl.decorators !== undefined &&\n                                    decl.name !== undefined)\n                            // Grab the symbol name.\n                            .map(decl => decl.name !.text);\n\n\n    // If there is a top-level comment in the original file, copy it over at the top of the\n    // generated factory file. This is important for preserving any load-bearing jsdoc comments.\n    let comment: string = '';\n    if (original.statements.length > 0) {\n      const firstStatement = original.statements[0];\n      // Must pass SourceFile to getLeadingTriviaWidth() and getFullText(), otherwise it'll try to\n      // get SourceFile by recursively looking up the parent of the Node and fail,\n      // because parent is undefined.\n      const leadingTriviaWidth = firstStatement.getLeadingTriviaWidth(original);\n      if (leadingTriviaWidth > 0) {\n        comment = firstStatement.getFullText(original).substr(0, leadingTriviaWidth);\n      }\n    }\n\n    let sourceText = comment;\n    if (symbolNames.length > 0) {\n      // For each symbol name, generate a constant export of the corresponding NgFactory.\n      // This will encompass a lot of symbols which don't need factories, but that's okay\n      // because it won't miss any that do.\n      const varLines = symbolNames.map(\n          name =>\n              `export const ${name}NgFactory: i0.ɵNgModuleFactory<any> = new i0.ɵNgModuleFactory(${name});`);\n      sourceText += [\n        // This might be incorrect if the current package being compiled is Angular core, but it's\n        // okay to leave in at type checking time. TypeScript can handle this reference via its path\n        // mapping, but downstream bundlers can't. If the current package is core itself, this will\n        // be replaced in the factory transformer before emit.\n        `import * as i0 from '@angular/core';`,\n        `import {${symbolNames.join(', ')}} from '${relativePathToSource}';`,\n        ...varLines,\n      ].join('\\n');\n    }\n\n    // Add an extra export to ensure this module has at least one. It'll be removed later in the\n    // factory transformer if it ends up not being needed.\n    sourceText += '\\nexport const ɵNonEmptyModule = true;';\n\n    const genFile = ts.createSourceFile(\n        genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);\n    if (original.moduleName !== undefined) {\n      genFile.moduleName =\n          generatedModuleName(original.moduleName, original.fileName, '.ngfactory');\n    }\n    return genFile;\n  }\n\n  static forRootFiles(files: ReadonlyArray<AbsoluteFsPath>): FactoryGenerator {\n    const map = new Map<AbsoluteFsPath, string>();\n    files.filter(sourceFile => isNonDeclarationTsPath(sourceFile))\n        .forEach(\n            sourceFile =>\n                map.set(absoluteFrom(sourceFile.replace(/\\.ts$/, '.ngfactory.ts')), sourceFile));\n    return new FactoryGenerator(map);\n  }\n}\n\nfunction isExported(decl: ts.Declaration): boolean {\n  return decl.modifiers !== undefined &&\n      decl.modifiers.some(mod => mod.kind == ts.SyntaxKind.ExportKeyword);\n}\n\nexport interface FactoryInfo {\n  sourceFilePath: string;\n  moduleSymbolNames: Set<string>;\n}\n\nexport function generatedFactoryTransform(\n    factoryMap: Map<string, FactoryInfo>,\n    importRewriter: ImportRewriter): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {\n    return (file: ts.SourceFile): ts.SourceFile => {\n      return transformFactorySourceFile(factoryMap, context, importRewriter, file);\n    };\n  };\n}\n\nfunction transformFactorySourceFile(\n    factoryMap: Map<string, FactoryInfo>, context: ts.TransformationContext,\n    importRewriter: ImportRewriter, file: ts.SourceFile): ts.SourceFile {\n  // If this is not a generated file, it won't have factory info associated with it.\n  if (!factoryMap.has(file.fileName)) {\n    // Don't transform non-generated code.\n    return file;\n  }\n\n  const {moduleSymbolNames, sourceFilePath} = factoryMap.get(file.fileName) !;\n\n  file = ts.getMutableClone(file);\n\n  // Not every exported factory statement is valid. They were generated before the program was\n  // analyzed, and before ngtsc knew which symbols were actually NgModules. factoryMap contains\n  // that knowledge now, so this transform filters the statement list and removes exported factories\n  // that aren't actually factories.\n  //\n  // This could leave the generated factory file empty. To prevent this (it causes issues with\n  // closure compiler) a 'ɵNonEmptyModule' export was added when the factory shim was created.\n  // Preserve that export if needed, and remove it otherwise.\n  //\n  // Additionally, an import to @angular/core is generated, but the current compilation unit could\n  // actually be @angular/core, in which case such an import is invalid and should be replaced with\n  // the proper path to access Ivy symbols in core.\n\n  // The filtered set of statements.\n  const transformedStatements: ts.Statement[] = [];\n\n  // The statement identified as the ɵNonEmptyModule export.\n  let nonEmptyExport: ts.Statement|null = null;\n\n  // Extracted identifiers which refer to import statements from @angular/core.\n  const coreImportIdentifiers = new Set<string>();\n\n  // Consider all the statements.\n  for (const stmt of file.statements) {\n    // Look for imports to @angular/core.\n    if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) &&\n        stmt.moduleSpecifier.text === '@angular/core') {\n      // Update the import path to point to the correct file using the ImportRewriter.\n      const rewrittenModuleSpecifier =\n          importRewriter.rewriteSpecifier('@angular/core', sourceFilePath);\n      if (rewrittenModuleSpecifier !== stmt.moduleSpecifier.text) {\n        transformedStatements.push(ts.updateImportDeclaration(\n            stmt, stmt.decorators, stmt.modifiers, stmt.importClause,\n            ts.createStringLiteral(rewrittenModuleSpecifier)));\n\n        // Record the identifier by which this imported module goes, so references to its symbols\n        // can be discovered later.\n        if (stmt.importClause !== undefined && stmt.importClause.namedBindings !== undefined &&\n            ts.isNamespaceImport(stmt.importClause.namedBindings)) {\n          coreImportIdentifiers.add(stmt.importClause.namedBindings.name.text);\n        }\n      } else {\n        transformedStatements.push(stmt);\n      }\n    } else if (ts.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {\n      const decl = stmt.declarationList.declarations[0];\n\n      // If this is the ɵNonEmptyModule export, then save it for later.\n      if (ts.isIdentifier(decl.name)) {\n        if (decl.name.text === 'ɵNonEmptyModule') {\n          nonEmptyExport = stmt;\n          continue;\n        }\n\n        // Otherwise, check if this export is a factory for a known NgModule, and retain it if so.\n        const match = STRIP_NG_FACTORY.exec(decl.name.text);\n        if (match !== null && moduleSymbolNames.has(match[1])) {\n          transformedStatements.push(stmt);\n        }\n      } else {\n        // Leave the statement alone, as it can't be understood.\n        transformedStatements.push(stmt);\n      }\n    } else {\n      // Include non-variable statements (imports, etc).\n      transformedStatements.push(stmt);\n    }\n  }\n\n  // Check whether the empty module export is still needed.\n  if (!transformedStatements.some(ts.isVariableStatement) && nonEmptyExport !== null) {\n    // If the resulting file has no factories, include an empty export to\n    // satisfy closure compiler.\n    transformedStatements.push(nonEmptyExport);\n  }\n  file.statements = ts.createNodeArray(transformedStatements);\n\n  // If any imports to @angular/core were detected and rewritten (which happens when compiling\n  // @angular/core), go through the SourceFile and rewrite references to symbols imported from core.\n  if (coreImportIdentifiers.size > 0) {\n    const visit = <T extends ts.Node>(node: T): T => {\n      node = ts.visitEachChild(node, child => visit(child), context);\n\n      // Look for expressions of the form \"i.s\" where 'i' is a detected name for an @angular/core\n      // import that was changed above. Rewrite 's' using the ImportResolver.\n      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) &&\n          coreImportIdentifiers.has(node.expression.text)) {\n        // This is an import of a symbol from @angular/core. Transform it with the importRewriter.\n        const rewrittenSymbol = importRewriter.rewriteSymbol(node.name.text, '@angular/core');\n        if (rewrittenSymbol !== node.name.text) {\n          const updated =\n              ts.updatePropertyAccess(node, node.expression, ts.createIdentifier(rewrittenSymbol));\n          node = updated as T & ts.PropertyAccessExpression;\n        }\n      }\n      return node;\n    };\n\n    file = visit(file);\n  }\n\n  return file;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory_generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/shims/src/factory_generator.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,+BAAiC;IAEjC,2EAAyE;IAEzE,kFAAiE;IAGjE,uEAA2C;IAE3C,IAAM,aAAa,GAAG,aAAa,CAAC;IACpC,IAAM,gBAAgB,GAAG,gBAAgB,CAAC;IAE1C;;;OAGG;IACH;QACE,0BAA4B,GAAwB;YAAxB,QAAG,GAAH,GAAG,CAAqB;QAAG,CAAC;QAExD,sBAAI,4CAAc;iBAAlB,cAA4C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;;;WAAA;QAE9D,oCAAS,GAAT,UAAU,QAAwB,IAAa,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAE/E,mCAAQ,GAAR,UAAS,WAA2B,EAAE,QAAoD;YAExF,IAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,CAAG,CAAC;YACjD,IAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACxC,IAAI,QAAQ,KAAK,IAAI,EAAE;gBACrB,OAAO,IAAI,CAAC;aACb;YAED,IAAM,oBAAoB,GAAG,IAAI,GAAG,sBAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;YAC3F,2FAA2F;YAC3F,6FAA6F;YAC7F,gGAAgG;YAChG,EAAE;YACF,8EAA8E;YAC9E,IAAM,WAAW,GAAG,QAAQ;iBACH,UAAU;gBACX,2CAA2C;iBAC1C,MAAM,CAAC,EAAE,CAAC,kBAAkB,CAAC;gBAC9B,kDAAkD;iBACjD,MAAM,CACH,UAAA,IAAI,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS;gBACrD,IAAI,CAAC,IAAI,KAAK,SAAS,EADnB,CACmB,CAAC;gBAChC,wBAAwB;iBACvB,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,IAAM,CAAC,IAAI,EAAhB,CAAgB,CAAC,CAAC;YAGvD,uFAAuF;YACvF,4FAA4F;YAC5F,IAAI,OAAO,GAAW,EAAE,CAAC;YACzB,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;gBAClC,IAAM,cAAc,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;gBAC9C,4FAA4F;gBAC5F,4EAA4E;gBAC5E,+BAA+B;gBAC/B,IAAM,kBAAkB,GAAG,cAAc,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;gBAC1E,IAAI,kBAAkB,GAAG,CAAC,EAAE;oBAC1B,OAAO,GAAG,cAAc,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;iBAC9E;aACF;YAED,IAAI,UAAU,GAAG,OAAO,CAAC;YACzB,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC1B,mFAAmF;gBACnF,mFAAmF;gBACnF,qCAAqC;gBACrC,IAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAC5B,UAAA,IAAI;oBACA,OAAA,kBAAgB,IAAI,gFAAiE,IAAI,OAAI;gBAA7F,CAA6F,CAAC,CAAC;gBACvG,UAAU,IAAI;oBACZ,0FAA0F;oBAC1F,4FAA4F;oBAC5F,2FAA2F;oBAC3F,sDAAsD;oBACtD,sCAAsC;oBACtC,aAAW,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAW,oBAAoB,OAAI;mBACjE,QAAQ,EACX,IAAI,CAAC,IAAI,CAAC,CAAC;aACd;YAED,4FAA4F;YAC5F,sDAAsD;YACtD,UAAU,IAAI,wCAAwC,CAAC;YAEvD,IAAM,OAAO,GAAG,EAAE,CAAC,gBAAgB,CAC/B,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC,eAAe,EAAE,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAC/E,IAAI,QAAQ,CAAC,UAAU,KAAK,SAAS,EAAE;gBACrC,OAAO,CAAC,UAAU;oBACd,0BAAmB,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;aAC/E;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QAEM,6BAAY,GAAnB,UAAoB,KAAoC;YACtD,IAAM,GAAG,GAAG,IAAI,GAAG,EAA0B,CAAC;YAC9C,KAAK,CAAC,MAAM,CAAC,UAAA,UAAU,IAAI,OAAA,mCAAsB,CAAC,UAAU,CAAC,EAAlC,CAAkC,CAAC;iBACzD,OAAO,CACJ,UAAA,UAAU;gBACN,OAAA,GAAG,CAAC,GAAG,CAAC,0BAAY,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,EAAE,UAAU,CAAC;YAA/E,CAA+E,CAAC,CAAC;YAC7F,OAAO,IAAI,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACnC,CAAC;QACH,uBAAC;IAAD,CAAC,AAvFD,IAuFC;IAvFY,4CAAgB;IAyF7B,SAAS,UAAU,CAAC,IAAoB;QACtC,OAAO,IAAI,CAAC,SAAS,KAAK,SAAS;YAC/B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,UAAU,CAAC,aAAa,EAAvC,CAAuC,CAAC,CAAC;IAC1E,CAAC;IAOD,SAAgB,yBAAyB,CACrC,UAAoC,EACpC,cAA8B;QAChC,OAAO,UAAC,OAAiC;YACvC,OAAO,UAAC,IAAmB;gBACzB,OAAO,0BAA0B,CAAC,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;YAC/E,CAAC,CAAC;QACJ,CAAC,CAAC;IACJ,CAAC;IARD,8DAQC;IAED,SAAS,0BAA0B,CAC/B,UAAoC,EAAE,OAAiC,EACvE,cAA8B,EAAE,IAAmB;;QACrD,kFAAkF;QAClF,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YAClC,sCAAsC;YACtC,OAAO,IAAI,CAAC;SACb;QAEK,IAAA,kCAAqE,EAApE,wCAAiB,EAAE,kCAAiD,CAAC;QAE5E,IAAI,GAAG,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAEhC,4FAA4F;QAC5F,6FAA6F;QAC7F,kGAAkG;QAClG,kCAAkC;QAClC,EAAE;QACF,4FAA4F;QAC5F,4FAA4F;QAC5F,2DAA2D;QAC3D,EAAE;QACF,gGAAgG;QAChG,iGAAiG;QACjG,iDAAiD;QAEjD,kCAAkC;QAClC,IAAM,qBAAqB,GAAmB,EAAE,CAAC;QAEjD,0DAA0D;QAC1D,IAAI,cAAc,GAAsB,IAAI,CAAC;QAE7C,6EAA6E;QAC7E,IAAM,qBAAqB,GAAG,IAAI,GAAG,EAAU,CAAC;;YAEhD,+BAA+B;YAC/B,KAAmB,IAAA,KAAA,iBAAA,IAAI,CAAC,UAAU,CAAA,gBAAA,4BAAE;gBAA/B,IAAM,IAAI,WAAA;gBACb,qCAAqC;gBACrC,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC;oBACxE,IAAI,CAAC,eAAe,CAAC,IAAI,KAAK,eAAe,EAAE;oBACjD,gFAAgF;oBAChF,IAAM,wBAAwB,GAC1B,cAAc,CAAC,gBAAgB,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;oBACrE,IAAI,wBAAwB,KAAK,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE;wBAC1D,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACjD,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,EACxD,EAAE,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;wBAEvD,yFAAyF;wBACzF,2BAA2B;wBAC3B,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,aAAa,KAAK,SAAS;4BAChF,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE;4BACzD,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;yBACtE;qBACF;yBAAM;wBACL,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBAClC;iBACF;qBAAM,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;oBACzF,IAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;oBAElD,iEAAiE;oBACjE,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;wBAC9B,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE;4BACxC,cAAc,GAAG,IAAI,CAAC;4BACtB,SAAS;yBACV;wBAED,0FAA0F;wBAC1F,IAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;wBACpD,IAAI,KAAK,KAAK,IAAI,IAAI,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;4BACrD,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;yBAClC;qBACF;yBAAM;wBACL,wDAAwD;wBACxD,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBAClC;iBACF;qBAAM;oBACL,kDAAkD;oBAClD,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAClC;aACF;;;;;;;;;QAED,yDAAyD;QACzD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,IAAI,cAAc,KAAK,IAAI,EAAE;YAClF,qEAAqE;YACrE,4BAA4B;YAC5B,qBAAqB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;SAC5C;QACD,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC;QAE5D,4FAA4F;QAC5F,kGAAkG;QAClG,IAAI,qBAAqB,CAAC,IAAI,GAAG,CAAC,EAAE;YAClC,IAAM,OAAK,GAAG,UAAoB,IAAO;gBACvC,IAAI,GAAG,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,UAAA,KAAK,IAAI,OAAA,OAAK,CAAC,KAAK,CAAC,EAAZ,CAAY,EAAE,OAAO,CAAC,CAAC;gBAE/D,2FAA2F;gBAC3F,uEAAuE;gBACvE,IAAI,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC;oBACvE,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;oBACnD,0FAA0F;oBAC1F,IAAM,eAAe,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;oBACtF,IAAI,eAAe,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;wBACtC,IAAM,OAAO,GACT,EAAE,CAAC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,CAAC;wBACzF,IAAI,GAAG,OAA0C,CAAC;qBACnD;iBACF;gBACD,OAAO,IAAI,CAAC;YACd,CAAC,CAAC;YAEF,IAAI,GAAG,OAAK,CAAC,IAAI,CAAC,CAAC;SACpB;QAED,OAAO,IAAI,CAAC;IACd,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath, absoluteFrom, basename} from '../../file_system';\nimport {ImportRewriter} from '../../imports';\nimport {isNonDeclarationTsPath} from '../../util/src/typescript';\n\nimport {ShimGenerator} from './api';\nimport {generatedModuleName} from './util';\n\nconst TS_DTS_SUFFIX = /(\\.d)?\\.ts$/;\nconst STRIP_NG_FACTORY = /(.*)NgFactory$/;\n\n/**\n * Generates ts.SourceFiles which contain variable declarations for NgFactories for every exported\n * class of an input ts.SourceFile.\n */\nexport class FactoryGenerator implements ShimGenerator {\n  private constructor(private map: Map<string, string>) {}\n\n  get factoryFileMap(): Map<string, string> { return this.map; }\n\n  recognize(fileName: AbsoluteFsPath): boolean { return this.map.has(fileName); }\n\n  generate(genFilePath: AbsoluteFsPath, readFile: (fileName: string) => ts.SourceFile | null):\n      ts.SourceFile|null {\n    const originalPath = this.map.get(genFilePath) !;\n    const original = readFile(originalPath);\n    if (original === null) {\n      return null;\n    }\n\n    const relativePathToSource = './' + basename(original.fileName).replace(TS_DTS_SUFFIX, '');\n    // Collect a list of classes that need to have factory types emitted for them. This list is\n    // overly broad as at this point the ts.TypeChecker hasn't been created, and can't be used to\n    // semantically understand which decorated types are actually decorated with Angular decorators.\n    //\n    // The exports generated here are pruned in the factory transform during emit.\n    const symbolNames = original\n                            .statements\n                            // Pick out top level class declarations...\n                            .filter(ts.isClassDeclaration)\n                            // which are named, exported, and have decorators.\n                            .filter(\n                                decl => isExported(decl) && decl.decorators !== undefined &&\n                                    decl.name !== undefined)\n                            // Grab the symbol name.\n                            .map(decl => decl.name !.text);\n\n\n    // If there is a top-level comment in the original file, copy it over at the top of the\n    // generated factory file. This is important for preserving any load-bearing jsdoc comments.\n    let comment: string = '';\n    if (original.statements.length > 0) {\n      const firstStatement = original.statements[0];\n      // Must pass SourceFile to getLeadingTriviaWidth() and getFullText(), otherwise it'll try to\n      // get SourceFile by recursively looking up the parent of the Node and fail,\n      // because parent is undefined.\n      const leadingTriviaWidth = firstStatement.getLeadingTriviaWidth(original);\n      if (leadingTriviaWidth > 0) {\n        comment = firstStatement.getFullText(original).substr(0, leadingTriviaWidth);\n      }\n    }\n\n    let sourceText = comment;\n    if (symbolNames.length > 0) {\n      // For each symbol name, generate a constant export of the corresponding NgFactory.\n      // This will encompass a lot of symbols which don't need factories, but that's okay\n      // because it won't miss any that do.\n      const varLines = symbolNames.map(\n          name =>\n              `export const ${name}NgFactory: i0.ɵNgModuleFactory<any> = new i0.ɵNgModuleFactory(${name});`);\n      sourceText += [\n        // This might be incorrect if the current package being compiled is Angular core, but it's\n        // okay to leave in at type checking time. TypeScript can handle this reference via its path\n        // mapping, but downstream bundlers can't. If the current package is core itself, this will\n        // be replaced in the factory transformer before emit.\n        `import * as i0 from '@angular/core';`,\n        `import {${symbolNames.join(', ')}} from '${relativePathToSource}';`,\n        ...varLines,\n      ].join('\\n');\n    }\n\n    // Add an extra export to ensure this module has at least one. It'll be removed later in the\n    // factory transformer if it ends up not being needed.\n    sourceText += '\\nexport const ɵNonEmptyModule = true;';\n\n    const genFile = ts.createSourceFile(\n        genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);\n    if (original.moduleName !== undefined) {\n      genFile.moduleName =\n          generatedModuleName(original.moduleName, original.fileName, '.ngfactory');\n    }\n    return genFile;\n  }\n\n  static forRootFiles(files: ReadonlyArray<AbsoluteFsPath>): FactoryGenerator {\n    const map = new Map<AbsoluteFsPath, string>();\n    files.filter(sourceFile => isNonDeclarationTsPath(sourceFile))\n        .forEach(\n            sourceFile =>\n                map.set(absoluteFrom(sourceFile.replace(/\\.ts$/, '.ngfactory.ts')), sourceFile));\n    return new FactoryGenerator(map);\n  }\n}\n\nfunction isExported(decl: ts.Declaration): boolean {\n  return decl.modifiers !== undefined &&\n      decl.modifiers.some(mod => mod.kind == ts.SyntaxKind.ExportKeyword);\n}\n\nexport interface FactoryInfo {\n  sourceFilePath: string;\n  moduleSymbolNames: Set<string>;\n}\n\nexport function generatedFactoryTransform(\n    factoryMap: Map<string, FactoryInfo>,\n    importRewriter: ImportRewriter): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {\n    return (file: ts.SourceFile): ts.SourceFile => {\n      return transformFactorySourceFile(factoryMap, context, importRewriter, file);\n    };\n  };\n}\n\nfunction transformFactorySourceFile(\n    factoryMap: Map<string, FactoryInfo>, context: ts.TransformationContext,\n    importRewriter: ImportRewriter, file: ts.SourceFile): ts.SourceFile {\n  // If this is not a generated file, it won't have factory info associated with it.\n  if (!factoryMap.has(file.fileName)) {\n    // Don't transform non-generated code.\n    return file;\n  }\n\n  const {moduleSymbolNames, sourceFilePath} = factoryMap.get(file.fileName) !;\n\n  file = ts.getMutableClone(file);\n\n  // Not every exported factory statement is valid. They were generated before the program was\n  // analyzed, and before ngtsc knew which symbols were actually NgModules. factoryMap contains\n  // that knowledge now, so this transform filters the statement list and removes exported factories\n  // that aren't actually factories.\n  //\n  // This could leave the generated factory file empty. To prevent this (it causes issues with\n  // closure compiler) a 'ɵNonEmptyModule' export was added when the factory shim was created.\n  // Preserve that export if needed, and remove it otherwise.\n  //\n  // Additionally, an import to @angular/core is generated, but the current compilation unit could\n  // actually be @angular/core, in which case such an import is invalid and should be replaced with\n  // the proper path to access Ivy symbols in core.\n\n  // The filtered set of statements.\n  const transformedStatements: ts.Statement[] = [];\n\n  // The statement identified as the ɵNonEmptyModule export.\n  let nonEmptyExport: ts.Statement|null = null;\n\n  // Extracted identifiers which refer to import statements from @angular/core.\n  const coreImportIdentifiers = new Set<string>();\n\n  // Consider all the statements.\n  for (const stmt of file.statements) {\n    // Look for imports to @angular/core.\n    if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) &&\n        stmt.moduleSpecifier.text === '@angular/core') {\n      // Update the import path to point to the correct file using the ImportRewriter.\n      const rewrittenModuleSpecifier =\n          importRewriter.rewriteSpecifier('@angular/core', sourceFilePath);\n      if (rewrittenModuleSpecifier !== stmt.moduleSpecifier.text) {\n        transformedStatements.push(ts.updateImportDeclaration(\n            stmt, stmt.decorators, stmt.modifiers, stmt.importClause,\n            ts.createStringLiteral(rewrittenModuleSpecifier)));\n\n        // Record the identifier by which this imported module goes, so references to its symbols\n        // can be discovered later.\n        if (stmt.importClause !== undefined && stmt.importClause.namedBindings !== undefined &&\n            ts.isNamespaceImport(stmt.importClause.namedBindings)) {\n          coreImportIdentifiers.add(stmt.importClause.namedBindings.name.text);\n        }\n      } else {\n        transformedStatements.push(stmt);\n      }\n    } else if (ts.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {\n      const decl = stmt.declarationList.declarations[0];\n\n      // If this is the ɵNonEmptyModule export, then save it for later.\n      if (ts.isIdentifier(decl.name)) {\n        if (decl.name.text === 'ɵNonEmptyModule') {\n          nonEmptyExport = stmt;\n          continue;\n        }\n\n        // Otherwise, check if this export is a factory for a known NgModule, and retain it if so.\n        const match = STRIP_NG_FACTORY.exec(decl.name.text);\n        if (match !== null && moduleSymbolNames.has(match[1])) {\n          transformedStatements.push(stmt);\n        }\n      } else {\n        // Leave the statement alone, as it can't be understood.\n        transformedStatements.push(stmt);\n      }\n    } else {\n      // Include non-variable statements (imports, etc).\n      transformedStatements.push(stmt);\n    }\n  }\n\n  // Check whether the empty module export is still needed.\n  if (!transformedStatements.some(ts.isVariableStatement) && nonEmptyExport !== null) {\n    // If the resulting file has no factories, include an empty export to\n    // satisfy closure compiler.\n    transformedStatements.push(nonEmptyExport);\n  }\n  file.statements = ts.createNodeArray(transformedStatements);\n\n  // If any imports to @angular/core were detected and rewritten (which happens when compiling\n  // @angular/core), go through the SourceFile and rewrite references to symbols imported from core.\n  if (coreImportIdentifiers.size > 0) {\n    const visit = <T extends ts.Node>(node: T): T => {\n      node = ts.visitEachChild(node, child => visit(child), context);\n\n      // Look for expressions of the form \"i.s\" where 'i' is a detected name for an @angular/core\n      // import that was changed above. Rewrite 's' using the ImportResolver.\n      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) &&\n          coreImportIdentifiers.has(node.expression.text)) {\n        // This is an import of a symbol from @angular/core. Transform it with the importRewriter.\n        const rewrittenSymbol = importRewriter.rewriteSymbol(node.name.text, '@angular/core');\n        if (rewrittenSymbol !== node.name.text) {\n          const updated =\n              ts.updatePropertyAccess(node, node.expression, ts.createIdentifier(rewrittenSymbol));\n          node = updated as T & ts.PropertyAccessExpression;\n        }\n      }\n      return node;\n    };\n\n    file = visit(file);\n  }\n\n  return file;\n}\n"]}

package/src/ngtsc/shims/src/summary_generator.d.ts

@@ -8,7 +8,7 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/shims/src/summary_generator" />
 import * as ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
-import { ShimGenerator } from './host';
+import { ShimGenerator } from './api';
 export declare class SummaryGenerator implements ShimGenerator {
     private map;
     private constructor();

package/src/ngtsc/shims/src/summary_generator.js

@@ -113,4 +113,4 @@
             decl.modifiers.some(function (mod) { return mod.kind == ts.SyntaxKind.ExportKeyword; });
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"summary_generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/shims/src/summary_generator.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 {AbsoluteFsPath, absoluteFrom} from '../../file_system';\nimport {isNonDeclarationTsPath} from '../../util/src/typescript';\n\nimport {ShimGenerator} from './host';\nimport {generatedModuleName} from './util';\n\nexport class SummaryGenerator implements ShimGenerator {\n  private constructor(private map: Map<AbsoluteFsPath, string>) {}\n\n  getSummaryFileNames(): string[] { return Array.from(this.map.keys()); }\n\n  recognize(fileName: AbsoluteFsPath): boolean { return this.map.has(fileName); }\n\n  generate(genFilePath: AbsoluteFsPath, readFile: (fileName: string) => ts.SourceFile | null):\n      ts.SourceFile|null {\n    const originalPath = this.map.get(genFilePath) !;\n    const original = readFile(originalPath);\n    if (original === null) {\n      return null;\n    }\n\n    // Collect a list of classes that need to have factory types emitted for them. This list is\n    // overly broad as at this point the ts.TypeChecker has not been created and so it can't be used\n    // to semantically understand which decorators are Angular decorators. It's okay to output an\n    // overly broad set of summary exports as the exports are no-ops anyway, and summaries are a\n    // compatibility layer which will be removed after Ivy is enabled.\n    const symbolNames: string[] = [];\n    for (const stmt of original.statements) {\n      if (ts.isClassDeclaration(stmt)) {\n        // If the class isn't exported, or if it's not decorated, then skip it.\n        if (!isExported(stmt) || stmt.decorators === undefined || stmt.name === undefined) {\n          continue;\n        }\n        symbolNames.push(stmt.name.text);\n      } else if (ts.isExportDeclaration(stmt)) {\n        // Look for an export statement of the form \"export {...};\". If it doesn't match that, then\n        // skip it.\n        if (stmt.exportClause === undefined || stmt.moduleSpecifier !== undefined) {\n          continue;\n        }\n\n        for (const specifier of stmt.exportClause.elements) {\n          // At this point, there is no guarantee that specifier here refers to a class declaration,\n          // but that's okay.\n\n          // Use specifier.name as that's guaranteed to be the exported name, regardless of whether\n          // specifier.propertyName is set.\n          symbolNames.push(specifier.name.text);\n        }\n      }\n    }\n\n    const varLines = symbolNames.map(name => `export const ${name}NgSummary: any = null;`);\n\n    if (varLines.length === 0) {\n      // In the event there are no other exports, add an empty export to ensure the generated\n      // summary file is still an ES module.\n      varLines.push(`export const ɵempty = null;`);\n    }\n    const sourceText = varLines.join('\\n');\n    const genFile = ts.createSourceFile(\n        genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);\n    if (original.moduleName !== undefined) {\n      genFile.moduleName =\n          generatedModuleName(original.moduleName, original.fileName, '.ngsummary');\n    }\n    return genFile;\n  }\n\n  static forRootFiles(files: ReadonlyArray<AbsoluteFsPath>): SummaryGenerator {\n    const map = new Map<AbsoluteFsPath, string>();\n    files.filter(sourceFile => isNonDeclarationTsPath(sourceFile))\n        .forEach(\n            sourceFile =>\n                map.set(absoluteFrom(sourceFile.replace(/\\.ts$/, '.ngsummary.ts')), sourceFile));\n    return new SummaryGenerator(map);\n  }\n}\n\nfunction isExported(decl: ts.Declaration): boolean {\n  return decl.modifiers !== undefined &&\n      decl.modifiers.some(mod => mod.kind == ts.SyntaxKind.ExportKeyword);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"summary_generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/shims/src/summary_generator.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 {AbsoluteFsPath, absoluteFrom} from '../../file_system';\nimport {isNonDeclarationTsPath} from '../../util/src/typescript';\n\nimport {ShimGenerator} from './api';\nimport {generatedModuleName} from './util';\n\nexport class SummaryGenerator implements ShimGenerator {\n  private constructor(private map: Map<AbsoluteFsPath, string>) {}\n\n  getSummaryFileNames(): string[] { return Array.from(this.map.keys()); }\n\n  recognize(fileName: AbsoluteFsPath): boolean { return this.map.has(fileName); }\n\n  generate(genFilePath: AbsoluteFsPath, readFile: (fileName: string) => ts.SourceFile | null):\n      ts.SourceFile|null {\n    const originalPath = this.map.get(genFilePath) !;\n    const original = readFile(originalPath);\n    if (original === null) {\n      return null;\n    }\n\n    // Collect a list of classes that need to have factory types emitted for them. This list is\n    // overly broad as at this point the ts.TypeChecker has not been created and so it can't be used\n    // to semantically understand which decorators are Angular decorators. It's okay to output an\n    // overly broad set of summary exports as the exports are no-ops anyway, and summaries are a\n    // compatibility layer which will be removed after Ivy is enabled.\n    const symbolNames: string[] = [];\n    for (const stmt of original.statements) {\n      if (ts.isClassDeclaration(stmt)) {\n        // If the class isn't exported, or if it's not decorated, then skip it.\n        if (!isExported(stmt) || stmt.decorators === undefined || stmt.name === undefined) {\n          continue;\n        }\n        symbolNames.push(stmt.name.text);\n      } else if (ts.isExportDeclaration(stmt)) {\n        // Look for an export statement of the form \"export {...};\". If it doesn't match that, then\n        // skip it.\n        if (stmt.exportClause === undefined || stmt.moduleSpecifier !== undefined) {\n          continue;\n        }\n\n        for (const specifier of stmt.exportClause.elements) {\n          // At this point, there is no guarantee that specifier here refers to a class declaration,\n          // but that's okay.\n\n          // Use specifier.name as that's guaranteed to be the exported name, regardless of whether\n          // specifier.propertyName is set.\n          symbolNames.push(specifier.name.text);\n        }\n      }\n    }\n\n    const varLines = symbolNames.map(name => `export const ${name}NgSummary: any = null;`);\n\n    if (varLines.length === 0) {\n      // In the event there are no other exports, add an empty export to ensure the generated\n      // summary file is still an ES module.\n      varLines.push(`export const ɵempty = null;`);\n    }\n    const sourceText = varLines.join('\\n');\n    const genFile = ts.createSourceFile(\n        genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);\n    if (original.moduleName !== undefined) {\n      genFile.moduleName =\n          generatedModuleName(original.moduleName, original.fileName, '.ngsummary');\n    }\n    return genFile;\n  }\n\n  static forRootFiles(files: ReadonlyArray<AbsoluteFsPath>): SummaryGenerator {\n    const map = new Map<AbsoluteFsPath, string>();\n    files.filter(sourceFile => isNonDeclarationTsPath(sourceFile))\n        .forEach(\n            sourceFile =>\n                map.set(absoluteFrom(sourceFile.replace(/\\.ts$/, '.ngsummary.ts')), sourceFile));\n    return new SummaryGenerator(map);\n  }\n}\n\nfunction isExported(decl: ts.Declaration): boolean {\n  return decl.modifiers !== undefined &&\n      decl.modifiers.some(mod => mod.kind == ts.SyntaxKind.ExportKeyword);\n}\n"]}

package/src/ngtsc/shims/src/typecheck_shim.d.ts

@@ -8,7 +8,7 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/shims/src/typecheck_shim" />
 import * as ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
-import { ShimGenerator } from './host';
+import { ShimGenerator } from './api';
 /**
  * A `ShimGenerator` which adds a type-checking file to the `ts.Program`.
  *

package/src/ngtsc/shims/src/typecheck_shim.js

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

package/src/ngtsc/transform/index.d.ts

@@ -7,6 +7,8 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/transform" />
 export * from './src/api';
+export { aliasTransformFactory } from './src/alias';
 export { ClassRecord, TraitCompiler } from './src/compilation';
 export { declarationTransformFactory, DtsTransformRegistry, IvyDeclarationDtsTransform, ReturnTypeTransform } from './src/declaration';
+export { AnalyzedTrait, ErroredTrait, PendingTrait, ResolvedTrait, SkippedTrait, Trait, TraitState } from './src/trait';
 export { ivyTransformFactory } from './src/transform';

package/src/ngtsc/transform/index.js

@@ -11,13 +11,15 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/transform", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/transform/src/api", "@angular/compiler-cli/src/ngtsc/transform/src/compilation", "@angular/compiler-cli/src/ngtsc/transform/src/declaration", "@angular/compiler-cli/src/ngtsc/transform/src/transform"], factory);
+        define("@angular/compiler-cli/src/ngtsc/transform", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/transform/src/api", "@angular/compiler-cli/src/ngtsc/transform/src/alias", "@angular/compiler-cli/src/ngtsc/transform/src/compilation", "@angular/compiler-cli/src/ngtsc/transform/src/declaration", "@angular/compiler-cli/src/ngtsc/transform/src/trait", "@angular/compiler-cli/src/ngtsc/transform/src/transform"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var tslib_1 = require("tslib");
     tslib_1.__exportStar(require("@angular/compiler-cli/src/ngtsc/transform/src/api"), exports);
+    var alias_1 = require("@angular/compiler-cli/src/ngtsc/transform/src/alias");
+    exports.aliasTransformFactory = alias_1.aliasTransformFactory;
     var compilation_1 = require("@angular/compiler-cli/src/ngtsc/transform/src/compilation");
     exports.TraitCompiler = compilation_1.TraitCompiler;
     var declaration_1 = require("@angular/compiler-cli/src/ngtsc/transform/src/declaration");
@@ -25,7 +27,10 @@
     exports.DtsTransformRegistry = declaration_1.DtsTransformRegistry;
     exports.IvyDeclarationDtsTransform = declaration_1.IvyDeclarationDtsTransform;
     exports.ReturnTypeTransform = declaration_1.ReturnTypeTransform;
+    var trait_1 = require("@angular/compiler-cli/src/ngtsc/transform/src/trait");
+    exports.Trait = trait_1.Trait;
+    exports.TraitState = trait_1.TraitState;
     var transform_1 = require("@angular/compiler-cli/src/ngtsc/transform/src/transform");
     exports.ivyTransformFactory = transform_1.ivyTransformFactory;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3RyYW5zZm9ybS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSCw0RkFBMEI7SUFDMUIseUZBQTZEO0lBQXhDLHNDQUFBLGFBQWEsQ0FBQTtJQUNsQyx5RkFBcUk7SUFBN0gsb0RBQUEsMkJBQTJCLENBQUE7SUFBRSw2Q0FBQSxvQkFBb0IsQ0FBQTtJQUFFLG1EQUFBLDBCQUEwQixDQUFBO0lBQUUsNENBQUEsbUJBQW1CLENBQUE7SUFDMUcscUZBQW9EO0lBQTVDLDBDQUFBLG1CQUFtQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcGknO1xuZXhwb3J0IHtDbGFzc1JlY29yZCwgVHJhaXRDb21waWxlcn0gZnJvbSAnLi9zcmMvY29tcGlsYXRpb24nO1xuZXhwb3J0IHtkZWNsYXJhdGlvblRyYW5zZm9ybUZhY3RvcnksIER0c1RyYW5zZm9ybVJlZ2lzdHJ5LCBJdnlEZWNsYXJhdGlvbkR0c1RyYW5zZm9ybSwgUmV0dXJuVHlwZVRyYW5zZm9ybX0gZnJvbSAnLi9zcmMvZGVjbGFyYXRpb24nO1xuZXhwb3J0IHtpdnlUcmFuc2Zvcm1GYWN0b3J5fSBmcm9tICcuL3NyYy90cmFuc2Zvcm0nO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3RyYW5zZm9ybS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSCw0RkFBMEI7SUFDMUIsNkVBQWtEO0lBQTFDLHdDQUFBLHFCQUFxQixDQUFBO0lBQzdCLHlGQUE2RDtJQUF4QyxzQ0FBQSxhQUFhLENBQUE7SUFDbEMseUZBQXFJO0lBQTdILG9EQUFBLDJCQUEyQixDQUFBO0lBQUUsNkNBQUEsb0JBQW9CLENBQUE7SUFBRSxtREFBQSwwQkFBMEIsQ0FBQTtJQUFFLDRDQUFBLG1CQUFtQixDQUFBO0lBQzFHLDZFQUFzSDtJQUF0Qyx3QkFBQSxLQUFLLENBQUE7SUFBRSw2QkFBQSxVQUFVLENBQUE7SUFDakcscUZBQW9EO0lBQTVDLDBDQUFBLG1CQUFtQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcGknO1xuZXhwb3J0IHthbGlhc1RyYW5zZm9ybUZhY3Rvcnl9IGZyb20gJy4vc3JjL2FsaWFzJztcbmV4cG9ydCB7Q2xhc3NSZWNvcmQsIFRyYWl0Q29tcGlsZXJ9IGZyb20gJy4vc3JjL2NvbXBpbGF0aW9uJztcbmV4cG9ydCB7ZGVjbGFyYXRpb25UcmFuc2Zvcm1GYWN0b3J5LCBEdHNUcmFuc2Zvcm1SZWdpc3RyeSwgSXZ5RGVjbGFyYXRpb25EdHNUcmFuc2Zvcm0sIFJldHVyblR5cGVUcmFuc2Zvcm19IGZyb20gJy4vc3JjL2RlY2xhcmF0aW9uJztcbmV4cG9ydCB7QW5hbHl6ZWRUcmFpdCwgRXJyb3JlZFRyYWl0LCBQZW5kaW5nVHJhaXQsIFJlc29sdmVkVHJhaXQsIFNraXBwZWRUcmFpdCwgVHJhaXQsIFRyYWl0U3RhdGV9IGZyb20gJy4vc3JjL3RyYWl0JztcbmV4cG9ydCB7aXZ5VHJhbnNmb3JtRmFjdG9yeX0gZnJvbSAnLi9zcmMvdHJhbnNmb3JtJztcbiJdfQ==

package/src/ngtsc/transform/src/alias.d.ts

@@ -7,4 +7,4 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/transform/src/alias" />
 import * as ts from 'typescript';
-export declare function aliasTransformFactory(exportStatements: Map<string, Map<string, [string, string]>>): ts.TransformerFactory<ts.Bundle | ts.SourceFile>;
+export declare function aliasTransformFactory(exportStatements: Map<string, Map<string, [string, string]>>): ts.TransformerFactory<ts.SourceFile>;

package/src/ngtsc/transform/src/alias.js

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