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

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

@@ -0,0 +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

@@ -0,0 +1,7 @@
+"use strict";
+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/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutorOptions, NormalizedExecutorOptions } from '../../../utils/schema';
+export declare function normalizeOptions(options: ExecutorOptions, contextRoot: string, sourceRoot: string, projectRoot: string): NormalizedExecutorOptions;

package/src/executors/tsc/lib/normalize-options.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const path_1 = require("path");
+const assets_1 = require("../../../utils/assets/assets");
+function normalizeOptions(options, contextRoot, sourceRoot, projectRoot) {
+    const outputPath = (0, path_1.join)(contextRoot, options.outputPath);
+    const rootDir = options.rootDir
+        ? (0, path_1.join)(contextRoot, options.rootDir)
+        : (0, path_1.join)(contextRoot, projectRoot);
+    if (options.watch == null) {
+        options.watch = false;
+    }
+    // TODO: put back when inlining story is more stable
+    // if (options.external == null) {
+    //   options.external = 'all';
+    // } else if (Array.isArray(options.external) && options.external.length === 0) {
+    //   options.external = 'none';
+    // }
+    if (Array.isArray(options.external) && options.external.length > 0) {
+        const firstItem = options.external[0];
+        if (firstItem === 'all' || firstItem === 'none') {
+            options.external = firstItem;
+        }
+    }
+    const files = (0, assets_1.assetGlobsToFiles)(options.assets, contextRoot, outputPath);
+    return Object.assign(Object.assign({}, options), { root: contextRoot, sourceRoot,
+        projectRoot,
+        files,
+        outputPath, tsConfig: (0, path_1.join)(contextRoot, options.tsConfig), rootDir, mainOutputPath: (0, path_1.resolve)(outputPath, options.main.replace(`${projectRoot}/`, '').replace('.ts', '.js')) });
+}
+exports.normalizeOptions = normalizeOptions;

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>;

package/src/executors/tsc/lib/typescript-compilation.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypescriptSolution = void 0;
+const tslib_1 = require("tslib");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const ts = require("typescript");
+const get_custom_transformers_factory_1 = require("./get-custom-transformers-factory");
+const typescript_diagnostic_reporters_1 = require("./typescript-diagnostic-reporters");
+// https://github.com/microsoft/TypeScript/blob/d45012c5e2ab122919ee4777a7887307c5f4a1e0/src/compiler/diagnosticMessages.json#L4050-L4053
+// Typescript diagnostic message for 5083: Cannot read file '{0}'.
+const TYPESCRIPT_CANNOT_READ_FILE = 5083;
+// https://github.com/microsoft/TypeScript/blob/d45012c5e2ab122919ee4777a7887307c5f4a1e0/src/compiler/diagnosticMessages.json#L4211-4214
+// Typescript diagnostic message for 6032: File change detected. Starting incremental compilation...
+const TYPESCRIPT_FILE_CHANGE_DETECTED_STARTING_INCREMENTAL_COMPILATION = 6032;
+function compileTypescriptSolution(context, watch, logger, hooks, reporters) {
+    if (watch) {
+        // create an AsyncIterable that doesn't complete, watch mode is only
+        // stopped by killing the process
+        return (0, async_iterable_1.createAsyncIterable)(({ next }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            hooks !== null && hooks !== void 0 ? hooks : (hooks = {});
+            const callerAfterProjectCompilationCallback = hooks.afterProjectCompilationCallback;
+            hooks.afterProjectCompilationCallback = (tsConfig, success) => {
+                callerAfterProjectCompilationCallback === null || callerAfterProjectCompilationCallback === void 0 ? void 0 : callerAfterProjectCompilationCallback(tsConfig, success);
+                next({ tsConfig, success });
+            };
+            compileTSWithWatch(context, logger, hooks, reporters);
+        }));
+    }
+    // turn it into an AsyncIterable
+    const compilationGenerator = compileTS(context, logger, hooks, reporters);
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    return Promise.resolve(compilationGenerator.next());
+                },
+            };
+        },
+    };
+}
+exports.compileTypescriptSolution = compileTypescriptSolution;
+function* compileTS(context, logger, hooks, reporters) {
+    var _a, _b, _c;
+    let project;
+    const formatDiagnosticsHost = {
+        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+        getNewLine: () => ts.sys.newLine,
+        getCanonicalFileName: (filename) => ts.sys.useCaseSensitiveFileNames ? filename : filename.toLowerCase(),
+    };
+    const solutionBuilderHost = ts.createSolutionBuilderHost(getSystem(context), 
+    /*createProgram*/ undefined, (diagnostic) => {
+        var _a;
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatDiagnosticReport)(diagnostic, formatDiagnosticsHost);
+        // handles edge case where a wrong a project reference path can't be read
+        if (diagnostic.code === TYPESCRIPT_CANNOT_READ_FILE) {
+            throw new Error(formattedDiagnostic);
+        }
+        logger.info(formattedDiagnostic, project.project);
+        (_a = reporters === null || reporters === void 0 ? void 0 : reporters.diagnosticReporter) === null || _a === void 0 ? void 0 : _a.call(reporters, project.project, diagnostic);
+    }, (diagnostic) => {
+        var _a;
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatSolutionBuilderStatusReport)(diagnostic);
+        logger.info(formattedDiagnostic, project.project);
+        (_a = reporters === null || reporters === void 0 ? void 0 : reporters.solutionBuilderStatusReporter) === null || _a === void 0 ? void 0 : _a.call(reporters, project.project, diagnostic);
+    });
+    const rootNames = Object.keys(context);
+    const solutionBuilder = ts.createSolutionBuilder(solutionBuilderHost, rootNames, {});
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        project = solutionBuilder.getNextInvalidatedProject();
+        if (!project) {
+            break;
+        }
+        const projectContext = context[project.project];
+        const projectName = projectContext === null || projectContext === void 0 ? void 0 : projectContext.project;
+        /**
+         * This only applies when the deprecated `prepend` option is set to `true`.
+         * Skip support.
+         */
+        if (project.kind === ts.InvalidatedProjectKind.UpdateBundle) {
+            logger.warn(`The project ${projectName} ` +
+                `is using the deprecated "prepend" Typescript compiler option. ` +
+                `This option is not supported by the batch executor and it's ignored.\n`, project.project);
+            continue;
+        }
+        (_a = hooks === null || hooks === void 0 ? void 0 : hooks.beforeProjectCompilationCallback) === null || _a === void 0 ? void 0 : _a.call(hooks, project.project);
+        if (project.kind === ts.InvalidatedProjectKind.UpdateOutputFileStamps) {
+            logger.info(`Updating output timestamps of project "${projectName}"...\n`, project.project);
+            // update output timestamps and mark project as complete
+            const status = project.done();
+            const success = status === ts.ExitStatus.Success;
+            if (success) {
+                logger.info(`Done updating output timestamps of project "${projectName}"...\n`, project.project);
+            }
+            (_b = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _b === void 0 ? void 0 : _b.call(hooks, project.project, success);
+            yield { success, tsConfig: project.project };
+            continue;
+        }
+        logger.info(`Compiling TypeScript files for project "${projectName}"...\n`, project.project);
+        // build and mark project as complete
+        const status = project.done(undefined, undefined, (0, get_custom_transformers_factory_1.getCustomTrasformersFactory)(projectContext.transformers)(project.getProgram()));
+        const success = status === ts.ExitStatus.Success;
+        if (success) {
+            logger.info(`Done compiling TypeScript files for project "${projectName}".\n`, project.project);
+        }
+        (_c = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _c === void 0 ? void 0 : _c.call(hooks, project.project, success);
+        yield {
+            success: status === ts.ExitStatus.Success,
+            tsConfig: project.project,
+        };
+    }
+}
+function compileTSWithWatch(context, logger, hooks, reporters) {
+    let project;
+    const solutionHost = ts.createSolutionBuilderWithWatchHost(getSystem(context), 
+    /*createProgram*/ undefined);
+    if (reporters === null || reporters === void 0 ? void 0 : reporters.diagnosticReporter) {
+        const originalDiagnosticReporter = solutionHost.reportDiagnostic;
+        solutionHost.reportDiagnostic = (diagnostic) => {
+            originalDiagnosticReporter(diagnostic);
+            reporters.diagnosticReporter(project.project, diagnostic);
+        };
+    }
+    if (reporters === null || reporters === void 0 ? void 0 : reporters.solutionBuilderStatusReporter) {
+        const originalSolutionBuilderStatusReporter = solutionHost.reportSolutionBuilderStatus;
+        solutionHost.reportDiagnostic = (diagnostic) => {
+            originalSolutionBuilderStatusReporter(diagnostic);
+            reporters.solutionBuilderStatusReporter(project.project, diagnostic);
+        };
+    }
+    const originalWatchStatusReporter = solutionHost.onWatchStatusChange;
+    solutionHost.onWatchStatusChange = (diagnostic, newLine, options, errorCount) => {
+        var _a;
+        originalWatchStatusReporter(diagnostic, newLine, options, errorCount);
+        if (diagnostic.code ===
+            TYPESCRIPT_FILE_CHANGE_DETECTED_STARTING_INCREMENTAL_COMPILATION) {
+            // there's a change, build invalidated projects
+            build();
+        }
+        (_a = reporters === null || reporters === void 0 ? void 0 : reporters.watchStatusReporter) === null || _a === void 0 ? void 0 : _a.call(reporters, project === null || project === void 0 ? void 0 : project.project, diagnostic, newLine, options, errorCount);
+    };
+    const rootNames = Object.keys(context);
+    const solutionBuilder = ts.createSolutionBuilderWithWatch(solutionHost, rootNames, {});
+    const build = () => {
+        var _a, _b;
+        while (true) {
+            project = solutionBuilder.getNextInvalidatedProject();
+            if (!project) {
+                break;
+            }
+            const projectContext = context[project.project];
+            const projectName = projectContext.project;
+            /**
+             * This only applies when the deprecated `prepend` option is set to `true`.
+             * Skip support.
+             */
+            if (project.kind === ts.InvalidatedProjectKind.UpdateBundle) {
+                logger.warn(`The project ${projectName} ` +
+                    `is using the deprecated "prepend" Typescript compiler option. ` +
+                    `This option is not supported by the batch executor and it's ignored.`);
+                continue;
+            }
+            hooks === null || hooks === void 0 ? void 0 : hooks.beforeProjectCompilationCallback(project.project);
+            if (project.kind === ts.InvalidatedProjectKind.UpdateOutputFileStamps) {
+                if (projectName) {
+                    logger.info(`Updating output timestamps of project "${projectName}"...\n`, project.project);
+                }
+                // update output timestamps and mark project as complete
+                const status = project.done();
+                const success = status === ts.ExitStatus.Success;
+                if (projectName && success) {
+                    logger.info(`Done updating output timestamps of project "${projectName}"...\n`, project.project);
+                }
+                (_a = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _a === void 0 ? void 0 : _a.call(hooks, project.project, success);
+                continue;
+            }
+            logger.info(`Compiling TypeScript files for project "${projectName}"...\n`, project.project);
+            // build and mark project as complete
+            const status = project.done(undefined, undefined, (0, get_custom_transformers_factory_1.getCustomTrasformersFactory)(projectContext.transformers)(project.getProgram()));
+            const success = status === ts.ExitStatus.Success;
+            if (success) {
+                logger.info(`Done compiling TypeScript files for project "${projectName}".\n`, project.project);
+            }
+            (_b = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _b === void 0 ? void 0 : _b.call(hooks, project.project, success);
+        }
+    };
+    // initial build
+    build();
+    /**
+     * This is a workaround to get the TS file watching to kick off. It won't
+     * build twice since the `build` call above will mark invalidated projects
+     * as completed and then, the implementation of the `solutionBuilder.build`
+     * skips them.
+     * We can't rely solely in `solutionBuilder.build()` because it doesn't
+     * accept custom transformers.
+     */
+    solutionBuilder.build();
+}
+function getSystem(context) {
+    return Object.assign(Object.assign({}, ts.sys), { readFile(path, encoding) {
+            if (context[path]) {
+                return context[path].tsConfig.content;
+            }
+            return ts.sys.readFile(path, encoding);
+        } });
+}

package/src/executors/tsc/lib/typescript-diagnostic-reporters.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+export declare function formatDiagnosticReport(diagnostic: ts.Diagnostic, host: ts.FormatDiagnosticsHost): string;
+export declare function formatSolutionBuilderStatusReport(diagnostic: ts.Diagnostic): string;

package/src/executors/tsc/lib/typescript-diagnostic-reporters.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSolutionBuilderStatusReport = exports.formatDiagnosticReport = void 0;
+const ts = require("typescript");
+// adapted from TS default diagnostic reporter
+function formatDiagnosticReport(diagnostic, host) {
+    const diagnostics = new Array(1);
+    diagnostics[0] = diagnostic;
+    const formattedDiagnostic = '\n' +
+        ts.formatDiagnosticsWithColorAndContext(diagnostics, host) +
+        host.getNewLine();
+    diagnostics[0] = undefined;
+    return formattedDiagnostic;
+}
+exports.formatDiagnosticReport = formatDiagnosticReport;
+// adapted from TS default solution builder status reporter
+function formatSolutionBuilderStatusReport(diagnostic) {
+    let formattedDiagnostic = `[${formatColorAndReset(getLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] `;
+    formattedDiagnostic += `${ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine)}${ts.sys.newLine + ts.sys.newLine}`;
+    return formattedDiagnostic;
+}
+exports.formatSolutionBuilderStatusReport = formatSolutionBuilderStatusReport;
+function formatColorAndReset(text, formatStyle) {
+    const resetEscapeSequence = '\u001b[0m';
+    return formatStyle + text + resetEscapeSequence;
+}
+function getLocaleTimeString() {
+    return new Date().toLocaleTimeString();
+}
+var ForegroundColorEscapeSequences;
+(function (ForegroundColorEscapeSequences) {
+    ForegroundColorEscapeSequences["Grey"] = "\u001B[90m";
+    ForegroundColorEscapeSequences["Red"] = "\u001B[91m";
+    ForegroundColorEscapeSequences["Yellow"] = "\u001B[93m";
+    ForegroundColorEscapeSequences["Blue"] = "\u001B[94m";
+    ForegroundColorEscapeSequences["Cyan"] = "\u001B[96m";
+})(ForegroundColorEscapeSequences || (ForegroundColorEscapeSequences = {}));

package/src/executors/tsc/tsc.batch-impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext, TaskGraph } from '@nx/devkit';
+import type { BatchExecutorTaskResult } from 'nx/src/config/misc-interfaces';
+import type { ExecutorOptions } from '../../utils/schema';
+export declare function tscBatchExecutor(taskGraph: TaskGraph, inputs: Record<string, ExecutorOptions>, overrides: ExecutorOptions, context: ExecutorContext): AsyncGenerator<BatchExecutorTaskResult, any, unknown>;
+export default tscBatchExecutor;

package/src/executors/tsc/tsc.batch-impl.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tscBatchExecutor = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const async_iterator_1 = require("nx/src/utils/async-iterator");
+const update_package_json_1 = require("../../utils/package-json/update-package-json");
+const lib_1 = require("./lib");
+const batch_1 = require("./lib/batch");
+function tscBatchExecutor(taskGraph, inputs, overrides, context) {
+    return tslib_1.__asyncGenerator(this, arguments, function* tscBatchExecutor_1() {
+        const tasksOptions = (0, batch_1.normalizeTasksOptions)(inputs, context);
+        let shouldWatch = false;
+        Object.values(tasksOptions).forEach((taskOptions) => {
+            if (taskOptions.clean) {
+                (0, fs_1.rmSync)(taskOptions.outputPath, { force: true, recursive: true });
+            }
+            if (taskOptions.watch) {
+                shouldWatch = true;
+            }
+        });
+        const taskInMemoryTsConfigMap = (0, lib_1.getProcessedTaskTsConfigs)(Object.keys(taskGraph.tasks), tasksOptions, context);
+        const tsConfigTaskInfoMap = (0, batch_1.createTaskInfoPerTsConfigMap)(tasksOptions, context, Object.keys(taskGraph.tasks), taskInMemoryTsConfigMap);
+        const tsCompilationContext = createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsConfigMap, context);
+        const logger = {
+            error: (message, tsConfig) => {
+                process.stderr.write(message);
+                if (tsConfig) {
+                    tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+                }
+            },
+            info: (message, tsConfig) => {
+                process.stdout.write(message);
+                if (tsConfig) {
+                    tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+                }
+            },
+            warn: (message, tsConfig) => {
+                process.stdout.write(message);
+                if (tsConfig) {
+                    tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+                }
+            },
+        };
+        const typescriptCompilation = (0, lib_1.compileTypescriptSolution)(tsCompilationContext, shouldWatch, logger, {
+            beforeProjectCompilationCallback: (tsConfig) => {
+                if (tsConfigTaskInfoMap[tsConfig]) {
+                    tsConfigTaskInfoMap[tsConfig].startTime = Date.now();
+                }
+            },
+            afterProjectCompilationCallback: (tsConfig) => {
+                if (tsConfigTaskInfoMap[tsConfig]) {
+                    const taskInfo = tsConfigTaskInfoMap[tsConfig];
+                    taskInfo.assetsHandler.processAllAssetsOnceSync();
+                    (0, update_package_json_1.updatePackageJson)(taskInfo.options, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
+                    taskInfo.endTime = Date.now();
+                }
+            },
+        });
+        if (shouldWatch) {
+            const taskInfos = Object.values(tsConfigTaskInfoMap);
+            const watchAssetsChangesDisposer = yield tslib_1.__await((0, batch_1.watchTaskProjectsFileChangesForAssets)(taskInfos));
+            const watchProjectsChangesDisposer = yield tslib_1.__await((0, batch_1.watchTaskProjectsPackageJsonFileChanges)(taskInfos, (changedTaskInfos) => {
+                for (const t of changedTaskInfos) {
+                    (0, update_package_json_1.updatePackageJson)(t.options, t.context, t.projectGraphNode, t.buildableProjectNodeDependencies);
+                }
+            }));
+            const handleTermination = (exitCode) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                watchAssetsChangesDisposer();
+                watchProjectsChangesDisposer();
+                process.exit(exitCode);
+            });
+            process.on('SIGINT', () => handleTermination(128 + 2));
+            process.on('SIGTERM', () => handleTermination(128 + 15));
+            return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(mapAsyncIterable(typescriptCompilation, (iterator) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                // drain the iterator, we don't use the results
+                yield (0, async_iterator_1.getLastValueFromAsyncIterableIterator)(iterator);
+                return { value: undefined, done: true };
+            }))))));
+        }
+        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(mapAsyncIterable(typescriptCompilation, (iterator) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { value, done } = yield iterator.next();
+            if (done) {
+                return { value, done: true };
+            }
+            const taskResult = {
+                task: tsConfigTaskInfoMap[value.tsConfig].task,
+                result: {
+                    success: value.success,
+                    terminalOutput: tsConfigTaskInfoMap[value.tsConfig].terminalOutput,
+                    startTime: tsConfigTaskInfoMap[value.tsConfig].startTime,
+                    endTime: tsConfigTaskInfoMap[value.tsConfig].endTime,
+                },
+            };
+            return { value: taskResult, done: false };
+        }))))));
+    });
+}
+exports.tscBatchExecutor = tscBatchExecutor;
+exports.default = tscBatchExecutor;
+function mapAsyncIterable(iterable, nextFn) {
+    return tslib_1.__asyncGenerator(this, arguments, function* mapAsyncIterable_1() {
+        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues({
+            [Symbol.asyncIterator]() {
+                const iterator = iterable[Symbol.asyncIterator].call(iterable);
+                return {
+                    next() {
+                        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            return yield nextFn(iterator);
+                        });
+                    },
+                };
+            },
+        }))));
+    });
+}
+function createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsConfigMap, context) {
+    const tsCompilationContext = Object.entries(tsConfigTaskInfoMap).reduce((acc, [tsConfig, taskInfo]) => {
+        acc[tsConfig] = {
+            project: taskInfo.context.projectName,
+            tsConfig: taskInfo.tsConfig,
+            transformers: taskInfo.options.transformers,
+        };
+        return acc;
+    }, {});
+    Object.entries(taskInMemoryTsConfigMap).forEach(([task, tsConfig]) => {
+        if (!tsCompilationContext[tsConfig.path]) {
+            tsCompilationContext[tsConfig.path] = {
+                project: (0, devkit_1.parseTargetString)(task, context.projectGraph).project,
+                transformers: [],
+                tsConfig: tsConfig,
+            };
+        }
+    });
+    return tsCompilationContext;
+}

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

@@ -1,7 +1,6 @@
 import { ExecutorContext } from '@nx/devkit';
 import type { TypeScriptCompilationOptions } from '@nx/workspace/src/utilities/typescript/compilation';
 import { ExecutorOptions, NormalizedExecutorOptions } from '../../utils/schema';
-export declare function normalizeOptions(options: ExecutorOptions, contextRoot: string, sourceRoot: string, projectRoot: string): NormalizedExecutorOptions;
 export declare function createTypeScriptCompilationOptions(normalizedOptions: NormalizedExecutorOptions, context: ExecutorContext): TypeScriptCompilationOptions;
 export declare function tscExecutor(_options: ExecutorOptions, context: ExecutorContext): AsyncGenerator<import("../../utils/typescript/compile-typescript-files").TypescriptCompilationResult, any, undefined>;
 export default tscExecutor;