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

package/src/ngtsc/core/src/host.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/core/src/host" />
+import * as ts from 'typescript';
+import { AbsoluteFsPath } from '../../file_system';
+import { FactoryTracker, ShimGenerator } from '../../shims';
+import { ExtendedTsCompilerHost, NgCompilerOptions, UnifiedModulesHost } from '../api';
+/**
+ * Represents the `ExtendedTsCompilerHost` interface, with a transformation applied that turns all
+ * methods (even optional ones) into required fields (which may be `undefined`, if the method was
+ * optional).
+ */
+export declare type RequiredCompilerHostDelegations = {
+    [M in keyof Required<ExtendedTsCompilerHost>]: ExtendedTsCompilerHost[M];
+};
+/**
+ * Delegates all methods of `ExtendedTsCompilerHost` to a delegate, with the exception of
+ * `getSourceFile` and `fileExists` which are implemented in `NgCompilerHost`.
+ *
+ * If a new method is added to `ts.CompilerHost` which is not delegated, a type error will be
+ * generated for this class.
+ */
+export declare class DelegatingCompilerHost implements Omit<RequiredCompilerHostDelegations, 'getSourceFile' | 'fileExists'> {
+    protected delegate: ExtendedTsCompilerHost;
+    constructor(delegate: ExtendedTsCompilerHost);
+    private delegateMethod;
+    createHash: ((data: string) => string) | undefined;
+    directoryExists: ((directoryName: string) => boolean) | undefined;
+    fileNameToModuleName: ((importedFilePath: string, containingFilePath: string) => string) | undefined;
+    getCancellationToken: (() => ts.CancellationToken) | undefined;
+    getCanonicalFileName: (fileName: string) => string;
+    getCurrentDirectory: () => string;
+    getDefaultLibFileName: (options: ts.CompilerOptions) => string;
+    getDefaultLibLocation: (() => string) | undefined;
+    getDirectories: ((path: string) => string[]) | undefined;
+    getEnvironmentVariable: ((name: string) => string | undefined) | undefined;
+    getModifiedResourceFiles: (() => Set<string> | undefined) | undefined;
+    getNewLine: () => string;
+    getParsedCommandLine: ((fileName: string) => ts.ParsedCommandLine | undefined) | undefined;
+    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
+    readDirectory: ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | undefined;
+    readFile: (fileName: string) => string | undefined;
+    readResource: ((fileName: string) => string | Promise<string>) | undefined;
+    realpath: ((path: string) => string) | undefined;
+    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedModule | undefined)[]) | undefined;
+    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
+    resourceNameToFileName: ((resourceName: string, containingFilePath: string) => string | null) | undefined;
+    trace: ((s: string) => void) | undefined;
+    useCaseSensitiveFileNames: () => boolean;
+    writeFile: ts.WriteFileCallback;
+}
+/**
+ * A wrapper around `ts.CompilerHost` (plus any extension methods from `ExtendedTsCompilerHost`).
+ *
+ * In order for a consumer to include Angular compilation in their TypeScript compiler, the
+ * `ts.Program` must be created with a host that adds Angular-specific files (e.g. factories,
+ * summaries, the template type-checking file, etc) to the compilation. `NgCompilerHost` is the
+ * host implementation which supports this.
+ *
+ * The interface implementations here ensure that `NgCompilerHost` fully delegates to
+ * `ExtendedTsCompilerHost` methods whenever present.
+ */
+export declare class NgCompilerHost extends DelegatingCompilerHost implements RequiredCompilerHostDelegations, ExtendedTsCompilerHost {
+    private shims;
+    readonly factoryTracker: FactoryTracker | null;
+    readonly entryPoint: AbsoluteFsPath | null;
+    readonly diagnostics: ts.Diagnostic[];
+    readonly inputFiles: ReadonlyArray<string>;
+    readonly rootDirs: ReadonlyArray<AbsoluteFsPath>;
+    readonly typeCheckFile: AbsoluteFsPath;
+    constructor(delegate: ExtendedTsCompilerHost, inputFiles: ReadonlyArray<string>, rootDirs: ReadonlyArray<AbsoluteFsPath>, shims: ShimGenerator[], entryPoint: AbsoluteFsPath | null, typeCheckFile: AbsoluteFsPath, factoryTracker: FactoryTracker | null, diagnostics: ts.Diagnostic[]);
+    /**
+     * Create an `NgCompilerHost` from a delegate host, an array of input filenames, and the full set
+     * of TypeScript and Angular compiler options.
+     */
+    static wrap(delegate: ts.CompilerHost, inputFiles: ReadonlyArray<string>, options: NgCompilerOptions): NgCompilerHost;
+    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined): ts.SourceFile | undefined;
+    fileExists(fileName: string): boolean;
+    get unifiedModulesHost(): UnifiedModulesHost | null;
+}

package/src/ngtsc/core/src/host.js

@@ -0,0 +1,208 @@
+/**
+ * @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/core/src/host", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/ngtsc/diagnostics", "@angular/compiler-cli/src/ngtsc/entry_point", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/shims", "@angular/compiler-cli/src/ngtsc/typecheck", "@angular/compiler-cli/src/ngtsc/util/src/path", "@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 diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics");
+    var entry_point_1 = require("@angular/compiler-cli/src/ngtsc/entry_point");
+    var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    var shims_1 = require("@angular/compiler-cli/src/ngtsc/shims");
+    var typecheck_1 = require("@angular/compiler-cli/src/ngtsc/typecheck");
+    var path_1 = require("@angular/compiler-cli/src/ngtsc/util/src/path");
+    var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
+    /**
+     * Delegates all methods of `ExtendedTsCompilerHost` to a delegate, with the exception of
+     * `getSourceFile` and `fileExists` which are implemented in `NgCompilerHost`.
+     *
+     * If a new method is added to `ts.CompilerHost` which is not delegated, a type error will be
+     * generated for this class.
+     */
+    var DelegatingCompilerHost = /** @class */ (function () {
+        function DelegatingCompilerHost(delegate) {
+            this.delegate = delegate;
+            // Excluded are 'getSourceFile' and 'fileExists', which are actually implemented by NgCompilerHost
+            // below.
+            this.createHash = this.delegateMethod('createHash');
+            this.directoryExists = this.delegateMethod('directoryExists');
+            this.fileNameToModuleName = this.delegateMethod('fileNameToModuleName');
+            this.getCancellationToken = this.delegateMethod('getCancellationToken');
+            this.getCanonicalFileName = this.delegateMethod('getCanonicalFileName');
+            this.getCurrentDirectory = this.delegateMethod('getCurrentDirectory');
+            this.getDefaultLibFileName = this.delegateMethod('getDefaultLibFileName');
+            this.getDefaultLibLocation = this.delegateMethod('getDefaultLibLocation');
+            this.getDirectories = this.delegateMethod('getDirectories');
+            this.getEnvironmentVariable = this.delegateMethod('getEnvironmentVariable');
+            this.getModifiedResourceFiles = this.delegateMethod('getModifiedResourceFiles');
+            this.getNewLine = this.delegateMethod('getNewLine');
+            this.getParsedCommandLine = this.delegateMethod('getParsedCommandLine');
+            this.getSourceFileByPath = this.delegateMethod('getSourceFileByPath');
+            this.readDirectory = this.delegateMethod('readDirectory');
+            this.readFile = this.delegateMethod('readFile');
+            this.readResource = this.delegateMethod('readResource');
+            this.realpath = this.delegateMethod('realpath');
+            this.resolveModuleNames = this.delegateMethod('resolveModuleNames');
+            this.resolveTypeReferenceDirectives = this.delegateMethod('resolveTypeReferenceDirectives');
+            this.resourceNameToFileName = this.delegateMethod('resourceNameToFileName');
+            this.trace = this.delegateMethod('trace');
+            this.useCaseSensitiveFileNames = this.delegateMethod('useCaseSensitiveFileNames');
+            this.writeFile = this.delegateMethod('writeFile');
+        }
+        DelegatingCompilerHost.prototype.delegateMethod = function (name) {
+            return this.delegate[name] !== undefined ? this.delegate[name].bind(this.delegate) :
+                undefined;
+        };
+        return DelegatingCompilerHost;
+    }());
+    exports.DelegatingCompilerHost = DelegatingCompilerHost;
+    /**
+     * A wrapper around `ts.CompilerHost` (plus any extension methods from `ExtendedTsCompilerHost`).
+     *
+     * In order for a consumer to include Angular compilation in their TypeScript compiler, the
+     * `ts.Program` must be created with a host that adds Angular-specific files (e.g. factories,
+     * summaries, the template type-checking file, etc) to the compilation. `NgCompilerHost` is the
+     * host implementation which supports this.
+     *
+     * The interface implementations here ensure that `NgCompilerHost` fully delegates to
+     * `ExtendedTsCompilerHost` methods whenever present.
+     */
+    var NgCompilerHost = /** @class */ (function (_super) {
+        tslib_1.__extends(NgCompilerHost, _super);
+        function NgCompilerHost(delegate, inputFiles, rootDirs, shims, entryPoint, typeCheckFile, factoryTracker, diagnostics) {
+            var _this = _super.call(this, delegate) || this;
+            _this.shims = shims;
+            _this.factoryTracker = null;
+            _this.entryPoint = null;
+            _this.factoryTracker = factoryTracker;
+            _this.entryPoint = entryPoint;
+            _this.typeCheckFile = typeCheckFile;
+            _this.diagnostics = diagnostics;
+            _this.inputFiles = inputFiles;
+            _this.rootDirs = rootDirs;
+            return _this;
+        }
+        /**
+         * Create an `NgCompilerHost` from a delegate host, an array of input filenames, and the full set
+         * of TypeScript and Angular compiler options.
+         */
+        NgCompilerHost.wrap = function (delegate, inputFiles, options) {
+            // TODO(alxhub): remove the fallback to allowEmptyCodegenFiles after verifying that the rest of
+            // our build tooling is no longer relying on it.
+            var allowEmptyCodegenFiles = options.allowEmptyCodegenFiles || false;
+            var shouldGenerateFactoryShims = options.generateNgFactoryShims !== undefined ?
+                options.generateNgFactoryShims :
+                allowEmptyCodegenFiles;
+            var shouldGenerateSummaryShims = options.generateNgSummaryShims !== undefined ?
+                options.generateNgSummaryShims :
+                allowEmptyCodegenFiles;
+            var rootFiles = tslib_1.__spread(inputFiles);
+            var normalizedInputFiles = inputFiles.map(function (n) { return file_system_1.resolve(n); });
+            var generators = [];
+            var summaryGenerator = null;
+            if (shouldGenerateSummaryShims) {
+                // Summary generation.
+                summaryGenerator = shims_1.SummaryGenerator.forRootFiles(normalizedInputFiles);
+                generators.push(summaryGenerator);
+            }
+            var factoryTracker = null;
+            if (shouldGenerateFactoryShims) {
+                // Factory generation.
+                var factoryGenerator = shims_1.FactoryGenerator.forRootFiles(normalizedInputFiles);
+                var factoryFileMap = factoryGenerator.factoryFileMap;
+                var factoryFileNames = Array.from(factoryFileMap.keys());
+                rootFiles.push.apply(rootFiles, tslib_1.__spread(factoryFileNames));
+                generators.push(factoryGenerator);
+                factoryTracker = new shims_1.FactoryTracker(factoryGenerator);
+            }
+            // Done separately to preserve the order of factory files before summary files in rootFiles.
+            // TODO(alxhub): validate that this is necessary.
+            if (summaryGenerator !== null) {
+                rootFiles.push.apply(rootFiles, tslib_1.__spread(summaryGenerator.getSummaryFileNames()));
+            }
+            var rootDirs = typescript_1.getRootDirs(delegate, options);
+            var typeCheckFile = typecheck_1.typeCheckFilePath(rootDirs);
+            generators.push(new shims_1.TypeCheckShimGenerator(typeCheckFile));
+            rootFiles.push(typeCheckFile);
+            var diagnostics = [];
+            var entryPoint = null;
+            if (options.flatModuleOutFile != null && options.flatModuleOutFile !== '') {
+                entryPoint = entry_point_1.findFlatIndexEntryPoint(normalizedInputFiles);
+                if (entryPoint === null) {
+                    // This error message talks specifically about having a single .ts file in "files". However
+                    // the actual logic is a bit more permissive. If a single file exists, that will be taken,
+                    // otherwise the highest level (shortest path) "index.ts" file will be used as the flat
+                    // module entry point instead. If neither of these conditions apply, the error below is
+                    // given.
+                    //
+                    // The user is not informed about the "index.ts" option as this behavior is deprecated -
+                    // an explicit entrypoint should always be specified.
+                    diagnostics.push({
+                        category: ts.DiagnosticCategory.Error,
+                        code: diagnostics_1.ngErrorCode(diagnostics_1.ErrorCode.CONFIG_FLAT_MODULE_NO_INDEX),
+                        file: undefined,
+                        start: undefined,
+                        length: undefined,
+                        messageText: 'Angular compiler option "flatModuleOutFile" requires one and only one .ts file in the "files" field.',
+                    });
+                }
+                else {
+                    var flatModuleId = options.flatModuleId || null;
+                    var flatModuleOutFile = path_1.normalizeSeparators(options.flatModuleOutFile);
+                    var flatIndexGenerator = new entry_point_1.FlatIndexGenerator(entryPoint, flatModuleOutFile, flatModuleId);
+                    generators.push(flatIndexGenerator);
+                    rootFiles.push(flatIndexGenerator.flatIndexPath);
+                }
+            }
+            return new NgCompilerHost(delegate, rootFiles, rootDirs, generators, entryPoint, typeCheckFile, factoryTracker, diagnostics);
+        };
+        NgCompilerHost.prototype.getSourceFile = function (fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+            var _this = this;
+            for (var i = 0; i < this.shims.length; i++) {
+                var generator = this.shims[i];
+                // TypeScript internal paths are guaranteed to be POSIX-like absolute file paths.
+                var absoluteFsPath = file_system_1.resolve(fileName);
+                if (generator.recognize(absoluteFsPath)) {
+                    var readFile = function (originalFile) {
+                        return _this.delegate.getSourceFile(originalFile, languageVersion, onError, shouldCreateNewSourceFile) ||
+                            null;
+                    };
+                    return generator.generate(absoluteFsPath, readFile) || undefined;
+                }
+            }
+            return this.delegate.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        };
+        NgCompilerHost.prototype.fileExists = function (fileName) {
+            // Consider the file as existing whenever
+            //  1) it really does exist in the delegate host, or
+            //  2) at least one of the shim generators recognizes it
+            // Note that we can pass the file name as branded absolute fs path because TypeScript
+            // internally only passes POSIX-like paths.
+            return this.delegate.fileExists(fileName) ||
+                this.shims.some(function (shim) { return shim.recognize(file_system_1.resolve(fileName)); });
+        };
+        Object.defineProperty(NgCompilerHost.prototype, "unifiedModulesHost", {
+            get: function () {
+                return this.fileNameToModuleName !== undefined ? this : null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return NgCompilerHost;
+    }(DelegatingCompilerHost));
+    exports.NgCompilerHost = NgCompilerHost;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/core/src/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 {ErrorCode, ngErrorCode} from '../../diagnostics';\nimport {FlatIndexGenerator, findFlatIndexEntryPoint} from '../../entry_point';\nimport {AbsoluteFsPath, resolve} from '../../file_system';\nimport {FactoryGenerator, FactoryTracker, ShimGenerator, SummaryGenerator, TypeCheckShimGenerator} from '../../shims';\nimport {typeCheckFilePath} from '../../typecheck';\nimport {normalizeSeparators} from '../../util/src/path';\nimport {getRootDirs} from '../../util/src/typescript';\nimport {ExtendedTsCompilerHost, NgCompilerOptions, UnifiedModulesHost} from '../api';\n\n// A persistent source of bugs in CompilerHost delegation has been the addition by TS of new,\n// optional methods on ts.CompilerHost. Since these methods are optional, it's not a type error that\n// the delegating host doesn't implement or delegate them. This causes subtle runtime failures. No\n// more. This infrastructure ensures that failing to delegate a method is a compile-time error.\n\n/**\n * Represents the `ExtendedTsCompilerHost` interface, with a transformation applied that turns all\n * methods (even optional ones) into required fields (which may be `undefined`, if the method was\n * optional).\n */\nexport type RequiredCompilerHostDelegations = {\n  [M in keyof Required<ExtendedTsCompilerHost>]: ExtendedTsCompilerHost[M];\n};\n\n/**\n * Delegates all methods of `ExtendedTsCompilerHost` to a delegate, with the exception of\n * `getSourceFile` and `fileExists` which are implemented in `NgCompilerHost`.\n *\n * If a new method is added to `ts.CompilerHost` which is not delegated, a type error will be\n * generated for this class.\n */\nexport class DelegatingCompilerHost implements\n    Omit<RequiredCompilerHostDelegations, 'getSourceFile'|'fileExists'> {\n  constructor(protected delegate: ExtendedTsCompilerHost) {}\n\n  private delegateMethod<M extends keyof ExtendedTsCompilerHost>(name: M):\n      ExtendedTsCompilerHost[M] {\n    return this.delegate[name] !== undefined ? (this.delegate[name] as any).bind(this.delegate) :\n                                               undefined;\n  }\n\n  // Excluded are 'getSourceFile' and 'fileExists', which are actually implemented by NgCompilerHost\n  // below.\n  createHash = this.delegateMethod('createHash');\n  directoryExists = this.delegateMethod('directoryExists');\n  fileNameToModuleName = this.delegateMethod('fileNameToModuleName');\n  getCancellationToken = this.delegateMethod('getCancellationToken');\n  getCanonicalFileName = this.delegateMethod('getCanonicalFileName');\n  getCurrentDirectory = this.delegateMethod('getCurrentDirectory');\n  getDefaultLibFileName = this.delegateMethod('getDefaultLibFileName');\n  getDefaultLibLocation = this.delegateMethod('getDefaultLibLocation');\n  getDirectories = this.delegateMethod('getDirectories');\n  getEnvironmentVariable = this.delegateMethod('getEnvironmentVariable');\n  getModifiedResourceFiles = this.delegateMethod('getModifiedResourceFiles');\n  getNewLine = this.delegateMethod('getNewLine');\n  getParsedCommandLine = this.delegateMethod('getParsedCommandLine');\n  getSourceFileByPath = this.delegateMethod('getSourceFileByPath');\n  readDirectory = this.delegateMethod('readDirectory');\n  readFile = this.delegateMethod('readFile');\n  readResource = this.delegateMethod('readResource');\n  realpath = this.delegateMethod('realpath');\n  resolveModuleNames = this.delegateMethod('resolveModuleNames');\n  resolveTypeReferenceDirectives = this.delegateMethod('resolveTypeReferenceDirectives');\n  resourceNameToFileName = this.delegateMethod('resourceNameToFileName');\n  trace = this.delegateMethod('trace');\n  useCaseSensitiveFileNames = this.delegateMethod('useCaseSensitiveFileNames');\n  writeFile = this.delegateMethod('writeFile');\n}\n\n/**\n * A wrapper around `ts.CompilerHost` (plus any extension methods from `ExtendedTsCompilerHost`).\n *\n * In order for a consumer to include Angular compilation in their TypeScript compiler, the\n * `ts.Program` must be created with a host that adds Angular-specific files (e.g. factories,\n * summaries, the template type-checking file, etc) to the compilation. `NgCompilerHost` is the\n * host implementation which supports this.\n *\n * The interface implementations here ensure that `NgCompilerHost` fully delegates to\n * `ExtendedTsCompilerHost` methods whenever present.\n */\nexport class NgCompilerHost extends DelegatingCompilerHost implements\n    RequiredCompilerHostDelegations,\n    ExtendedTsCompilerHost {\n  readonly factoryTracker: FactoryTracker|null = null;\n  readonly entryPoint: AbsoluteFsPath|null = null;\n  readonly diagnostics: ts.Diagnostic[];\n\n  readonly inputFiles: ReadonlyArray<string>;\n  readonly rootDirs: ReadonlyArray<AbsoluteFsPath>;\n  readonly typeCheckFile: AbsoluteFsPath;\n\n  constructor(\n      delegate: ExtendedTsCompilerHost, inputFiles: ReadonlyArray<string>,\n      rootDirs: ReadonlyArray<AbsoluteFsPath>, private shims: ShimGenerator[],\n      entryPoint: AbsoluteFsPath|null, typeCheckFile: AbsoluteFsPath,\n      factoryTracker: FactoryTracker|null, diagnostics: ts.Diagnostic[]) {\n    super(delegate);\n\n    this.factoryTracker = factoryTracker;\n    this.entryPoint = entryPoint;\n    this.typeCheckFile = typeCheckFile;\n    this.diagnostics = diagnostics;\n    this.inputFiles = inputFiles;\n    this.rootDirs = rootDirs;\n  }\n\n  /**\n   * Create an `NgCompilerHost` from a delegate host, an array of input filenames, and the full set\n   * of TypeScript and Angular compiler options.\n   */\n  static wrap(\n      delegate: ts.CompilerHost, inputFiles: ReadonlyArray<string>,\n      options: NgCompilerOptions): NgCompilerHost {\n    // TODO(alxhub): remove the fallback to allowEmptyCodegenFiles after verifying that the rest of\n    // our build tooling is no longer relying on it.\n    const allowEmptyCodegenFiles = options.allowEmptyCodegenFiles || false;\n    const shouldGenerateFactoryShims = options.generateNgFactoryShims !== undefined ?\n        options.generateNgFactoryShims :\n        allowEmptyCodegenFiles;\n\n    const shouldGenerateSummaryShims = options.generateNgSummaryShims !== undefined ?\n        options.generateNgSummaryShims :\n        allowEmptyCodegenFiles;\n\n    let rootFiles = [...inputFiles];\n    let normalizedInputFiles = inputFiles.map(n => resolve(n));\n\n    const generators: ShimGenerator[] = [];\n    let summaryGenerator: SummaryGenerator|null = null;\n\n    if (shouldGenerateSummaryShims) {\n      // Summary generation.\n      summaryGenerator = SummaryGenerator.forRootFiles(normalizedInputFiles);\n      generators.push(summaryGenerator);\n    }\n\n    let factoryTracker: FactoryTracker|null = null;\n    if (shouldGenerateFactoryShims) {\n      // Factory generation.\n      const factoryGenerator = FactoryGenerator.forRootFiles(normalizedInputFiles);\n      const factoryFileMap = factoryGenerator.factoryFileMap;\n\n      const factoryFileNames = Array.from(factoryFileMap.keys());\n      rootFiles.push(...factoryFileNames);\n      generators.push(factoryGenerator);\n\n      factoryTracker = new FactoryTracker(factoryGenerator);\n    }\n\n    // Done separately to preserve the order of factory files before summary files in rootFiles.\n    // TODO(alxhub): validate that this is necessary.\n    if (summaryGenerator !== null) {\n      rootFiles.push(...summaryGenerator.getSummaryFileNames());\n    }\n\n\n    const rootDirs = getRootDirs(delegate, options as ts.CompilerOptions);\n\n    const typeCheckFile = typeCheckFilePath(rootDirs);\n    generators.push(new TypeCheckShimGenerator(typeCheckFile));\n    rootFiles.push(typeCheckFile);\n\n    let diagnostics: ts.Diagnostic[] = [];\n\n    let entryPoint: AbsoluteFsPath|null = null;\n    if (options.flatModuleOutFile != null && options.flatModuleOutFile !== '') {\n      entryPoint = findFlatIndexEntryPoint(normalizedInputFiles);\n      if (entryPoint === null) {\n        // This error message talks specifically about having a single .ts file in \"files\". However\n        // the actual logic is a bit more permissive. If a single file exists, that will be taken,\n        // otherwise the highest level (shortest path) \"index.ts\" file will be used as the flat\n        // module entry point instead. If neither of these conditions apply, the error below is\n        // given.\n        //\n        // The user is not informed about the \"index.ts\" option as this behavior is deprecated -\n        // an explicit entrypoint should always be specified.\n        diagnostics.push({\n          category: ts.DiagnosticCategory.Error,\n          code: ngErrorCode(ErrorCode.CONFIG_FLAT_MODULE_NO_INDEX),\n          file: undefined,\n          start: undefined,\n          length: undefined,\n          messageText:\n              'Angular compiler option \"flatModuleOutFile\" requires one and only one .ts file in the \"files\" field.',\n        });\n      } else {\n        const flatModuleId = options.flatModuleId || null;\n        const flatModuleOutFile = normalizeSeparators(options.flatModuleOutFile);\n        const flatIndexGenerator =\n            new FlatIndexGenerator(entryPoint, flatModuleOutFile, flatModuleId);\n        generators.push(flatIndexGenerator);\n        rootFiles.push(flatIndexGenerator.flatIndexPath);\n      }\n    }\n\n    return new NgCompilerHost(\n        delegate, rootFiles, rootDirs, generators, entryPoint, typeCheckFile, factoryTracker,\n        diagnostics);\n  }\n\n  getSourceFile(\n      fileName: string, languageVersion: ts.ScriptTarget,\n      onError?: ((message: string) => void)|undefined,\n      shouldCreateNewSourceFile?: boolean|undefined): ts.SourceFile|undefined {\n    for (let i = 0; i < this.shims.length; i++) {\n      const generator = this.shims[i];\n      // TypeScript internal paths are guaranteed to be POSIX-like absolute file paths.\n      const absoluteFsPath = resolve(fileName);\n      if (generator.recognize(absoluteFsPath)) {\n        const readFile = (originalFile: string) => {\n          return this.delegate.getSourceFile(\n                     originalFile, languageVersion, onError, shouldCreateNewSourceFile) ||\n              null;\n        };\n\n        return generator.generate(absoluteFsPath, readFile) || undefined;\n      }\n    }\n\n    return this.delegate.getSourceFile(\n        fileName, languageVersion, onError, shouldCreateNewSourceFile);\n  }\n\n  fileExists(fileName: string): boolean {\n    // Consider the file as existing whenever\n    //  1) it really does exist in the delegate host, or\n    //  2) at least one of the shim generators recognizes it\n    // Note that we can pass the file name as branded absolute fs path because TypeScript\n    // internally only passes POSIX-like paths.\n    return this.delegate.fileExists(fileName) ||\n        this.shims.some(shim => shim.recognize(resolve(fileName)));\n  }\n\n  get unifiedModulesHost(): UnifiedModulesHost|null {\n    return this.fileNameToModuleName !== undefined ? this as UnifiedModulesHost : null;\n  }\n}\n"]}

package/src/ngtsc/cycles/src/imports.js

@@ -73,7 +73,7 @@
                     stmt.moduleSpecifier !== undefined && ts.isStringLiteral(stmt.moduleSpecifier)) {
                     // Resolve the module to a file, and check whether that file is in the ts.Program.
                     var moduleName = stmt.moduleSpecifier.text;
-                    var moduleFile = _this.resolver.resolveModuleName(moduleName, sf);
+                    var moduleFile = _this.resolver.resolveModule(moduleName, sf.fileName);
                     if (moduleFile !== null && isLocalFile(moduleFile)) {
                         // Record this local import.
                         imports.add(moduleFile);
@@ -89,4 +89,4 @@
         return !sf.fileName.endsWith('.d.ts');
     }
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1wb3J0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvY3ljbGVzL3NyYy9pbXBvcnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBRUgsK0JBQWlDO0lBSWpDOzs7OztPQUtHO0lBQ0g7UUFHRSxxQkFBb0IsUUFBd0I7WUFBeEIsYUFBUSxHQUFSLFFBQVEsQ0FBZ0I7WUFGcEMsUUFBRyxHQUFHLElBQUksR0FBRyxFQUFxQyxDQUFDO1FBRVosQ0FBQztRQUVoRDs7OztXQUlHO1FBQ0gsK0JBQVMsR0FBVCxVQUFVLEVBQWlCO1lBQ3pCLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRTtnQkFDckIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQzthQUN4QztZQUNELE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFHLENBQUM7UUFDNUIsQ0FBQztRQUVEOztXQUVHO1FBQ0gseUNBQW1CLEdBQW5CLFVBQW9CLEVBQWlCO1lBQ25DLElBQU0sT0FBTyxHQUFHLElBQUksR0FBRyxFQUFpQixDQUFDO1lBQ3pDLElBQUksQ0FBQyx5QkFBeUIsQ0FBQyxFQUFFLEVBQUUsT0FBTyxDQUFDLENBQUM7WUFDNUMsT0FBTyxPQUFPLENBQUM7UUFDakIsQ0FBQztRQUVPLCtDQUF5QixHQUFqQyxVQUFrQyxFQUFpQixFQUFFLE9BQTJCO1lBQWhGLGlCQU1DO1lBTEMsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFO2dCQUNuQixPQUFPO2FBQ1I7WUFDRCxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ2hCLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLFVBQUEsUUFBUSxJQUFNLEtBQUksQ0FBQyx5QkFBeUIsQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNqRyxDQUFDO1FBRUQ7OztXQUdHO1FBQ0gsd0NBQWtCLEdBQWxCLFVBQW1CLEVBQWlCLEVBQUUsUUFBdUI7WUFDM0QsSUFBSSxXQUFXLENBQUMsUUFBUSxDQUFDLEVBQUU7Z0JBQ3pCLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO2FBQ2xDO1FBQ0gsQ0FBQztRQUVPLGlDQUFXLEdBQW5CLFVBQW9CLEVBQWlCO1lBQXJDLGlCQWdCQztZQWZDLElBQU0sT0FBTyxHQUFHLElBQUksR0FBRyxFQUFpQixDQUFDO1lBQ3pDLHNEQUFzRDtZQUN0RCxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxVQUFBLElBQUk7Z0JBQ3hCLElBQUksQ0FBQyxFQUFFLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxDQUFDO29CQUM5RCxJQUFJLENBQUMsZUFBZSxLQUFLLFNBQVMsSUFBSSxFQUFFLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsRUFBRTtvQkFDbEYsa0ZBQWtGO29CQUNsRixJQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQztvQkFDN0MsSUFBTSxVQUFVLEdBQUcsS0FBSSxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLENBQUM7b0JBQ25FLElBQUksVUFBVSxLQUFLLElBQUksSUFBSSxXQUFXLENBQUMsVUFBVSxDQUFDLEVBQUU7d0JBQ2xELDRCQUE0Qjt3QkFDNUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztxQkFDekI7aUJBQ0Y7WUFDSCxDQUFDLENBQUMsQ0FBQztZQUNILE9BQU8sT0FBTyxDQUFDO1FBQ2pCLENBQUM7UUFDSCxrQkFBQztJQUFELENBQUMsQUE3REQsSUE2REM7SUE3RFksa0NBQVc7SUErRHhCLFNBQVMsV0FBVyxDQUFDLEVBQWlCO1FBQ3BDLE9BQU8sQ0FBQyxFQUFFLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgKiBhcyB0cyBmcm9tICd0eXBlc2NyaXB0JztcblxuaW1wb3J0IHtNb2R1bGVSZXNvbHZlcn0gZnJvbSAnLi4vLi4vaW1wb3J0cyc7XG5cbi8qKlxuICogQSBjYWNoZWQgZ3JhcGggb2YgaW1wb3J0cyBpbiB0aGUgYHRzLlByb2dyYW1gLlxuICpcbiAqIFRoZSBgSW1wb3J0R3JhcGhgIGtlZXBzIHRyYWNrIG9mIGRlcGVuZGVuY2llcyAoaW1wb3J0cykgb2YgaW5kaXZpZHVhbCBgdHMuU291cmNlRmlsZWBzLiBPbmx5XG4gKiBkZXBlbmRlbmNpZXMgd2l0aGluIHRoZSBzYW1lIHByb2dyYW0gYXJlIHRyYWNrZWQ7IGltcG9ydHMgaW50byBwYWNrYWdlcyBvbiBOUE0gYXJlIG5vdC5cbiAqL1xuZXhwb3J0IGNsYXNzIEltcG9ydEdyYXBoIHtcbiAgcHJpdmF0ZSBtYXAgPSBuZXcgTWFwPHRzLlNvdXJjZUZpbGUsIFNldDx0cy5Tb3VyY2VGaWxlPj4oKTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlc29sdmVyOiBNb2R1bGVSZXNvbHZlcikge31cblxuICAvKipcbiAgICogTGlzdCB0aGUgZGlyZWN0IChub3QgdHJhbnNpdGl2ZSkgaW1wb3J0cyBvZiBhIGdpdmVuIGB0cy5Tb3VyY2VGaWxlYC5cbiAgICpcbiAgICogVGhpcyBvcGVyYXRpb24gaXMgY2FjaGVkLlxuICAgKi9cbiAgaW1wb3J0c09mKHNmOiB0cy5Tb3VyY2VGaWxlKTogU2V0PHRzLlNvdXJjZUZpbGU+IHtcbiAgICBpZiAoIXRoaXMubWFwLmhhcyhzZikpIHtcbiAgICAgIHRoaXMubWFwLnNldChzZiwgdGhpcy5zY2FuSW1wb3J0cyhzZikpO1xuICAgIH1cbiAgICByZXR1cm4gdGhpcy5tYXAuZ2V0KHNmKSAhO1xuICB9XG5cbiAgLyoqXG4gICAqIExpc3RzIHRoZSB0cmFuc2l0aXZlIGltcG9ydHMgb2YgYSBnaXZlbiBgdHMuU291cmNlRmlsZWAuXG4gICAqL1xuICB0cmFuc2l0aXZlSW1wb3J0c09mKHNmOiB0cy5Tb3VyY2VGaWxlKTogU2V0PHRzLlNvdXJjZUZpbGU+IHtcbiAgICBjb25zdCBpbXBvcnRzID0gbmV3IFNldDx0cy5Tb3VyY2VGaWxlPigpO1xuICAgIHRoaXMudHJhbnNpdGl2ZUltcG9ydHNPZkhlbHBlcihzZiwgaW1wb3J0cyk7XG4gICAgcmV0dXJuIGltcG9ydHM7XG4gIH1cblxuICBwcml2YXRlIHRyYW5zaXRpdmVJbXBvcnRzT2ZIZWxwZXIoc2Y6IHRzLlNvdXJjZUZpbGUsIHJlc3VsdHM6IFNldDx0cy5Tb3VyY2VGaWxlPik6IHZvaWQge1xuICAgIGlmIChyZXN1bHRzLmhhcyhzZikpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgcmVzdWx0cy5hZGQoc2YpO1xuICAgIHRoaXMuaW1wb3J0c09mKHNmKS5mb3JFYWNoKGltcG9ydGVkID0+IHsgdGhpcy50cmFuc2l0aXZlSW1wb3J0c09mSGVscGVyKGltcG9ydGVkLCByZXN1bHRzKTsgfSk7XG4gIH1cblxuICAvKipcbiAgICogQWRkIGEgcmVjb3JkIG9mIGFuIGltcG9ydCBmcm9tIGBzZmAgdG8gYGltcG9ydGVkYCwgdGhhdCdzIG5vdCBwcmVzZW50IGluIHRoZSBvcmlnaW5hbFxuICAgKiBgdHMuUHJvZ3JhbWAgYnV0IHdpbGwgYmUgcmVtZW1iZXJlZCBieSB0aGUgYEltcG9ydEdyYXBoYC5cbiAgICovXG4gIGFkZFN5bnRoZXRpY0ltcG9ydChzZjogdHMuU291cmNlRmlsZSwgaW1wb3J0ZWQ6IHRzLlNvdXJjZUZpbGUpOiB2b2lkIHtcbiAgICBpZiAoaXNMb2NhbEZpbGUoaW1wb3J0ZWQpKSB7XG4gICAgICB0aGlzLmltcG9ydHNPZihzZikuYWRkKGltcG9ydGVkKTtcbiAgICB9XG4gIH1cblxuICBwcml2YXRlIHNjYW5JbXBvcnRzKHNmOiB0cy5Tb3VyY2VGaWxlKTogU2V0PHRzLlNvdXJjZUZpbGU+IHtcbiAgICBjb25zdCBpbXBvcnRzID0gbmV3IFNldDx0cy5Tb3VyY2VGaWxlPigpO1xuICAgIC8vIExvb2sgdGhyb3VnaCB0aGUgc291cmNlIGZpbGUgZm9yIGltcG9ydCBzdGF0ZW1lbnRzLlxuICAgIHNmLnN0YXRlbWVudHMuZm9yRWFjaChzdG10ID0+IHtcbiAgICAgIGlmICgodHMuaXNJbXBvcnREZWNsYXJhdGlvbihzdG10KSB8fCB0cy5pc0V4cG9ydERlY2xhcmF0aW9uKHN0bXQpKSAmJlxuICAgICAgICAgIHN0bXQubW9kdWxlU3BlY2lmaWVyICE9PSB1bmRlZmluZWQgJiYgdHMuaXNTdHJpbmdMaXRlcmFsKHN0bXQubW9kdWxlU3BlY2lmaWVyKSkge1xuICAgICAgICAvLyBSZXNvbHZlIHRoZSBtb2R1bGUgdG8gYSBmaWxlLCBhbmQgY2hlY2sgd2hldGhlciB0aGF0IGZpbGUgaXMgaW4gdGhlIHRzLlByb2dyYW0uXG4gICAgICAgIGNvbnN0IG1vZHVsZU5hbWUgPSBzdG10Lm1vZHVsZVNwZWNpZmllci50ZXh0O1xuICAgICAgICBjb25zdCBtb2R1bGVGaWxlID0gdGhpcy5yZXNvbHZlci5yZXNvbHZlTW9kdWxlTmFtZShtb2R1bGVOYW1lLCBzZik7XG4gICAgICAgIGlmIChtb2R1bGVGaWxlICE9PSBudWxsICYmIGlzTG9jYWxGaWxlKG1vZHVsZUZpbGUpKSB7XG4gICAgICAgICAgLy8gUmVjb3JkIHRoaXMgbG9jYWwgaW1wb3J0LlxuICAgICAgICAgIGltcG9ydHMuYWRkKG1vZHVsZUZpbGUpO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfSk7XG4gICAgcmV0dXJuIGltcG9ydHM7XG4gIH1cbn1cblxuZnVuY3Rpb24gaXNMb2NhbEZpbGUoc2Y6IHRzLlNvdXJjZUZpbGUpOiBib29sZWFuIHtcbiAgcmV0dXJuICFzZi5maWxlTmFtZS5lbmRzV2l0aCgnLmQudHMnKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -6,6 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/diagnostics" />
-export { ErrorCode, ngErrorCode } from './src/code';
 export { FatalDiagnosticError, isFatalDiagnosticError, makeDiagnostic } from './src/error';
+export { ErrorCode, ngErrorCode } from './src/error_code';
 export { replaceTsWithNgInErrors } from './src/util';

package/src/ngtsc/diagnostics/index.js

@@ -11,19 +11,19 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/diagnostics", ["require", "exports", "@angular/compiler-cli/src/ngtsc/diagnostics/src/code", "@angular/compiler-cli/src/ngtsc/diagnostics/src/error", "@angular/compiler-cli/src/ngtsc/diagnostics/src/util"], factory);
+        define("@angular/compiler-cli/src/ngtsc/diagnostics", ["require", "exports", "@angular/compiler-cli/src/ngtsc/diagnostics/src/error", "@angular/compiler-cli/src/ngtsc/diagnostics/src/error_code", "@angular/compiler-cli/src/ngtsc/diagnostics/src/util"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    var code_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics/src/code");
-    exports.ErrorCode = code_1.ErrorCode;
-    exports.ngErrorCode = code_1.ngErrorCode;
     var error_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics/src/error");
     exports.FatalDiagnosticError = error_1.FatalDiagnosticError;
     exports.isFatalDiagnosticError = error_1.isFatalDiagnosticError;
     exports.makeDiagnostic = error_1.makeDiagnostic;
+    var error_code_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics/src/error_code");
+    exports.ErrorCode = error_code_1.ErrorCode;
+    exports.ngErrorCode = error_code_1.ngErrorCode;
     var util_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics/src/util");
     exports.replaceTsWithNgInErrors = util_1.replaceTsWithNgInErrors;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL2RpYWdub3N0aWNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBRUgsNkVBQWtEO0lBQTFDLDJCQUFBLFNBQVMsQ0FBQTtJQUFFLDZCQUFBLFdBQVcsQ0FBQTtJQUM5QiwrRUFBeUY7SUFBakYsdUNBQUEsb0JBQW9CLENBQUE7SUFBRSx5Q0FBQSxzQkFBc0IsQ0FBQTtJQUFFLGlDQUFBLGNBQWMsQ0FBQTtJQUNwRSw2RUFBbUQ7SUFBM0MseUNBQUEsdUJBQXVCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCB7RXJyb3JDb2RlLCBuZ0Vycm9yQ29kZX0gZnJvbSAnLi9zcmMvY29kZSc7XG5leHBvcnQge0ZhdGFsRGlhZ25vc3RpY0Vycm9yLCBpc0ZhdGFsRGlhZ25vc3RpY0Vycm9yLCBtYWtlRGlhZ25vc3RpY30gZnJvbSAnLi9zcmMvZXJyb3InO1xuZXhwb3J0IHtyZXBsYWNlVHNXaXRoTmdJbkVycm9yc30gZnJvbSAnLi9zcmMvdXRpbCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL2RpYWdub3N0aWNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBRUgsK0VBQXlGO0lBQWpGLHVDQUFBLG9CQUFvQixDQUFBO0lBQUUseUNBQUEsc0JBQXNCLENBQUE7SUFBRSxpQ0FBQSxjQUFjLENBQUE7SUFDcEUseUZBQXdEO0lBQWhELGlDQUFBLFNBQVMsQ0FBQTtJQUFFLG1DQUFBLFdBQVcsQ0FBQTtJQUM5Qiw2RUFBbUQ7SUFBM0MseUNBQUEsdUJBQXVCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCB7RmF0YWxEaWFnbm9zdGljRXJyb3IsIGlzRmF0YWxEaWFnbm9zdGljRXJyb3IsIG1ha2VEaWFnbm9zdGljfSBmcm9tICcuL3NyYy9lcnJvcic7XG5leHBvcnQge0Vycm9yQ29kZSwgbmdFcnJvckNvZGV9IGZyb20gJy4vc3JjL2Vycm9yX2NvZGUnO1xuZXhwb3J0IHtyZXBsYWNlVHNXaXRoTmdJbkVycm9yc30gZnJvbSAnLi9zcmMvdXRpbCc7XG4iXX0=

package/src/ngtsc/diagnostics/src/error.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/diagnostics/src/error" />
 import * as ts from 'typescript';
-import { ErrorCode } from './code';
+import { ErrorCode } from './error_code';
 export declare class FatalDiagnosticError {
     readonly code: ErrorCode;
     readonly node: ts.Node;

package/src/ngtsc/diagnostics/src/error.js

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

package/src/ngtsc/diagnostics/src/{code.d.ts → error_code.d.ts}

@@ -5,7 +5,10 @@
  * 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
  */
-/// <amd-module name="@angular/compiler-cli/src/ngtsc/diagnostics/src/code" />
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/diagnostics/src/error_code" />
+/**
+ * @publicApi
+ */
 export declare enum ErrorCode {
     DECORATOR_ARG_NOT_LITERAL = 1001,
     DECORATOR_ARITY_WRONG = 1002,
@@ -22,9 +25,17 @@ export declare enum ErrorCode {
     PIPE_MISSING_NAME = 2002,
     PARAM_MISSING_TOKEN = 2003,
     DIRECTIVE_MISSING_SELECTOR = 2004,
+    /** Raised when an undecorated class is passed in as a provider to a module or a directive. */
+    UNDECORATED_PROVIDER = 2005,
+    /**
+     * Raised when a Directive inherits its constructor from a base class without an Angular
+     * decorator.
+     */
+    DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,
     SYMBOL_NOT_EXPORTED = 3001,
     SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME = 3002,
     CONFIG_FLAT_MODULE_NO_INDEX = 4001,
+    CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,
     /**
      * Raised when a host expression has a parse error, such as a host listener or host binding
      * expression containing a pipe.
@@ -58,9 +69,9 @@ export declare enum ErrorCode {
      */
     NGMODULE_REEXPORT_NAME_COLLISION = 6006,
     /**
-     * Raised when ngcc tries to inject a synthetic decorator over one that already exists.
+     * Raised when a directive/pipe is part of the declarations of two or more NgModules.
      */
-    NGCC_MIGRATION_DECORATOR_INJECTION_ERROR = 7001,
+    NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
     /**
      * An element name failed validation against the DOM schema.
      */
@@ -77,9 +88,21 @@ export declare enum ErrorCode {
      * No matching pipe was found for a
      */
     MISSING_PIPE = 8004,
+    /**
+     * The left-hand side of an assignment expression was a template variable. Effectively, the
+     * template looked like:
+     *
+     * ```
+     * <ng-template let-something>
+     *   <button (click)="something = ...">...</button>
+     * </ng-template>
+     * ```
+     *
+     * Template variables are read-only.
+     */
+    WRITE_TO_READ_ONLY_VARIABLE = 8005,
     /**
      * An injectable already has a `ɵprov` property.
      */
     INJECTABLE_DUPLICATE_PROV = 9001
 }
-export declare function ngErrorCode(code: ErrorCode): number;