@nx/js 0.0.0-pr-28667-37ba4e7 → 0.0.0-pr-28682-017d55a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "0.0.0-pr-28667-37ba4e7",
+  "version": "0.0.0-pr-28682-017d55a",
   "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": "0.0.0-pr-28667-37ba4e7",
-    "@nx/workspace": "0.0.0-pr-28667-37ba4e7",
+    "@nx/devkit": "0.0.0-pr-28682-017d55a",
+    "@nx/workspace": "0.0.0-pr-28682-017d55a",
     "@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/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,10 +148,10 @@ 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);
     }
@@ -471,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);
@@ -489,14 +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) {
-        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?`,
@@ -505,14 +494,14 @@ async function normalizeOptions(tree, options) {
         }, { unitTestRunner: 'none' }).then(({ unitTestRunner }) => unitTestRunner);
     }
     else {
-        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?`,

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/plugins/typescript/plugin.js

@@ -77,13 +77,21 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
      * - hashes of the content of the relevant files that can affect what's inferred by the plugin:
      *   - current config file
      *   - config files extended by the current config file (recursively up to the root config file)
+     *   - referenced config files that are internal to the owning Nx project of the current config file
      *   - lock file
      * - hash of the plugin options
      * - current config file path
      */
-    const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, readCachedTsConfig(fullConfigPath));
+    const tsConfig = readCachedTsConfig(fullConfigPath);
+    const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, tsConfig);
+    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
     const nodeHash = (0, file_hasher_1.hashArray)([
-        ...[configFilePath, ...extendedConfigFiles, lockFileName].map(file_hasher_1.hashFile),
+        ...[
+            configFilePath,
+            ...extendedConfigFiles.files,
+            ...Object.keys(internalReferencedFiles),
+            lockFileName,
+        ].map(file_hasher_1.hashFile),
         (0, file_hasher_1.hashObject)(options),
     ]);
     const cacheKey = `${nodeHash}_${configFilePath}`;
@@ -169,12 +177,14 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
 }
 function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
     const configFiles = new Set();
-    const includePaths = new Set();
-    const excludePaths = new Set();
+    const externalDependencies = ['typescript'];
     const extendedConfigFiles = getExtendedConfigFiles(configFilePath, tsConfig);
-    extendedConfigFiles.forEach((configPath) => {
+    extendedConfigFiles.files.forEach((configPath) => {
         configFiles.add(configPath);
     });
+    externalDependencies.push(...extendedConfigFiles.packages);
+    const includePaths = new Set();
+    const excludePaths = new Set();
     const projectTsConfigFiles = [
         [configFilePath, tsConfig],
         ...Object.entries(internalProjectReferences),
@@ -225,7 +235,7 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     else {
         inputs.push('production' in namedInputs ? '^production' : '^default');
     }
-    inputs.push({ externalDependencies: ['typescript'] });
+    inputs.push({ externalDependencies });
     return inputs;
 }
 function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
@@ -238,19 +248,24 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
         if (config.options.outFile) {
             const outFileName = (0, node_path_1.basename)(config.options.outFile, '.js');
             const outFileDir = (0, node_path_1.dirname)(config.options.outFile);
-            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, config.options.outFile)));
+            outputs.add(pathToInputOrOutput(config.options.outFile, workspaceRoot, projectRoot));
             // outFile is not be used with .cjs, .mjs, .jsx, so the list is simpler
             const outDir = (0, node_path_1.relative)(workspaceRoot, outFileDir);
-            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.js.map`));
-            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.d.ts`));
-            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.d.ts.map`));
+            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.js.map`), workspaceRoot, projectRoot));
+            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.d.ts`), workspaceRoot, projectRoot));
+            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.d.ts.map`), workspaceRoot, projectRoot));
             // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
             outputs.add(tsConfig.options.tsBuildInfoFile
                 ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, projectRoot)
-                : (0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.tsbuildinfo`));
+                : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, projectRoot));
         }
         else if (config.options.outDir) {
-            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, config.options.outDir)));
+            outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
+            if (config.options.tsBuildInfoFile &&
+                !(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
+                // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
+                outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
+            }
         }
         else if (config.fileNames.length) {
             // tsc produce files in place when no outDir or outFile is set
@@ -284,16 +299,26 @@ function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
 }
 function getExtendedConfigFiles(tsConfigPath, tsConfig) {
     const extendedConfigFiles = new Set();
+    const extendedExternalPackages = new Set();
     let currentConfigPath = tsConfigPath;
     let currentConfig = tsConfig;
     while (currentConfig.raw?.extends) {
-        const extendedConfigPath = (0, node_path_1.join)((0, node_path_1.dirname)(currentConfigPath), currentConfig.raw.extends);
-        extendedConfigFiles.add(extendedConfigPath);
-        const extendedConfig = readCachedTsConfig(extendedConfigPath);
-        currentConfigPath = extendedConfigPath;
-        currentConfig = extendedConfig;
+        const extendedConfigPath = resolveExtendedTsConfigPath(currentConfig.raw.extends, (0, node_path_1.dirname)(currentConfigPath));
+        if (!extendedConfigPath) {
+            break;
+        }
+        if (extendedConfigPath.externalPackage) {
+            extendedExternalPackages.add(extendedConfigPath.externalPackage);
+            break;
+        }
+        extendedConfigFiles.add(extendedConfigPath.filePath);
+        currentConfig = readCachedTsConfig(extendedConfigPath.filePath);
+        currentConfigPath = extendedConfigPath.filePath;
     }
-    return Array.from(extendedConfigFiles);
+    return {
+        files: Array.from(extendedConfigFiles),
+        packages: Array.from(extendedExternalPackages),
+    };
 }
 function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
@@ -422,3 +447,21 @@ function normalizePluginOptions(pluginOptions = {}) {
         build,
     };
 }
+function resolveExtendedTsConfigPath(tsConfigPath, directory) {
+    try {
+        const resolvedPath = require.resolve(tsConfigPath, {
+            paths: directory ? [directory] : undefined,
+        });
+        if (tsConfigPath.startsWith('.')) {
+            return { filePath: resolvedPath };
+        }
+        // parse the package from the tsconfig path
+        const packageName = tsConfigPath.startsWith('@')
+            ? tsConfigPath.split('/').slice(0, 2).join('/')
+            : tsConfigPath.split('/')[0];
+        return { filePath: resolvedPath, externalPackage: packageName };
+    }
+    catch {
+        return null;
+    }
+}

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/{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/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}.`,
-                ],
-            });
-        }
-    };
-}