@nx/js 0.0.0-pr-22179-271588f

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

@@ -0,0 +1,17 @@
+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;
+    context: ExecutorContext;
+    assetsHandler: CopyAssetsHandler;
+    buildableProjectNodeDependencies: DependentBuildableProjectNode[];
+    projectGraphNode: ProjectGraphProjectNode;
+    tsConfig: TypescriptInMemoryTsConfig;
+    startTime?: number;
+    endTime?: number;
+    terminalOutput: string;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+import type { TaskInfo } from './types';
+export declare function watchTaskProjectsPackageJsonFileChanges(taskInfos: TaskInfo[], callback: (changedTaskInfos: TaskInfo[]) => void): Promise<() => void>;
+export declare function watchTaskProjectsFileChangesForAssets(taskInfos: TaskInfo[]): Promise<() => void>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchTaskProjectsFileChangesForAssets = exports.watchTaskProjectsPackageJsonFileChanges = void 0;
+const devkit_1 = require("@nx/devkit");
+const client_1 = require("nx/src/daemon/client/client");
+const path_1 = require("path");
+async function watchTaskProjectsPackageJsonFileChanges(taskInfos, callback) {
+    const projects = [];
+    const packageJsonTaskInfoMap = new Map();
+    taskInfos.forEach((t) => {
+        projects.push(t.context.projectName);
+        packageJsonTaskInfoMap.set((0, path_1.join)(t.options.projectRoot, 'package.json'), t);
+    });
+    const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({ watchProjects: projects }, (err, data) => {
+        if (err === 'closed') {
+            devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+            process.exit(1);
+        }
+        else if (err) {
+            devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
+        }
+        else {
+            const changedTasks = [];
+            data.changedFiles.forEach((file) => {
+                if (packageJsonTaskInfoMap.has(file.path)) {
+                    changedTasks.push(packageJsonTaskInfoMap.get(file.path));
+                }
+            });
+            if (changedTasks.length) {
+                callback(changedTasks);
+            }
+        }
+    });
+    return () => unregisterFileWatcher();
+}
+exports.watchTaskProjectsPackageJsonFileChanges = watchTaskProjectsPackageJsonFileChanges;
+async function watchTaskProjectsFileChangesForAssets(taskInfos) {
+    const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({
+        watchProjects: taskInfos.map((t) => t.context.projectName),
+        includeDependentProjects: true,
+        includeGlobalWorkspaceFiles: true,
+    }, (err, data) => {
+        if (err === 'closed') {
+            devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+            process.exit(1);
+        }
+        else if (err) {
+            devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
+        }
+        else {
+            taskInfos.forEach((t) => t.assetsHandler.processWatchEvents(data.changedFiles));
+        }
+    });
+    return () => unregisterFileWatcher();
+}
+exports.watchTaskProjectsFileChangesForAssets = watchTaskProjectsFileChangesForAssets;

package/src/executors/tsc/lib/get-custom-transformers-factory.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import type { TransformerEntry } from '../../../utils/typescript/types';
+export declare function getCustomTrasformersFactory(transformers: TransformerEntry[]): (program: ts.Program) => ts.CustomTransformers;

package/src/executors/tsc/lib/get-custom-transformers-factory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomTrasformersFactory = void 0;
+const load_ts_transformers_1 = require("../../../utils/typescript/load-ts-transformers");
+function getCustomTrasformersFactory(transformers) {
+    const { compilerPluginHooks } = (0, load_ts_transformers_1.loadTsTransformers)(transformers);
+    return (program) => ({
+        before: compilerPluginHooks.beforeHooks.map((hook) => hook(program)),
+        after: compilerPluginHooks.afterHooks.map((hook) => hook(program)),
+        afterDeclarations: compilerPluginHooks.afterDeclarationsHooks.map((hook) => hook(program)),
+    });
+}
+exports.getCustomTrasformersFactory = getCustomTrasformersFactory;

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskOptions = void 0;
+const normalize_options_1 = require("./normalize-options");
+const tasksOptionsCache = new Map();
+function getTaskOptions(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 {
+        tasksOptionsCache.set(taskName, null);
+        return null;
+    }
+}
+exports.getTaskOptions = getTaskOptions;
+function parseTaskInfo(taskName, context) {
+    const target = context.taskGraph.tasks[taskName].target;
+    const projectNode = context.projectGraph.nodes[target.project];
+    const targetConfig = projectNode.data.targets?.[target.target];
+    const { sourceRoot, root } = projectNode.data;
+    const taskOptions = {
+        ...targetConfig.options,
+        ...(target.configuration
+            ? targetConfig.configurations?.[target.configuration]
+            : {}),
+    };
+    return { taskOptions, root, sourceRoot, projectNode, target };
+}

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

@@ -0,0 +1,4 @@
+import { type 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,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessedTaskTsConfigs = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const get_task_options_1 = require("./get-task-options");
+function getProcessedTaskTsConfigs(tasks, tasksOptions, context) {
+    const taskInMemoryTsConfigMap = {};
+    for (const task of tasks) {
+        generateTaskProjectTsConfig(task, tasksOptions, context, taskInMemoryTsConfigMap);
+    }
+    return taskInMemoryTsConfigMap;
+}
+exports.getProcessedTaskTsConfigs = getProcessedTaskTsConfigs;
+const projectTsConfigCache = new Map();
+function generateTaskProjectTsConfig(task, tasksOptions, context, taskInMemoryTsConfigMap) {
+    const { project } = (0, devkit_1.parseTargetString)(task, context);
+    if (projectTsConfigCache.has(project)) {
+        const { tsConfig, tsConfigPath } = projectTsConfigCache.get(project);
+        taskInMemoryTsConfigMap[task] = tsConfig;
+        return tsConfigPath;
+    }
+    const tasksInProject = [
+        task,
+        ...getDependencyTasksInSameProject(task, context),
+    ];
+    const taskWithTscExecutor = tasksInProject.find((t) => hasTscExecutor(t, context));
+    if (!taskWithTscExecutor) {
+        throw new Error((0, devkit_1.stripIndents) `The "@nx/js:tsc" batch executor requires all dependencies to use the "@nx/js:tsc" executor.
+        None of the following tasks in the "${project}" project use the "@nx/js:tsc" executor:
+        ${tasksInProject.map((t) => `- ${t}`).join('\n')}`);
+    }
+    const projectReferences = [];
+    for (const task of tasksInProject) {
+        for (const depTask of getDependencyTasksInOtherProjects(task, project, context)) {
+            const tsConfigPath = generateTaskProjectTsConfig(depTask, tasksOptions, context, taskInMemoryTsConfigMap);
+            projectReferences.push(tsConfigPath);
+        }
+    }
+    const taskOptions = tasksOptions[taskWithTscExecutor] ??
+        (0, get_task_options_1.getTaskOptions)(taskWithTscExecutor, context);
+    const tsConfigPath = taskOptions.tsConfig;
+    taskInMemoryTsConfigMap[taskWithTscExecutor] = getInMemoryTsConfig(tsConfigPath, taskOptions, projectReferences);
+    projectTsConfigCache.set(project, {
+        tsConfigPath: tsConfigPath,
+        tsConfig: taskInMemoryTsConfigMap[taskWithTscExecutor],
+    });
+    return tsConfigPath;
+}
+function getDependencyTasksInOtherProjects(task, project, context) {
+    return context.taskGraph.dependencies[task].filter((t) => t !== task && (0, devkit_1.parseTargetString)(t, context).project !== project);
+}
+function getDependencyTasksInSameProject(task, context) {
+    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context);
+    return Object.keys(context.taskGraph.tasks).filter((t) => t !== task && (0, devkit_1.parseTargetString)(t, context).project === taskProject);
+}
+function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences) {
+    const originalTsConfig = (0, devkit_1.readJsonFile)(tsConfig, {
+        allowTrailingComma: true,
+        disallowComments: false,
+    });
+    const allProjectReferences = Array.from(new Set((originalTsConfig.references ?? [])
+        .map((r) => r.path)
+        .concat(projectReferences)));
+    return {
+        content: JSON.stringify({
+            ...originalTsConfig,
+            compilerOptions: {
+                ...originalTsConfig.compilerOptions,
+                rootDir: taskOptions.rootDir,
+                outDir: taskOptions.outputPath,
+                composite: true,
+                declaration: true,
+                declarationMap: true,
+                tsBuildInfoFile: (0, path_1.join)(taskOptions.outputPath, 'tsconfig.tsbuildinfo'),
+            },
+            references: allProjectReferences.map((pr) => ({ path: pr })),
+        }),
+        path: tsConfig.replace(/\\/g, '/'),
+    };
+}
+function hasTscExecutor(task, context) {
+    const { project, target } = (0, devkit_1.parseTargetString)(task, context);
+    return (context.projectGraph.nodes[project].data.targets[target].executor ===
+        '@nx/js:tsc');
+}

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,39 @@
+"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 {
+        ...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,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypescriptSolution = void 0;
+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)(async ({ next }) => {
+            hooks ??= {};
+            const callerAfterProjectCompilationCallback = hooks.afterProjectCompilationCallback;
+            hooks.afterProjectCompilationCallback = (tsConfig, success) => {
+                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) {
+    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) => {
+        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);
+        reporters?.diagnosticReporter?.(project.project, diagnostic);
+    }, (diagnostic) => {
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatSolutionBuilderStatusReport)(diagnostic);
+        logger.info(formattedDiagnostic, project.project);
+        reporters?.solutionBuilderStatusReporter?.(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?.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;
+        }
+        hooks?.beforeProjectCompilationCallback?.(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);
+            }
+            hooks?.afterProjectCompilationCallback?.(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);
+        }
+        hooks?.afterProjectCompilationCallback?.(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?.diagnosticReporter) {
+        const originalDiagnosticReporter = solutionHost.reportDiagnostic;
+        solutionHost.reportDiagnostic = (diagnostic) => {
+            originalDiagnosticReporter(diagnostic);
+            reporters.diagnosticReporter(project.project, diagnostic);
+        };
+    }
+    if (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) => {
+        originalWatchStatusReporter(diagnostic, newLine, options, errorCount);
+        if (diagnostic.code ===
+            TYPESCRIPT_FILE_CHANGE_DETECTED_STARTING_INCREMENTAL_COMPILATION) {
+            // there's a change, build invalidated projects
+            build();
+        }
+        reporters?.watchStatusReporter?.(project?.project, diagnostic, newLine, options, errorCount);
+    };
+    const rootNames = Object.keys(context);
+    const solutionBuilder = ts.createSolutionBuilderWithWatch(solutionHost, rootNames, {});
+    const build = () => {
+        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?.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);
+                }
+                hooks?.afterProjectCompilationCallback?.(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);
+            }
+            hooks?.afterProjectCompilationCallback?.(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 {
+        ...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 = {}));