@rushstack/heft-typescript-plugin 1.1.14 → 1.2.1

package/lib-esm/TypeScriptBuilder.js

@@ -0,0 +1,758 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import { Worker } from 'node:worker_threads';
+import { Path, FileError } from '@rushstack/node-core-library';
+import { configureProgramForMultiEmit } from './configureProgramForMultiEmit';
+import { loadTsconfig } from './tsconfigLoader';
+import { loadTypeScriptToolAsync } from './loadTypeScriptTool';
+export class TypeScriptBuilder {
+    get _tsCacheFilePath() {
+        var _a;
+        if (!this.__tsCacheFilePath) {
+            // TypeScript internally handles if the tsconfig options have changed from when the tsbuildinfo file was created.
+            // We only need to hash our additional Heft configuration.
+            const configHash = crypto.createHash('sha1');
+            // Relativize the outFolderName paths before hashing to ensure portability across different machines
+            const normalizedConfig = ((_a = this._configuration.additionalModuleKindsToEmit) === null || _a === void 0 ? void 0 : _a.map((emitKind) => ({
+                ...emitKind,
+                outFolderName: Path.convertToSlashes(path.relative(this._configuration.buildFolderPath, emitKind.outFolderName))
+            }))) || [];
+            configHash.update(JSON.stringify(normalizedConfig));
+            const serializedConfigHash = configHash.digest('base64url').slice(0, 8);
+            // This conversion is theoretically redundant, but it is here to make absolutely sure that the path is formatted
+            // using only '/' as the directory separator so that incremental builds don't break on Windows.
+            // TypeScript will normalize to '/' when serializing, but not on the direct input, and uses exact string equality.
+            const normalizedCacheFolderPath = Path.convertToSlashes(this._configuration.buildMetadataFolderPath);
+            this.__tsCacheFilePath = `${normalizedCacheFolderPath}/ts_${serializedConfigHash}.json`;
+        }
+        return this.__tsCacheFilePath;
+    }
+    constructor(configuration) {
+        this._suppressedDiagnosticCodes = new Set();
+        this._tool = undefined;
+        this._nextRequestId = 0;
+        this._configuration = configuration;
+        this._typescriptLogger = configuration.scopedLogger;
+        this._typescriptTerminal = configuration.scopedLogger.terminal;
+    }
+    async invokeAsync(onChangeDetected) {
+        var _a, _b;
+        if (!this._tool) {
+            const { tool: { ts, system: baseSystem, typeScriptToolPath } } = await loadTypeScriptToolAsync({
+                terminal: this._typescriptTerminal,
+                heftConfiguration: this._configuration.heftConfiguration,
+                buildProjectReferences: this._configuration.buildProjectReferences,
+                onlyResolveSymlinksInNodeModules: this._configuration.onlyResolveSymlinksInNodeModules
+            });
+            this._useSolutionBuilder = !!this._configuration.buildProjectReferences;
+            ts.performance.enable();
+            const suppressedCodes = [
+                (_a = ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor) === null || _a === void 0 ? void 0 : _a.code,
+                // This diagnostic code is not present in old versions of TypeScript
+                (_b = ts.Diagnostics
+                    .Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1) === null || _b === void 0 ? void 0 : _b.code
+            ];
+            for (const code of suppressedCodes) {
+                if (code !== undefined) {
+                    this._suppressedDiagnosticCodes.add(code);
+                }
+            }
+            const measureTsPerformance = (measurementName, fn) => {
+                const beforeName = `before${measurementName}`;
+                ts.performance.mark(beforeName);
+                const result = fn();
+                const afterName = `after${measurementName}`;
+                ts.performance.mark(afterName);
+                ts.performance.measure(measurementName, beforeName, afterName);
+                return {
+                    ...result,
+                    duration: ts.performance.getDuration(measurementName),
+                    count: ts.performance.getCount(beforeName)
+                };
+            };
+            this._typescriptTerminal.writeLine(`Using TypeScript version ${ts.version}`);
+            const rawDiagnostics = [];
+            const pendingOperations = new Set();
+            const clearTimeout = (timeout) => {
+                pendingOperations.delete(timeout);
+            };
+            const setTimeout = (fn, ms, ...args) => {
+                var _a;
+                const timeout = () => {
+                    fn(...args);
+                };
+                pendingOperations.add(timeout);
+                if (!((_a = this._tool) === null || _a === void 0 ? void 0 : _a.executing) && onChangeDetected) {
+                    onChangeDetected();
+                }
+                return timeout;
+            };
+            const getCurrentDirectory = () => this._configuration.buildFolderPath;
+            // Need to also update watchFile and watchDirectory
+            const system = {
+                ...baseSystem,
+                getCurrentDirectory,
+                clearTimeout,
+                setTimeout
+            };
+            const { realpath } = system;
+            if (realpath && system.getAccessibleFileSystemEntries) {
+                const { getAccessibleFileSystemEntries } = system;
+                system.readDirectory = (folderPath, extensions, exclude, include, depth) => {
+                    return ts.matchFiles(folderPath, extensions, exclude, include, ts.sys.useCaseSensitiveFileNames, getCurrentDirectory(), depth, getAccessibleFileSystemEntries, realpath, ts.sys.directoryExists);
+                };
+            }
+            this._tool = {
+                typeScriptToolPath,
+                ts,
+                system,
+                measureSync: measureTsPerformance,
+                sourceFileCache: new Map(),
+                watchProgram: undefined,
+                solutionBuilder: undefined,
+                rawDiagnostics,
+                pendingOperations,
+                executing: false,
+                reportDiagnostic: (diagnostic) => {
+                    rawDiagnostics.push(diagnostic);
+                },
+                worker: undefined,
+                pendingTranspilePromises: new Map(),
+                pendingTranspileSignals: new Map()
+            };
+        }
+        const { performance } = this._tool.ts;
+        // Reset the performance counters to 0 to avoid contamination from previous runs
+        performance.disable();
+        performance.enable();
+        if (onChangeDetected !== undefined) {
+            await this._runWatchAsync(this._tool);
+        }
+        else if (this._useSolutionBuilder) {
+            await this._runSolutionBuildAsync(this._tool);
+        }
+        else {
+            await this._runBuildAsync(this._tool);
+        }
+    }
+    async _runWatchAsync(tool) {
+        const { ts, measureSync: measureTsPerformance, pendingOperations, rawDiagnostics, pendingTranspilePromises } = tool;
+        if (!tool.solutionBuilder && !tool.watchProgram) {
+            //#region CONFIGURE
+            const { duration: configureDurationMs, tsconfig } = measureTsPerformance('Configure', () => {
+                const _tsconfig = loadTsconfig({
+                    tool,
+                    tsconfigPath: this._configuration.tsconfigPath,
+                    tsCacheFilePath: this._tsCacheFilePath
+                });
+                this._validateTsconfig(ts, _tsconfig);
+                return {
+                    tsconfig: _tsconfig
+                };
+            });
+            this._typescriptTerminal.writeVerboseLine(`Configure: ${configureDurationMs}ms`);
+            //#endregion
+            if (this._useSolutionBuilder) {
+                const solutionHost = this._buildWatchSolutionBuilderHost(tool);
+                const builder = ts.createSolutionBuilderWithWatch(solutionHost, [this._configuration.tsconfigPath], {});
+                tool.solutionBuilder = builder;
+                builder.build();
+            }
+            else {
+                const compilerHost = this._buildWatchCompilerHost(tool, tsconfig);
+                tool.watchProgram = ts.createWatchProgram(compilerHost);
+            }
+        }
+        if (pendingOperations.size > 0) {
+            rawDiagnostics.length = 0;
+            tool.executing = true;
+            for (const operation of pendingOperations) {
+                pendingOperations.delete(operation);
+                operation();
+            }
+            if (pendingTranspilePromises.size) {
+                const emitResults = await Promise.all(pendingTranspilePromises.values());
+                for (const { diagnostics } of emitResults) {
+                    for (const diagnostic of diagnostics) {
+                        rawDiagnostics.push(diagnostic);
+                    }
+                }
+            }
+            // eslint-disable-next-line require-atomic-updates
+            tool.executing = false;
+        }
+        this._logDiagnostics(ts, rawDiagnostics, this._useSolutionBuilder);
+    }
+    async _runBuildAsync(tool) {
+        const { ts, measureSync: measureTsPerformance, pendingTranspilePromises } = tool;
+        //#region CONFIGURE
+        const { duration: configureDurationMs, tsconfig, compilerHost } = measureTsPerformance('Configure', () => {
+            const _tsconfig = loadTsconfig({
+                tool,
+                tsconfigPath: this._configuration.tsconfigPath,
+                tsCacheFilePath: this._tsCacheFilePath
+            });
+            this._validateTsconfig(ts, _tsconfig);
+            const _compilerHost = this._buildIncrementalCompilerHost(tool, _tsconfig);
+            return {
+                tsconfig: _tsconfig,
+                compilerHost: _compilerHost
+            };
+        });
+        this._typescriptTerminal.writeVerboseLine(`Configure: ${configureDurationMs}ms`);
+        //#endregion
+        //#region PROGRAM
+        // There will be only one program here; emit will get a bit abused if we produce multiple outputs
+        let builderProgram = undefined;
+        let innerProgram;
+        const isolatedModules = !!this._configuration.useTranspilerWorker && !!tsconfig.options.isolatedModules;
+        const mode = isolatedModules ? 'declaration' : 'both';
+        let filesToTranspile;
+        if (tsconfig.options.incremental) {
+            // Use ts.createEmitAndSemanticDiagnositcsBuilderProgram directly because the customizations performed by
+            // _getCreateBuilderProgram duplicate those performed in this function for non-incremental build.
+            const oldProgram = ts.readBuilderProgram(tsconfig.options, compilerHost);
+            builderProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(tsconfig.fileNames, tsconfig.options, compilerHost, oldProgram, ts.getConfigFileParsingDiagnostics(tsconfig), tsconfig.projectReferences);
+            filesToTranspile = getFilesToTranspileFromBuilderProgram(builderProgram);
+            innerProgram = builderProgram.getProgram();
+        }
+        else {
+            innerProgram = ts.createProgram({
+                rootNames: tsconfig.fileNames,
+                options: tsconfig.options,
+                projectReferences: tsconfig.projectReferences,
+                host: compilerHost,
+                oldProgram: undefined,
+                configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(tsconfig)
+            });
+            filesToTranspile = getFilesToTranspileFromProgram(innerProgram);
+        }
+        // Prefer the builder program, since it is what gives us incremental builds
+        const genericProgram = builderProgram || innerProgram;
+        this._logReadPerformance(ts);
+        //#endregion
+        if (isolatedModules) {
+            // Kick the transpilation worker.
+            this._queueTranspileInWorker(tool, genericProgram.getCompilerOptions(), filesToTranspile);
+        }
+        //#region ANALYSIS
+        const { duration: diagnosticsDurationMs, diagnostics: preDiagnostics } = measureTsPerformance('Analyze', () => {
+            const rawDiagnostics = [
+                ...genericProgram.getConfigFileParsingDiagnostics(),
+                ...genericProgram.getOptionsDiagnostics(),
+                ...genericProgram.getSyntacticDiagnostics(),
+                ...genericProgram.getGlobalDiagnostics(),
+                ...genericProgram.getSemanticDiagnostics()
+            ];
+            return { diagnostics: rawDiagnostics };
+        });
+        this._typescriptTerminal.writeVerboseLine(`Analyze: ${diagnosticsDurationMs}ms`);
+        //#endregion
+        //#region EMIT
+        const { changedFiles } = configureProgramForMultiEmit(innerProgram, ts, this._moduleKindsToEmit, mode);
+        const emitResult = genericProgram.emit(undefined, 
+        // The writeFile callback must be provided for the multi-emit redirector
+        ts.sys.writeFile, undefined, undefined, undefined);
+        this._cleanupWorker();
+        //#endregion
+        this._logEmitPerformance(ts);
+        //#region FINAL_ANALYSIS
+        // Need to ensure that we include emit diagnostics, since they might not be part of the other sets
+        const rawDiagnostics = [...preDiagnostics, ...emitResult.diagnostics];
+        //#endregion
+        this._configuration.emitChangedFilesCallback(innerProgram, changedFiles);
+        if (pendingTranspilePromises.size) {
+            const emitResults = await Promise.all(pendingTranspilePromises.values());
+            for (const { diagnostics } of emitResults) {
+                for (const diagnostic of diagnostics) {
+                    rawDiagnostics.push(diagnostic);
+                }
+            }
+        }
+        this._logDiagnostics(ts, rawDiagnostics);
+        // Reset performance counters in case any are used in the callback
+        ts.performance.disable();
+        ts.performance.enable();
+    }
+    async _runSolutionBuildAsync(tool) {
+        this._typescriptTerminal.writeVerboseLine(`Using solution mode`);
+        const { ts, measureSync, rawDiagnostics, pendingTranspilePromises } = tool;
+        rawDiagnostics.length = 0;
+        if (!tool.solutionBuilder) {
+            //#region CONFIGURE
+            const { duration: configureDurationMs, solutionBuilderHost } = measureSync('Configure', () => {
+                const _tsconfig = loadTsconfig({
+                    tool,
+                    tsconfigPath: this._configuration.tsconfigPath,
+                    tsCacheFilePath: this._tsCacheFilePath
+                });
+                this._validateTsconfig(ts, _tsconfig);
+                const _solutionBuilderHost = this._buildSolutionBuilderHost(tool);
+                return {
+                    solutionBuilderHost: _solutionBuilderHost
+                };
+            });
+            this._typescriptTerminal.writeVerboseLine(`Configure: ${configureDurationMs}ms`);
+            //#endregion
+            tool.solutionBuilder = ts.createSolutionBuilder(solutionBuilderHost, [this._configuration.tsconfigPath], {});
+        }
+        else {
+            // Force reload everything from disk
+            for (const project of tool.solutionBuilder.getBuildOrder()) {
+                tool.solutionBuilder.invalidateProject(project, 1);
+            }
+        }
+        //#region EMIT
+        // Ignoring the exit status because we only care about presence of diagnostics
+        tool.solutionBuilder.build();
+        this._cleanupWorker();
+        //#endregion
+        if (pendingTranspilePromises.size) {
+            const emitResults = await Promise.all(pendingTranspilePromises.values());
+            for (const { diagnostics } of emitResults) {
+                for (const diagnostic of diagnostics) {
+                    rawDiagnostics.push(diagnostic);
+                }
+            }
+        }
+        this._logDiagnostics(ts, rawDiagnostics, true);
+    }
+    _logDiagnostics(ts, rawDiagnostics, isSolutionMode) {
+        const diagnostics = ts.sortAndDeduplicateDiagnostics(rawDiagnostics);
+        if (diagnostics.length > 0) {
+            let warningCount = 0;
+            let hasError = false;
+            this._typescriptTerminal.writeLine(`Encountered ${diagnostics.length} TypeScript issue${diagnostics.length > 1 ? 's' : ''}:`);
+            for (const diagnostic of diagnostics) {
+                const diagnosticCategory = this._getAdjustedDiagnosticCategory(diagnostic, ts);
+                if (diagnosticCategory === ts.DiagnosticCategory.Warning) {
+                    warningCount++;
+                }
+                else if (diagnosticCategory === ts.DiagnosticCategory.Error) {
+                    hasError = true;
+                }
+                this._printDiagnosticMessage(ts, diagnostic, diagnosticCategory);
+            }
+            if (isSolutionMode && warningCount > 0 && !hasError) {
+                this._typescriptLogger.emitError(new Error(`TypeScript encountered ${warningCount} warning${warningCount === 1 ? '' : 's'} ` +
+                    `and is configured to build project references. As a result, no files were emitted. Please fix the reported warnings to proceed.`));
+            }
+        }
+    }
+    _logEmitPerformance(ts) {
+        this._typescriptTerminal.writeVerboseLine(`Bind: ${ts.performance.getDuration('Bind')}ms`);
+        this._typescriptTerminal.writeVerboseLine(`Check: ${ts.performance.getDuration('Check')}ms`);
+        this._typescriptTerminal.writeVerboseLine(`Transform: ${ts.performance.getDuration('transformTime')}ms ` +
+            `(${ts.performance.getCount('beforeTransform')} files)`);
+        this._typescriptTerminal.writeVerboseLine(`Print: ${ts.performance.getDuration('printTime')}ms ` +
+            `(${ts.performance.getCount('beforePrint')} files) (Includes Transform)`);
+        this._typescriptTerminal.writeVerboseLine(`Emit: ${ts.performance.getDuration('Emit')}ms (Includes Print)`);
+        this._typescriptTerminal.writeVerboseLine(`I/O Write: ${ts.performance.getDuration('I/O Write')}ms (${ts.performance.getCount('beforeIOWrite')} files)`);
+    }
+    _logReadPerformance(ts) {
+        this._typescriptTerminal.writeVerboseLine(`I/O Read: ${ts.performance.getDuration('I/O Read')}ms (${ts.performance.getCount('beforeIORead')} files)`);
+        this._typescriptTerminal.writeVerboseLine(`Parse: ${ts.performance.getDuration('Parse')}ms (${ts.performance.getCount('beforeParse')} files)`);
+        this._typescriptTerminal.writeVerboseLine(`Program (includes Read + Parse): ${ts.performance.getDuration('Program')}ms`);
+    }
+    _printDiagnosticMessage(ts, diagnostic, diagnosticCategory = this._getAdjustedDiagnosticCategory(diagnostic, ts)) {
+        // Code taken from reference example
+        let diagnosticMessage;
+        let errorObject;
+        if (diagnostic.file) {
+            const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            const formattedMessage = `(TS${diagnostic.code}) ${message}`;
+            errorObject = new FileError(formattedMessage, {
+                absolutePath: diagnostic.file.fileName,
+                projectFolder: this._configuration.buildFolderPath,
+                line: line + 1,
+                column: character + 1
+            });
+            diagnosticMessage = errorObject.toString();
+        }
+        else {
+            diagnosticMessage = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            errorObject = new Error(diagnosticMessage);
+        }
+        switch (diagnosticCategory) {
+            case ts.DiagnosticCategory.Error: {
+                this._typescriptLogger.emitError(errorObject);
+                break;
+            }
+            case ts.DiagnosticCategory.Warning: {
+                this._typescriptLogger.emitWarning(errorObject);
+                break;
+            }
+            default: {
+                this._typescriptTerminal.writeLine(...diagnosticMessage);
+                break;
+            }
+        }
+    }
+    _getAdjustedDiagnosticCategory(diagnostic, ts) {
+        // Workaround for https://github.com/microsoft/TypeScript/issues/40058
+        // The compiler reports a hard error for issues such as this:
+        //
+        //    error TS6133: 'x' is declared but its value is never read.
+        //
+        // These should properly be treated as warnings, because they are purely cosmetic issues.
+        // TODO: Maybe heft should provide a config file for managing DiagnosticCategory mappings.
+        if (diagnostic.reportsUnnecessary && diagnostic.category === ts.DiagnosticCategory.Error) {
+            return ts.DiagnosticCategory.Warning;
+        }
+        // These pedantic checks also should not be treated as hard errors
+        if (this._suppressedDiagnosticCodes.has(diagnostic.code)) {
+            return ts.DiagnosticCategory.Warning;
+        }
+        return diagnostic.category;
+    }
+    _validateTsconfig(ts, tsconfig) {
+        if ((tsconfig.options.module && !tsconfig.options.outDir) ||
+            (!tsconfig.options.module && tsconfig.options.outDir)) {
+            throw new Error('If either the module or the outDir option is provided in the tsconfig compilerOptions, both must be provided');
+        }
+        this._moduleKindsToEmit = [];
+        const specifiedKinds = new Map();
+        const specifiedOutDirs = new Map();
+        if (!tsconfig.options.module) {
+            throw new Error('If the module tsconfig compilerOption is not provided, the builder must be provided with the ' +
+                'additionalModuleKindsToEmit configuration option.');
+        }
+        if (this._configuration.emitCjsExtensionForCommonJS) {
+            this._addModuleKindToEmit(ts.ModuleKind.CommonJS, tsconfig.options.outDir, 
+            /* isPrimary */ tsconfig.options.module === ts.ModuleKind.CommonJS, '.cjs');
+            const cjsReason = {
+                outDir: tsconfig.options.outDir,
+                kind: 'CommonJS',
+                extension: '.cjs',
+                reason: 'emitCjsExtensionForCommonJS'
+            };
+            specifiedKinds.set(ts.ModuleKind.CommonJS, cjsReason);
+            specifiedOutDirs.set(`${tsconfig.options.outDir}:.cjs`, cjsReason);
+        }
+        if (this._configuration.emitMjsExtensionForESModule) {
+            this._addModuleKindToEmit(ts.ModuleKind.ESNext, tsconfig.options.outDir, 
+            /* isPrimary */ tsconfig.options.module === ts.ModuleKind.ESNext, '.mjs');
+            const mjsReason = {
+                outDir: tsconfig.options.outDir,
+                kind: 'ESNext',
+                extension: '.mjs',
+                reason: 'emitMjsExtensionForESModule'
+            };
+            specifiedKinds.set(ts.ModuleKind.ESNext, mjsReason);
+            specifiedOutDirs.set(`${tsconfig.options.outDir}:.mjs`, mjsReason);
+        }
+        if (!specifiedKinds.has(tsconfig.options.module)) {
+            this._addModuleKindToEmit(tsconfig.options.module, tsconfig.options.outDir, 
+            /* isPrimary */ true, 
+            /* jsExtensionOverride */ undefined);
+            const tsConfigReason = {
+                outDir: tsconfig.options.outDir,
+                kind: ts.ModuleKind[tsconfig.options.module],
+                extension: '.js',
+                reason: 'tsconfig.json'
+            };
+            specifiedKinds.set(tsconfig.options.module, tsConfigReason);
+            specifiedOutDirs.set(`${tsconfig.options.outDir}:.js`, tsConfigReason);
+        }
+        if (this._configuration.additionalModuleKindsToEmit) {
+            for (const additionalModuleKindToEmit of this._configuration.additionalModuleKindsToEmit) {
+                const moduleKind = this._parseModuleKind(ts, additionalModuleKindToEmit.moduleKind);
+                const outDirKey = `${additionalModuleKindToEmit.outFolderName}:.js`;
+                const moduleKindReason = {
+                    kind: ts.ModuleKind[moduleKind],
+                    outDir: additionalModuleKindToEmit.outFolderName,
+                    extension: '.js',
+                    reason: `additionalModuleKindsToEmit`
+                };
+                const existingKind = specifiedKinds.get(moduleKind);
+                const existingDir = specifiedOutDirs.get(outDirKey);
+                if (existingKind) {
+                    throw new Error(`Module kind "${additionalModuleKindToEmit.moduleKind}" is already emitted at ${existingKind.outDir} with extension '${existingKind.extension}' by option ${existingKind.reason}.`);
+                }
+                else if (existingDir) {
+                    throw new Error(`Output folder "${additionalModuleKindToEmit.outFolderName}" already contains module kind ${existingDir.kind} with extension '${existingDir.extension}', specified by option ${existingDir.reason}.`);
+                }
+                else {
+                    const outFolderKey = this._addModuleKindToEmit(moduleKind, additionalModuleKindToEmit.outFolderName, 
+                    /* isPrimary */ false, undefined);
+                    if (outFolderKey) {
+                        specifiedKinds.set(moduleKind, moduleKindReason);
+                        specifiedOutDirs.set(outFolderKey, moduleKindReason);
+                    }
+                }
+            }
+        }
+    }
+    _addModuleKindToEmit(moduleKind, outFolderPath, isPrimary, jsExtensionOverride) {
+        let outFolderName;
+        if (path.isAbsolute(outFolderPath)) {
+            outFolderName = path.relative(this._configuration.buildFolderPath, outFolderPath);
+        }
+        else {
+            outFolderName = outFolderPath;
+            outFolderPath = path.resolve(this._configuration.buildFolderPath, outFolderPath);
+        }
+        outFolderPath = Path.convertToSlashes(outFolderPath);
+        outFolderPath = outFolderPath.replace(/\/*$/, '/'); // Ensure the outFolderPath ends with a slash
+        for (const existingModuleKindToEmit of this._moduleKindsToEmit) {
+            let errorText;
+            if (existingModuleKindToEmit.outFolderPath === outFolderPath) {
+                if (existingModuleKindToEmit.jsExtensionOverride === jsExtensionOverride) {
+                    errorText =
+                        'Unable to output two different module kinds with the same ' +
+                            `module extension (${jsExtensionOverride || '.js'}) to the same ` +
+                            `folder ("${outFolderPath}").`;
+                }
+            }
+            else {
+                let parentFolder;
+                let childFolder;
+                if (outFolderPath.startsWith(existingModuleKindToEmit.outFolderPath)) {
+                    parentFolder = outFolderPath;
+                    childFolder = existingModuleKindToEmit.outFolderPath;
+                }
+                else if (existingModuleKindToEmit.outFolderPath.startsWith(outFolderPath)) {
+                    parentFolder = existingModuleKindToEmit.outFolderPath;
+                    childFolder = outFolderPath;
+                }
+                if (parentFolder) {
+                    errorText =
+                        'Unable to output two different module kinds to nested folders ' +
+                            `("${parentFolder}" and "${childFolder}").`;
+                }
+            }
+            if (errorText) {
+                this._typescriptLogger.emitError(new Error(errorText));
+                return undefined;
+            }
+        }
+        this._moduleKindsToEmit.push({
+            outFolderPath,
+            moduleKind,
+            jsExtensionOverride,
+            isPrimary
+        });
+        return `${outFolderName}:${jsExtensionOverride || '.js'}`;
+    }
+    _getCreateBuilderProgram(ts) {
+        const { _configuration: { emitChangedFilesCallback } } = this;
+        const createMultiEmitBuilderProgram = (fileNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+            // Reset performance counters
+            ts.performance.disable();
+            ts.performance.enable();
+            this._typescriptTerminal.writeVerboseLine(`Reading program "${compilerOptions.configFilePath}"`);
+            const newProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(fileNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences);
+            this._logReadPerformance(ts);
+            const isolatedModules = !!this._configuration.useTranspilerWorker && !!compilerOptions.isolatedModules;
+            const mode = isolatedModules ? 'declaration' : 'both';
+            if (isolatedModules) {
+                // Kick the transpilation worker.
+                const filesToTranspile = getFilesToTranspileFromBuilderProgram(newProgram);
+                this._queueTranspileInWorker(this._tool, compilerOptions, filesToTranspile);
+            }
+            const { emit: originalEmit } = newProgram;
+            const emit = (outerTargetSourceFile, outerWriteFile, outerCancellationToken, outerEmitOnlyDtsFiles, outerCustomTransformers) => {
+                const innerProgram = newProgram.getProgram();
+                const innerCompilerOptions = innerProgram.getCompilerOptions();
+                const { changedFiles } = configureProgramForMultiEmit(innerProgram, ts, this._moduleKindsToEmit, mode);
+                const result = originalEmit.call(newProgram, outerTargetSourceFile, outerWriteFile, outerCancellationToken, outerEmitOnlyDtsFiles, outerCustomTransformers);
+                result.changedSourceFiles = changedFiles;
+                this._typescriptTerminal.writeVerboseLine(`Emitting program "${innerCompilerOptions.configFilePath}"`);
+                this._logEmitPerformance(ts);
+                // Reset performance counters
+                ts.performance.disable();
+                ts.performance.enable();
+                emitChangedFilesCallback(innerProgram, changedFiles);
+                return result;
+            };
+            newProgram.emit = emit;
+            return newProgram;
+        };
+        return createMultiEmitBuilderProgram;
+    }
+    _buildSolutionBuilderHost(tool) {
+        const reportSolutionBuilderStatus = tool.reportDiagnostic;
+        const reportEmitErrorSummary = (errorCount) => {
+            // Do nothing
+        };
+        const { ts, system } = tool;
+        const solutionBuilderHost = ts.createSolutionBuilderHost(system, this._getCreateBuilderProgram(ts), tool.reportDiagnostic, reportSolutionBuilderStatus, reportEmitErrorSummary);
+        solutionBuilderHost.afterProgramEmitAndDiagnostics = (program) => {
+            // Use the native metric since we aren't overwriting the writer
+            this._typescriptTerminal.writeVerboseLine(`I/O Write: ${ts.performance.getDuration('I/O Write')}ms (${ts.performance.getCount('beforeIOWrite')} files)`);
+        };
+        return solutionBuilderHost;
+    }
+    _buildIncrementalCompilerHost(tool, tsconfig) {
+        var _a;
+        const { ts, system } = tool;
+        let compilerHost;
+        if (tsconfig.options.incremental) {
+            compilerHost = ts.createIncrementalCompilerHost(tsconfig.options, system);
+        }
+        else {
+            compilerHost = ((_a = ts.createCompilerHostWorker) !== null && _a !== void 0 ? _a : ts.createCompilerHost)(tsconfig.options, undefined, system);
+        }
+        this._changeCompilerHostToUseCache(compilerHost, tool);
+        return compilerHost;
+    }
+    _buildWatchCompilerHost(tool, tsconfig) {
+        const { ts, system } = tool;
+        const reportWatchStatus = (diagnostic) => {
+            this._printDiagnosticMessage(ts, diagnostic);
+        };
+        const compilerHost = ts.createWatchCompilerHost(tsconfig.fileNames, tsconfig.options, system, this._getCreateBuilderProgram(ts), tool.reportDiagnostic, reportWatchStatus, tsconfig.projectReferences, tsconfig.watchOptions);
+        return compilerHost;
+    }
+    _changeCompilerHostToUseCache(compilerHost, tool) {
+        const { sourceFileCache } = tool;
+        const { getSourceFile: innerGetSourceFile } = compilerHost;
+        if (innerGetSourceFile.cache === sourceFileCache) {
+            return;
+        }
+        compilerHost.getCurrentDirectory = () => this._configuration.buildFolderPath;
+        // Enable source file persistence
+        const getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+            if (!shouldCreateNewSourceFile) {
+                const cachedSourceFile = sourceFileCache.get(fileName);
+                if (cachedSourceFile) {
+                    return cachedSourceFile;
+                }
+            }
+            const result = innerGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            if (result) {
+                sourceFileCache.set(fileName, result);
+            }
+            else {
+                sourceFileCache.delete(fileName);
+            }
+            return result;
+        };
+        getSourceFile.cache = sourceFileCache;
+        compilerHost.getSourceFile = getSourceFile;
+    }
+    _buildWatchSolutionBuilderHost(tool) {
+        const { reportDiagnostic, ts, system } = tool;
+        const host = ts.createSolutionBuilderWithWatchHost(system, this._getCreateBuilderProgram(ts), reportDiagnostic, reportDiagnostic, reportDiagnostic);
+        return host;
+    }
+    _parseModuleKind(ts, moduleKindName) {
+        switch (moduleKindName.toLowerCase()) {
+            case 'commonjs':
+                return ts.ModuleKind.CommonJS;
+            case 'amd':
+                return ts.ModuleKind.AMD;
+            case 'umd':
+                return ts.ModuleKind.UMD;
+            case 'system':
+                return ts.ModuleKind.System;
+            case 'es2015':
+                return ts.ModuleKind.ES2015;
+            case 'esnext':
+                return ts.ModuleKind.ESNext;
+            default:
+                throw new Error(`"${moduleKindName}" is not a valid module kind name.`);
+        }
+    }
+    _queueTranspileInWorker(tool, compilerOptions, filesToTranspile) {
+        const { typeScriptToolPath, pendingTranspilePromises, pendingTranspileSignals } = tool;
+        let maybeWorker = tool.worker;
+        if (!maybeWorker) {
+            const workerData = {
+                typeScriptToolPath
+            };
+            tool.worker = maybeWorker = new Worker(require.resolve('./TranspilerWorker.js'), {
+                workerData: workerData
+            });
+            maybeWorker.on('message', (response) => {
+                const { requestId: resolvingRequestId, type, result } = response;
+                const signal = pendingTranspileSignals.get(resolvingRequestId);
+                if (type === 'error') {
+                    const error = Object.assign(new Error(result.message), result);
+                    if (signal) {
+                        signal.reject(error);
+                    }
+                    else {
+                        this._typescriptTerminal.writeErrorLine(`Unexpected worker rejection for request with id ${resolvingRequestId}: ${error}`);
+                    }
+                }
+                else if (signal) {
+                    signal.resolve(result);
+                }
+                else {
+                    this._typescriptTerminal.writeErrorLine(`Unexpected worker resolution for request with id ${resolvingRequestId}`);
+                }
+                pendingTranspileSignals.delete(resolvingRequestId);
+                pendingTranspilePromises.delete(resolvingRequestId);
+            });
+            maybeWorker.once('exit', (exitCode) => {
+                if (pendingTranspileSignals.size) {
+                    const error = new Error(`Worker exited unexpectedly with code ${exitCode}.`);
+                    for (const { reject: rejectTranspile } of pendingTranspileSignals.values()) {
+                        rejectTranspile(error);
+                    }
+                    pendingTranspileSignals.clear();
+                }
+            });
+            maybeWorker.once('error', (err) => {
+                for (const { reject: rejectTranspile } of pendingTranspileSignals.values()) {
+                    rejectTranspile(err);
+                }
+                pendingTranspileSignals.clear();
+            });
+        }
+        // make linter happy
+        const worker = maybeWorker;
+        const requestId = ++this._nextRequestId;
+        const transpilePromise = new Promise((resolve, reject) => {
+            pendingTranspileSignals.set(requestId, { resolve, reject });
+            this._typescriptTerminal.writeLine(`Asynchronously transpiling ${compilerOptions.configFilePath}`);
+            const request = {
+                compilerOptions,
+                filesToTranspile,
+                moduleKindsToEmit: this._moduleKindsToEmit,
+                requestId
+            };
+            worker.postMessage(request);
+        });
+        pendingTranspilePromises.set(requestId, transpilePromise);
+    }
+    _cleanupWorker() {
+        const tool = this._tool;
+        if (!tool) {
+            return;
+        }
+        const { worker } = tool;
+        if (worker) {
+            worker.postMessage(false);
+            tool.worker = undefined;
+        }
+    }
+}
+function getFilesToTranspileFromBuilderProgram(builderProgram) {
+    var _a;
+    const program = builderProgram;
+    // getState was removed in Typescript 5.6, replaced with state
+    const changedFilesSet = ((_a = program.state) !== null && _a !== void 0 ? _a : program.getState()).changedFilesSet;
+    const filesToTranspile = new Map();
+    for (const fileName of changedFilesSet) {
+        const sourceFile = builderProgram.getSourceFile(fileName);
+        if (sourceFile && !sourceFile.isDeclarationFile) {
+            filesToTranspile.set(sourceFile.fileName, sourceFile.text);
+        }
+    }
+    return filesToTranspile;
+}
+function getFilesToTranspileFromProgram(program) {
+    const filesToTranspile = new Map();
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!sourceFile.isDeclarationFile) {
+            filesToTranspile.set(sourceFile.fileName, sourceFile.text);
+        }
+    }
+    return filesToTranspile;
+}
+//# sourceMappingURL=TypeScriptBuilder.js.map