@rushstack/heft-typescript-plugin 0.0.0

package/lib/TypeScriptBuilder.js

@@ -0,0 +1,790 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptBuilder = void 0;
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+const worker_threads_1 = require("worker_threads");
+const semver = __importStar(require("semver"));
+const node_core_library_1 = require("@rushstack/node-core-library");
+const configureProgramForMultiEmit_1 = require("./configureProgramForMultiEmit");
+const OLDEST_SUPPORTED_TS_MAJOR_VERSION = 2;
+const OLDEST_SUPPORTED_TS_MINOR_VERSION = 9;
+const NEWEST_SUPPORTED_TS_MAJOR_VERSION = 5;
+const NEWEST_SUPPORTED_TS_MINOR_VERSION = 0;
+class TypeScriptBuilder {
+    get _tsCacheFilePath() {
+        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');
+            configHash.update(JSON.stringify(this._configuration.additionalModuleKindsToEmit || {}));
+            const serializedConfigHash = configHash
+                .digest('base64')
+                .slice(0, 8)
+                .replace(/\+/g, '-')
+                .replace(/\//g, '_');
+            // 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 = node_core_library_1.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) {
+            // Determine the compiler version
+            const compilerPackageJsonFilename = path.join(this._configuration.typeScriptToolPath, 'package.json');
+            const packageJson = await node_core_library_1.JsonFile.loadAsync(compilerPackageJsonFilename);
+            this._typescriptVersion = packageJson.version;
+            const parsedVersion = semver.parse(this._typescriptVersion);
+            if (!parsedVersion) {
+                throw new Error(`Unable to parse version "${this._typescriptVersion}" for TypeScript compiler package in: ` +
+                    compilerPackageJsonFilename);
+            }
+            this._typescriptParsedVersion = parsedVersion;
+            // Detect what features this compiler supports.  Note that manually comparing major/minor numbers
+            // loosens the matching to accept prereleases such as "3.6.0-dev.20190530"
+            this._capabilities = {
+                incrementalProgram: false,
+                solutionBuilder: this._typescriptParsedVersion.major >= 3
+            };
+            if (this._typescriptParsedVersion.major > 3 ||
+                (this._typescriptParsedVersion.major === 3 && this._typescriptParsedVersion.minor >= 6)) {
+                this._capabilities.incrementalProgram = true;
+            }
+            this._useSolutionBuilder = !!this._configuration.buildProjectReferences;
+            if (this._useSolutionBuilder && !this._capabilities.solutionBuilder) {
+                throw new Error(`Building project references requires TypeScript@>=3.0, but the current version is ${this._typescriptVersion}`);
+            }
+            // Report a warning if the TypeScript version is too old/new.  The current oldest supported version is
+            // TypeScript 2.9. Prior to that the "ts.getConfigFileParsingDiagnostics()" API is missing; more fixups
+            // would be required to deal with that.  We won't do that work unless someone requests it.
+            if (this._typescriptParsedVersion.major < OLDEST_SUPPORTED_TS_MAJOR_VERSION ||
+                (this._typescriptParsedVersion.major === OLDEST_SUPPORTED_TS_MAJOR_VERSION &&
+                    this._typescriptParsedVersion.minor < OLDEST_SUPPORTED_TS_MINOR_VERSION)) {
+                // We don't use writeWarningLine() here because, if the person wants to take their chances with
+                // a seemingly unsupported compiler, their build should be allowed to succeed.
+                this._typescriptTerminal.writeLine(`The TypeScript compiler version ${this._typescriptVersion} is very old` +
+                    ` and has not been tested with Heft; it may not work correctly.`);
+            }
+            else if (this._typescriptParsedVersion.major > NEWEST_SUPPORTED_TS_MAJOR_VERSION ||
+                (this._typescriptParsedVersion.major === NEWEST_SUPPORTED_TS_MAJOR_VERSION &&
+                    this._typescriptParsedVersion.minor > NEWEST_SUPPORTED_TS_MINOR_VERSION)) {
+                this._typescriptTerminal.writeLine(`The TypeScript compiler version ${this._typescriptVersion} is newer` +
+                    ' than the latest version that was tested with Heft ' +
+                    `(${NEWEST_SUPPORTED_TS_MAJOR_VERSION}.${NEWEST_SUPPORTED_TS_MINOR_VERSION}); it may not work correctly.`);
+            }
+            const ts = require(this._configuration.typeScriptToolPath);
+            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 Object.assign(Object.assign({}, 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();
+            this._tool = {
+                ts,
+                measureSync: measureTsPerformance,
+                sourceFileCache: new Map(),
+                watchProgram: undefined,
+                solutionBuilder: undefined,
+                rawDiagnostics,
+                pendingOperations,
+                executing: false,
+                reportDiagnostic: (diagnostic) => {
+                    rawDiagnostics.push(diagnostic);
+                },
+                clearTimeout(timeout) {
+                    pendingOperations.delete(timeout);
+                },
+                setTimeout(fn, ms, ...args) {
+                    const timeout = () => {
+                        fn(...args);
+                    };
+                    pendingOperations.add(timeout);
+                    if (!this.executing && onChangeDetected) {
+                        onChangeDetected();
+                    }
+                    return timeout;
+                },
+                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 = this._loadTsconfig(ts);
+                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);
+    }
+    async _runBuildAsync(tool) {
+        const { ts, measureSync: measureTsPerformance, pendingTranspilePromises } = tool;
+        //#region CONFIGURE
+        const { duration: configureDurationMs, tsconfig, compilerHost } = measureTsPerformance('Configure', () => {
+            const _tsconfig = this._loadTsconfig(ts);
+            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 } = (0, configureProgramForMultiEmit_1.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 = this._loadTsconfig(ts);
+                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);
+    }
+    _logDiagnostics(ts, rawDiagnostics) {
+        const diagnostics = ts.sortAndDeduplicateDiagnostics(rawDiagnostics);
+        if (diagnostics.length > 0) {
+            this._typescriptTerminal.writeLine(`Encountered ${diagnostics.length} TypeScript issue${diagnostics.length > 1 ? 's' : ''}:`);
+            for (const diagnostic of diagnostics) {
+                const diagnosticCategory = this._getAdjustedDiagnosticCategory(diagnostic, ts);
+                this._printDiagnosticMessage(ts, diagnostic, diagnosticCategory);
+            }
+        }
+    }
+    _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 node_core_library_1.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 = node_core_library_1.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'}`;
+    }
+    _loadTsconfig(ts) {
+        const parsedConfigFile = ts.readConfigFile(this._configuration.tsconfigPath, ts.sys.readFile);
+        const currentFolder = path.dirname(this._configuration.tsconfigPath);
+        const tsconfig = ts.parseJsonConfigFileContent(parsedConfigFile.config, {
+            fileExists: ts.sys.fileExists,
+            readFile: ts.sys.readFile,
+            readDirectory: ts.sys.readDirectory,
+            useCaseSensitiveFileNames: true
+        }, currentFolder, 
+        /*existingOptions:*/ undefined, this._configuration.tsconfigPath);
+        if (tsconfig.options.incremental) {
+            tsconfig.options.tsBuildInfoFile = this._tsCacheFilePath;
+        }
+        return tsconfig;
+    }
+    _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 } = (0, configureProgramForMultiEmit_1.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 } = tool;
+        const solutionBuilderHost = ts.createSolutionBuilderHost(ts.sys, 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) {
+        const { ts } = tool;
+        let compilerHost;
+        if (tsconfig.options.incremental) {
+            compilerHost = ts.createIncrementalCompilerHost(tsconfig.options, ts.sys);
+        }
+        else {
+            compilerHost = ts.createCompilerHost(tsconfig.options);
+        }
+        this._changeCompilerHostToUseCache(compilerHost, tool);
+        return compilerHost;
+    }
+    _buildWatchCompilerHost(tool, tsconfig) {
+        const { ts } = tool;
+        const reportWatchStatus = (diagnostic) => {
+            this._printDiagnosticMessage(ts, diagnostic);
+        };
+        const compilerHost = ts.createWatchCompilerHost(tsconfig.fileNames, tsconfig.options, ts.sys, this._getCreateBuilderProgram(ts), tool.reportDiagnostic, reportWatchStatus, tsconfig.projectReferences, tsconfig.watchOptions);
+        compilerHost.clearTimeout = tool.clearTimeout;
+        compilerHost.setTimeout = tool.setTimeout;
+        return compilerHost;
+    }
+    _changeCompilerHostToUseCache(compilerHost, tool) {
+        const { sourceFileCache } = tool;
+        const { getSourceFile: innerGetSourceFile } = compilerHost;
+        if (innerGetSourceFile.cache === sourceFileCache) {
+            return;
+        }
+        // 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 } = tool;
+        const host = ts.createSolutionBuilderWithWatchHost(ts.sys, this._getCreateBuilderProgram(ts), reportDiagnostic, reportDiagnostic, reportDiagnostic);
+        host.clearTimeout = tool.clearTimeout;
+        host.setTimeout = tool.setTimeout;
+        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 { pendingTranspilePromises, pendingTranspileSignals } = tool;
+        let maybeWorker = tool.worker;
+        if (!maybeWorker) {
+            const workerData = {
+                typeScriptToolPath: this._configuration.typeScriptToolPath
+            };
+            tool.worker = maybeWorker = new worker_threads_1.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;
+        }
+    }
+}
+exports.TypeScriptBuilder = TypeScriptBuilder;
+function getFilesToTranspileFromBuilderProgram(builderProgram) {
+    const changedFilesSet = builderProgram.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