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

package/babel.js

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

package/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/generators.json

@@ -29,6 +29,12 @@
       "schema": "./src/generators/setup-verdaccio/schema.json",
       "alias": ["verdaccio"],
       "description": "Setup Verdaccio for local package management."
+    },
+    "setup-build": {
+      "factory": "./src/generators/setup-build/generator#setupBuildSchematic",
+      "schema": "./src/generators/setup-build/schema.json",
+      "alias": ["build"],
+      "description": "setup-build generator"
     }
   },
   "generators": {
@@ -59,6 +65,12 @@
       "schema": "./src/generators/setup-verdaccio/schema.json",
       "alias": ["verdaccio"],
       "description": "Setup Verdaccio for local package management."
+    },
+    "setup-build": {
+      "factory": "./src/generators/setup-build/generator",
+      "schema": "./src/generators/setup-build/schema.json",
+      "alias": ["build"],
+      "description": "setup-build generator"
     }
   }
 }

package/migrations.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.4.0-beta.1",
+  "version": "16.4.0-beta.13",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,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.13",
+    "@nx/devkit": "16.4.0-beta.13",
+    "@nx/workspace": "16.4.0-beta.13",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
     "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": "d81afedfcc8d07db8cdb9b0e9286de0321ee184e"
 }

package/plugins/jest/local-registry.d.ts

@@ -0,0 +1 @@
+export * from '../../src/plugins/jest/start-local-registry';

package/plugins/jest/local-registry.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../../src/plugins/jest/start-local-registry"), exports);

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

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

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

@@ -7,10 +7,12 @@ const child_process_1 = require("child_process");
 const devkit_1 = require("@nx/devkit");
 const client_1 = require("nx/src/daemon/client/client");
 const crypto_1 = require("crypto");
+const path = require("path");
 const path_1 = require("path");
 const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 const buildable_libs_utils_1 = require("../../utils/buildable-libs-utils");
 const kill_tree_1 = require("./lib/kill-tree");
+const fileutils_1 = require("nx/src/utils/fileutils");
 function debounce(fn, wait) {
     let timeoutId;
     return () => {
@@ -25,13 +27,25 @@ 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)}`);
         }
+        if (options.waitUntilTargets && options.waitUntilTargets.length > 0) {
+            const results = yield tslib_1.__await(runWaitUntilTargets(options, context));
+            for (const [i, result] of results.entries()) {
+                if (!result.success) {
+                    throw new Error(`Wait until target failed: ${options.waitUntilTargets[i]}.`);
+                }
+            }
+        }
         // Re-map buildable workspace projects to their output directory.
         const mappings = calculateResolveMappings(context, options);
-        const fileToRun = (0, path_1.join)(context.root, buildOptions.outputPath, (_d = buildOptions.outputFileName) !== null && _d !== void 0 ? _d : 'main.js');
+        const outputFileName = (_d = buildOptions.outputFileName) !== null && _d !== void 0 ? _d : `${path.parse(buildOptions.main).name}.js`;
+        const fileToRun = (0, path_1.join)(context.root, buildOptions.outputPath, outputFileName);
         const tasks = [];
         let currentTask = null;
         yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ done, next, error }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -56,9 +70,7 @@ function nodeExecutor(options, context) {
                         let buildFailed = false;
                         // Run the build
                         task.promise = new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                            task.childProcess = (0, child_process_1.exec)(`npx nx run ${context.projectName}:${buildTarget.target}${buildTarget.configuration
-                                ? `:${buildTarget.configuration}`
-                                : ''}`, {
+                            task.childProcess = (0, child_process_1.exec)(`npx nx run ${context.projectName}:${buildTarget.target}${buildTarget.configuration ? `:${buildTarget.configuration}` : ''}`, {
                                 cwd: context.root,
                             }, (error, stdout, stderr) => {
                                 if (
@@ -90,15 +102,16 @@ 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) }),
+                                env: Object.assign(Object.assign({}, process.env), { NX_FILE_TO_RUN: fileToRunCorrectPath(fileToRun), NX_MAPPINGS: JSON.stringify(mappings) }),
                             });
                             task.childProcess.stderr.on('data', (data) => {
                                 // Don't log out error if task is killed and new one has started.
                                 // This could happen if a new build is triggered while new process is starting, since the operation is not atomic.
-                                if (options.watch && !task.killed) {
+                                // Log the error in normal mode
+                                if (!options.watch || !task.killed) {
                                     devkit_1.logger.error(data.toString());
                                 }
                             });
@@ -110,7 +123,7 @@ function nodeExecutor(options, context) {
                                     done();
                                 resolve();
                             });
-                            next({ success: true });
+                            next({ success: true, options: buildOptions });
                         });
                     }),
                     stop: (signal = 'SIGTERM') => tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -171,7 +184,9 @@ function nodeExecutor(options, context) {
 }
 exports.nodeExecutor = nodeExecutor;
 function getExecArgv(options) {
-    const args = ['-r', require.resolve('source-map-support/register')];
+    var _a;
+    const args = ((_a = options.runtimeArgs) !== null && _a !== void 0 ? _a : (options.runtimeArgs = []));
+    args.push('-r', require.resolve('source-map-support/register'));
     if (options.inspect === true) {
         options.inspect = "inspect" /* InspectType.Inspect */;
     }
@@ -190,4 +205,37 @@ function calculateResolveMappings(context, options) {
         return m;
     }, {});
 }
+function runWaitUntilTargets(options, context) {
+    return Promise.all(options.waitUntilTargets.map((waitUntilTarget) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const target = (0, devkit_1.parseTargetString)(waitUntilTarget, context.projectGraph);
+        const output = yield (0, devkit_1.runExecutor)(target, {}, context);
+        return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let event = yield output.next();
+            // Resolve after first event
+            resolve(event.value);
+            // Continue iterating
+            while (!event.done) {
+                event = yield output.next();
+            }
+        }));
+    })));
+}
+function fileToRunCorrectPath(fileToRun) {
+    if (!(0, fileutils_1.fileExists)(fileToRun)) {
+        const cjsFile = fileToRun.replace(/\.js$/, '.cjs');
+        if ((0, fileutils_1.fileExists)(cjsFile)) {
+            fileToRun = cjsFile;
+        }
+        else {
+            const mjsFile = fileToRun.replace(/\.js$/, '.mjs');
+            if ((0, fileutils_1.fileExists)(mjsFile)) {
+                fileToRun = mjsFile;
+            }
+            else {
+                throw new Error(`Could not find ${fileToRun}. Make sure your build succeeded.`);
+            }
+        }
+    }
+    return fileToRun;
+}
 exports.default = nodeExecutor;

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

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

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskInfoPerTsConfigMap = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const copy_assets_handler_1 = require("../../../../utils/assets/copy-assets-handler");
+const buildable_libs_utils_1 = require("../../../../utils/buildable-libs-utils");
+const get_task_options_1 = require("../get-task-options");
+const taskTsConfigCache = new Set();
+function createTaskInfoPerTsConfigMap(tasksOptions, context, tasks, taskInMemoryTsConfigMap) {
+    const tsConfigTaskInfoMap = {};
+    processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOptions, context, tasks, taskInMemoryTsConfigMap);
+    return tsConfigTaskInfoMap;
+}
+exports.createTaskInfoPerTsConfigMap = createTaskInfoPerTsConfigMap;
+function processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOptions, context, tasks, taskInMemoryTsConfigMap) {
+    var _a;
+    for (const taskName of tasks) {
+        if (taskTsConfigCache.has(taskName)) {
+            continue;
+        }
+        const tsConfig = taskInMemoryTsConfigMap[taskName];
+        if (!tsConfig) {
+            continue;
+        }
+        let taskOptions = (_a = tasksOptions[taskName]) !== null && _a !== void 0 ? _a : (0, get_task_options_1.getTaskWithTscExecutorOptions)(taskName, context);
+        if (taskOptions) {
+            const taskInfo = createTaskInfo(taskName, taskOptions, context, tsConfig);
+            const tsConfigPath = (0, path_1.join)(context.root, (0, path_1.relative)(context.root, taskOptions.tsConfig));
+            tsConfigTaskInfoMap[tsConfigPath] = taskInfo;
+            taskTsConfigCache.add(taskName);
+        }
+        processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOptions, context, context.taskGraph.dependencies[taskName], taskInMemoryTsConfigMap);
+    }
+}
+function createTaskInfo(taskName, taskOptions, context, tsConfig) {
+    const target = (0, devkit_1.parseTargetString)(taskName, context.projectGraph);
+    const taskContext = Object.assign(Object.assign({}, context), { 
+        // batch executors don't get these in the context, we provide them
+        // 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,
+        tsConfig,
+        terminalOutput: '',
+    };
+}

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

@@ -0,0 +1,4 @@
+export * from './build-task-info-per-tsconfig-map';
+export * from './normalize-tasks-options';
+export * from './types';
+export * from './watch';

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

@@ -0,0 +1,7 @@
+"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("./normalize-tasks-options"), exports);
+tslib_1.__exportStar(require("./types"), 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,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,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/get-task-options.d.ts

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

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

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

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

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