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

package/executors.json

@@ -3,6 +3,7 @@
   "executors": {
     "tsc": {
       "implementation": "./src/executors/tsc/tsc.impl",
+      "batchImplementation": "./src/executors/tsc/tsc.batch-impl",
       "schema": "./src/executors/tsc/schema.json",
       "description": "Build a project using TypeScript."
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.4.0-beta.1",
+  "version": "16.4.0-beta.3",
   "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,14 +39,15 @@
     "@babel/preset-env": "^7.15.0",
     "@babel/preset-typescript": "^7.15.0",
     "@babel/runtime": "^7.14.8",
-    "@nrwl/js": "16.4.0-beta.1",
-    "@nx/devkit": "16.4.0-beta.1",
-    "@nx/workspace": "16.4.0-beta.1",
+    "@nrwl/js": "16.4.0-beta.3",
+    "@nx/devkit": "16.4.0-beta.3",
+    "@nx/workspace": "16.4.0-beta.3",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
     "babel-plugin-transform-typescript-metadata": "^0.3.1",
     "chalk": "^4.1.0",
+    "detect-port": "^1.5.1",
     "fast-glob": "3.2.7",
     "fs-extra": "^11.1.0",
     "ignore": "^5.0.4",
@@ -68,5 +69,5 @@
     "access": "public"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "1c4fb934b607f0d93bb23bff2cf0f39b31a8fa43"
+  "gitHead": "d7f500985ba56117bf17c133bf70d22e42a7af27"
 }

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

@@ -25,8 +25,11 @@ function nodeExecutor(options, context) {
         (_a = (_e = process.env).NODE_ENV) !== null && _a !== void 0 ? _a : (_e.NODE_ENV = (_b = context === null || context === void 0 ? void 0 : context.configurationName) !== null && _b !== void 0 ? _b : 'development');
         const project = context.projectGraph.nodes[context.projectName];
         const buildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph);
-        const buildOptions = (_c = project.data.targets[buildTarget.target]) === null || _c === void 0 ? void 0 : _c.options;
-        if (!buildOptions) {
+        let buildOptions;
+        if (project.data.targets[buildTarget.target]) {
+            buildOptions = Object.assign(Object.assign({}, (_c = project.data.targets[buildTarget.target]) === null || _c === void 0 ? void 0 : _c.options), options.buildTargetOptions);
+        }
+        else {
             throw new Error(`Cannot find build target ${chalk.bold(options.buildTarget)} for project ${chalk.bold(context.projectName)}`);
         }
         // Re-map buildable workspace projects to their output directory.
@@ -90,7 +93,7 @@ function nodeExecutor(options, context) {
                         // Run the program
                         task.promise = new Promise((resolve, reject) => {
                             var _a;
-                            task.childProcess = (0, child_process_1.fork)((0, devkit_1.joinPathFragments)(__dirname, 'node-with-require-overrides'), (_a = options.runtimeArgs) !== null && _a !== void 0 ? _a : [], {
+                            task.childProcess = (0, child_process_1.fork)((0, devkit_1.joinPathFragments)(__dirname, 'node-with-require-overrides'), (_a = options.args) !== null && _a !== void 0 ? _a : [], {
                                 execArgv: getExecArgv(options),
                                 stdio: [0, 1, 'pipe', 'ipc'],
                                 env: Object.assign(Object.assign({}, process.env), { NX_FILE_TO_RUN: fileToRun, NX_MAPPINGS: JSON.stringify(mappings) }),

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskInfoPerTsConfigMap = void 0;
+const devkit_1 = require("@nx/devkit");
+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 taskTsConfigCache = new Set();
+function buildTaskInfoPerTsConfigMap(tsConfigTaskInfoMap, tasksOptions, context, tasks, shouldWatch) {
+    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
+        if (taskOptions) {
+            const taskInfo = createTaskInfo(taskName, taskOptions, context);
+            const tsConfigPath = (0, generate_temp_tsconfig_1.generateTempTsConfig)(tasksOptions, taskName, taskOptions, context);
+            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);
+    }
+}
+exports.buildTaskInfoPerTsConfigMap = buildTaskInfoPerTsConfigMap;
+function createTaskInfo(taskName, taskOptions, context) {
+    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
+        // here per task
+        projectName: target.project, targetName: target.target, configurationName: target.configuration });
+    const assetsHandler = new copy_assets_handler_1.CopyAssetsHandler({
+        projectDir: taskOptions.projectRoot,
+        rootDir: context.root,
+        outputDir: taskOptions.outputPath,
+        assets: taskOptions.assets,
+    });
+    const { target: projectGraphNode, dependencies: buildableProjectNodeDependencies, } = (0, buildable_libs_utils_1.calculateProjectDependencies)(context.projectGraph, context.root, context.taskGraph.tasks[taskName].target.project, context.taskGraph.tasks[taskName].target.target, context.taskGraph.tasks[taskName].target.configuration);
+    return {
+        task: taskName,
+        options: taskOptions,
+        context: taskContext,
+        assetsHandler,
+        buildableProjectNodeDependencies,
+        projectGraphNode,
+    };
+}

package/src/executors/tsc/lib/batch/generate-temp-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { NormalizedExecutorOptions } from '../../../../utils/schema';
+export declare function generateTempTsConfig(taskOptionsMap: Record<string, NormalizedExecutorOptions>, taskName: string, taskOptions: NormalizedExecutorOptions, context: ExecutorContext): string;

package/src/executors/tsc/lib/batch/generate-temp-tsconfig.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTempTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ts = require("typescript");
+const get_task_options_1 = require("./get-task-options");
+function generateTempTsConfig(taskOptionsMap, taskName, taskOptions, context) {
+    const tmpDir = (0, path_1.join)(context.root, 'tmp');
+    const originalTsConfigPath = taskOptions.tsConfig;
+    const tmpTsConfigPath = (0, path_1.join)(tmpDir, (0, path_1.relative)(context.root, originalTsConfigPath));
+    const projectReferences = [];
+    for (const depTask of context.taskGraph.dependencies[taskName]) {
+        // if included in the provided map, use it
+        if (taskOptionsMap[depTask]) {
+            projectReferences.push({
+                path: (0, path_1.join)(tmpDir, (0, path_1.relative)(context.root, taskOptionsMap[depTask].tsConfig)),
+            });
+            continue;
+        }
+        // if it's not included in the provided map, it could be a cached task and
+        // we need to pull the tsconfig from the relevant project graph node
+        const options = (0, get_task_options_1.getTaskOptions)(depTask, context);
+        if (options.tsConfig) {
+            projectReferences.push({
+                path: (0, path_1.join)(tmpDir, (0, path_1.relative)(context.root, options.tsConfig)),
+            });
+        }
+    }
+    (0, devkit_1.writeJsonFile)(tmpTsConfigPath, {
+        extends: (0, devkit_1.normalizePath)((0, path_1.relative)((0, path_1.dirname)(tmpTsConfigPath), taskOptions.tsConfig)),
+        compilerOptions: {
+            rootDir: taskOptions.rootDir,
+            outDir: taskOptions.outputPath,
+            composite: true,
+            declaration: true,
+            declarationMap: true,
+            tsBuildInfoFile: (0, devkit_1.joinPathFragments)(taskOptions.outputPath, 'tsconfig.tsbuildinfo'),
+        },
+        references: projectReferences,
+    });
+    /**
+     * Ensure the temp tsconfig has the same modified date as the original.
+     * Typescript compares this against the modified date of the tsbuildinfo
+     * file. If the tsbuildinfo file is older, the cache is invalidated.
+     * Since we always generate the temp tsconfig, any existing tsbuildinfo
+     * file will be older even if they are not older than the original tsconfig.
+     */
+    ts.sys.setModifiedTime(tmpTsConfigPath, ts.sys.getModifiedTime(originalTsConfigPath));
+    return tmpTsConfigPath;
+}
+exports.generateTempTsConfig = generateTempTsConfig;

package/src/executors/tsc/lib/batch/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;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const normalize_options_1 = require("../normalize-options");
+const tasksOptionsCache = new Map();
+function getTaskOptions(taskName, context) {
+    var _a, _b;
+    if (tasksOptionsCache.has(taskName)) {
+        return tasksOptionsCache.get(taskName);
+    }
+    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 taskOptions = Object.assign(Object.assign({}, targetConfig.options), (target.configuration
+        ? (_b = targetConfig.configurations) === null || _b === void 0 ? void 0 : _b[target.configuration]
+        : {}));
+    const { project } = (0, devkit_1.parseTargetString)(taskName, context.projectGraph);
+    const { sourceRoot, root } = context.projectsConfigurations.projects[project];
+    const normalizedTaskOptions = (0, normalize_options_1.normalizeOptions)(taskOptions, context.root, sourceRoot, root);
+    tasksOptionsCache.set(taskName, normalizedTaskOptions);
+    return normalizedTaskOptions;
+}
+exports.getTaskOptions = getTaskOptions;

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

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

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

@@ -0,0 +1,3 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { ExecutorOptions, NormalizedExecutorOptions } from '../../../../utils/schema';
+export declare function normalizeTasksOptions(inputs: Record<string, ExecutorOptions>, context: ExecutorContext): Record<string, NormalizedExecutorOptions>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTasksOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const normalize_options_1 = require("../normalize-options");
+function normalizeTasksOptions(inputs, context) {
+    return Object.entries(inputs).reduce((tasksOptions, [taskName, options]) => {
+        const { project } = (0, devkit_1.parseTargetString)(taskName, context.projectGraph);
+        const { sourceRoot, root } = context.projectsConfigurations.projects[project];
+        tasksOptions[taskName] = (0, normalize_options_1.normalizeOptions)(options, context.root, sourceRoot, root);
+        return tasksOptions;
+    }, {});
+}
+exports.normalizeTasksOptions = normalizeTasksOptions;

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

@@ -0,0 +1,12 @@
+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';
+export interface TaskInfo {
+    task: string;
+    options: NormalizedExecutorOptions;
+    context: ExecutorContext;
+    assetsHandler: CopyAssetsHandler;
+    buildableProjectNodeDependencies: DependentBuildableProjectNode[];
+    projectGraphNode: ProjectGraphProjectNode;
+}

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/typescript-compilation.d.ts

@@ -0,0 +1,7 @@
+import type { TaskGraph } from '@nx/devkit';
+import type { BatchResults } from 'nx/src/tasks-runner/batch/batch-messages';
+import type { TaskInfo } from './types';
+export declare function compileBatchTypescript(tsConfigTaskInfoMap: Record<string, TaskInfo>, taskGraph: TaskGraph, watch: boolean, postProjectCompilationCallback: (taskInfo: TaskInfo) => void): {
+    iterator: AsyncIterable<BatchResults>;
+    close: () => void | Promise<void>;
+};

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

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileBatchTypescript = void 0;
+const devkit_1 = require("@nx/devkit");
+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 compileBatchTypescript(tsConfigTaskInfoMap, taskGraph, watch, postProjectCompilationCallback) {
+    const timeNow = Date.now();
+    const defaultResults = Object.keys(taskGraph.tasks).reduce((acc, task) => {
+        acc[task] = { success: true, startTime: timeNow, terminalOutput: '' };
+        return acc;
+    }, {});
+    let tearDown;
+    return {
+        iterator: (0, async_iterable_1.createAsyncIterable)(({ next, done }) => {
+            if (watch) {
+                compileTSWithWatch(tsConfigTaskInfoMap, postProjectCompilationCallback);
+                tearDown = () => {
+                    done();
+                };
+            }
+            else {
+                const compilationResults = compileTS(tsConfigTaskInfoMap, postProjectCompilationCallback);
+                next(Object.assign(Object.assign({}, defaultResults), compilationResults));
+                done();
+            }
+        }),
+        close: () => tearDown === null || tearDown === void 0 ? void 0 : tearDown(),
+    };
+}
+exports.compileBatchTypescript = compileBatchTypescript;
+function compileTSWithWatch(tsConfigTaskInfoMap, postProjectCompilationCallback) {
+    const formatDiagnosticsHost = {
+        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+        getNewLine: () => ts.sys.newLine,
+        getCanonicalFileName: (filename) => ts.sys.useCaseSensitiveFileNames ? filename : filename.toLowerCase(),
+    };
+    const solutionHost = ts.createSolutionBuilderWithWatchHost(ts.sys, 
+    /*createProgram*/ undefined, (diagnostic) => {
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatDiagnosticReport)(diagnostic, formatDiagnosticsHost);
+        devkit_1.logger.info(formattedDiagnostic);
+    }, (diagnostic) => {
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatSolutionBuilderStatusReport)(diagnostic);
+        devkit_1.logger.info(formattedDiagnostic);
+    }, (diagnostic, newLine) => {
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatWatchStatusReport)(diagnostic, newLine);
+        devkit_1.logger.info(formattedDiagnostic);
+        if (diagnostic.code ===
+            TYPESCRIPT_FILE_CHANGE_DETECTED_STARTING_INCREMENTAL_COMPILATION) {
+            // there's a change, build invalidated projects
+            build();
+        }
+    });
+    const rootNames = Object.keys(tsConfigTaskInfoMap);
+    const solutionBuilder = ts.createSolutionBuilderWithWatch(solutionHost, rootNames, {});
+    const build = () => {
+        while (true) {
+            const project = solutionBuilder.getNextInvalidatedProject();
+            if (!project) {
+                break;
+            }
+            const taskInfo = tsConfigTaskInfoMap[project.project];
+            if (project.kind === ts.InvalidatedProjectKind.UpdateOutputFileStamps) {
+                // update output timestamps and mark project as complete
+                project.done();
+                continue;
+            }
+            /**
+             * This only applies when the deprecated `prepend` option is set to `true`.
+             * Skip support.
+             */
+            if (project.kind === ts.InvalidatedProjectKind.UpdateBundle) {
+                devkit_1.logger.warn(`The project ${taskInfo.context.projectName} ` +
+                    `is using the deprecated "prepend" Typescript compiler option. ` +
+                    `This option is not supported by the batch executor and it's ignored.`);
+                continue;
+            }
+            // build and mark project as complete
+            project.done(undefined, undefined, (0, get_custom_transformers_factory_1.getCustomTrasformersFactory)(taskInfo.options.transformers)(project.getProgram()));
+            postProjectCompilationCallback(taskInfo);
+        }
+    };
+    // 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();
+    return solutionHost;
+}
+function compileTS(tsConfigTaskInfoMap, postProjectCompilationCallback) {
+    var _a;
+    const results = {};
+    let terminalOutput;
+    const logInfo = (text) => {
+        devkit_1.logger.info(text);
+        terminalOutput += `${text}\n`;
+    };
+    const logWarn = (text) => {
+        devkit_1.logger.warn(text);
+        terminalOutput += `${text}\n`;
+    };
+    const formatDiagnosticsHost = {
+        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+        getNewLine: () => ts.sys.newLine,
+        getCanonicalFileName: (filename) => ts.sys.useCaseSensitiveFileNames ? filename : filename.toLowerCase(),
+    };
+    const solutionBuilderHost = ts.createSolutionBuilderHost(ts.sys, 
+    /*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) {
+            Object.values(tsConfigTaskInfoMap).forEach((taskInfo) => {
+                var _a, _b;
+                var _c;
+                (_a = results[_c = taskInfo.task]) !== null && _a !== void 0 ? _a : (results[_c] = { success: false, terminalOutput: '' });
+                results[taskInfo.task].success = false;
+                results[taskInfo.task].terminalOutput = `${(_b = results[taskInfo.task]) === null || _b === void 0 ? void 0 : _b.terminalOutput}${formattedDiagnostic}`;
+            });
+        }
+        logInfo(formattedDiagnostic);
+    }, (diagnostic) => {
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatSolutionBuilderStatusReport)(diagnostic);
+        logInfo(formattedDiagnostic);
+    });
+    const rootNames = Object.keys(tsConfigTaskInfoMap);
+    const solutionBuilder = ts.createSolutionBuilder(solutionBuilderHost, rootNames, {});
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const project = solutionBuilder.getNextInvalidatedProject();
+        if (!project) {
+            break;
+        }
+        const startTime = Date.now();
+        terminalOutput = '';
+        const taskInfo = tsConfigTaskInfoMap[project.project];
+        const projectName = (_a = taskInfo === null || taskInfo === void 0 ? void 0 : taskInfo.context) === null || _a === void 0 ? void 0 : _a.projectName;
+        if (project.kind === ts.InvalidatedProjectKind.UpdateOutputFileStamps) {
+            if (projectName) {
+                logInfo(`Updating output timestamps of project "${projectName}"...`);
+            }
+            // update output timestamps and mark project as complete
+            const status = project.done();
+            if (projectName && status === ts.ExitStatus.Success) {
+                logInfo(`Done updating output timestamps of project "${projectName}"...`);
+            }
+            if (taskInfo) {
+                results[taskInfo.task] = {
+                    success: status === ts.ExitStatus.Success,
+                    terminalOutput,
+                    startTime,
+                    endTime: Date.now(),
+                };
+            }
+            continue;
+        }
+        /**
+         * This only applies when the deprecated `prepend` option is set to `true`.
+         * Skip support.
+         */
+        if (project.kind === ts.InvalidatedProjectKind.UpdateBundle) {
+            logWarn(`The project ${taskInfo.context.projectName} ` +
+                `is using the deprecated "prepend" Typescript compiler option. ` +
+                `This option is not supported by the batch executor and it's ignored.`);
+            continue;
+        }
+        logInfo(`Compiling TypeScript files for project "${projectName}"...`);
+        // build and mark project as complete
+        const status = project.done(undefined, undefined, (0, get_custom_transformers_factory_1.getCustomTrasformersFactory)(taskInfo.options.transformers)(project.getProgram()));
+        postProjectCompilationCallback(taskInfo);
+        if (status === ts.ExitStatus.Success) {
+            logInfo(`Done compiling TypeScript files for project "${projectName}".`);
+        }
+        results[taskInfo.task] = {
+            success: status === ts.ExitStatus.Success,
+            terminalOutput,
+            startTime,
+            endTime: Date.now(),
+        };
+    }
+    return results;
+}

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

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

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWatchStatusReport = 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;
+// adapted from TS default watch status reporter
+function formatWatchStatusReport(diagnostic, newLine) {
+    let output = `[${formatColorAndReset(getLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] `;
+    output += `${ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine)}${newLine + newLine}`;
+    return output;
+}
+exports.formatWatchStatusReport = formatWatchStatusReport;
+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/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,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchTaskProjectsFileChangesForAssets = exports.watchTaskProjectsPackageJsonFileChanges = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const client_1 = require("nx/src/daemon/client/client");
+const path_1 = require("path");
+function watchTaskProjectsPackageJsonFileChanges(taskInfos, callback) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        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 = yield client_1.daemonClient.registerFileWatcher({ watchProjects: projects }, (err, data) => {
+            var _a;
+            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: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : '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;
+function watchTaskProjectsFileChangesForAssets(taskInfos) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const unregisterFileWatcher = yield client_1.daemonClient.registerFileWatcher({
+            watchProjects: taskInfos.map((t) => t.context.projectName),
+            includeDependentProjects: true,
+            includeGlobalWorkspaceFiles: true,
+        }, (err, data) => {
+            var _a;
+            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: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : '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/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-custom-transformers-factory';
+export * from './normalize-options';

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

@@ -0,0 +1,5 @@
+"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("./normalize-options"), 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/tsc.batch-impl.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutorContext, TaskGraph } from '@nx/devkit';
+import type { ExecutorOptions } from '../../utils/schema';
+export declare function tscBatchExecutor(taskGraph: TaskGraph, inputs: Record<string, ExecutorOptions>, overrides: ExecutorOptions, context: ExecutorContext): AsyncGenerator<import("../../../../../build/packages/nx/src/tasks-runner/batch/batch-messages").BatchResults, any, undefined>;
+export default tscBatchExecutor;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tscBatchExecutor = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const update_package_json_1 = require("../../utils/package-json/update-package-json");
+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 tsConfigTaskInfoMap = {};
+        (0, batch_1.buildTaskInfoPerTsConfigMap)(tsConfigTaskInfoMap, tasksOptions, context, Object.keys(taskGraph.tasks), shouldWatch);
+        const typescriptCompilation = (0, batch_1.compileBatchTypescript)(tsConfigTaskInfoMap, taskGraph, shouldWatch, (taskInfo) => {
+            taskInfo.assetsHandler.processAllAssetsOnceSync();
+            (0, update_package_json_1.updatePackageJson)(taskInfo.options, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
+        });
+        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* () {
+                yield typescriptCompilation.close();
+                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(typescriptCompilation.iterator))));
+    });
+}
+exports.tscBatchExecutor = tscBatchExecutor;
+exports.default = tscBatchExecutor;

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;

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

@@ -1,51 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tscExecutor = exports.createTypeScriptCompilationOptions = exports.normalizeOptions = void 0;
+exports.tscExecutor = exports.createTypeScriptCompilationOptions = void 0;
 const tslib_1 = require("tslib");
-const assets_1 = require("../../utils/assets/assets");
-const path_1 = require("path");
 const copy_assets_handler_1 = require("../../utils/assets/copy-assets-handler");
 const check_dependencies_1 = require("../../utils/check-dependencies");
 const compiler_helper_dependency_1 = require("../../utils/compiler-helper-dependency");
 const inline_1 = require("../../utils/inline");
 const update_package_json_1 = require("../../utils/package-json/update-package-json");
 const compile_typescript_files_1 = require("../../utils/typescript/compile-typescript-files");
-const load_ts_transformers_1 = require("../../utils/typescript/load-ts-transformers");
 const watch_for_single_file_changes_1 = require("../../utils/watch-for-single-file-changes");
-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)
-        : 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;
+const lib_1 = require("./lib");
 function createTypeScriptCompilationOptions(normalizedOptions, context) {
-    const { compilerPluginHooks } = (0, load_ts_transformers_1.loadTsTransformers)(normalizedOptions.transformers);
-    const getCustomTransformers = (program) => ({
-        before: compilerPluginHooks.beforeHooks.map((hook) => hook(program)),
-        after: compilerPluginHooks.afterHooks.map((hook) => hook(program)),
-        afterDeclarations: compilerPluginHooks.afterDeclarationsHooks.map((hook) => hook(program)),
-    });
     return {
         outputPath: normalizedOptions.outputPath,
         projectName: context.projectName,
@@ -54,14 +19,14 @@ function createTypeScriptCompilationOptions(normalizedOptions, context) {
         tsConfig: normalizedOptions.tsConfig,
         watch: normalizedOptions.watch,
         deleteOutputPath: normalizedOptions.clean,
-        getCustomTransformers,
+        getCustomTransformers: (0, lib_1.getCustomTrasformersFactory)(normalizedOptions.transformers),
     };
 }
 exports.createTypeScriptCompilationOptions = createTypeScriptCompilationOptions;
 function tscExecutor(_options, context) {
     return tslib_1.__asyncGenerator(this, arguments, function* tscExecutor_1() {
         const { sourceRoot, root } = context.projectsConfigurations.projects[context.projectName];
-        const options = normalizeOptions(_options, context.root, sourceRoot, root);
+        const options = (0, lib_1.normalizeOptions)(_options, context.root, sourceRoot, root);
         const { projectRoot, tmpTsConfig, target, dependencies } = (0, check_dependencies_1.checkDependencies)(context, _options.tsConfig);
         if (tmpTsConfig) {
             options.tsConfig = tmpTsConfig;

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

@@ -7,5 +7,6 @@ import { VerdaccioExecutorSchema } from './schema';
  */
 export declare function verdaccioExecutor(options: VerdaccioExecutorSchema, context: ExecutorContext): Promise<{
     success: boolean;
+    port: number;
 }>;
 export default verdaccioExecutor;

package/src/executors/verdaccio/verdaccio.impl.js

@@ -5,6 +5,8 @@ const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const fs_extra_1 = require("fs-extra");
 const child_process_1 = require("child_process");
+const detectPort = require("detect-port");
+const path_1 = require("path");
 let childProcess;
 /**
  * - set npm and yarn to use local registry
@@ -36,16 +38,23 @@ function verdaccioExecutor(options, context) {
         process.on('SIGINT', processExitListener);
         process.on('SIGHUP', processExitListener);
         try {
-            yield startVerdaccio(options);
+            const port = yield detectPort(options.port);
+            if (port === options.port) {
+                devkit_1.logger.info(`Port ${options.port} was occupied. Using port ${port}.`);
+                options.port = port;
+            }
+            yield startVerdaccio(options, context.root);
         }
         catch (e) {
-            devkit_1.logger.error('Failed to start verdaccio: ' + e.toString());
+            devkit_1.logger.error('Failed to start verdaccio: ' + (e === null || e === void 0 ? void 0 : e.toString()));
             return {
                 success: false,
+                port: options.port,
             };
         }
         return {
             success: true,
+            port: options.port,
         };
     });
 }
@@ -53,10 +62,12 @@ exports.verdaccioExecutor = verdaccioExecutor;
 /**
  * Fork the verdaccio process: https://verdaccio.org/docs/verdaccio-programmatically/#using-fork-from-child_process-module
  */
-function startVerdaccio(options) {
+function startVerdaccio(options, workspaceRoot) {
     return new Promise((resolve, reject) => {
-        childProcess = (0, child_process_1.fork)(require.resolve('verdaccio/bin/verdaccio'), createVerdaccioOptions(options), {
-            env: Object.assign(Object.assign({}, process.env), { VERDACCIO_HANDLE_KILL_SIGNALS: 'true' }),
+        childProcess = (0, child_process_1.fork)(require.resolve('verdaccio/bin/verdaccio'), createVerdaccioOptions(options, workspaceRoot), {
+            env: Object.assign(Object.assign(Object.assign({}, process.env), { VERDACCIO_HANDLE_KILL_SIGNALS: 'true' }), (options.storage
+                ? { VERDACCIO_STORAGE_PATH: options.storage }
+                : {})),
             stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
         });
         childProcess.stdout.on('data', (data) => {
@@ -87,13 +98,13 @@ function startVerdaccio(options) {
         });
     });
 }
-function createVerdaccioOptions(options) {
+function createVerdaccioOptions(options, workspaceRoot) {
     const verdaccioArgs = [];
     if (options.port) {
         verdaccioArgs.push('--listen', options.port.toString());
     }
     if (options.config) {
-        verdaccioArgs.push('--config', options.config);
+        verdaccioArgs.push('--config', (0, path_1.join)(workspaceRoot, options.config));
     }
     return verdaccioArgs;
 }

package/src/generators/library/library.js

@@ -47,9 +47,6 @@ function projectGenerator(tree, schema, destinationDir, filesDir) {
             });
             tasks.push(viteTask);
         }
-        if (options.bundler === 'rollup') {
-            ensureBabelRootConfigExists(tree);
-        }
         if (options.linter !== 'none') {
             const lintCallback = yield addLint(tree, options);
             tasks.push(lintCallback);
@@ -384,13 +381,6 @@ function getBuildExecutor(bundler) {
             return undefined;
     }
 }
-function ensureBabelRootConfigExists(tree) {
-    if (tree.exists('babel.config.json'))
-        return;
-    (0, devkit_1.writeJson)(tree, 'babel.config.json', {
-        babelrcRoots: ['*'],
-    });
-}
 function getOutputPath(options, destinationDir) {
     const parts = ['dist'];
     if (destinationDir) {

package/src/index.d.ts

@@ -1,3 +1,4 @@
+export * from './utils/typescript/add-tslib-dependencies';
 export * from './utils/typescript/load-ts-transformers';
 export * from './utils/typescript/print-diagnostics';
 export * from './utils/typescript/run-type-check';

package/src/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPackageJson = exports.getLockFileName = exports.createLockFile = exports.initGenerator = exports.libraryGenerator = void 0;
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./utils/typescript/add-tslib-dependencies"), exports);
 tslib_1.__exportStar(require("./utils/typescript/load-ts-transformers"), exports);
 tslib_1.__exportStar(require("./utils/typescript/print-diagnostics"), exports);
 tslib_1.__exportStar(require("./utils/typescript/run-type-check"), exports);

package/src/utils/add-babel-inputs.d.ts

@@ -1,2 +1,3 @@
 import { Tree } from '@nx/devkit';
+/** @deprecated Do not use this function as the root babel.config.json file is no longer needed */
 export declare function addBabelInputs(tree: Tree): void;

package/src/utils/add-babel-inputs.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addBabelInputs = void 0;
 const devkit_1 = require("@nx/devkit");
+/** @deprecated Do not use this function as the root babel.config.json file is no longer needed */
+// TODO(jack): Remove This in Nx 17 once we don't need to support Nx 15 anymore. Currently this function is used in v15 migrations.
 function addBabelInputs(tree) {
     var _a;
     const nxJson = (0, devkit_1.readNxJson)(tree);

package/src/utils/assets/copy-assets-handler.d.ts

@@ -1,4 +1,5 @@
 import { AssetGlob } from './assets';
+import { ChangedFile } from 'nx/src/daemon/client/client';
 export type FileEventType = 'create' | 'update' | 'delete';
 export interface FileEvent {
     type: FileEventType;
@@ -22,7 +23,10 @@ export declare class CopyAssetsHandler {
     private readonly callback;
     constructor(opts: CopyAssetHandlerOptions);
     processAllAssetsOnce(): Promise<void>;
+    processAllAssetsOnceSync(): void;
     watchAndProcessOnAssetChange(): Promise<() => void>;
-    private processEvents;
+    processWatchEvents(events: ChangedFile[]): Promise<void>;
+    private filesToEvent;
+    private normalizeAssetPattern;
 }
 export {};

package/src/utils/assets/copy-assets-handler.js

@@ -74,35 +74,27 @@ class CopyAssetsHandler {
     processAllAssetsOnce() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             yield Promise.all(this.assetGlobs.map((ag) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                let pattern;
-                if (typeof ag === 'string') {
-                    pattern = ag;
-                }
-                else {
-                    pattern = ag.pattern;
-                }
+                const pattern = this.normalizeAssetPattern(ag);
                 // fast-glob only supports Unix paths
                 const files = yield fg(pattern.replace(/\\/g, '/'), {
                     cwd: this.rootDir,
                     dot: true, // enable hidden files
                 });
-                this.callback(files.reduce((acc, src) => {
-                    var _a;
-                    if (!((_a = ag.ignore) === null || _a === void 0 ? void 0 : _a.some((ig) => minimatch(src, ig))) &&
-                        !this.ignore.ignores(src)) {
-                        const relPath = path.relative(ag.input, src);
-                        const dest = relPath.startsWith('..') ? src : relPath;
-                        acc.push({
-                            type: 'create',
-                            src: path.join(this.rootDir, src),
-                            dest: path.join(this.rootDir, ag.output, dest),
-                        });
-                    }
-                    return acc;
-                }, []));
+                this.callback(this.filesToEvent(files, ag));
             })));
         });
     }
+    processAllAssetsOnceSync() {
+        this.assetGlobs.forEach((ag) => {
+            const pattern = this.normalizeAssetPattern(ag);
+            // fast-glob only supports Unix paths
+            const files = fg.sync(pattern.replace(/\\/g, '/'), {
+                cwd: this.rootDir,
+                dot: true, // enable hidden files
+            });
+            this.callback(this.filesToEvent(files, ag));
+        });
+    }
     watchAndProcessOnAssetChange() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const unregisterFileWatcher = yield client_1.daemonClient.registerFileWatcher({
@@ -118,13 +110,13 @@ class CopyAssetsHandler {
                     devkit_1.logger.error(`Watch error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'Unknown'}`);
                 }
                 else {
-                    this.processEvents(data.changedFiles);
+                    this.processWatchEvents(data.changedFiles);
                 }
             });
             return () => unregisterFileWatcher();
         });
     }
-    processEvents(events) {
+    processWatchEvents(events) {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const fileEvents = [];
@@ -150,5 +142,24 @@ class CopyAssetsHandler {
                 this.callback(fileEvents);
         });
     }
+    filesToEvent(files, assetGlob) {
+        return files.reduce((acc, src) => {
+            var _a;
+            if (!((_a = assetGlob.ignore) === null || _a === void 0 ? void 0 : _a.some((ig) => minimatch(src, ig))) &&
+                !this.ignore.ignores(src)) {
+                const relPath = path.relative(assetGlob.input, src);
+                const dest = relPath.startsWith('..') ? src : relPath;
+                acc.push({
+                    type: 'create',
+                    src: path.join(this.rootDir, src),
+                    dest: path.join(this.rootDir, assetGlob.output, dest),
+                });
+            }
+            return acc;
+        }, []);
+    }
+    normalizeAssetPattern(assetEntry) {
+        return typeof assetEntry === 'string' ? assetEntry : assetEntry.pattern;
+    }
 }
 exports.CopyAssetsHandler = CopyAssetsHandler;

package/src/utils/inline.d.ts

@@ -13,7 +13,7 @@ export interface InlineProjectGraph {
     dependencies: Record<string, string[]>;
 }
 export declare function isInlineGraphEmpty(inlineGraph: InlineProjectGraph): boolean;
-export declare function handleInliningBuild(context: ExecutorContext, options: NormalizedExecutorOptions, tsConfigPath: string): InlineProjectGraph;
+export declare function handleInliningBuild(context: ExecutorContext, options: NormalizedExecutorOptions, tsConfigPath: string, projectName?: string): InlineProjectGraph;
 export declare function postProcessInlinedDependencies(outputPath: string, parentOutputPath: string, inlineGraph: InlineProjectGraph): void;
 export declare function getRootTsConfigPath(context: ExecutorContext): string | null;
 export {};

package/src/utils/inline.js

@@ -9,11 +9,11 @@ function isInlineGraphEmpty(inlineGraph) {
     return Object.keys(inlineGraph.nodes).length === 0;
 }
 exports.isInlineGraphEmpty = isInlineGraphEmpty;
-function handleInliningBuild(context, options, tsConfigPath) {
+function handleInliningBuild(context, options, tsConfigPath, projectName = context.projectName) {
     var _a;
     const tsConfigJson = (0, devkit_1.readJsonFile)(tsConfigPath);
     const pathAliases = ((_a = tsConfigJson['compilerOptions']) === null || _a === void 0 ? void 0 : _a['paths']) || readBasePathAliases(context);
-    const inlineGraph = createInlineGraph(context, options, pathAliases);
+    const inlineGraph = createInlineGraph(context, options, pathAliases, projectName);
     if (isInlineGraphEmpty(inlineGraph)) {
         return inlineGraph;
     }
@@ -81,7 +81,7 @@ function projectNodeToInlineProjectNode(projectNode, pathAlias = '', buildOutput
         buildOutputPath,
     };
 }
-function createInlineGraph(context, options, pathAliases, projectName = context.projectName, inlineGraph = emptyInlineGraph()) {
+function createInlineGraph(context, options, pathAliases, projectName, inlineGraph = emptyInlineGraph()) {
     var _a;
     var _b;
     if (options.external == null)

package/src/utils/schema.d.ts

@@ -50,11 +50,12 @@ export interface ExecutorOptions {
 }
 
 export interface NormalizedExecutorOptions extends ExecutorOptions {
-  root?: string;
-  sourceRoot?: string;
+  rootDir: string;
   projectRoot: string;
   mainOutputPath: string;
   files: Array<FileInputOutput>;
+  root?: string;
+  sourceRoot?: string;
 }
 
 export interface SwcExecutorOptions extends ExecutorOptions {