@angular/compiler-cli 9.0.0-rc.9 → 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/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,
@@ -69,10 +72,6 @@ export declare enum ErrorCode {
      * Raised when a directive/pipe is part of the declarations of two or more NgModules.
      */
     NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
-    /**
-     * Raised when ngcc tries to inject a synthetic decorator over one that already exists.
-     */
-    NGCC_MIGRATION_DECORATOR_INJECTION_ERROR = 7001,
     /**
      * An element name failed validation against the DOM schema.
      */
@@ -107,4 +106,3 @@ export declare enum ErrorCode {
      */
     INJECTABLE_DUPLICATE_PROV = 9001
 }
-export declare function ngErrorCode(code: ErrorCode): number;

package/src/ngtsc/diagnostics/src/error_code.js

@@ -0,0 +1,128 @@
+/**
+ * @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/diagnostics/src/error_code", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @publicApi
+     */
+    var ErrorCode;
+    (function (ErrorCode) {
+        ErrorCode[ErrorCode["DECORATOR_ARG_NOT_LITERAL"] = 1001] = "DECORATOR_ARG_NOT_LITERAL";
+        ErrorCode[ErrorCode["DECORATOR_ARITY_WRONG"] = 1002] = "DECORATOR_ARITY_WRONG";
+        ErrorCode[ErrorCode["DECORATOR_NOT_CALLED"] = 1003] = "DECORATOR_NOT_CALLED";
+        ErrorCode[ErrorCode["DECORATOR_ON_ANONYMOUS_CLASS"] = 1004] = "DECORATOR_ON_ANONYMOUS_CLASS";
+        ErrorCode[ErrorCode["DECORATOR_UNEXPECTED"] = 1005] = "DECORATOR_UNEXPECTED";
+        /**
+         * This error code indicates that there are incompatible decorators on a type or a class field.
+         */
+        ErrorCode[ErrorCode["DECORATOR_COLLISION"] = 1006] = "DECORATOR_COLLISION";
+        ErrorCode[ErrorCode["VALUE_HAS_WRONG_TYPE"] = 1010] = "VALUE_HAS_WRONG_TYPE";
+        ErrorCode[ErrorCode["VALUE_NOT_LITERAL"] = 1011] = "VALUE_NOT_LITERAL";
+        ErrorCode[ErrorCode["COMPONENT_MISSING_TEMPLATE"] = 2001] = "COMPONENT_MISSING_TEMPLATE";
+        ErrorCode[ErrorCode["PIPE_MISSING_NAME"] = 2002] = "PIPE_MISSING_NAME";
+        ErrorCode[ErrorCode["PARAM_MISSING_TOKEN"] = 2003] = "PARAM_MISSING_TOKEN";
+        ErrorCode[ErrorCode["DIRECTIVE_MISSING_SELECTOR"] = 2004] = "DIRECTIVE_MISSING_SELECTOR";
+        /** Raised when an undecorated class is passed in as a provider to a module or a directive. */
+        ErrorCode[ErrorCode["UNDECORATED_PROVIDER"] = 2005] = "UNDECORATED_PROVIDER";
+        /**
+         * Raised when a Directive inherits its constructor from a base class without an Angular
+         * decorator.
+         */
+        ErrorCode[ErrorCode["DIRECTIVE_INHERITS_UNDECORATED_CTOR"] = 2006] = "DIRECTIVE_INHERITS_UNDECORATED_CTOR";
+        ErrorCode[ErrorCode["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
+        ErrorCode[ErrorCode["SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME"] = 3002] = "SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME";
+        ErrorCode[ErrorCode["CONFIG_FLAT_MODULE_NO_INDEX"] = 4001] = "CONFIG_FLAT_MODULE_NO_INDEX";
+        ErrorCode[ErrorCode["CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK"] = 4002] = "CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK";
+        /**
+         * Raised when a host expression has a parse error, such as a host listener or host binding
+         * expression containing a pipe.
+         */
+        ErrorCode[ErrorCode["HOST_BINDING_PARSE_ERROR"] = 5001] = "HOST_BINDING_PARSE_ERROR";
+        /**
+         * Raised when an NgModule contains an invalid reference in `declarations`.
+         */
+        ErrorCode[ErrorCode["NGMODULE_INVALID_DECLARATION"] = 6001] = "NGMODULE_INVALID_DECLARATION";
+        /**
+         * Raised when an NgModule contains an invalid type in `imports`.
+         */
+        ErrorCode[ErrorCode["NGMODULE_INVALID_IMPORT"] = 6002] = "NGMODULE_INVALID_IMPORT";
+        /**
+         * Raised when an NgModule contains an invalid type in `exports`.
+         */
+        ErrorCode[ErrorCode["NGMODULE_INVALID_EXPORT"] = 6003] = "NGMODULE_INVALID_EXPORT";
+        /**
+         * Raised when an NgModule contains a type in `exports` which is neither in `declarations` nor
+         * otherwise imported.
+         */
+        ErrorCode[ErrorCode["NGMODULE_INVALID_REEXPORT"] = 6004] = "NGMODULE_INVALID_REEXPORT";
+        /**
+         * Raised when a `ModuleWithProviders` with a missing
+         * generic type argument is passed into an `NgModule`.
+         */
+        ErrorCode[ErrorCode["NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC"] = 6005] = "NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC";
+        /**
+         * Raised when an NgModule exports multiple directives/pipes of the same name and the compiler
+         * attempts to generate private re-exports within the NgModule file.
+         */
+        ErrorCode[ErrorCode["NGMODULE_REEXPORT_NAME_COLLISION"] = 6006] = "NGMODULE_REEXPORT_NAME_COLLISION";
+        /**
+         * Raised when a directive/pipe is part of the declarations of two or more NgModules.
+         */
+        ErrorCode[ErrorCode["NGMODULE_DECLARATION_NOT_UNIQUE"] = 6007] = "NGMODULE_DECLARATION_NOT_UNIQUE";
+        /**
+         * An element name failed validation against the DOM schema.
+         */
+        ErrorCode[ErrorCode["SCHEMA_INVALID_ELEMENT"] = 8001] = "SCHEMA_INVALID_ELEMENT";
+        /**
+         * An element's attribute name failed validation against the DOM schema.
+         */
+        ErrorCode[ErrorCode["SCHEMA_INVALID_ATTRIBUTE"] = 8002] = "SCHEMA_INVALID_ATTRIBUTE";
+        /**
+         * No matching directive was found for a `#ref="target"` expression.
+         */
+        ErrorCode[ErrorCode["MISSING_REFERENCE_TARGET"] = 8003] = "MISSING_REFERENCE_TARGET";
+        /**
+         * No matching pipe was found for a
+         */
+        ErrorCode[ErrorCode["MISSING_PIPE"] = 8004] = "MISSING_PIPE";
+        /**
+         * 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.
+         */
+        ErrorCode[ErrorCode["WRITE_TO_READ_ONLY_VARIABLE"] = 8005] = "WRITE_TO_READ_ONLY_VARIABLE";
+        /**
+         * An injectable already has a `ɵprov` property.
+         */
+        ErrorCode[ErrorCode["INJECTABLE_DUPLICATE_PROV"] = 9001] = "INJECTABLE_DUPLICATE_PROV";
+    })(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {}));
+    /**
+     * @internal
+     */
+    function ngErrorCode(code) {
+        return parseInt('-99' + code);
+    }
+    exports.ngErrorCode = ngErrorCode;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/file_system/src/cached_file_system.d.ts

@@ -21,11 +21,13 @@ export declare class CachedFileSystem implements FileSystem {
     constructor(delegate: FileSystem);
     exists(path: AbsoluteFsPath): boolean;
     readFile(path: AbsoluteFsPath): string;
-    writeFile(path: AbsoluteFsPath, data: string): void;
+    writeFile(path: AbsoluteFsPath, data: string, exclusive?: boolean): void;
+    removeFile(path: AbsoluteFsPath): void;
     symlink(target: AbsoluteFsPath, path: AbsoluteFsPath): void;
     copyFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
     moveFile(from: AbsoluteFsPath, to: AbsoluteFsPath): void;
     ensureDir(path: AbsoluteFsPath): void;
+    removeDeep(path: AbsoluteFsPath): void;
     lstat(path: AbsoluteFsPath): FileStats;
     stat(path: AbsoluteFsPath): FileStats;
     readdir(path: AbsoluteFsPath): PathSegment[];