@nx/angular 16.8.0-beta.4 → 16.8.0-beta.5

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/ngc/compile-source-files.js

@@ -9,7 +9,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileSourceFiles = void 0;
-const tslib_1 = require("tslib");
 const nodes_1 = require("ng-packagr/lib/ng-package/nodes");
 const cache_compiler_host_1 = require("ng-packagr/lib/ts/cache-compiler-host");
 const log = require("ng-packagr/lib/utils/log");
@@ -17,134 +16,135 @@ const ng_compiler_cli_1 = require("ng-packagr/lib/utils/ng-compiler-cli");
 const ts = require("typescript");
 const angular_version_utils_1 = require("../../../utilities/angular-version-utils");
 const cache_compiler_host_2 = require("../ts/cache-compiler-host");
-function compileSourceFiles(graph, tsConfig, moduleResolutionCache, extraOptions, stylesheetProcessor, watch) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { NgtscProgram, formatDiagnostics } = yield (0, ng_compiler_cli_1.ngCompilerCli)();
-        const tsConfigOptions = Object.assign(Object.assign({}, tsConfig.options), extraOptions);
-        const entryPoint = graph.find((0, nodes_1.isEntryPointInProgress)());
-        const ngPackageNode = graph.find(nodes_1.isPackage);
-        const inlineStyleLanguage = ngPackageNode.data.inlineStyleLanguage;
-        const tsCompilerHost = (0, cache_compiler_host_2.cacheCompilerHost)(graph, entryPoint, tsConfigOptions, moduleResolutionCache, stylesheetProcessor, inlineStyleLanguage);
-        const cache = entryPoint.cache;
-        const sourceFileCache = cache.sourcesFileCache;
-        // Create the Angular specific program that contains the Angular compiler
-        const angularProgram = new NgtscProgram(tsConfig.rootNames, tsConfigOptions, tsCompilerHost, cache.oldNgtscProgram);
-        const angularCompiler = angularProgram.compiler;
-        const { ignoreForDiagnostics, ignoreForEmit } = angularCompiler;
-        // SourceFile versions are required for builder programs.
-        // The wrapped host inside NgtscProgram adds additional files that will not have versions.
-        const typeScriptProgram = angularProgram.getTsProgram();
-        (0, cache_compiler_host_1.augmentProgramWithVersioning)(typeScriptProgram);
-        let builder;
-        if (watch) {
-            builder = cache.oldBuilder =
-                ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, tsCompilerHost, cache.oldBuilder);
-            cache.oldNgtscProgram = angularProgram;
-        }
-        else {
-            // When not in watch mode, the startup cost of the incremental analysis can be avoided by
-            // using an abstract builder that only wraps a TypeScript program.
-            builder = ts.createAbstractBuilder(typeScriptProgram, tsCompilerHost);
-        }
-        // Update semantic diagnostics cache
-        const affectedFiles = new Set();
-        // Analyze affected files when in watch mode for incremental type checking
-        if ('getSemanticDiagnosticsOfNextAffectedFile' in builder) {
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-                    // If the affected file is a TTC shim, add the shim's original source file.
-                    // This ensures that changes that affect TTC are typechecked even when the changes
-                    // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.
-                    // For example, changing @Input property types of a directive used in another component's
-                    // template.
-                    if (ignoreForDiagnostics.has(sourceFile) &&
-                        sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
-                        // This file name conversion relies on internal compiler logic and should be converted
-                        // to an official method when available. 15 is length of `.ngtypecheck.ts`
-                        const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
-                        const originalSourceFile = builder.getSourceFile(originalFilename);
-                        if (originalSourceFile) {
-                            affectedFiles.add(originalSourceFile);
-                        }
-                        return true;
+async function compileSourceFiles(graph, tsConfig, moduleResolutionCache, extraOptions, stylesheetProcessor, watch) {
+    const { NgtscProgram, formatDiagnostics } = await (0, ng_compiler_cli_1.ngCompilerCli)();
+    const tsConfigOptions = {
+        ...tsConfig.options,
+        ...extraOptions,
+    };
+    const entryPoint = graph.find((0, nodes_1.isEntryPointInProgress)());
+    const ngPackageNode = graph.find(nodes_1.isPackage);
+    const inlineStyleLanguage = ngPackageNode.data.inlineStyleLanguage;
+    const tsCompilerHost = (0, cache_compiler_host_2.cacheCompilerHost)(graph, entryPoint, tsConfigOptions, moduleResolutionCache, stylesheetProcessor, inlineStyleLanguage);
+    const cache = entryPoint.cache;
+    const sourceFileCache = cache.sourcesFileCache;
+    // Create the Angular specific program that contains the Angular compiler
+    const angularProgram = new NgtscProgram(tsConfig.rootNames, tsConfigOptions, tsCompilerHost, cache.oldNgtscProgram);
+    const angularCompiler = angularProgram.compiler;
+    const { ignoreForDiagnostics, ignoreForEmit } = angularCompiler;
+    // SourceFile versions are required for builder programs.
+    // The wrapped host inside NgtscProgram adds additional files that will not have versions.
+    const typeScriptProgram = angularProgram.getTsProgram();
+    (0, cache_compiler_host_1.augmentProgramWithVersioning)(typeScriptProgram);
+    let builder;
+    if (watch) {
+        builder = cache.oldBuilder =
+            ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, tsCompilerHost, cache.oldBuilder);
+        cache.oldNgtscProgram = angularProgram;
+    }
+    else {
+        // When not in watch mode, the startup cost of the incremental analysis can be avoided by
+        // using an abstract builder that only wraps a TypeScript program.
+        builder = ts.createAbstractBuilder(typeScriptProgram, tsCompilerHost);
+    }
+    // Update semantic diagnostics cache
+    const affectedFiles = new Set();
+    // Analyze affected files when in watch mode for incremental type checking
+    if ('getSemanticDiagnosticsOfNextAffectedFile' in builder) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+                // If the affected file is a TTC shim, add the shim's original source file.
+                // This ensures that changes that affect TTC are typechecked even when the changes
+                // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.
+                // For example, changing @Input property types of a directive used in another component's
+                // template.
+                if (ignoreForDiagnostics.has(sourceFile) &&
+                    sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                    // This file name conversion relies on internal compiler logic and should be converted
+                    // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                    const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                    const originalSourceFile = builder.getSourceFile(originalFilename);
+                    if (originalSourceFile) {
+                        affectedFiles.add(originalSourceFile);
                     }
-                    return false;
-                });
-                if (!result) {
-                    break;
+                    return true;
                 }
-                affectedFiles.add(result.affected);
+                return false;
+            });
+            if (!result) {
+                break;
             }
+            affectedFiles.add(result.affected);
         }
-        // Collect program level diagnostics
-        const allDiagnostics = [
-            ...angularCompiler.getOptionDiagnostics(),
-            ...builder.getOptionsDiagnostics(),
-            ...builder.getGlobalDiagnostics(),
-        ];
-        // Required to support asynchronous resource loading
-        // Must be done before creating transformers or getting template diagnostics
-        yield angularCompiler.analyzeAsync();
-        // Collect source file specific diagnostics
-        for (const sourceFile of builder.getSourceFiles()) {
-            if (!ignoreForDiagnostics.has(sourceFile)) {
-                allDiagnostics.push(...builder.getDeclarationDiagnostics(sourceFile), ...builder.getSyntacticDiagnostics(sourceFile), ...builder.getSemanticDiagnostics(sourceFile));
-            }
-            if (sourceFile.isDeclarationFile) {
-                continue;
-            }
-            // Collect sources that are required to be emitted
-            const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
-            const incrementalCompilation = angularVersion.major < 16
-                ? angularCompiler.incrementalDriver
-                : angularCompiler.incrementalCompilation;
-            if (!ignoreForEmit.has(sourceFile) &&
-                !incrementalCompilation.safeToSkipEmit(sourceFile)) {
-                // If required to emit, diagnostics may have also changed
-                if (!ignoreForDiagnostics.has(sourceFile)) {
-                    affectedFiles.add(sourceFile);
-                }
-            }
-            else if (sourceFileCache &&
-                !affectedFiles.has(sourceFile) &&
-                !ignoreForDiagnostics.has(sourceFile)) {
-                // Use cached Angular diagnostics for unchanged and unaffected files
-                const angularDiagnostics = sourceFileCache.getAngularDiagnostics(sourceFile);
-                if (angularDiagnostics === null || angularDiagnostics === void 0 ? void 0 : angularDiagnostics.length) {
-                    allDiagnostics.push(...angularDiagnostics);
-                }
-            }
+    }
+    // Collect program level diagnostics
+    const allDiagnostics = [
+        ...angularCompiler.getOptionDiagnostics(),
+        ...builder.getOptionsDiagnostics(),
+        ...builder.getGlobalDiagnostics(),
+    ];
+    // Required to support asynchronous resource loading
+    // Must be done before creating transformers or getting template diagnostics
+    await angularCompiler.analyzeAsync();
+    // Collect source file specific diagnostics
+    for (const sourceFile of builder.getSourceFiles()) {
+        if (!ignoreForDiagnostics.has(sourceFile)) {
+            allDiagnostics.push(...builder.getDeclarationDiagnostics(sourceFile), ...builder.getSyntacticDiagnostics(sourceFile), ...builder.getSemanticDiagnostics(sourceFile));
         }
-        // Collect new Angular diagnostics for files affected by changes
-        for (const affectedFile of affectedFiles) {
-            const angularDiagnostics = angularCompiler.getDiagnosticsForFile(affectedFile, 
-            /** OptimizeFor.WholeProgram */ 1);
-            allDiagnostics.push(...angularDiagnostics);
-            sourceFileCache.updateAngularDiagnostics(affectedFile, angularDiagnostics);
+        if (sourceFile.isDeclarationFile) {
+            continue;
         }
-        const otherDiagnostics = [];
-        const errorDiagnostics = [];
-        for (const diagnostic of allDiagnostics) {
-            if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                errorDiagnostics.push(diagnostic);
+        // Collect sources that are required to be emitted
+        const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+        const incrementalCompilation = angularVersion.major < 16
+            ? angularCompiler.incrementalDriver
+            : angularCompiler.incrementalCompilation;
+        if (!ignoreForEmit.has(sourceFile) &&
+            !incrementalCompilation.safeToSkipEmit(sourceFile)) {
+            // If required to emit, diagnostics may have also changed
+            if (!ignoreForDiagnostics.has(sourceFile)) {
+                affectedFiles.add(sourceFile);
             }
-            else {
-                otherDiagnostics.push(diagnostic);
+        }
+        else if (sourceFileCache &&
+            !affectedFiles.has(sourceFile) &&
+            !ignoreForDiagnostics.has(sourceFile)) {
+            // Use cached Angular diagnostics for unchanged and unaffected files
+            const angularDiagnostics = sourceFileCache.getAngularDiagnostics(sourceFile);
+            if (angularDiagnostics?.length) {
+                allDiagnostics.push(...angularDiagnostics);
             }
         }
-        if (otherDiagnostics.length) {
-            log.msg(formatDiagnostics(errorDiagnostics));
+    }
+    // Collect new Angular diagnostics for files affected by changes
+    for (const affectedFile of affectedFiles) {
+        const angularDiagnostics = angularCompiler.getDiagnosticsForFile(affectedFile, 
+        /** OptimizeFor.WholeProgram */ 1);
+        allDiagnostics.push(...angularDiagnostics);
+        sourceFileCache.updateAngularDiagnostics(affectedFile, angularDiagnostics);
+    }
+    const otherDiagnostics = [];
+    const errorDiagnostics = [];
+    for (const diagnostic of allDiagnostics) {
+        if (diagnostic.category === ts.DiagnosticCategory.Error) {
+            errorDiagnostics.push(diagnostic);
         }
-        if (errorDiagnostics.length) {
-            throw new Error(formatDiagnostics(errorDiagnostics));
+        else {
+            otherDiagnostics.push(diagnostic);
         }
-        const transformers = angularCompiler.prepareEmit().transformers;
-        for (const sourceFile of builder.getSourceFiles()) {
-            if (!ignoreForEmit.has(sourceFile)) {
-                builder.emit(sourceFile, undefined, undefined, undefined, transformers);
-            }
+    }
+    if (otherDiagnostics.length) {
+        log.msg(formatDiagnostics(errorDiagnostics));
+    }
+    if (errorDiagnostics.length) {
+        throw new Error(formatDiagnostics(errorDiagnostics));
+    }
+    const transformers = angularCompiler.prepareEmit().transformers;
+    for (const sourceFile of builder.getSourceFiles()) {
+        if (!ignoreForEmit.has(sourceFile)) {
+            builder.emit(sourceFile, undefined, undefined, undefined, transformers);
         }
-    });
+    }
 }
 exports.compileSourceFiles = compileSourceFiles;

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/styles/stylesheet-processor.js

@@ -10,7 +10,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StylesheetProcessor = exports.InlineStyleLanguage = exports.CssUrl = void 0;
-const tslib_1 = require("tslib");
 const browserslist = require("browserslist");
 const fs_1 = require("fs");
 const esbuild_executor_1 = require("ng-packagr/lib/esbuild/esbuild-executor");
@@ -72,82 +71,78 @@ class StylesheetProcessor {
         this.tailwindSetup = (0, tailwindcss_1.getTailwindSetup)(this.basePath, this.tailwindConfig);
         this.postCssProcessor = this.createPostCssPlugins();
     }
-    process({ filePath, content, }) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let key;
-            if (this.cacheDirectory &&
-                !content.includes('@import') &&
-                !content.includes('@use') &&
-                !this.containsTailwindDirectives(content)) {
-                // No transitive deps and no Tailwind directives, we can cache more aggressively.
-                key = yield (0, cache_1.generateKey)(content, ...this.browserslistData, filePath);
-                const result = yield (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
-                if (result) {
-                    result.warnings.forEach((msg) => log.warn(msg));
-                    return result.css;
-                }
+    async process({ filePath, content, }) {
+        let key;
+        if (this.cacheDirectory &&
+            !content.includes('@import') &&
+            !content.includes('@use') &&
+            !this.containsTailwindDirectives(content)) {
+            // No transitive deps and no Tailwind directives, we can cache more aggressively.
+            key = await (0, cache_1.generateKey)(content, ...this.browserslistData, filePath);
+            const result = await (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
+            if (result) {
+                result.warnings.forEach((msg) => log.warn(msg));
+                return result.css;
             }
-            // Render pre-processor language (sass, styl, less)
-            const renderedCss = yield this.renderCss(filePath, content);
-            let containsTailwindDirectives = false;
-            if (this.cacheDirectory) {
-                containsTailwindDirectives = this.containsTailwindDirectives(renderedCss);
-                if (!containsTailwindDirectives) {
-                    // No Tailwind directives to process by PostCSS, we can return cached results
-                    if (!key) {
-                        key = yield (0, cache_1.generateKey)(renderedCss, ...this.browserslistData, filePath);
-                    }
-                    const cachedResult = yield this.getCachedResult(key);
-                    if (cachedResult) {
-                        return cachedResult;
-                    }
+        }
+        // Render pre-processor language (sass, styl, less)
+        const renderedCss = await this.renderCss(filePath, content);
+        let containsTailwindDirectives = false;
+        if (this.cacheDirectory) {
+            containsTailwindDirectives = this.containsTailwindDirectives(renderedCss);
+            if (!containsTailwindDirectives) {
+                // No Tailwind directives to process by PostCSS, we can return cached results
+                if (!key) {
+                    key = await (0, cache_1.generateKey)(renderedCss, ...this.browserslistData, filePath);
                 }
-            }
-            // Render postcss (autoprefixing and friends)
-            const result = yield this.postCssProcessor.process(renderedCss, {
-                from: filePath,
-                to: filePath.replace((0, path_1.extname)(filePath), '.css'),
-            });
-            if (this.cacheDirectory && containsTailwindDirectives) {
-                // We had Tailwind directives to process by PostCSS, only now
-                // is safe to return cached results
-                key = yield (0, cache_1.generateKey)(result.css, ...this.browserslistData, filePath);
-                const cachedResult = yield this.getCachedResult(key);
+                const cachedResult = await this.getCachedResult(key);
                 if (cachedResult) {
                     return cachedResult;
                 }
             }
-            const warnings = result.warnings().map((w) => w.toString());
-            const { code, warnings: esBuildWarnings } = yield this.esbuild.transform(result.css, {
-                loader: 'css',
-                minify: true,
-                target: this.targets,
-                sourcefile: filePath,
-            });
-            if (esBuildWarnings.length > 0) {
-                warnings.push(...(yield this.esbuild.formatMessages(esBuildWarnings, {
-                    kind: 'warning',
-                })));
-            }
-            if (this.cacheDirectory) {
-                yield (0, cache_1.saveCacheEntry)(this.cacheDirectory, key, JSON.stringify({
-                    css: code,
-                    warnings,
-                }));
-            }
-            warnings.forEach((msg) => log.warn(msg));
-            return code;
+        }
+        // Render postcss (autoprefixing and friends)
+        const result = await this.postCssProcessor.process(renderedCss, {
+            from: filePath,
+            to: filePath.replace((0, path_1.extname)(filePath), '.css'),
         });
-    }
-    getCachedResult(key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const cachedResult = yield (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
+        if (this.cacheDirectory && containsTailwindDirectives) {
+            // We had Tailwind directives to process by PostCSS, only now
+            // is safe to return cached results
+            key = await (0, cache_1.generateKey)(result.css, ...this.browserslistData, filePath);
+            const cachedResult = await this.getCachedResult(key);
             if (cachedResult) {
-                cachedResult.warnings.forEach((msg) => log.warn(msg));
-                return cachedResult.css;
+                return cachedResult;
             }
-            return undefined;
+        }
+        const warnings = result.warnings().map((w) => w.toString());
+        const { code, warnings: esBuildWarnings } = await this.esbuild.transform(result.css, {
+            loader: 'css',
+            minify: true,
+            target: this.targets,
+            sourcefile: filePath,
         });
+        if (esBuildWarnings.length > 0) {
+            warnings.push(...(await this.esbuild.formatMessages(esBuildWarnings, {
+                kind: 'warning',
+            })));
+        }
+        if (this.cacheDirectory) {
+            await (0, cache_1.saveCacheEntry)(this.cacheDirectory, key, JSON.stringify({
+                css: code,
+                warnings,
+            }));
+        }
+        warnings.forEach((msg) => log.warn(msg));
+        return code;
+    }
+    async getCachedResult(key) {
+        const cachedResult = await (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
+        if (cachedResult) {
+            cachedResult.warnings.forEach((msg) => log.warn(msg));
+            return cachedResult.css;
+        }
+        return undefined;
     }
     containsTailwindDirectives(content) {
         return (this.tailwindSetup && tailwindcss_1.tailwindDirectives.some((d) => content.includes(d)));
@@ -167,46 +162,44 @@ class StylesheetProcessor {
         }));
         return postcss(postCssPlugins);
     }
-    renderCss(filePath, css) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const ext = (0, path_1.extname)(filePath);
-            switch (ext) {
-                case '.sass':
-                case '.scss': {
-                    const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
-                    if (angularVersion && angularVersion.major < 15) {
-                        return (yield Promise.resolve().then(() => require('sass')))
-                            .renderSync({
-                            file: filePath,
-                            data: css,
-                            indentedSyntax: '.sass' === ext,
-                            importer: customSassImporter,
-                            includePaths: this.styleIncludePaths,
-                        })
-                            .css.toString();
-                    }
-                    return (yield Promise.resolve().then(() => require('sass')))
-                        .compileString(css, {
-                        url: (0, node_url_1.pathToFileURL)(filePath),
-                        syntax: '.sass' === ext ? 'indented' : 'scss',
-                        loadPaths: this.styleIncludePaths,
+    async renderCss(filePath, css) {
+        const ext = (0, path_1.extname)(filePath);
+        switch (ext) {
+            case '.sass':
+            case '.scss': {
+                const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+                if (angularVersion && angularVersion.major < 15) {
+                    return (await Promise.resolve().then(() => require('sass')))
+                        .renderSync({
+                        file: filePath,
+                        data: css,
+                        indentedSyntax: '.sass' === ext,
+                        importer: customSassImporter,
+                        includePaths: this.styleIncludePaths,
                     })
                         .css.toString();
                 }
-                case '.less': {
-                    const { css: content } = yield (yield Promise.resolve().then(() => require('less'))).render(css, {
-                        filename: filePath,
-                        math: 'always',
-                        javascriptEnabled: true,
-                        paths: this.styleIncludePaths,
-                    });
-                    return content;
-                }
-                case '.css':
-                default:
-                    return css;
+                return (await Promise.resolve().then(() => require('sass')))
+                    .compileString(css, {
+                    url: (0, node_url_1.pathToFileURL)(filePath),
+                    syntax: '.sass' === ext ? 'indented' : 'scss',
+                    loadPaths: this.styleIncludePaths,
+                })
+                    .css.toString();
             }
-        });
+            case '.less': {
+                const { css: content } = await (await Promise.resolve().then(() => require('less'))).render(css, {
+                    filename: filePath,
+                    math: 'always',
+                    javascriptEnabled: true,
+                    paths: this.styleIncludePaths,
+                });
+                return content;
+            }
+            case '.css':
+            default:
+                return css;
+        }
     }
 }
 exports.StylesheetProcessor = StylesheetProcessor;

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/ts/cache-compiler-host.js

@@ -7,7 +7,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.augmentProgramWithVersioning = exports.cacheCompilerHost = void 0;
-const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
 const node_1 = require("ng-packagr/lib/graph/node");
 const nodes_1 = require("ng-packagr/lib/ng-package/nodes");
@@ -33,7 +32,8 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
     const flatModuleFileDtsFilename = `${flatModuleFile}.d.ts`;
     const flatModuleFileDtsPath = (0, path_1.ensureUnixPath)(path.join(destinationPath, flatModuleFileDtsFilename));
     const hasIndexEntryFile = path.basename(entryFile.toLowerCase()) === 'index.ts';
-    return Object.assign(Object.assign({}, compilerHost), { 
+    return {
+        ...compilerHost,
         // ts specific
         fileExists: (fileName) => {
             const cache = sourcesFileCache.getOrCreate(fileName);
@@ -41,14 +41,16 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
                 cache.exists = compilerHost.fileExists.call(this, fileName);
             }
             return cache.exists;
-        }, getSourceFile: (fileName, languageVersion) => {
+        },
+        getSourceFile: (fileName, languageVersion) => {
             addDependee(fileName);
             const cache = sourcesFileCache.getOrCreate(fileName);
             if (!cache.sourceFile) {
                 cache.sourceFile = compilerHost.getSourceFile.call(this, fileName, languageVersion);
             }
             return cache.sourceFile;
-        }, writeFile: (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+        },
+        writeFile: (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
             if (fileName.endsWith('.d.ts')) {
                 if (fileName === flatModuleFileDtsPath) {
                     if (hasIndexEntryFile) {
@@ -78,25 +80,29 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
                 });
             }
             compilerHost.writeFile.call(this, fileName, data, writeByteOrderMark, onError, sourceFiles);
-        }, readFile: (fileName) => {
+        },
+        readFile: (fileName) => {
             addDependee(fileName);
             const cache = sourcesFileCache.getOrCreate(fileName);
             if (cache.content === undefined) {
                 cache.content = compilerHost.readFile.call(this, fileName);
             }
             return cache.content;
-        }, resolveModuleNames: (moduleNames, containingFile) => {
+        },
+        resolveModuleNames: (moduleNames, containingFile) => {
             return moduleNames.map((moduleName) => {
                 const { resolvedModule } = ts.resolveModuleName(moduleName, (0, path_1.ensureUnixPath)(containingFile), compilerOptions, compilerHost, moduleResolutionCache);
                 return resolvedModule;
             });
-        }, resourceNameToFileName: (resourceName, containingFilePath) => {
+        },
+        resourceNameToFileName: (resourceName, containingFilePath) => {
             const resourcePath = path.resolve(path.dirname(containingFilePath), resourceName);
             const containingNode = getNode(containingFilePath);
             const resourceNode = getNode(resourcePath);
             containingNode.dependsOn(resourceNode);
             return resourcePath;
-        }, readResource: (fileName) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        },
+        readResource: async (fileName) => {
             addDependee(fileName);
             const cache = sourcesFileCache.getOrCreate(fileName);
             if (cache.content === undefined) {
@@ -109,7 +115,7 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
                 }
                 else {
                     // stylesheet
-                    cache.content = yield stylesheetProcessor.process({
+                    cache.content = await stylesheetProcessor.process({
                         filePath: fileName,
                         content: compilerHost.readFile.call(this, fileName),
                     });
@@ -117,7 +123,8 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
                 cache.exists = true;
             }
             return cache.content;
-        }), transformResource: (data, context) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        },
+        transformResource: async (data, context) => {
             if (context.resourceFile || context.type !== 'style') {
                 return null;
             }
@@ -126,7 +133,7 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
                 const fileName = `${context.containingFile}-${key}.${inlineStyleLanguage}`;
                 const cache = sourcesFileCache.getOrCreate(fileName);
                 if (cache.content === undefined) {
-                    cache.content = yield stylesheetProcessor.process({
+                    cache.content = await stylesheetProcessor.process({
                         filePath: context.containingFile,
                         content: data,
                     });
@@ -138,7 +145,8 @@ function cacheCompilerHost(graph, entryPoint, compilerOptions, moduleResolutionC
                 return { content: cache.content };
             }
             return null;
-        }) });
+        },
+    };
 }
 exports.cacheCompilerHost = cacheCompilerHost;
 function augmentProgramWithVersioning(program) {