@nx/js 20.0.8 → 20.1.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "20.0.8",
+  "version": "20.1.0-beta.0",
   "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,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "20.0.8",
-    "@nx/workspace": "20.0.8",
+    "@nx/devkit": "20.1.0-beta.0",
+    "@nx/workspace": "20.1.0-beta.0",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",

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

@@ -29,8 +29,7 @@ async function* nodeExecutor(options, context) {
         throw new Error(`Cannot find build target ${chalk.bold(options.buildTarget)} for project ${chalk.bold(context.projectName)}`);
     }
     const buildTargetExecutor = project.data.targets[buildTarget.target]?.executor;
-    if (buildTargetExecutor === 'nx:run-commands' ||
-        buildTargetExecutor === '@nrwl/workspace:run-commands') {
+    if (buildTargetExecutor === 'nx:run-commands') {
         // Run commands does not emit build event, so we have to switch to run entire build through Nx CLI.
         options.runBuildTargetDependencies = true;
     }

package/src/executors/swc/schema.json

@@ -113,13 +113,13 @@
       "description": "Generate a lockfile (e.g. package-lock.json) that matches the workspace lockfile to ensure package versions match.",
       "default": false,
       "x-priority": "internal"
+    },
+    "stripLeadingPaths": {
+      "type": "boolean",
+      "description": "Remove leading directory from output (e.g. src). See: https://swc.rs/docs/usage/cli#--strip-leading-paths",
+      "default": false
     }
   },
-  "stripLeadingPaths": {
-    "type": "boolean",
-    "description": "Remove leading directory from output (e.g. src). See: https://swc.rs/docs/usage/cli#--strip-leading-paths",
-    "default": false
-  },
   "required": ["main", "outputPath", "tsConfig"],
   "definitions": {
     "assetPattern": {

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

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.swcExecutor = swcExecutor;
 const devkit_1 = require("@nx/devkit");
-const assets_1 = require("../../utils/assets/assets");
 const fast_glob_1 = require("fast-glob");
 const node_fs_1 = require("node:fs");
 const path_1 = require("path");
-const assets_2 = require("../../utils/assets");
+const assets_1 = require("../../utils/assets");
+const assets_2 = require("../../utils/assets/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");
@@ -14,7 +14,20 @@ 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");
+const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 function normalizeOptions(options, root, sourceRoot, projectRoot) {
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+    if (isTsSolutionSetup) {
+        if (options.generateLockfile) {
+            throw new Error(`Setting 'generateLockfile: true' is not supported with the current TypeScript setup. Unset the 'generateLockfile' option and try again.`);
+        }
+        if (options.generateExportsField) {
+            throw new Error(`Setting 'generateExportsField: true' is not supported with the current TypeScript setup. Set 'exports' field in the 'package.json' file at the project root and unset the 'generateExportsField' option.`);
+        }
+        if (options.additionalEntryPoints?.length) {
+            throw new Error(`Setting 'additionalEntryPoints' is not supported with the current TypeScript setup. Set additional entry points in the 'package.json' file at the project root and unset the 'additionalEntryPoints' option.`);
+        }
+    }
     const outputPath = (0, path_1.join)(root, options.outputPath);
     if (options.skipTypeCheck == null) {
         options.skipTypeCheck = false;
@@ -34,7 +47,7 @@ function normalizeOptions(options, root, sourceRoot, projectRoot) {
             options.external = firstItem;
         }
     }
-    const files = (0, assets_1.assetGlobsToFiles)(options.assets, root, outputPath);
+    const files = (0, assets_2.assetGlobsToFiles)(options.assets, root, outputPath);
     // Always execute from root of project, same as with SWC CLI.
     const swcCwd = (0, path_1.join)(root, projectRoot);
     const { swcrcPath, tmpSwcrcPath } = (0, get_swcrc_path_1.getSwcrcPath)(options, root, projectRoot);
@@ -57,34 +70,39 @@ function normalizeOptions(options, root, sourceRoot, projectRoot) {
         tsConfig: (0, path_1.join)(root, options.tsConfig),
         swcCliOptions,
         tmpSwcrcPath,
+        isTsSolutionSetup: isTsSolutionSetup,
     };
 }
 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)) {
-        if (options.stripLeadingPaths) {
-            throw new Error(`Cannot use --strip-leading-paths with inlining.`);
+    let swcHelperDependency;
+    let inlineProjectGraph;
+    if (!options.isTsSolutionSetup) {
+        const { tmpTsConfig, dependencies } = (0, check_dependencies_1.checkDependencies)(context, options.tsConfig);
+        if (tmpTsConfig) {
+            options.tsConfig = tmpTsConfig;
+        }
+        swcHelperDependency = (0, compiler_helper_dependency_1.getHelperDependency)(compiler_helper_dependency_1.HelperDependency.swc, options.swcCliOptions.swcrcPath, dependencies, context.projectGraph);
+        if (swcHelperDependency) {
+            dependencies.push(swcHelperDependency);
+        }
+        inlineProjectGraph = (0, inline_1.handleInliningBuild)(context, options, options.tsConfig);
+        if (!(0, inline_1.isInlineGraphEmpty)(inlineProjectGraph)) {
+            if (options.stripLeadingPaths) {
+                throw new Error(`Cannot use --strip-leading-paths with inlining.`);
+            }
+            options.projectRoot = '.'; // set to root of workspace to include other libs for type check
+            // remap paths for SWC compilation
+            options.inline = true;
+            options.swcCliOptions.swcCwd = '.';
+            options.swcCliOptions.srcPath = 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);
         }
-        options.projectRoot = '.'; // set to root of workspace to include other libs for type check
-        // remap paths for SWC compilation
-        options.inline = true;
-        options.swcCliOptions.swcCwd = '.';
-        options.swcCliOptions.srcPath = 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);
@@ -95,14 +113,17 @@ async function* swcExecutor(_options, context) {
         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),
-                ],
-            }, context);
+            const assetResult = await (0, assets_1.copyAssets)(options, context);
+            let packageJsonResult;
+            if (!options.isTsSolutionSetup) {
+                packageJsonResult = await (0, package_json_1.copyPackageJson)({
+                    ...options,
+                    additionalEntryPoints: createEntryPoints(options, context),
+                    format: [
+                        determineModuleFormatFromSwcrc(options.swcCliOptions.swcrcPath),
+                    ],
+                }, context);
+            }
             removeTmpSwcrc(options.swcCliOptions.swcrcPath);
             disposeFn = () => {
                 assetResult?.stop();
@@ -112,17 +133,19 @@ async function* swcExecutor(_options, context) {
     }
     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),
-                ],
-                extraDependencies: swcHelperDependency ? [swcHelperDependency] : [],
-            }, context);
+            await (0, assets_1.copyAssets)(options, context);
+            if (!options.isTsSolutionSetup) {
+                await (0, package_json_1.copyPackageJson)({
+                    ...options,
+                    additionalEntryPoints: createEntryPoints(options, context),
+                    format: [
+                        determineModuleFormatFromSwcrc(options.swcCliOptions.swcrcPath),
+                    ],
+                    extraDependencies: swcHelperDependency ? [swcHelperDependency] : [],
+                }, context);
+                (0, inline_1.postProcessInlinedDependencies)(options.outputPath, options.originalProjectRoot, inlineProjectGraph);
+            }
             removeTmpSwcrc(options.swcCliOptions.swcrcPath);
-            (0, inline_1.postProcessInlinedDependencies)(options.outputPath, options.originalProjectRoot, inlineProjectGraph);
         });
     }
 }

package/src/generators/convert-to-swc/convert-to-swc.js

@@ -9,8 +9,8 @@ const versions_1 = require("../../utils/versions");
 async function convertToSwcGenerator(tree, schema) {
     const options = normalizeOptions(schema);
     const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    updateProjectBuildTargets(tree, projectConfiguration, options.project, options.targets);
-    return checkSwcDependencies(tree, projectConfiguration);
+    const updated = updateProjectBuildTargets(tree, projectConfiguration, options.project, options.targets);
+    return updated ? checkSwcDependencies(tree, projectConfiguration) : () => { };
 }
 function normalizeOptions(schema) {
     const options = { ...schema };
@@ -20,15 +20,18 @@ function normalizeOptions(schema) {
     return options;
 }
 function updateProjectBuildTargets(tree, projectConfiguration, projectName, projectTargets) {
+    let updated = false;
     for (const target of projectTargets) {
-        const targetConfiguration = projectConfiguration.targets[target];
-        if (!targetConfiguration ||
-            (targetConfiguration.executor !== '@nx/js:tsc' &&
-                targetConfiguration.executor !== '@nrwl/js:tsc'))
+        const targetConfiguration = projectConfiguration.targets?.[target];
+        if (!targetConfiguration || targetConfiguration.executor !== '@nx/js:tsc')
             continue;
         targetConfiguration.executor = '@nx/js:swc';
+        updated = true;
     }
-    (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+    if (updated) {
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+    }
+    return updated;
 }
 function checkSwcDependencies(tree, projectConfiguration) {
     const isSwcrcPresent = tree.exists((0, path_1.join)(projectConfiguration.root, '.swcrc'));

package/src/generators/library/library.js

@@ -5,11 +5,10 @@ exports.libraryGeneratorInternal = libraryGeneratorInternal;
 exports.addLint = addLint;
 const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const prompt_1 = require("@nx/devkit/src/generators/prompt");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
-const enquirer_1 = require("enquirer");
 const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
-const is_ci_1 = require("nx/src/utils/is-ci");
 const path_1 = require("path");
 const package_manager_workspaces_1 = require("../../utils/package-manager-workspaces");
 const add_swc_config_1 = require("../../utils/swc/add-swc-config");
@@ -21,8 +20,7 @@ const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
 const generator_1 = require("../setup-verdaccio/generator");
-const package_manager_workspaces_2 = require("./utils/package-manager-workspaces");
-const plugin_registrations_1 = require("./utils/plugin-registrations");
+const plugin_1 = require("../../utils/typescript/plugin");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
@@ -134,7 +132,7 @@ async function libraryGeneratorInternal(tree, schema) {
     }
     if (options.isUsingTsSolutionConfig &&
         options.projectPackageManagerWorkspaceState !== 'included') {
-        tasks.push((0, package_manager_workspaces_2.getProjectPackageManagerWorkspaceStateWarningTask)(options.projectPackageManagerWorkspaceState, tree.root));
+        tasks.push((0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceStateWarningTask)(options.projectPackageManagerWorkspaceState, tree.root));
     }
     if (options.publishable) {
         tasks.push(() => {
@@ -150,32 +148,13 @@ async function configureProject(tree, options) {
     if (options.hasPlugin) {
         const nxJson = (0, devkit_1.readNxJson)(tree);
         if (options.bundler === 'none') {
-            (0, plugin_registrations_1.ensureProjectIsExcludedFromPluginRegistrations)(nxJson, options.projectRoot);
+            (0, plugin_1.ensureProjectIsExcludedFromPluginRegistrations)(nxJson, options.projectRoot);
         }
         else {
-            (0, plugin_registrations_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot);
+            (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot);
         }
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
-    if (!options.useProjectJson) {
-        // we create a cleaner project configuration for the package.json file
-        const projectConfiguration = {
-            root: options.projectRoot,
-        };
-        if (options.name !== options.importPath) {
-            // if the name is different than the package.json name, we need to set
-            // the proper name in the configuration
-            projectConfiguration.name = options.name;
-        }
-        if (options.parsedTags?.length) {
-            projectConfiguration.tags = options.parsedTags;
-        }
-        if (options.publishable) {
-            await addProjectToNxReleaseConfig(tree, options, projectConfiguration);
-        }
-        (0, devkit_1.updateProjectConfiguration)(tree, options.name, projectConfiguration);
-        return;
-    }
     const projectConfiguration = {
         root: options.projectRoot,
         sourceRoot: (0, devkit_1.joinPathFragments)(options.projectRoot, 'src'),
@@ -183,36 +162,46 @@ async function configureProject(tree, options) {
         targets: {},
         tags: options.parsedTags,
     };
-    if (options.bundler &&
-        options.bundler !== 'none' &&
-        options.config !== 'npm-scripts') {
-        if (options.bundler !== 'rollup') {
-            const outputPath = getOutputPath(options);
-            const executor = getBuildExecutor(options.bundler);
-            (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, executor);
-            projectConfiguration.targets.build = {
-                executor,
-                outputs: ['{options.outputPath}'],
-                options: {
-                    outputPath,
-                    main: `${options.projectRoot}/src/index` + (options.js ? '.js' : '.ts'),
-                    tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
-                    assets: [],
-                },
-            };
+    if (options.config !== 'npm-scripts' &&
+        (options.bundler === 'swc' ||
+            options.bundler === 'esbuild' ||
+            (!options.isUsingTsSolutionConfig && options.bundler === 'tsc'))) {
+        const outputPath = getOutputPath(options);
+        const executor = getBuildExecutor(options.bundler);
+        (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, executor);
+        projectConfiguration.targets.build = {
+            executor,
+            outputs: ['{options.outputPath}'],
+            options: {
+                outputPath,
+                main: `${options.projectRoot}/src/index` + (options.js ? '.js' : '.ts'),
+                tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
+            },
+        };
+        if (options.bundler === 'esbuild') {
+            projectConfiguration.targets.build.options.format = ['cjs'];
+        }
+        if (options.bundler === 'swc' && options.skipTypeCheck) {
+            projectConfiguration.targets.build.options.skipTypeCheck = true;
+        }
+        if (options.isUsingTsSolutionConfig) {
             if (options.bundler === 'esbuild') {
-                projectConfiguration.targets.build.options.generatePackageJson = true;
-                projectConfiguration.targets.build.options.format = ['cjs'];
+                projectConfiguration.targets.build.options.declarationRootDir = `${options.projectRoot}/src`;
             }
-            if (options.bundler === 'swc' && options.skipTypeCheck) {
-                projectConfiguration.targets.build.options.skipTypeCheck = true;
+        }
+        else {
+            projectConfiguration.targets.build.options.assets = [];
+            if (options.bundler === 'esbuild') {
+                projectConfiguration.targets.build.options.generatePackageJson = true;
             }
             if (!options.minimal) {
                 projectConfiguration.targets.build.options.assets ??= [];
                 projectConfiguration.targets.build.options.assets.push((0, devkit_1.joinPathFragments)(options.projectRoot, '*.md'));
             }
         }
-        if (options.publishable) {
+    }
+    if (options.publishable) {
+        if (!options.isUsingTsSolutionConfig) {
             const packageRoot = (0, devkit_1.joinPathFragments)(defaultOutputDirectory, '{projectRoot}');
             projectConfiguration.targets ??= {};
             projectConfiguration.targets['nx-release-publish'] = {
@@ -230,10 +219,20 @@ async function configureProject(tree, options) {
                     },
                 },
             };
-            await addProjectToNxReleaseConfig(tree, options, projectConfiguration);
         }
+        await addProjectToNxReleaseConfig(tree, options, projectConfiguration);
+    }
+    if (!options.useProjectJson) {
+        // we want the package.json as clean as possible, with the bare minimum
+        if (!projectConfiguration.tags?.length) {
+            delete projectConfiguration.tags;
+        }
+        // automatically inferred as `library`
+        delete projectConfiguration.projectType;
+        // empty targets are cleaned up automatically by `updateProjectConfiguration`
+        (0, devkit_1.updateProjectConfiguration)(tree, options.name, projectConfiguration);
     }
-    if (options.config === 'workspace' || options.config === 'project') {
+    else if (options.config === 'workspace' || options.config === 'project') {
         (0, devkit_1.addProjectConfiguration)(tree, options.name, projectConfiguration);
     }
     else {
@@ -470,15 +469,6 @@ function replaceJestConfig(tree, options) {
         testEnvironment: options.testEnvironment,
     });
 }
-function isNonInteractive() {
-    return ((0, is_ci_1.isCI)() || !process.stdout.isTTY || process.env.NX_INTERACTIVE !== 'true');
-}
-async function promptWhenInteractive(questions, defaultValue) {
-    if (isNonInteractive()) {
-        return defaultValue;
-    }
-    return await (0, enquirer_1.prompt)(questions);
-}
 async function normalizeOptions(tree, options) {
     await (0, project_name_and_root_utils_1.ensureProjectName)(tree, options, 'library');
     const nxJson = (0, devkit_1.readNxJson)(tree);
@@ -488,31 +478,14 @@ async function normalizeOptions(tree, options) {
     const hasPlugin = (0, ts_solution_setup_1.isUsingTypeScriptPlugin)(tree);
     const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
     if (isUsingTsSolutionConfig) {
-        if (options.bundler === 'esbuild' || options.bundler === 'swc') {
-            throw new Error(`Cannot use the "${options.bundler}" bundler when using the @nx/js/typescript plugin.`);
-        }
-        if (options.bundler === undefined && options.compiler === undefined) {
-            options.bundler = await promptWhenInteractive({
-                type: 'select',
-                name: 'bundler',
-                message: `Which bundler would you like to use to build the library? Choose 'none' to skip build setup.`,
-                choices: [
-                    { name: 'tsc' },
-                    { name: 'rollup' },
-                    { name: 'vite' },
-                    { name: 'none' },
-                ],
-                initial: 0,
-            }, { bundler: 'tsc' }).then(({ bundler }) => bundler);
-        }
-        options.linter ??= await promptWhenInteractive({
+        options.linter ??= await (0, prompt_1.promptWhenInteractive)({
             type: 'select',
             name: 'linter',
             message: `Which linter would you like to use?`,
             choices: [{ name: 'none' }, { name: 'eslint' }],
             initial: 0,
         }, { linter: 'none' }).then(({ linter }) => linter);
-        options.unitTestRunner ??= await promptWhenInteractive({
+        options.unitTestRunner ??= await (0, prompt_1.promptWhenInteractive)({
             type: 'select',
             name: 'unitTestRunner',
             message: `Which unit test runner would you like to use?`,
@@ -521,54 +494,14 @@ async function normalizeOptions(tree, options) {
         }, { unitTestRunner: 'none' }).then(({ unitTestRunner }) => unitTestRunner);
     }
     else {
-        if (options.bundler === undefined && options.compiler === undefined) {
-            options.bundler = await promptWhenInteractive({
-                type: 'select',
-                name: 'bundler',
-                message: `Which bundler would you like to use to build the library? Choose 'none' to skip build setup.`,
-                choices: [
-                    { name: 'swc' },
-                    { name: 'tsc' },
-                    { name: 'rollup' },
-                    { name: 'vite' },
-                    { name: 'esbuild' },
-                    { name: 'none' },
-                ],
-                initial: 1,
-            }, { bundler: 'tsc' }).then(({ bundler }) => bundler);
-        }
-        else {
-            /**
-             * We are deprecating the compiler and the buildable options.
-             * However, we want to keep the existing behavior for now.
-             *
-             * So, if the user has not provided a bundler, we will use the compiler option, if any.
-             *
-             * If the user has not provided a bundler and no compiler, but has set buildable to true,
-             * we will use tsc, since that is the compiler the old generator used to default to, if buildable was true
-             * and no compiler was provided.
-             *
-             * If the user has not provided a bundler and no compiler, and has not set buildable to true, then
-             * set the bundler to tsc, to preserve old default behaviour (buildable: true by default).
-             *
-             * If it's publishable, we need to build the code before publishing it, so again
-             * we default to `tsc`. In the previous version of this, it would set `buildable` to true
-             * and that would default to `tsc`.
-             *
-             * In the past, the only way to get a non-buildable library was to set buildable to false.
-             * Now, the only way to get a non-buildble library is to set bundler to none.
-             * By default, with nothing provided, libraries are buildable with `@nx/js:tsc`.
-             */
-            options.bundler ??= options.compiler;
-        }
-        options.linter ??= await promptWhenInteractive({
+        options.linter ??= await (0, prompt_1.promptWhenInteractive)({
             type: 'select',
             name: 'linter',
             message: `Which linter would you like to use?`,
             choices: [{ name: 'eslint' }, { name: 'none' }],
             initial: 0,
         }, { linter: 'eslint' }).then(({ linter }) => linter);
-        options.unitTestRunner ??= await promptWhenInteractive({
+        options.unitTestRunner ??= await (0, prompt_1.promptWhenInteractive)({
             type: 'select',
             name: 'unitTestRunner',
             message: `Which unit test runner would you like to use?`,
@@ -582,6 +515,28 @@ async function normalizeOptions(tree, options) {
             options.unitTestRunner = 'jest';
         }
     }
+    /**
+     * We are deprecating the compiler and the buildable options.
+     * However, we want to keep the existing behavior for now.
+     *
+     * So, if the user has not provided a bundler, we will use the compiler option, if any.
+     *
+     * If the user has not provided a bundler and no compiler, but has set buildable to true,
+     * we will use tsc, since that is the compiler the old generator used to default to, if buildable was true
+     * and no compiler was provided.
+     *
+     * If the user has not provided a bundler and no compiler, and has not set buildable to true, then
+     * set the bundler to tsc, to preserve old default behaviour (buildable: true by default).
+     *
+     * If it's publishable, we need to build the code before publishing it, so again
+     * we default to `tsc`. In the previous version of this, it would set `buildable` to true
+     * and that would default to `tsc`.
+     *
+     * In the past, the only way to get a non-buildable library was to set buildable to false.
+     * Now, the only way to get a non-buildble library is to set bundler to none.
+     * By default, with nothing provided, libraries are buildable with `@nx/js:tsc`.
+     */
+    options.bundler ??= options.compiler ?? 'tsc';
     // ensure programmatic runs have an expected default
     if (!options.config) {
         options.config = 'project';
@@ -685,6 +640,10 @@ function getBuildExecutor(bundler) {
     }
 }
 function getOutputPath(options) {
+    if (options.isUsingTsSolutionConfig) {
+        // Executors expect paths relative to workspace root, so we prepend the project root
+        return (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist');
+    }
     const parts = [defaultOutputDirectory];
     if (options.projectRoot === '.') {
         parts.push(options.name);
@@ -824,8 +783,12 @@ function determineEntryFields(options) {
         case 'swc':
             return {
                 type: 'commonjs',
-                main: './src/index.js',
-                typings: './src/index.d.ts',
+                main: options.isUsingTsSolutionConfig
+                    ? './dist/src/index.js'
+                    : './src/index.js',
+                typings: options.isUsingTsSolutionConfig
+                    ? './dist/src/index.d.ts'
+                    : './src/index.d.ts',
             };
         case 'rollup':
             return {
@@ -856,8 +819,12 @@ function determineEntryFields(options) {
             // For libraries intended for Node, use CJS.
             return {
                 type: 'commonjs',
-                main: './index.cjs',
-                // typings is missing for esbuild currently
+                main: options.isUsingTsSolutionConfig
+                    ? './dist/index.cjs'
+                    : './index.cjs',
+                typings: options.isUsingTsSolutionConfig
+                    ? './dist/index.d.ts'
+                    : './index.d.ts',
             };
         default: {
             return {

package/src/generators/library/schema.json

@@ -24,6 +24,8 @@
       "description": "The bundler to use. Choosing 'none' means this library is not buildable.",
       "type": "string",
       "enum": ["swc", "tsc", "rollup", "vite", "esbuild", "none"],
+      "default": "tsc",
+      "x-prompt": "Which bundler would you like to use to build the library? Choose 'none' to skip build setup.",
       "x-priority": "important"
     },
     "linter": {

package/src/generators/setup-build/generator.js

@@ -2,15 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupBuildGenerator = setupBuildGenerator;
 const devkit_1 = require("@nx/devkit");
+const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
+const posix_1 = require("node:path/posix");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const plugin_1 = require("../..//utils/typescript/plugin");
+const get_import_path_1 = require("../../utils/get-import-path");
+const update_package_json_1 = require("../../utils/package-json/update-package-json");
 const add_swc_config_1 = require("../../utils/swc/add-swc-config");
 const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
+const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
+const ts_config_1 = require("../../utils/typescript/ts-config");
+const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
-const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
+let ts;
 async function setupBuildGenerator(tree, options) {
     const tasks = [];
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const buildTarget = options.buildTarget ?? 'build';
-    const prevBuildOptions = project.targets?.[buildTarget]?.options;
+    options.buildTarget ??= 'build';
+    const prevBuildOptions = project.targets?.[options.buildTarget]?.options;
     project.targets ??= {};
     let mainFile;
     if (prevBuildOptions?.main) {
@@ -36,6 +45,7 @@ async function setupBuildGenerator(tree, options) {
     if (!mainFile || !tree.exists(mainFile)) {
         throw new Error(`Cannot locate a main file for ${options.project}. Please specify one using --main=<file-path>.`);
     }
+    options.main = mainFile;
     let tsConfigFile;
     if (prevBuildOptions?.tsConfig) {
         tsConfigFile = prevBuildOptions.tsConfig;
@@ -59,16 +69,22 @@ async function setupBuildGenerator(tree, options) {
     if (!tsConfigFile || !tree.exists(tsConfigFile)) {
         throw new Error(`Cannot locate a tsConfig file for ${options.project}. Please specify one using --tsConfig=<file-path>.`);
     }
+    options.tsConfig = tsConfigFile;
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
     switch (options.bundler) {
         case 'vite': {
             const { viteConfigurationGenerator } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
             const task = await viteConfigurationGenerator(tree, {
                 buildTarget: options.buildTarget,
                 project: options.project,
-                newProject: true,
+                newProject: false,
                 uiFramework: 'none',
                 includeVitest: false,
                 includeLib: true,
+                addPlugin,
                 skipFormat: true,
             });
             tasks.push(task);
@@ -82,6 +98,7 @@ async function setupBuildGenerator(tree, options) {
                 project: options.project,
                 skipFormat: true,
                 skipValidation: true,
+                format: ['cjs'],
             });
             tasks.push(task);
             break;
@@ -95,6 +112,7 @@ async function setupBuildGenerator(tree, options) {
                 project: options.project,
                 compiler: 'tsc',
                 format: ['cjs', 'esm'],
+                addPlugin,
                 skipFormat: true,
                 skipValidation: true,
             });
@@ -102,40 +120,133 @@ async function setupBuildGenerator(tree, options) {
             break;
         }
         case 'tsc': {
-            (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, '@nx/js:tsc');
-            const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
-            project.targets[buildTarget] = {
-                executor: `@nx/js:tsc`,
-                outputs: ['{options.outputPath}'],
-                options: {
-                    outputPath,
-                    main: mainFile,
-                    tsConfig: tsConfigFile,
-                    assets: [],
-                },
-            };
-            (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+            if (isTsSolutionSetup) {
+                const nxJson = (0, devkit_1.readNxJson)(tree);
+                (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, project.root, options.buildTarget);
+                (0, devkit_1.updateNxJson)(tree, nxJson);
+                updatePackageJsonForTsc(tree, options, project);
+            }
+            else {
+                (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, '@nx/js:tsc');
+                const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
+                project.targets[options.buildTarget] = {
+                    executor: `@nx/js:tsc`,
+                    outputs: ['{options.outputPath}'],
+                    options: {
+                        outputPath,
+                        main: mainFile,
+                        tsConfig: tsConfigFile,
+                        assets: [],
+                    },
+                };
+                (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+            }
             break;
         }
         case 'swc': {
             (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, '@nx/js:swc');
-            const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
-            project.targets[buildTarget] = {
+            const outputPath = isTsSolutionSetup
+                ? (0, devkit_1.joinPathFragments)(project.root, 'dist')
+                : (0, devkit_1.joinPathFragments)('dist', project.root);
+            project.targets[options.buildTarget] = {
                 executor: `@nx/js:swc`,
                 outputs: ['{options.outputPath}'],
                 options: {
                     outputPath,
                     main: mainFile,
                     tsConfig: tsConfigFile,
-                    assets: [],
                 },
             };
+            if (isTsSolutionSetup) {
+                project.targets[options.buildTarget].options.stripLeadingPaths = true;
+            }
+            else {
+                project.targets[options.buildTarget].options.assets = [];
+            }
             (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
-            (0, add_swc_dependencies_1.addSwcDependencies)(tree);
-            (0, add_swc_config_1.addSwcConfig)(tree, project.root, 'es6');
+            tasks.push((0, add_swc_dependencies_1.addSwcDependencies)(tree));
+            (0, add_swc_config_1.addSwcConfig)(tree, project.root, 'commonjs');
+            if (isTsSolutionSetup) {
+                updatePackageJsonForSwc(tree, options, project);
+            }
         }
     }
     await (0, devkit_1.formatFiles)(tree);
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.default = setupBuildGenerator;
+function updatePackageJsonForTsc(tree, options, project) {
+    if (!ts) {
+        ts = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const tsconfig = (0, ts_config_1.readTsConfig)(options.tsConfig, {
+        ...ts.sys,
+        readFile: (p) => tree.read(p, 'utf-8'),
+        fileExists: (p) => tree.exists(p),
+    });
+    let main;
+    let rootDir;
+    let outputPath;
+    if (project.targets?.[options.buildTarget]) {
+        const mergedTarget = mergeTargetDefaults(tree, project, options.buildTarget);
+        ({ main, rootDir, outputPath } = mergedTarget.options);
+    }
+    else {
+        main = options.main;
+        ({ rootDir = project.root, outDir: outputPath } = tsconfig.options);
+        const tsOutFile = tsconfig.options.outFile;
+        if (tsOutFile) {
+            main = (0, posix_1.join)(project.root, (0, posix_1.basename)(tsOutFile));
+            outputPath = (0, posix_1.dirname)(tsOutFile);
+        }
+        if (!outputPath) {
+            outputPath = project.root;
+        }
+    }
+    const module = Object.keys(ts.ModuleKind).find((m) => ts.ModuleKind[m] === tsconfig.options.module);
+    const format = module.toLowerCase().startsWith('es')
+        ? ['esm']
+        : ['cjs'];
+    updatePackageJson(tree, options.project, project.root, main, outputPath, rootDir, format);
+}
+function updatePackageJsonForSwc(tree, options, project) {
+    const mergedTarget = mergeTargetDefaults(tree, project, options.buildTarget);
+    const { main, outputPath, swcrc: swcrcPath = (0, posix_1.join)(project.root, '.swcrc'), } = mergedTarget.options;
+    const swcrc = (0, devkit_1.readJson)(tree, swcrcPath);
+    const format = swcrc.module?.type?.startsWith('es')
+        ? ['esm']
+        : ['cjs'];
+    updatePackageJson(tree, options.project, project.root, main, outputPath, 
+    // we set the `stripLeadingPaths` option, so the rootDir would match the dirname of the entry point
+    (0, posix_1.dirname)(main), format);
+}
+function updatePackageJson(tree, projectName, projectRoot, main, outputPath, rootDir, format) {
+    const packageJsonPath = (0, posix_1.join)(projectRoot, 'package.json');
+    let packageJson;
+    if (tree.exists(packageJsonPath)) {
+        packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    }
+    else {
+        packageJson = {
+            name: (0, get_import_path_1.getImportPath)(tree, projectName),
+            version: '0.0.1',
+        };
+    }
+    packageJson = (0, update_package_json_1.getUpdatedPackageJsonContent)(packageJson, {
+        main,
+        outputPath,
+        projectRoot,
+        generateExportsField: true,
+        packageJsonPath,
+        rootDir,
+        format,
+    });
+    (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
+}
+function mergeTargetDefaults(tree, project, buildTarget) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const projectTarget = project.targets[buildTarget];
+    return (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (projectTarget.executor
+        ? nxJson.targetDefaults?.[projectTarget.executor]
+        : undefined) ?? nxJson.targetDefaults?.[buildTarget]);
+}

package/src/utils/package-json/update-package-json.d.ts

@@ -18,14 +18,16 @@ export interface UpdatePackageJsonOption {
     updateBuildableProjectDepsInPackageJson?: boolean;
     buildableProjectDepsInPackageJsonType?: 'dependencies' | 'peerDependencies';
     generateLockfile?: boolean;
+    packageJsonPath?: string;
 }
 export declare function updatePackageJson(options: UpdatePackageJsonOption, context: ExecutorContext, target: ProjectGraphProjectNode, dependencies: DependentBuildableProjectNode[], fileMap?: ProjectFileMap): void;
 interface Exports {
     '.': string;
     [name: string]: string;
 }
-export declare function getExports(options: Pick<UpdatePackageJsonOption, 'main' | 'rootDir' | 'projectRoot' | 'outputFileName' | 'additionalEntryPoints'> & {
+export declare function getExports(options: Pick<UpdatePackageJsonOption, 'main' | 'rootDir' | 'projectRoot' | 'outputFileName' | 'additionalEntryPoints' | 'outputPath' | 'packageJsonPath'> & {
     fileExt: string;
 }): Exports;
 export declare function getUpdatedPackageJsonContent(packageJson: PackageJson, options: UpdatePackageJsonOption): PackageJson;
+export declare function getOutputDir(options: Pick<UpdatePackageJsonOption, 'main' | 'rootDir' | 'projectRoot' | 'outputFileName' | 'outputPath' | 'packageJsonPath'>): string;
 export {};

package/src/utils/package-json/update-package-json.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updatePackageJson = updatePackageJson;
 exports.getExports = getExports;
 exports.getUpdatedPackageJsonContent = getUpdatedPackageJsonContent;
+exports.getOutputDir = getOutputDir;
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
@@ -111,14 +112,12 @@ function addMissingDependencies(packageJson, { projectName, targetName, configur
     });
 }
 function getExports(options) {
+    const outputDir = getOutputDir(options);
     const mainFile = options.outputFileName
         ? options.outputFileName.replace(/\.[tj]s$/, '')
         : (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
-    const relativeMainFileDir = options.outputFileName
-        ? './'
-        : (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(options.main, options.rootDir ?? options.projectRoot);
     const exports = {
-        '.': relativeMainFileDir + mainFile + options.fileExt,
+        '.': outputDir + mainFile + options.fileExt,
     };
     if (options.additionalEntryPoints) {
         const jsRegex = /\.[jt]sx?$/;
@@ -148,6 +147,21 @@ function getUpdatedPackageJsonContent(packageJson, options) {
             typeof packageJson.exports === 'string' ? {} : { ...packageJson.exports };
         packageJson.exports['./package.json'] ??= './package.json';
     }
+    if (!options.skipTypings) {
+        const mainFile = (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
+        const outputDir = getOutputDir(options);
+        const typingsFile = `${outputDir}${mainFile}.d.ts`;
+        packageJson.types ??= typingsFile;
+        if (options.generateExportsField) {
+            if (!packageJson.exports['.']) {
+                packageJson.exports['.'] = { types: typingsFile };
+            }
+            else if (typeof packageJson.exports['.'] === 'object' &&
+                !packageJson.exports['.'].types) {
+                packageJson.exports['.'].types = typingsFile;
+            }
+        }
+    }
     if (hasEsmFormat) {
         const esmExports = getExports({
             ...options,
@@ -160,9 +174,14 @@ function getUpdatedPackageJsonContent(packageJson, options) {
         }
         if (options.generateExportsField) {
             for (const [exportEntry, filePath] of Object.entries(esmExports)) {
-                packageJson.exports[exportEntry] ??= hasCjsFormat
-                    ? { import: filePath }
-                    : filePath;
+                if (!packageJson.exports[exportEntry]) {
+                    packageJson.exports[exportEntry] ??= hasCjsFormat
+                        ? { import: filePath }
+                        : filePath;
+                }
+                else if (typeof packageJson.exports[exportEntry] === 'object') {
+                    packageJson.exports[exportEntry].import ??= filePath;
+                }
             }
         }
     }
@@ -180,20 +199,27 @@ function getUpdatedPackageJsonContent(packageJson, options) {
         }
         if (options.generateExportsField) {
             for (const [exportEntry, filePath] of Object.entries(cjsExports)) {
-                if (hasEsmFormat) {
-                    packageJson.exports[exportEntry]['default'] ??= filePath;
+                if (!packageJson.exports[exportEntry]) {
+                    packageJson.exports[exportEntry] ??= hasEsmFormat
+                        ? { default: filePath }
+                        : filePath;
                 }
-                else {
-                    packageJson.exports[exportEntry] ??= filePath;
+                else if (typeof packageJson.exports[exportEntry] === 'object') {
+                    packageJson.exports[exportEntry].default ??= filePath;
                 }
             }
         }
     }
-    if (!options.skipTypings) {
-        const mainFile = (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
-        const relativeMainFileDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(options.main, options.projectRoot);
-        const typingsFile = `${relativeMainFileDir}${mainFile}.d.ts`;
-        packageJson.types ??= typingsFile;
-    }
     return packageJson;
 }
+function getOutputDir(options) {
+    const packageJsonDir = options.packageJsonPath
+        ? (0, path_1.dirname)(options.packageJsonPath)
+        : options.outputPath;
+    const relativeOutputPath = (0, path_1.relative)(packageJsonDir, options.outputPath);
+    const relativeMainDir = options.outputFileName
+        ? ''
+        : (0, path_1.relative)(options.rootDir ?? options.projectRoot, (0, path_1.dirname)(options.main));
+    const outputDir = (0, path_1.join)(relativeOutputPath, relativeMainDir);
+    return outputDir === '.' ? `./` : `./${outputDir}/`;
+}

package/src/utils/package-manager-workspaces.d.ts

@@ -1,4 +1,5 @@
-import { type Tree } from '@nx/devkit';
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
 export type ProjectPackageManagerWorkspaceState = 'included' | 'excluded' | 'no-workspaces';
 export declare function getProjectPackageManagerWorkspaceState(tree: Tree, projectRoot: string): ProjectPackageManagerWorkspaceState;
 export declare function isUsingPackageManagerWorkspaces(tree: Tree): boolean;
+export declare function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState, workspaceRoot: string): GeneratorCallback;

package/src/utils/package-manager-workspaces.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectPackageManagerWorkspaceState = getProjectPackageManagerWorkspaceState;
 exports.isUsingPackageManagerWorkspaces = isUsingPackageManagerWorkspaces;
+exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageManagerWorkspaceStateWarningTask;
 const devkit_1 = require("@nx/devkit");
 const minimatch_1 = require("minimatch");
 const posix_1 = require("node:path/posix");
 const package_json_1 = require("nx/src/plugins/package-json");
+const semver_1 = require("semver");
 function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     if (!isUsingPackageManagerWorkspaces(tree)) {
         return 'no-workspaces';
@@ -17,3 +19,45 @@ function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
 function isUsingPackageManagerWorkspaces(tree) {
     return (0, devkit_1.isWorkspacesEnabled)((0, devkit_1.detectPackageManager)(tree.root), tree.root);
 }
+function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState, workspaceRoot) {
+    return () => {
+        if (projectPackageManagerWorkspaceState !== 'excluded') {
+            return;
+        }
+        const packageManager = (0, devkit_1.detectPackageManager)(workspaceRoot);
+        let adviseMessage = 'updating the "workspaces" option in the workspace root "package.json" file with the project root or pattern that includes it';
+        let packageManagerWorkspaceSetupDocs;
+        if (packageManager === 'pnpm') {
+            adviseMessage =
+                'updating the "pnpm-workspace.yaml" file with the project root or pattern that includes it';
+            packageManagerWorkspaceSetupDocs =
+                'https://pnpm.io/workspaces and https://pnpm.io/pnpm-workspace_yaml';
+        }
+        else if (packageManager === 'yarn') {
+            const yarnVersion = (0, devkit_1.getPackageManagerVersion)(packageManager, workspaceRoot);
+            if ((0, semver_1.lt)(yarnVersion, '2.0.0')) {
+                packageManagerWorkspaceSetupDocs =
+                    'https://classic.yarnpkg.com/lang/en/docs/workspaces/';
+            }
+            else {
+                packageManagerWorkspaceSetupDocs =
+                    'https://yarnpkg.com/features/workspaces';
+            }
+        }
+        else if (packageManager === 'npm') {
+            packageManagerWorkspaceSetupDocs =
+                'https://docs.npmjs.com/cli/v10/using-npm/workspaces';
+        }
+        else if (packageManager === 'bun') {
+            packageManagerWorkspaceSetupDocs =
+                'https://bun.sh/docs/install/workspaces';
+        }
+        devkit_1.output.warn({
+            title: `The project is not included in the package manager workspaces configuration`,
+            bodyLines: [
+                `Please add the project to the package manager workspaces configuration by ${adviseMessage}.`,
+                `Read more about the ${packageManager} workspaces feature and how to set it up at ${packageManagerWorkspaceSetupDocs}.`,
+            ],
+        });
+    };
+}

package/src/utils/schema.d.ts

@@ -53,6 +53,7 @@ export interface NormalizedSwcExecutorOptions
   skipTypeCheck: boolean;
   swcCliOptions: SwcCliOptions;
   tmpSwcrcPath: string;
+  isTsSolutionSetup: boolean;
   sourceRoot?: string;
   // TODO(v21): remove inline feature
   inline?: boolean;

package/src/{generators/library/utils/plugin-registrations.d.ts → utils/typescript/plugin.d.ts}

@@ -1,3 +1,3 @@
 import type { NxJsonConfiguration } from '@nx/devkit';
-export declare function ensureProjectIsIncludedInPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string): void;
+export declare function ensureProjectIsIncludedInPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string, buildTargetName?: string): void;
 export declare function ensureProjectIsExcludedFromPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string): void;

package/src/{generators/library/utils/plugin-registrations.js → utils/typescript/plugin.js}

@@ -3,11 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureProjectIsIncludedInPluginRegistrations = ensureProjectIsIncludedInPluginRegistrations;
 exports.ensureProjectIsExcludedFromPluginRegistrations = ensureProjectIsExcludedFromPluginRegistrations;
 const devkit_internals_1 = require("nx/src/devkit-internals");
-function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot) {
-    if (!nxJson.plugins?.length ||
-        !nxJson.plugins.some(isTypeScriptPluginRegistration)) {
-        return;
-    }
+function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, buildTargetName = 'build') {
+    nxJson.plugins ??= [];
     let isIncluded = false;
     let index = 0;
     for (const registration of nxJson.plugins) {
@@ -17,7 +14,7 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot) {
         }
         if (typeof registration === 'string') {
             // if it's a string all projects are included but the are no user-specified options
-            // and the `build` task is not inferred by default, so we need to exclude it
+            // and the build task is not inferred by default, so we need to exclude it
             nxJson.plugins[index] = {
                 plugin: '@nx/js/typescript',
                 exclude: [`${projectRoot}/*`],
@@ -28,42 +25,54 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot) {
             const matchingConfigFiles = (0, devkit_internals_1.findMatchingConfigFiles)([`${projectRoot}/tsconfig.json`], '**/tsconfig.json', registration.include, registration.exclude);
             if (matchingConfigFiles.length) {
                 // it's included by the plugin registration, check if the user-specified options would result
-                // in a `build` task being inferred, if not, we need to exclude it
-                if (registration.options?.typecheck && registration.options?.build) {
-                    // it has the desired options, do nothing
+                // in the appropriate build task being inferred, if not, we need to exclude it
+                if (registration.options?.typecheck !== false &&
+                    matchesBuildTarget(registration.options?.build, buildTargetName)) {
+                    // it has the desired options, do nothing, but continue processing
+                    // other registrations to exclude as needed
                     isIncluded = true;
                 }
                 else {
-                    // it would not have the `build` task inferred, so we need to exclude it
+                    // it would not have the typecheck or build task inferred, so we need to exclude it
                     registration.exclude ??= [];
                     registration.exclude.push(`${projectRoot}/*`);
                 }
             }
-            else if (registration.options?.typecheck &&
-                registration.options?.build &&
-                !registration.exclude?.length) {
-                // negative pattern are not supported by the `exclude` option so we
-                // can't update it to not exclude the project, so we only update the
-                // plugin registration if there's no `exclude` option, in which case
-                // the plugin registration should have an `include` options that doesn't
-                // include the project
-                isIncluded = true;
-                registration.include ??= [];
-                registration.include.push(`${projectRoot}/*`);
+            else if (!isIncluded &&
+                registration.options?.typecheck !== false &&
+                matchesBuildTarget(registration.options?.build, buildTargetName)) {
+                if (!registration.exclude?.length) {
+                    // negative pattern are not supported by the `exclude` option so we
+                    // can't update it to not exclude the project, so we only update the
+                    // plugin registration if there's no `exclude` option, in which case
+                    // the plugin registration should have an `include` options that doesn't
+                    // include the project
+                    isIncluded = true;
+                    registration.include ??= [];
+                    registration.include.push(`${projectRoot}/*`);
+                }
+                else if (registration.exclude?.includes(`${projectRoot}/*`)) {
+                    isIncluded = true;
+                    registration.exclude = registration.exclude.filter((e) => e !== `${projectRoot}/*`);
+                    if (!registration.exclude.length) {
+                        // if there's no `exclude` option left, we can remove the exclude option
+                        delete registration.exclude;
+                    }
+                }
             }
         }
         index++;
     }
     if (!isIncluded) {
-        // the project is not included by any plugin registration with an inferred `build` task,
-        // so we create a new plugin registration for it
+        // the project is not included by any plugin registration with an inferred build task
+        // with the given name, so we create a new plugin registration for it
         nxJson.plugins.push({
             plugin: '@nx/js/typescript',
             include: [`${projectRoot}/*`],
             options: {
                 typecheck: { targetName: 'typecheck' },
                 build: {
-                    targetName: 'build',
+                    targetName: buildTargetName,
                     configName: 'tsconfig.lib.json',
                 },
             },
@@ -106,3 +115,13 @@ function isTypeScriptPluginRegistration(plugin) {
     return ((typeof plugin === 'string' && plugin === '@nx/js/typescript') ||
         (typeof plugin !== 'string' && plugin.plugin === '@nx/js/typescript'));
 }
+function matchesBuildTarget(buildOptions, buildTargetName) {
+    if (buildOptions === undefined || buildOptions === false) {
+        return false;
+    }
+    if (buildOptions === true && buildTargetName === 'build') {
+        return true;
+    }
+    return (typeof buildOptions === 'object' &&
+        buildOptions.targetName === buildTargetName);
+}

package/src/utils/typescript/ts-config.d.ts

@@ -1,6 +1,6 @@
 import { Tree } from '@nx/devkit';
-import * as ts from 'typescript';
-export declare function readTsConfig(tsConfigPath: string): ts.ParsedCommandLine;
+import type * as ts from 'typescript';
+export declare function readTsConfig(tsConfigPath: string, sys?: ts.System): ts.ParsedCommandLine;
 export declare function getRootTsConfigPathInTree(tree: Tree): string | null;
 export declare function getRelativePathToRootTsConfig(tree: Tree, targetPath: string): string;
 export declare function getRootTsConfigPath(): string | null;

package/src/utils/typescript/ts-config.js

@@ -12,12 +12,13 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const ensure_typescript_1 = require("./ensure-typescript");
 let tsModule;
-function readTsConfig(tsConfigPath) {
+function readTsConfig(tsConfigPath, sys) {
     if (!tsModule) {
         tsModule = require('typescript');
     }
-    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
-    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+    sys ??= tsModule.sys;
+    const readResult = tsModule.readConfigFile(tsConfigPath, sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, sys, (0, path_1.dirname)(tsConfigPath));
 }
 function getRootTsConfigPathInTree(tree) {
     for (const path of ['tsconfig.base.json', 'tsconfig.json']) {

package/src/utils/typescript/ts-solution-setup.d.ts

@@ -1,4 +1,4 @@
 import { type Tree } from '@nx/devkit';
 export declare function isUsingTypeScriptPlugin(tree: Tree): boolean;
-export declare function isUsingTsSolutionSetup(tree: Tree): boolean;
+export declare function isUsingTsSolutionSetup(tree?: Tree): boolean;
 export declare function assertNotUsingTsSolutionSetup(tree: Tree, pluginName: string, generatorName: string): void;

package/src/utils/typescript/ts-solution-setup.js

@@ -4,6 +4,7 @@ exports.isUsingTypeScriptPlugin = isUsingTypeScriptPlugin;
 exports.isUsingTsSolutionSetup = isUsingTsSolutionSetup;
 exports.assertNotUsingTsSolutionSetup = assertNotUsingTsSolutionSetup;
 const devkit_1 = require("@nx/devkit");
+const tree_1 = require("nx/src/generators/tree");
 const package_manager_workspaces_1 = require("../package-manager-workspaces");
 function isUsingTypeScriptPlugin(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
@@ -12,6 +13,7 @@ function isUsingTypeScriptPlugin(tree) {
         : p.plugin === '@nx/js/typescript') ?? false);
 }
 function isUsingTsSolutionSetup(tree) {
+    tree ??= new tree_1.FsTree(devkit_1.workspaceRoot, false);
     return ((0, package_manager_workspaces_1.isUsingPackageManagerWorkspaces)(tree) &&
         isWorkspaceSetupWithTsSolution(tree));
 }

package/src/generators/library/utils/package-manager-workspaces.d.ts

@@ -1,3 +0,0 @@
-import { type GeneratorCallback } from '@nx/devkit';
-import type { ProjectPackageManagerWorkspaceState } from '../../../utils/package-manager-workspaces';
-export declare function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState, workspaceRoot: string): GeneratorCallback;

package/src/generators/library/utils/package-manager-workspaces.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageManagerWorkspaceStateWarningTask;
-const devkit_1 = require("@nx/devkit");
-const semver_1 = require("semver");
-function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState, workspaceRoot) {
-    return () => {
-        const packageManager = (0, devkit_1.detectPackageManager)(workspaceRoot);
-        let packageManagerWorkspaceSetupDocs;
-        if (packageManager === 'pnpm') {
-            packageManagerWorkspaceSetupDocs =
-                'https://pnpm.io/workspaces and https://pnpm.io/pnpm-workspace_yaml';
-        }
-        else if (packageManager === 'yarn') {
-            const yarnVersion = (0, devkit_1.getPackageManagerVersion)(packageManager, workspaceRoot);
-            if ((0, semver_1.lt)(yarnVersion, '2.0.0')) {
-                packageManagerWorkspaceSetupDocs =
-                    'https://classic.yarnpkg.com/lang/en/docs/workspaces/';
-            }
-            else {
-                packageManagerWorkspaceSetupDocs =
-                    'https://yarnpkg.com/features/workspaces';
-            }
-        }
-        else if (packageManager === 'npm') {
-            packageManagerWorkspaceSetupDocs =
-                'https://docs.npmjs.com/cli/v10/using-npm/workspaces';
-        }
-        else if (packageManager === 'bun') {
-            packageManagerWorkspaceSetupDocs =
-                'https://bun.sh/docs/install/workspaces';
-        }
-        if (projectPackageManagerWorkspaceState === 'no-workspaces') {
-            devkit_1.output.warn({
-                title: `The package manager workspaces feature is not enabled in the workspace`,
-                bodyLines: [
-                    'You must enable the package manager workspaces feature to use the "@nx/js/typescript" plugin.',
-                    `Read more about the ${packageManager} workspaces feature and how to set it up at ${packageManagerWorkspaceSetupDocs}.`,
-                ],
-            });
-        }
-        else if (projectPackageManagerWorkspaceState === 'excluded') {
-            devkit_1.output.warn({
-                title: `The project is not included in the package manager workspaces configuration`,
-                bodyLines: [
-                    'Please add it to the workspace configuration to use the "@nx/js/typescript" plugin.',
-                    `Read more about the ${packageManager} workspaces feature and how to set it up at ${packageManagerWorkspaceSetupDocs}.`,
-                ],
-            });
-        }
-    };
-}