@nx/js 16.4.0-beta.10 → 16.4.0-beta.13

package/babel.js

@@ -5,6 +5,8 @@ module.exports = function (api, options = {}) {
     var _a, _b, _c;
     api.assertVersion(7);
     const isModern = api.caller((caller) => caller === null || caller === void 0 ? void 0 : caller.isModern);
+    // use by @nx/cypress react component testing to prevent core js build issues
+    const isTest = api.caller((caller) => caller === null || caller === void 0 ? void 0 : caller.isTest);
     // This is set by `@nx/rollup:rollup` executor
     const isNxPackage = api.caller((caller) => caller === null || caller === void 0 ? void 0 : caller.isNxPackage);
     const emitDecoratorMetadata = api.caller((caller) => { var _a; return (_a = caller === null || caller === void 0 ? void 0 : caller.emitDecoratorMetadata) !== null && _a !== void 0 ? _a : true; });
@@ -19,7 +21,7 @@ module.exports = function (api, options = {}) {
                 // For Jest tests, NODE_ENV is set as 'test' and we only want to set target as Node.
                 // All other options will fail in Jest since Node does not support some ES features
                 // such as import syntax.
-                process.env.NODE_ENV === 'test'
+                isTest || process.env.NODE_ENV === 'test'
                     ? { targets: { node: 'current' }, loose: true }
                     : {
                         // Allow importing core-js in entrypoint and use browserslist to select polyfills.

package/migrations.json

@@ -80,6 +80,18 @@
           "version": "~5.0.2"
         }
       }
+    },
+    "16.4.0": {
+      "version": "16.4.0-beta.11",
+      "x-prompt": "Do you want to update to TypeScript v5.1?",
+      "requires": {
+        "typescript": ">=5.0.0 <5.1.0"
+      },
+      "packages": {
+        "typescript": {
+          "version": "~5.1.3"
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.4.0-beta.10",
+  "version": "16.4.0-beta.13",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,9 +39,9 @@
     "@babel/preset-env": "^7.15.0",
     "@babel/preset-typescript": "^7.15.0",
     "@babel/runtime": "^7.14.8",
-    "@nrwl/js": "16.4.0-beta.10",
-    "@nx/devkit": "16.4.0-beta.10",
-    "@nx/workspace": "16.4.0-beta.10",
+    "@nrwl/js": "16.4.0-beta.13",
+    "@nx/devkit": "16.4.0-beta.13",
+    "@nx/workspace": "16.4.0-beta.13",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
@@ -69,5 +69,5 @@
     "access": "public"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "d2bde0605c692a023bc9c28686f3a3037bbd56d3"
+  "gitHead": "d81afedfcc8d07db8cdb9b0e9286de0321ee184e"
 }

package/src/executors/node/node.impl.d.ts

@@ -2,5 +2,6 @@ import { ExecutorContext } from '@nx/devkit';
 import { NodeExecutorOptions } from './schema';
 export declare function nodeExecutor(options: NodeExecutorOptions, context: ExecutorContext): AsyncGenerator<{
     success: boolean;
+    options?: Record<string, any>;
 }, void, undefined>;
 export default nodeExecutor;

package/src/executors/node/node.impl.js

@@ -7,8 +7,8 @@ const child_process_1 = require("child_process");
 const devkit_1 = require("@nx/devkit");
 const client_1 = require("nx/src/daemon/client/client");
 const crypto_1 = require("crypto");
-const path_1 = require("path");
 const path = require("path");
+const path_1 = require("path");
 const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 const buildable_libs_utils_1 = require("../../utils/buildable-libs-utils");
 const kill_tree_1 = require("./lib/kill-tree");
@@ -70,9 +70,7 @@ function nodeExecutor(options, context) {
                         let buildFailed = false;
                         // Run the build
                         task.promise = new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                            task.childProcess = (0, child_process_1.exec)(`npx nx run ${context.projectName}:${buildTarget.target}${buildTarget.configuration
-                                ? `:${buildTarget.configuration}`
-                                : ''}`, {
+                            task.childProcess = (0, child_process_1.exec)(`npx nx run ${context.projectName}:${buildTarget.target}${buildTarget.configuration ? `:${buildTarget.configuration}` : ''}`, {
                                 cwd: context.root,
                             }, (error, stdout, stderr) => {
                                 if (
@@ -125,7 +123,7 @@ function nodeExecutor(options, context) {
                                     done();
                                 resolve();
                             });
-                            next({ success: true });
+                            next({ success: true, options: buildOptions });
                         });
                     }),
                     stop: (signal = 'SIGTERM') => tslib_1.__awaiter(this, void 0, void 0, function* () {

package/src/executors/tsc/lib/batch/build-task-info-per-tsconfig-map.d.ts

@@ -1,4 +1,5 @@
 import type { ExecutorContext } from '@nx/devkit';
 import type { NormalizedExecutorOptions } from '../../../../utils/schema';
+import type { TypescriptInMemoryTsConfig } from '../typescript-compilation';
 import type { TaskInfo } from './types';
-export declare function buildTaskInfoPerTsConfigMap(tsConfigTaskInfoMap: Record<string, TaskInfo>, tasksOptions: Record<string, NormalizedExecutorOptions>, context: ExecutorContext, tasks: string[], shouldWatch: boolean): void;
+export declare function createTaskInfoPerTsConfigMap(tasksOptions: Record<string, NormalizedExecutorOptions>, context: ExecutorContext, tasks: string[], taskInMemoryTsConfigMap: Record<string, TypescriptInMemoryTsConfig>): Record<string, TaskInfo>;

package/src/executors/tsc/lib/batch/build-task-info-per-tsconfig-map.js

@@ -1,36 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildTaskInfoPerTsConfigMap = void 0;
+exports.createTaskInfoPerTsConfigMap = void 0;
 const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
 const copy_assets_handler_1 = require("../../../../utils/assets/copy-assets-handler");
 const buildable_libs_utils_1 = require("../../../../utils/buildable-libs-utils");
-const generate_temp_tsconfig_1 = require("./generate-temp-tsconfig");
-const get_task_options_1 = require("./get-task-options");
+const get_task_options_1 = require("../get-task-options");
 const taskTsConfigCache = new Set();
-function buildTaskInfoPerTsConfigMap(tsConfigTaskInfoMap, tasksOptions, context, tasks, shouldWatch) {
+function createTaskInfoPerTsConfigMap(tasksOptions, context, tasks, taskInMemoryTsConfigMap) {
+    const tsConfigTaskInfoMap = {};
+    processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOptions, context, tasks, taskInMemoryTsConfigMap);
+    return tsConfigTaskInfoMap;
+}
+exports.createTaskInfoPerTsConfigMap = createTaskInfoPerTsConfigMap;
+function processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOptions, context, tasks, taskInMemoryTsConfigMap) {
+    var _a;
     for (const taskName of tasks) {
         if (taskTsConfigCache.has(taskName)) {
             continue;
         }
-        let taskOptions = tasksOptions[taskName];
-        // task is in the batch (it's meant to be processed), create TaskInfo
+        const tsConfig = taskInMemoryTsConfigMap[taskName];
+        if (!tsConfig) {
+            continue;
+        }
+        let taskOptions = (_a = tasksOptions[taskName]) !== null && _a !== void 0 ? _a : (0, get_task_options_1.getTaskWithTscExecutorOptions)(taskName, context);
         if (taskOptions) {
-            const taskInfo = createTaskInfo(taskName, taskOptions, context);
-            const tsConfigPath = (0, generate_temp_tsconfig_1.generateTempTsConfig)(tasksOptions, taskName, taskOptions, context);
+            const taskInfo = createTaskInfo(taskName, taskOptions, context, tsConfig);
+            const tsConfigPath = (0, path_1.join)(context.root, (0, path_1.relative)(context.root, taskOptions.tsConfig));
             tsConfigTaskInfoMap[tsConfigPath] = taskInfo;
             taskTsConfigCache.add(taskName);
         }
-        else {
-            // if it's not included in the provided map, it could be a cached task and
-            // we need to pull the options from the relevant project graph node
-            taskOptions = (0, get_task_options_1.getTaskOptions)(taskName, context);
-            (0, generate_temp_tsconfig_1.generateTempTsConfig)(tasksOptions, taskName, taskOptions, context);
-        }
-        buildTaskInfoPerTsConfigMap(tsConfigTaskInfoMap, tasksOptions, context, context.taskGraph.dependencies[taskName], shouldWatch);
+        processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOptions, context, context.taskGraph.dependencies[taskName], taskInMemoryTsConfigMap);
     }
 }
-exports.buildTaskInfoPerTsConfigMap = buildTaskInfoPerTsConfigMap;
-function createTaskInfo(taskName, taskOptions, context) {
+function createTaskInfo(taskName, taskOptions, context, tsConfig) {
     const target = (0, devkit_1.parseTargetString)(taskName, context.projectGraph);
     const taskContext = Object.assign(Object.assign({}, context), { 
         // batch executors don't get these in the context, we provide them
@@ -50,5 +53,7 @@ function createTaskInfo(taskName, taskOptions, context) {
         assetsHandler,
         buildableProjectNodeDependencies,
         projectGraphNode,
+        tsConfig,
+        terminalOutput: '',
     };
 }

package/src/executors/tsc/lib/batch/index.d.ts

@@ -1,8 +1,4 @@
 export * from './build-task-info-per-tsconfig-map';
-export * from './generate-temp-tsconfig';
-export * from './get-task-options';
 export * from './normalize-tasks-options';
 export * from './types';
-export * from './typescript-compilation';
-export * from './typescript-diagnostic-reporters';
 export * from './watch';

package/src/executors/tsc/lib/batch/index.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./build-task-info-per-tsconfig-map"), exports);
-tslib_1.__exportStar(require("./generate-temp-tsconfig"), exports);
-tslib_1.__exportStar(require("./get-task-options"), exports);
 tslib_1.__exportStar(require("./normalize-tasks-options"), exports);
 tslib_1.__exportStar(require("./types"), exports);
-tslib_1.__exportStar(require("./typescript-compilation"), exports);
-tslib_1.__exportStar(require("./typescript-diagnostic-reporters"), exports);
 tslib_1.__exportStar(require("./watch"), exports);

package/src/executors/tsc/lib/batch/types.d.ts

@@ -2,6 +2,7 @@ import type { ExecutorContext, ProjectGraphProjectNode } from '@nx/devkit';
 import type { CopyAssetsHandler } from '../../../../utils/assets/copy-assets-handler';
 import type { DependentBuildableProjectNode } from '../../../../utils/buildable-libs-utils';
 import type { NormalizedExecutorOptions } from '../../../../utils/schema';
+import type { TypescriptInMemoryTsConfig } from '../typescript-compilation';
 export interface TaskInfo {
     task: string;
     options: NormalizedExecutorOptions;
@@ -9,4 +10,8 @@ export interface TaskInfo {
     assetsHandler: CopyAssetsHandler;
     buildableProjectNodeDependencies: DependentBuildableProjectNode[];
     projectGraphNode: ProjectGraphProjectNode;
+    tsConfig: TypescriptInMemoryTsConfig;
+    startTime?: number;
+    endTime?: number;
+    terminalOutput: string;
 }

package/src/executors/tsc/lib/get-task-options.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { NormalizedExecutorOptions } from '../../../utils/schema';
+export declare function getTaskOptions(taskName: string, context: ExecutorContext): NormalizedExecutorOptions | {
+    tsConfig: string | null;
+    rootDir: string;
+    outputPath: string;
+};
+export declare function getTaskWithTscExecutorOptions(taskName: string, context: ExecutorContext): NormalizedExecutorOptions | null;

package/src/executors/tsc/lib/get-task-options.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskWithTscExecutorOptions = exports.getTaskOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const normalize_options_1 = require("./normalize-options");
+function getTaskOptions(taskName, context) {
+    const result = getTaskWithTscExecutorOptions(taskName, context);
+    if (result) {
+        return result;
+    }
+    const { taskOptions, root, projectNode, target } = parseTaskInfo(taskName, context);
+    const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({ overrides: context.taskGraph.tasks[taskName].overrides, target }, projectNode);
+    const outputPath = outputs.length
+        ? (0, path_1.join)(context.root, outputs[0])
+        : (0, path_1.join)(context.root, 'dist', root);
+    const rootDir = (0, path_1.join)(context.root, root);
+    const tsConfig = taskOptions.tsConfig
+        ? (0, path_1.join)(context.root, taskOptions.tsConfig)
+        : null;
+    return { tsConfig, rootDir, outputPath };
+}
+exports.getTaskOptions = getTaskOptions;
+const tasksOptionsCache = new Map();
+function getTaskWithTscExecutorOptions(taskName, context) {
+    if (tasksOptionsCache.has(taskName)) {
+        return tasksOptionsCache.get(taskName);
+    }
+    try {
+        const { taskOptions, sourceRoot, root } = parseTaskInfo(taskName, context);
+        const normalizedTaskOptions = (0, normalize_options_1.normalizeOptions)(taskOptions, context.root, sourceRoot, root);
+        tasksOptionsCache.set(taskName, normalizedTaskOptions);
+        return normalizedTaskOptions;
+    }
+    catch (_a) {
+        tasksOptionsCache.set(taskName, null);
+        return null;
+    }
+}
+exports.getTaskWithTscExecutorOptions = getTaskWithTscExecutorOptions;
+function parseTaskInfo(taskName, context) {
+    var _a, _b;
+    const target = context.taskGraph.tasks[taskName].target;
+    const projectNode = context.projectGraph.nodes[target.project];
+    const targetConfig = (_a = projectNode.data.targets) === null || _a === void 0 ? void 0 : _a[target.target];
+    const { sourceRoot, root } = projectNode.data;
+    const taskOptions = Object.assign(Object.assign({}, targetConfig.options), (target.configuration
+        ? (_b = targetConfig.configurations) === null || _b === void 0 ? void 0 : _b[target.configuration]
+        : {}));
+    return { taskOptions, root, sourceRoot, projectNode, target };
+}

package/src/executors/tsc/lib/get-tsconfig.d.ts

@@ -0,0 +1,4 @@
+import { ExecutorContext } from '@nx/devkit';
+import type { NormalizedExecutorOptions } from '../../../utils/schema';
+import type { TypescriptInMemoryTsConfig } from './typescript-compilation';
+export declare function getProcessedTaskTsConfigs(tasks: string[], tasksOptions: Record<string, NormalizedExecutorOptions>, context: ExecutorContext): Record<string, TypescriptInMemoryTsConfig>;

package/src/executors/tsc/lib/get-tsconfig.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessedTaskTsConfigs = void 0;
+const devkit_1 = require("@nx/devkit");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const path_1 = require("path");
+const buildable_libs_utils_1 = require("../../../utils/buildable-libs-utils");
+const get_task_options_1 = require("./get-task-options");
+function getProcessedTaskTsConfigs(tasks, tasksOptions, context) {
+    const taskInMemoryTsConfigMap = {};
+    for (const task of tasks) {
+        generateTaskTsConfigOrGetDependentBuildableProjectNode(task, tasksOptions, context, taskInMemoryTsConfigMap);
+    }
+    return taskInMemoryTsConfigMap;
+}
+exports.getProcessedTaskTsConfigs = getProcessedTaskTsConfigs;
+const taskTsConfigGenerationCache = new Map();
+function generateTaskTsConfigOrGetDependentBuildableProjectNode(task, tasksOptions, context, taskInMemoryTsConfigMap) {
+    var _a, _b, _c;
+    if (taskTsConfigGenerationCache.has(task)) {
+        return taskTsConfigGenerationCache.get(task);
+    }
+    let tsConfig = (_b = (_a = tasksOptions[task]) === null || _a === void 0 ? void 0 : _a.tsConfig) !== null && _b !== void 0 ? _b : (0, get_task_options_1.getTaskOptions)(task, context).tsConfig;
+    let taskWithTsConfig = task;
+    if (!tsConfig) {
+        // check if other tasks in the task graph from the same project has a tsConfig
+        const otherTasksInProject = getDependencyTasksInSameProject(task, context);
+        const taskTsConfig = findTaskWithTsConfig(otherTasksInProject, context);
+        if (taskTsConfig) {
+            if (taskTsConfigGenerationCache.has(taskTsConfig.tsConfig)) {
+                return taskTsConfigGenerationCache.get(taskTsConfig.tsConfig);
+            }
+            tsConfig = taskTsConfig.tsConfig;
+            taskWithTsConfig = taskTsConfig.task;
+        }
+    }
+    if (tsConfig) {
+        const { projectReferences, dependentBuildableProjectNodes } = collectDependenciesFromTask(task, tasksOptions, context, taskInMemoryTsConfigMap);
+        taskInMemoryTsConfigMap[taskWithTsConfig] = getInMemoryTsConfig(tsConfig, (_c = tasksOptions[taskWithTsConfig]) !== null && _c !== void 0 ? _c : (0, get_task_options_1.getTaskOptions)(taskWithTsConfig, context), projectReferences, dependentBuildableProjectNodes);
+        const result = { tsConfig };
+        taskTsConfigGenerationCache.set(task, result);
+        return result;
+    }
+    // there's no tsConfig, return a buildable project node so the path mapping
+    // is remapped to the output
+    const result = taskToDependentBuildableProjectNode(task, context);
+    taskTsConfigGenerationCache.set(task, result);
+    return result;
+}
+const projectDependenciesCache = new Map();
+function collectDependenciesFromTask(task, tasksOptions, context, taskInMemoryTsConfigMap) {
+    var _a;
+    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    if (projectDependenciesCache.has(taskProject)) {
+        return projectDependenciesCache.get(taskProject);
+    }
+    const dependentBuildableProjectNodes = [];
+    const projectReferences = new Set();
+    const allProjectTasks = [
+        task,
+        ...getDependencyTasksInSameProject(task, context),
+    ];
+    for (const projectTask of allProjectTasks) {
+        for (const depTask of (_a = context.taskGraph.dependencies[projectTask]) !== null && _a !== void 0 ? _a : []) {
+            if (task === depTask) {
+                continue;
+            }
+            const { project: depTaskProject } = (0, devkit_1.parseTargetString)(depTask, context.projectGraph);
+            if (depTaskProject === taskProject) {
+                // recursively collect dependencies for tasks in the same project
+                const result = collectDependenciesFromTask(depTask, tasksOptions, context, taskInMemoryTsConfigMap);
+                result.projectReferences.forEach((pr) => {
+                    projectReferences.add(pr);
+                });
+                result.dependentBuildableProjectNodes.forEach((node) => {
+                    dependentBuildableProjectNodes.push(node);
+                });
+            }
+            else {
+                // task is from a different project, get its project reference or buildable node
+                const result = generateTaskTsConfigOrGetDependentBuildableProjectNode(depTask, tasksOptions, context, taskInMemoryTsConfigMap);
+                if ('tsConfig' in result) {
+                    projectReferences.add(result.tsConfig);
+                }
+                else {
+                    dependentBuildableProjectNodes.push(result);
+                }
+            }
+        }
+    }
+    projectDependenciesCache.set(taskProject, {
+        projectReferences: Array.from(projectReferences),
+        dependentBuildableProjectNodes,
+    });
+    return projectDependenciesCache.get(taskProject);
+}
+function taskToDependentBuildableProjectNode(task, context) {
+    const target = context.taskGraph.tasks[task].target;
+    const projectGraphNode = context.projectGraph.nodes[target.project];
+    const libPackageJsonPath = (0, path_1.join)(context.root, projectGraphNode.data.root, 'package.json');
+    return {
+        name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+            ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name
+            : target.project,
+        outputs: (0, devkit_1.getOutputsForTargetAndConfiguration)({ overrides: {}, target }, projectGraphNode),
+        node: projectGraphNode,
+    };
+}
+function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences, dependentBuildableProjectNodes) {
+    var _a, _b;
+    const originalTsConfig = (0, devkit_1.readJsonFile)(tsConfig, {
+        allowTrailingComma: true,
+        disallowComments: false,
+    });
+    const allProjectReferences = Array.from(new Set(((_a = originalTsConfig.references) !== null && _a !== void 0 ? _a : [])
+        .map((r) => r.path)
+        .concat(projectReferences)));
+    return {
+        content: JSON.stringify(Object.assign(Object.assign({}, originalTsConfig), { compilerOptions: Object.assign(Object.assign({}, originalTsConfig.compilerOptions), { rootDir: taskOptions.rootDir, outDir: taskOptions.outputPath, composite: true, declaration: true, declarationMap: true, tsBuildInfoFile: (0, path_1.join)(taskOptions.outputPath, 'tsconfig.tsbuildinfo'), paths: dependentBuildableProjectNodes.length
+                    ? (0, buildable_libs_utils_1.computeCompilerOptionsPaths)(tsConfig, dependentBuildableProjectNodes)
+                    : (_b = originalTsConfig.compilerOptions) === null || _b === void 0 ? void 0 : _b.paths }), references: allProjectReferences.map((pr) => ({ path: pr })) })),
+        path: tsConfig,
+    };
+}
+function findTaskWithTsConfig(tasks, context) {
+    for (const task of tasks) {
+        const depTaskOptions = (0, get_task_options_1.getTaskOptions)(task, context);
+        if (depTaskOptions === null || depTaskOptions === void 0 ? void 0 : depTaskOptions.tsConfig) {
+            return { task: task, tsConfig: depTaskOptions.tsConfig };
+        }
+    }
+    return null;
+}
+function getDependencyTasksInSameProject(task, context) {
+    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    return Object.keys(context.taskGraph.tasks).filter((t) => t !== task &&
+        (0, devkit_1.parseTargetString)(t, context.projectGraph).project === taskProject);
+}

package/src/executors/tsc/lib/index.d.ts

@@ -1,2 +1,4 @@
 export * from './get-custom-transformers-factory';
+export * from './get-tsconfig';
 export * from './normalize-options';
+export * from './typescript-compilation';

package/src/executors/tsc/lib/index.js

@@ -2,4 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./get-custom-transformers-factory"), exports);
+tslib_1.__exportStar(require("./get-tsconfig"), exports);
 tslib_1.__exportStar(require("./normalize-options"), exports);
+tslib_1.__exportStar(require("./typescript-compilation"), exports);

package/src/executors/tsc/lib/typescript-compilation.d.ts

@@ -0,0 +1,29 @@
+import * as ts from 'typescript';
+import type { TransformerEntry } from '../../../utils/typescript/types';
+export interface TypescriptInMemoryTsConfig {
+    content: string;
+    path: string;
+}
+export interface TypescripCompilationLogger {
+    error: (message: string, tsConfig?: string) => void;
+    info: (message: string, tsConfig?: string) => void;
+    warn: (message: string, tsConfig?: string) => void;
+}
+export interface TypescriptProjectContext {
+    project: string;
+    tsConfig: TypescriptInMemoryTsConfig;
+    transformers: TransformerEntry[];
+}
+export interface TypescriptCompilationResult {
+    tsConfig: string;
+    success: boolean;
+}
+export type ReporterWithTsConfig<Fn extends (...args: any[]) => any> = (tsConfig: string | undefined, ...foo: Parameters<Fn>) => ReturnType<Fn>;
+export declare function compileTypescriptSolution(context: Record<string, TypescriptProjectContext>, watch: boolean, logger: TypescripCompilationLogger, hooks?: {
+    beforeProjectCompilationCallback?: (tsConfig: string) => void;
+    afterProjectCompilationCallback?: (tsConfig: string, success: boolean) => void;
+}, reporters?: {
+    diagnosticReporter?: ReporterWithTsConfig<ts.DiagnosticReporter>;
+    solutionBuilderStatusReporter?: ReporterWithTsConfig<ts.DiagnosticReporter>;
+    watchStatusReporter?: ReporterWithTsConfig<ts.WatchStatusReporter>;
+}): AsyncIterable<TypescriptCompilationResult>;