@rushstack/heft-typescript-plugin 0.1.0-rc.4 → 0.2.0-rc.6

package/lib/TypeScriptBuilder.js

@@ -28,25 +28,15 @@ 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 EmitFilesPatch_1 = require("./EmitFilesPatch");
-const TypeScriptCachedFileSystem_1 = require("./fileSystem/TypeScriptCachedFileSystem");
-const EMPTY_JSON = {};
+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 = 4;
-const NEWEST_SUPPORTED_TS_MINOR_VERSION = 8;
+const NEWEST_SUPPORTED_TS_MAJOR_VERSION = 5;
+const NEWEST_SUPPORTED_TS_MINOR_VERSION = 0;
 class TypeScriptBuilder {
-    constructor(configuration) {
-        this.__tsCacheFilePath = undefined;
-        this._tsReadJsonCache = new Map();
-        this._cachedFileSystem = new TypeScriptCachedFileSystem_1.TypeScriptCachedFileSystem();
-        this._tool = undefined;
-        this._configuration = configuration;
-        this._typescriptLogger = configuration.scopedLogger;
-        this._typescriptTerminal = configuration.scopedLogger.terminal;
-    }
     get _tsCacheFilePath() {
         if (!this.__tsCacheFilePath) {
             // TypeScript internally handles if the tsconfig options have changed from when the tsbuildinfo file was created.
@@ -66,7 +56,16 @@ class TypeScriptBuilder {
         }
         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');
@@ -111,6 +110,18 @@ class TypeScriptBuilder {
                     `(${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);
@@ -120,23 +131,12 @@ class TypeScriptBuilder {
                 ts.performance.measure(measurementName, beforeName, afterName);
                 return Object.assign(Object.assign({}, result), { duration: ts.performance.getDuration(measurementName), count: ts.performance.getCount(beforeName) });
             };
-            const measureTsPerformanceAsync = async (measurementName, fn) => {
-                const beforeName = `before${measurementName}`;
-                ts.performance.mark(beforeName);
-                const resultPromise = fn();
-                const result = await resultPromise;
-                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) });
-            };
             this._typescriptTerminal.writeLine(`Using TypeScript version ${ts.version}`);
             const rawDiagnostics = [];
             const pendingOperations = new Set();
             this._tool = {
                 ts,
                 measureSync: measureTsPerformance,
-                measureAsync: measureTsPerformanceAsync,
                 sourceFileCache: new Map(),
                 watchProgram: undefined,
                 solutionBuilder: undefined,
@@ -158,7 +158,10 @@ class TypeScriptBuilder {
                         onChangeDetected();
                     }
                     return timeout;
-                }
+                },
+                worker: undefined,
+                pendingTranspilePromises: new Map(),
+                pendingTranspileSignals: new Map()
             };
         }
         const { performance } = this._tool.ts;
@@ -166,17 +169,17 @@ class TypeScriptBuilder {
         performance.disable();
         performance.enable();
         if (onChangeDetected !== undefined) {
-            this._runWatch(this._tool);
+            await this._runWatchAsync(this._tool);
         }
         else if (this._useSolutionBuilder) {
-            this._runSolutionBuild(this._tool);
+            await this._runSolutionBuildAsync(this._tool);
         }
         else {
             await this._runBuildAsync(this._tool);
         }
     }
-    _runWatch(tool) {
-        const { ts, measureSync: measureTsPerformance, pendingOperations, rawDiagnostics } = 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', () => {
@@ -206,15 +209,23 @@ class TypeScriptBuilder {
                 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, measureAsync: measureTsPerformanceAsync } = tool;
+        const { ts, measureSync: measureTsPerformance, pendingTranspilePromises } = tool;
         //#region CONFIGURE
         const { duration: configureDurationMs, tsconfig, compilerHost } = measureTsPerformance('Configure', () => {
-            this._overrideTypeScriptReadJson(ts);
             const _tsconfig = this._loadTsconfig(ts);
             this._validateTsconfig(ts, _tsconfig);
             const _compilerHost = this._buildIncrementalCompilerHost(tool, _tsconfig);
@@ -228,13 +239,20 @@ class TypeScriptBuilder {
         //#region PROGRAM
         // There will be only one program here; emit will get a bit abused if we produce multiple outputs
         let builderProgram = undefined;
-        let tsProgram;
+        let innerProgram;
+        const isolatedModules = !!this._configuration.useTranspilerWorker && !!tsconfig.options.isolatedModules;
+        const mode = isolatedModules ? 'declaration' : 'both';
+        let filesToTranspile;
         if (tsconfig.options.incremental) {
-            builderProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(tsconfig.fileNames, tsconfig.options, compilerHost, ts.readBuilderProgram(tsconfig.options, compilerHost), ts.getConfigFileParsingDiagnostics(tsconfig), tsconfig.projectReferences);
-            tsProgram = builderProgram.getProgram();
+            // 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 {
-            tsProgram = ts.createProgram({
+            innerProgram = ts.createProgram({
                 rootNames: tsconfig.fileNames,
                 options: tsconfig.options,
                 projectReferences: tsconfig.projectReferences,
@@ -242,11 +260,16 @@ class TypeScriptBuilder {
                 oldProgram: undefined,
                 configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(tsconfig)
             });
+            filesToTranspile = getFilesToTranspileFromProgram(innerProgram);
         }
         // Prefer the builder program, since it is what gives us incremental builds
-        const genericProgram = builderProgram || tsProgram;
+        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 = [
@@ -261,29 +284,34 @@ class TypeScriptBuilder {
         this._typescriptTerminal.writeVerboseLine(`Analyze: ${diagnosticsDurationMs}ms`);
         //#endregion
         //#region EMIT
-        const emitResult = this._emit(ts, genericProgram);
+        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
-        //#region WRITE
-        // Using async file system I/O for theoretically better peak performance
-        // Also allows to run concurrently with linting
-        const writePromise = measureTsPerformanceAsync('Write', () => node_core_library_1.Async.forEachAsync(emitResult.filesToWrite, async ({ filePath, data }) => this._cachedFileSystem.writeFile(filePath, data, { ensureFolderExists: true }), { concurrency: this._configuration.maxWriteParallelism }));
-        //#endregion
-        const { duration: writeDuration } = await writePromise;
-        this._typescriptTerminal.writeVerboseLine(`I/O Write: ${writeDuration}ms (${emitResult.filesToWrite.length} files)`);
+        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();
-        this._configuration.emitChangedFilesCallback(tsProgram, emitResult.changedSourceFiles);
     }
-    _runSolutionBuild(tool) {
+    async _runSolutionBuildAsync(tool) {
         this._typescriptTerminal.writeVerboseLine(`Using solution mode`);
-        const { ts, measureSync, rawDiagnostics } = tool;
+        const { ts, measureSync, rawDiagnostics, pendingTranspilePromises } = tool;
         rawDiagnostics.length = 0;
         if (!tool.solutionBuilder) {
             //#region CONFIGURE
@@ -308,7 +336,16 @@ class TypeScriptBuilder {
         //#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) {
@@ -329,6 +366,7 @@ class TypeScriptBuilder {
         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)`);
@@ -382,31 +420,11 @@ class TypeScriptBuilder {
             return ts.DiagnosticCategory.Warning;
         }
         // These pedantic checks also should not be treated as hard errors
-        switch (diagnostic.code) {
-            case ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor
-                .code:
-            case ts.Diagnostics
-                .Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1.code:
-                return ts.DiagnosticCategory.Warning;
+        if (this._suppressedDiagnosticCodes.has(diagnostic.code)) {
+            return ts.DiagnosticCategory.Warning;
         }
         return diagnostic.category;
     }
-    _emit(ts, genericProgram) {
-        const filesToWrite = [];
-        const changedFiles = new Set();
-        EmitFilesPatch_1.EmitFilesPatch.install(ts, genericProgram.getCompilerOptions(), this._moduleKindsToEmit, changedFiles);
-        const writeFileCallback = (filePath, data) => {
-            filesToWrite.push({ filePath, data });
-        };
-        try {
-            const result = genericProgram.emit(undefined, // Target source file
-            writeFileCallback);
-            return Object.assign(Object.assign({}, result), { changedSourceFiles: changedFiles, filesToWrite });
-        }
-        finally {
-            EmitFilesPatch_1.EmitFilesPatch.uninstall(ts);
-        }
-    }
     _validateTsconfig(ts, tsconfig) {
         if ((tsconfig.options.module && !tsconfig.options.outDir) ||
             (!tsconfig.options.module && tsconfig.options.outDir)) {
@@ -537,13 +555,12 @@ class TypeScriptBuilder {
         return `${outFolderName}:${jsExtensionOverride || '.js'}`;
     }
     _loadTsconfig(ts) {
-        const parsedConfigFile = ts.readConfigFile(this._configuration.tsconfigPath, this._cachedFileSystem.readFile);
+        const parsedConfigFile = ts.readConfigFile(this._configuration.tsconfigPath, ts.sys.readFile);
         const currentFolder = path.dirname(this._configuration.tsconfigPath);
         const tsconfig = ts.parseJsonConfigFileContent(parsedConfigFile.config, {
-            fileExists: this._cachedFileSystem.exists,
-            readFile: this._cachedFileSystem.readFile,
-            readDirectory: (folderPath, extensions, excludes, includes, depth) => ts.matchFiles(folderPath, extensions, excludes, includes, 
-            /* useCaseSensitiveFileNames */ true, currentFolder, depth, this._cachedFileSystem.readFolderFilesAndDirectories.bind(this._cachedFileSystem), this._cachedFileSystem.getRealPath.bind(this._cachedFileSystem), this._cachedFileSystem.directoryExists.bind(this._cachedFileSystem)),
+            fileExists: ts.sys.fileExists,
+            readFile: ts.sys.readFile,
+            readDirectory: ts.sys.readDirectory,
             useCaseSensitiveFileNames: true
         }, currentFolder, 
         /*existingOptions:*/ undefined, this._configuration.tsconfigPath);
@@ -552,41 +569,41 @@ class TypeScriptBuilder {
         }
         return tsconfig;
     }
-    _getCreateBuilderProgram(tool) {
-        const { _moduleKindsToEmit: moduleKindsToEmit, _configuration: { emitChangedFilesCallback } } = this;
-        const { ts } = tool;
-        const createMultiEmitProgram = (fileNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+    _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 { emit: originalEmit } = newProgram;
-            if (!compilerOptions) {
-                throw new Error(`Expected compilerOptions!`);
+            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 = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
-                const changedFiles = new Set();
-                try {
-                    EmitFilesPatch_1.EmitFilesPatch.install(ts, compilerOptions, moduleKindsToEmit, changedFiles);
-                    const result = originalEmit.call(newProgram, targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
-                    this._typescriptTerminal.writeVerboseLine(`Emitting program "${compilerOptions.configFilePath}"`);
-                    this._logEmitPerformance(ts);
-                    // Reset performance counters
-                    ts.performance.disable();
-                    ts.performance.enable();
-                    emitChangedFilesCallback(newProgram.getProgram(), changedFiles);
-                    return result;
-                }
-                finally {
-                    EmitFilesPatch_1.EmitFilesPatch.uninstall(ts);
-                }
+            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 createMultiEmitProgram;
+        return createMultiEmitBuilderProgram;
     }
     _buildSolutionBuilderHost(tool) {
         const reportSolutionBuilderStatus = tool.reportDiagnostic;
@@ -594,7 +611,7 @@ class TypeScriptBuilder {
             // Do nothing
         };
         const { ts } = tool;
-        const solutionBuilderHost = ts.createSolutionBuilderHost(ts.sys, this._getCreateBuilderProgram(tool), tool.reportDiagnostic, reportSolutionBuilderStatus, reportEmitErrorSummary);
+        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)`);
@@ -618,7 +635,7 @@ class TypeScriptBuilder {
         const reportWatchStatus = (diagnostic) => {
             this._printDiagnosticMessage(ts, diagnostic);
         };
-        const compilerHost = ts.createWatchCompilerHost(tsconfig.fileNames, tsconfig.options, ts.sys, this._getCreateBuilderProgram(tool), tool.reportDiagnostic, reportWatchStatus, tsconfig.projectReferences);
+        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;
@@ -651,42 +668,11 @@ class TypeScriptBuilder {
     }
     _buildWatchSolutionBuilderHost(tool) {
         const { reportDiagnostic, ts } = tool;
-        const host = ts.createSolutionBuilderWithWatchHost(ts.sys, this._getCreateBuilderProgram(tool), reportDiagnostic, reportDiagnostic, reportDiagnostic);
+        const host = ts.createSolutionBuilderWithWatchHost(ts.sys, this._getCreateBuilderProgram(ts), reportDiagnostic, reportDiagnostic, reportDiagnostic);
         host.clearTimeout = tool.clearTimeout;
         host.setTimeout = tool.setTimeout;
         return host;
     }
-    _overrideTypeScriptReadJson(ts) {
-        const cachedReadJson = (filePath) => {
-            let jsonData = this._tsReadJsonCache.get(filePath);
-            if (jsonData) {
-                return jsonData;
-            }
-            else {
-                try {
-                    const fileContents = this._cachedFileSystem.readFile(filePath);
-                    if (!fileContents) {
-                        jsonData = EMPTY_JSON;
-                    }
-                    else {
-                        const parsedFile = ts.parseConfigFileTextToJson(filePath, fileContents);
-                        if (parsedFile.error) {
-                            jsonData = EMPTY_JSON;
-                        }
-                        else {
-                            jsonData = parsedFile.config;
-                        }
-                    }
-                }
-                catch (error) {
-                    jsonData = EMPTY_JSON;
-                }
-                this._tsReadJsonCache.set(filePath, jsonData);
-                return jsonData;
-            }
-        };
-        ts.readJson = cachedReadJson;
-    }
     _parseModuleKind(ts, moduleKindName) {
         switch (moduleKindName.toLowerCase()) {
             case 'commonjs':
@@ -705,6 +691,100 @@ class TypeScriptBuilder {
                 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