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

package/src/executors/release-publish/release-publish.impl.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const npm_run_path_1 = require("npm-run-path");
+const log_tar_1 = require("./log-tar");
+const chalk = require("chalk");
+const LARGE_BUFFER = 1024 * 1000000;
+function processEnv(color) {
+    const env = {
+        ...process.env,
+        ...(0, npm_run_path_1.env)(),
+    };
+    if (color) {
+        env.FORCE_COLOR = `${color}`;
+    }
+    return env;
+}
+async function runExecutor(options, context) {
+    /**
+     * We need to check both the env var and the option because the executor may have been triggered
+     * indirectly via dependsOn, in which case the env var will be set, but the option will not.
+     */
+    const isDryRun = process.env.NX_DRY_RUN === 'true' || options.dryRun || false;
+    const projectConfig = context.projectsConfigurations.projects[context.projectName];
+    const packageRoot = (0, devkit_1.joinPathFragments)(context.root, options.packageRoot ?? projectConfig.root);
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
+    const projectPackageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    const packageName = projectPackageJson.name;
+    // If package and project name match, we can make log messages terser
+    let packageTxt = packageName === context.projectName
+        ? `package "${packageName}"`
+        : `package "${packageName}" from project "${context.projectName}"`;
+    if (projectPackageJson.private === true) {
+        console.warn(`Skipped ${packageTxt}, because it has \`"private": true\` in ${packageJsonPath}`);
+        return {
+            success: true,
+        };
+    }
+    const npmPublishCommandSegments = [`npm publish --json`];
+    const npmViewCommandSegments = [
+        `npm view ${packageName} versions dist-tags --json`,
+    ];
+    if (options.registry) {
+        npmPublishCommandSegments.push(`--registry=${options.registry}`);
+        npmViewCommandSegments.push(`--registry=${options.registry}`);
+    }
+    if (options.tag) {
+        npmPublishCommandSegments.push(`--tag=${options.tag}`);
+    }
+    if (options.otp) {
+        npmPublishCommandSegments.push(`--otp=${options.otp}`);
+    }
+    if (isDryRun) {
+        npmPublishCommandSegments.push(`--dry-run`);
+    }
+    // Resolve values using the `npm config` command so that things like environment variables and `publishConfig`s are accounted for
+    const registry = options.registry ?? (0, child_process_1.execSync)(`npm config get registry`).toString().trim();
+    const tag = options.tag ?? (0, child_process_1.execSync)(`npm config get tag`).toString().trim();
+    /**
+     * In a dry-run scenario, it is most likely that all commands are being run with dry-run, therefore
+     * the most up to date/relevant version might not exist on disk for us to read and make the npm view
+     * request with.
+     *
+     * Therefore, so as to not produce misleading output in dry around dist-tags being altered, we do not
+     * perform the npm view step, and just show npm publish's dry-run output.
+     */
+    if (!isDryRun && !options.firstRelease) {
+        const currentVersion = projectPackageJson.version;
+        try {
+            const result = (0, child_process_1.execSync)(npmViewCommandSegments.join(' '), {
+                env: processEnv(true),
+                cwd: packageRoot,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const resultJson = JSON.parse(result.toString());
+            const distTags = resultJson['dist-tags'] || {};
+            if (distTags[tag] === currentVersion) {
+                console.warn(`Skipped ${packageTxt} because v${currentVersion} already exists in ${registry} with tag "${tag}"`);
+                return {
+                    success: true,
+                };
+            }
+            if (resultJson.versions.includes(currentVersion)) {
+                try {
+                    if (!isDryRun) {
+                        (0, child_process_1.execSync)(`npm dist-tag add ${packageName}@${currentVersion} ${tag} --registry=${registry}`, {
+                            env: processEnv(true),
+                            cwd: packageRoot,
+                            stdio: 'ignore',
+                        });
+                        console.log(`Added the dist-tag ${tag} to v${currentVersion} for registry ${registry}.\n`);
+                    }
+                    else {
+                        console.log(`Would add the dist-tag ${tag} to v${currentVersion} for registry ${registry}, but ${chalk.keyword('orange')('[dry-run]')} was set.\n`);
+                    }
+                    return {
+                        success: true,
+                    };
+                }
+                catch (err) {
+                    try {
+                        const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+                        // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
+                        if (!(stdoutData.error?.code?.includes('E404') &&
+                            stdoutData.error?.summary?.includes('no such package available')) &&
+                            !(err.stderr?.toString().includes('E404') &&
+                                err.stderr?.toString().includes('no such package available'))) {
+                            console.error('npm dist-tag add error:');
+                            if (stdoutData.error.summary) {
+                                console.error(stdoutData.error.summary);
+                            }
+                            if (stdoutData.error.detail) {
+                                console.error(stdoutData.error.detail);
+                            }
+                            if (context.isVerbose) {
+                                console.error('npm dist-tag add stdout:');
+                                console.error(JSON.stringify(stdoutData, null, 2));
+                            }
+                            return {
+                                success: false,
+                            };
+                        }
+                    }
+                    catch (err) {
+                        console.error('Something unexpected went wrong when processing the npm dist-tag add output\n', err);
+                        return {
+                            success: false,
+                        };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+            // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
+            if (!(stdoutData.error?.code?.includes('E404') &&
+                stdoutData.error?.summary?.toLowerCase().includes('not found')) &&
+                !(err.stderr?.toString().includes('E404') &&
+                    err.stderr?.toString().toLowerCase().includes('not found'))) {
+                console.error(`Something unexpected went wrong when checking for existing dist-tags.\n`, err);
+                return {
+                    success: false,
+                };
+            }
+        }
+    }
+    if (options.firstRelease && context.isVerbose) {
+        console.log('Skipped npm view because --first-release was set');
+    }
+    try {
+        const output = (0, child_process_1.execSync)(npmPublishCommandSegments.join(' '), {
+            maxBuffer: LARGE_BUFFER,
+            env: processEnv(true),
+            cwd: packageRoot,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutData = JSON.parse(output.toString());
+        // If npm workspaces are in use, the publish output will nest the data under the package name, so we normalize it first
+        const normalizedStdoutData = stdoutData[packageName] ?? stdoutData;
+        (0, log_tar_1.logTar)(normalizedStdoutData);
+        if (isDryRun) {
+            console.log(`Would publish to ${registry} with tag "${tag}", but ${chalk.keyword('orange')('[dry-run]')} was set`);
+        }
+        else {
+            console.log(`Published to ${registry} with tag "${tag}"`);
+        }
+        return {
+            success: true,
+        };
+    }
+    catch (err) {
+        try {
+            const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+            console.error('npm publish error:');
+            if (stdoutData.error.summary) {
+                console.error(stdoutData.error.summary);
+            }
+            if (stdoutData.error.detail) {
+                console.error(stdoutData.error.detail);
+            }
+            if (context.isVerbose) {
+                console.error('npm publish stdout:');
+                console.error(JSON.stringify(stdoutData, null, 2));
+            }
+            return {
+                success: false,
+            };
+        }
+        catch (err) {
+            console.error('Something unexpected went wrong when processing the npm publish output\n', err);
+            return {
+                success: false,
+            };
+        }
+    }
+}
+exports.default = runExecutor;

package/src/executors/release-publish/schema.d.ts

@@ -0,0 +1,8 @@
+export interface PublishExecutorSchema {
+  packageRoot?: string;
+  registry?: string;
+  tag?: string;
+  otp?: number;
+  dryRun?: boolean;
+  firstRelease?: boolean;
+}

package/src/executors/release-publish/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Implementation details of `nx release publish`",
+  "description": "DO NOT INVOKE DIRECTLY WITH `nx run`. Use `nx release publish` instead.",
+  "type": "object",
+  "properties": {
+    "packageRoot": {
+      "type": "string",
+      "description": "The root directory of the directory (containing a manifest file at its root) to publish. Defaults to the project root."
+    },
+    "registry": {
+      "type": "string",
+      "description": "The registry to publish the package to."
+    },
+    "tag": {
+      "type": "string",
+      "description": "The distribution tag to apply to the published package."
+    },
+    "dryRun": {
+      "type": "boolean",
+      "description": "Whether to run the command without actually publishing the package to the registry."
+    }
+  },
+  "required": []
+}

package/src/executors/swc/schema.json

@@ -0,0 +1,154 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "title": "Typescript Build Target",
+  "description": "Builds using SWC.",
+  "type": "object",
+  "properties": {
+    "main": {
+      "type": "string",
+      "description": "The name of the main entry-point file.",
+      "x-completion-type": "file",
+      "x-completion-glob": "main@(.js|.ts|.tsx)",
+      "x-priority": "important"
+    },
+    "generateExportsField": {
+      "type": "boolean",
+      "alias": "exports",
+      "description": "Update the output package.json file's 'exports' field. This field is used by Node and bundles.",
+      "x-priority": "important",
+      "default": false
+    },
+    "additionalEntryPoints": {
+      "type": "array",
+      "description": "Additional entry-points to add to exports field in the package.json file.",
+      "items": {
+        "type": "string"
+      },
+      "x-priority": "important"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "The output path of the generated files.",
+      "x-completion-type": "directory",
+      "x-priority": "important"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The path to the Typescript configuration file.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig.*.json",
+      "x-priority": "important"
+    },
+    "swcrc": {
+      "type": "string",
+      "description": "The path to the SWC configuration file. Default: .swcrc",
+      "x-completion-type": "file",
+      "x-completion-glob": ".swcrc"
+    },
+    "assets": {
+      "type": "array",
+      "description": "List of static assets.",
+      "default": [],
+      "items": {
+        "$ref": "#/definitions/assetPattern"
+      }
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Enable re-building when files change.",
+      "default": false
+    },
+    "clean": {
+      "type": "boolean",
+      "description": "Remove previous output before build.",
+      "default": true
+    },
+    "skipTypeCheck": {
+      "type": "boolean",
+      "description": "Whether to skip TypeScript type checking.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "swcExclude": {
+      "type": "array",
+      "description": "List of SWC Glob/Regex to be excluded from compilation (https://swc.rs/docs/configuration/compilation#exclude).",
+      "default": [
+        "./src/**/.*.spec.ts$",
+        "./**/.*.spec.ts$",
+        "./src/**/jest-setup.ts$",
+        "./**/jest-setup.ts$",
+        "./**/.*.js$"
+      ],
+      "hidden": true
+    },
+    "external": {
+      "description": "A list projects to be treated as external. This feature is experimental",
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["all", "none"]
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
+    },
+    "externalBuildTargets": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of target names that annotate a build target for a project",
+      "default": ["build"]
+    },
+    "generateLockfile": {
+      "type": "boolean",
+      "description": "Generate a lockfile (e.g. package-lock.json) that matches the workspace lockfile to ensure package versions match.",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["main", "outputPath", "tsConfig"],
+  "definitions": {
+    "assetPattern": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "glob": {
+              "type": "string",
+              "description": "The pattern to match."
+            },
+            "input": {
+              "type": "string",
+              "description": "The input directory path in which to apply 'glob'. Defaults to the project root."
+            },
+            "ignore": {
+              "description": "An array of globs to ignore.",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "output": {
+              "type": "string",
+              "description": "Absolute path within the output."
+            }
+          },
+          "additionalProperties": false,
+          "required": ["glob", "input", "output"]
+        },
+        {
+          "type": "string"
+        }
+      ]
+    }
+  },
+  "examplesFile": "../../../docs/swc-examples.md"
+}

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

@@ -0,0 +1,10 @@
+import { ExecutorContext } from '@nx/devkit';
+import { SwcExecutorOptions } from '../../utils/schema';
+export declare function swcExecutor(_options: SwcExecutorOptions, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    outfile?: undefined;
+} | {
+    success: boolean;
+    outfile: string;
+}, any, undefined>;
+export default swcExecutor;

package/src/executors/swc/swc.impl.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swcExecutor = void 0;
+const devkit_1 = require("@nx/devkit");
+const assets_1 = require("../../utils/assets/assets");
+const fs_extra_1 = require("fs-extra");
+const fast_glob_1 = require("fast-glob");
+const path_1 = require("path");
+const assets_2 = require("../../utils/assets");
+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 package_json_1 = require("../../utils/package-json");
+const compile_swc_1 = require("../../utils/swc/compile-swc");
+const get_swcrc_path_1 = require("../../utils/swc/get-swcrc-path");
+const inline_2 = require("../../utils/swc/inline");
+function normalizeOptions(options, root, sourceRoot, projectRoot) {
+    const outputPath = (0, path_1.join)(root, options.outputPath);
+    if (options.skipTypeCheck == null) {
+        options.skipTypeCheck = false;
+    }
+    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, root, outputPath);
+    const projectRootParts = projectRoot.split('/');
+    // We pop the last part of the `projectRoot` to pass
+    // the last part (projectDir) and the remainder (projectRootParts) to swc
+    const projectDir = projectRootParts.pop();
+    // default to current directory if projectRootParts is [].
+    // Eg: when a project is at the root level, outside of layout dir
+    const swcCwd = projectRootParts.join('/') || '.';
+    const { swcrcPath, tmpSwcrcPath } = (0, get_swcrc_path_1.getSwcrcPath)(options, root, projectRoot);
+    const swcCliOptions = {
+        srcPath: projectDir,
+        destPath: (0, path_1.relative)((0, path_1.join)(root, swcCwd), outputPath),
+        swcCwd,
+        swcrcPath,
+    };
+    return {
+        ...options,
+        mainOutputPath: (0, path_1.resolve)(outputPath, options.main.replace(`${projectRoot}/`, '').replace('.ts', '.js')),
+        files,
+        root,
+        sourceRoot,
+        projectRoot,
+        originalProjectRoot: projectRoot,
+        outputPath,
+        tsConfig: (0, path_1.join)(root, options.tsConfig),
+        swcCliOptions,
+        tmpSwcrcPath,
+    };
+}
+async function* swcExecutor(_options, context) {
+    const { sourceRoot, root } = context.projectsConfigurations.projects[context.projectName];
+    const options = normalizeOptions(_options, context.root, sourceRoot, root);
+    const { tmpTsConfig, dependencies } = (0, check_dependencies_1.checkDependencies)(context, options.tsConfig);
+    if (tmpTsConfig) {
+        options.tsConfig = tmpTsConfig;
+    }
+    const swcHelperDependency = (0, compiler_helper_dependency_1.getHelperDependency)(compiler_helper_dependency_1.HelperDependency.swc, options.swcCliOptions.swcrcPath, dependencies, context.projectGraph);
+    if (swcHelperDependency) {
+        dependencies.push(swcHelperDependency);
+    }
+    const inlineProjectGraph = (0, inline_1.handleInliningBuild)(context, options, options.tsConfig);
+    if (!(0, inline_1.isInlineGraphEmpty)(inlineProjectGraph)) {
+        options.projectRoot = '.'; // set to root of workspace to include other libs for type check
+        // remap paths for SWC compilation
+        options.swcCliOptions.srcPath = options.swcCliOptions.swcCwd;
+        options.swcCliOptions.swcCwd = '.';
+        options.swcCliOptions.destPath = (0, path_1.join)(options.swcCliOptions.destPath.split((0, path_1.normalize)('../')).at(-1), options.swcCliOptions.srcPath);
+        // tmp swcrc with dependencies to exclude
+        // - buildable libraries
+        // - other libraries that are not dependent on the current project
+        options.swcCliOptions.swcrcPath = (0, inline_2.generateTmpSwcrc)(inlineProjectGraph, options.swcCliOptions.swcrcPath, options.tmpSwcrcPath);
+    }
+    function determineModuleFormatFromSwcrc(absolutePathToSwcrc) {
+        const swcrc = (0, devkit_1.readJsonFile)(absolutePathToSwcrc);
+        return swcrc.module?.type?.startsWith('es') ? 'esm' : 'cjs';
+    }
+    if (options.watch) {
+        let disposeFn;
+        process.on('SIGINT', () => disposeFn());
+        process.on('SIGTERM', () => disposeFn());
+        return yield* (0, compile_swc_1.compileSwcWatch)(context, options, async () => {
+            const assetResult = await (0, assets_2.copyAssets)(options, context);
+            const packageJsonResult = await (0, package_json_1.copyPackageJson)({
+                ...options,
+                additionalEntryPoints: createEntryPoints(options, context),
+                format: [
+                    determineModuleFormatFromSwcrc(options.swcCliOptions.swcrcPath),
+                ],
+                // As long as d.ts files match their .js counterparts, we don't need to emit them.
+                // TSC can match them correctly based on file names.
+                skipTypings: true,
+            }, context);
+            removeTmpSwcrc(options.swcCliOptions.swcrcPath);
+            disposeFn = () => {
+                assetResult?.stop();
+                packageJsonResult?.stop();
+            };
+        });
+    }
+    else {
+        return yield (0, compile_swc_1.compileSwc)(context, options, async () => {
+            await (0, assets_2.copyAssets)(options, context);
+            await (0, package_json_1.copyPackageJson)({
+                ...options,
+                additionalEntryPoints: createEntryPoints(options, context),
+                format: [
+                    determineModuleFormatFromSwcrc(options.swcCliOptions.swcrcPath),
+                ],
+                // As long as d.ts files match their .js counterparts, we don't need to emit them.
+                // TSC can match them correctly based on file names.
+                skipTypings: true,
+                extraDependencies: swcHelperDependency ? [swcHelperDependency] : [],
+            }, context);
+            removeTmpSwcrc(options.swcCliOptions.swcrcPath);
+            (0, inline_1.postProcessInlinedDependencies)(options.outputPath, options.originalProjectRoot, inlineProjectGraph);
+        });
+    }
+}
+exports.swcExecutor = swcExecutor;
+function removeTmpSwcrc(swcrcPath) {
+    if (swcrcPath.includes((0, path_1.normalize)('tmp/')) &&
+        swcrcPath.includes('.generated.swcrc')) {
+        (0, fs_extra_1.removeSync)((0, path_1.dirname)(swcrcPath));
+    }
+}
+function createEntryPoints(options, context) {
+    if (!options.additionalEntryPoints?.length)
+        return [];
+    return (0, fast_glob_1.sync)(options.additionalEntryPoints, {
+        cwd: context.root,
+    });
+}
+exports.default = swcExecutor;

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,62 @@
+"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) {
+    for (const taskName of tasks) {
+        if (taskTsConfigCache.has(taskName)) {
+            continue;
+        }
+        const tsConfig = taskInMemoryTsConfigMap[taskName];
+        if (!tsConfig) {
+            continue;
+        }
+        let taskOptions = tasksOptions[taskName] ?? (0, get_task_options_1.getTaskOptions)(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)).replace(/\\/g, '/');
+            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);
+    const taskContext = {
+        ...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.calculateProjectBuildableDependencies)(context.taskGraph, 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);
+        const { sourceRoot, root } = context.projectsConfigurations.projects[project];
+        tasksOptions[taskName] = (0, normalize_options_1.normalizeOptions)(options, context.root, sourceRoot, root);
+        return tasksOptions;
+    }, {});
+}
+exports.normalizeTasksOptions = normalizeTasksOptions;