@nx/js 0.0.0-pr-30418-4e2b721 → 0.0.0-pr-3-ec41644

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "0.0.0-pr-30418-4e2b721",
+  "version": "0.0.0-pr-3-ec41644",
   "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-30418-4e2b721",
-    "@nx/workspace": "0.0.0-pr-30418-4e2b721",
+    "@nx/devkit": "0.0.0-pr-3-ec41644",
+    "@nx/workspace": "0.0.0-pr-3-ec41644",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -52,11 +52,10 @@
     "ignore": "^5.0.4",
     "js-tokens": "^4.0.0",
     "jsonc-parser": "3.2.0",
+    "minimatch": "9.0.3",
     "npm-package-arg": "11.0.1",
     "npm-run-path": "^4.0.1",
     "ora": "5.3.0",
-    "picocolors": "^1.1.0",
-    "picomatch": "4.0.2",
     "semver": "^7.5.3",
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.10",

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

@@ -298,7 +298,7 @@ function getFileToRun(context, project, buildOptions, buildTargetExecutor) {
             const outputFilePath = (0, utils_1.interpolate)(outputPath, {
                 projectName: project.name,
                 projectRoot: project.data.root,
-                workspaceRoot: context.root,
+                workspaceRoot: '',
             });
             return path.join(outputFilePath, 'main.js');
         }

package/src/generators/init/init.js

@@ -54,7 +54,8 @@ async function initGeneratorInternal(tree, schema) {
     schema.addPlugin ??=
         process.env.NX_ADD_PLUGINS !== 'false' &&
             nxJson.useInferencePlugins !== false;
-    schema.addTsPlugin ??= schema.addPlugin;
+    schema.addTsPlugin ??=
+        schema.addPlugin && process.env.NX_ADD_TS_PLUGIN !== 'false';
     if (schema.addTsPlugin) {
         await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/js/typescript', plugin_1.createNodesV2, {
             typecheck: [

package/src/generators/library/library.js

@@ -22,6 +22,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 sort_fields_1 = require("../../utils/package-json/sort-fields");
+const get_import_path_1 = require("../../utils/get-import-path");
 const add_release_config_1 = require("./utils/add-release-config");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
@@ -42,16 +43,16 @@ async function libraryGeneratorInternal(tree, schema) {
         formatter: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree) ? 'none' : 'prettier',
     }));
     const options = await normalizeOptions(tree, schema);
+    // If we are using the new TS solution
+    // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
+    if (options.isUsingTsSolutionConfig) {
+        (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
+    }
     createFiles(tree, options);
     await configureProject(tree, options);
     if (!options.skipPackageJson) {
         tasks.push(addProjectDependencies(tree, options));
     }
-    // If we are using the new TS solution
-    // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
-    if (options.isUsingTsSolutionConfig) {
-        await (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
-    }
     if (options.bundler === 'rollup') {
         const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/rollup', versions_1.nxVersion);
         await configurationGenerator(tree, {
@@ -160,7 +161,7 @@ async function libraryGeneratorInternal(tree, schema) {
 async function configureProject(tree, options) {
     if (options.hasPlugin) {
         const nxJson = (0, devkit_1.readNxJson)(tree);
-        (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot, options.bundler === 'none' ? null : 'build');
+        (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot);
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
     const projectConfiguration = {
@@ -235,7 +236,9 @@ async function configureProject(tree, options) {
             }
         }
         // empty targets are cleaned up automatically by `updateProjectConfiguration`
-        (0, devkit_1.updateProjectConfiguration)(tree, options.name, projectConfiguration);
+        (0, devkit_1.updateProjectConfiguration)(tree, options.isUsingTsSolutionConfig
+            ? options.importPath ?? options.name
+            : options.name, projectConfiguration);
     }
     else if (options.config === 'workspace' || options.config === 'project') {
         (0, devkit_1.addProjectConfiguration)(tree, options.name, projectConfiguration);
@@ -465,11 +468,6 @@ function createFiles(tree, options) {
                 format: ['esm'],
             });
         }
-        if (!options.useProjectJson && options.name !== options.importPath) {
-            packageJson.nx = {
-                name: options.name,
-            };
-        }
         (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
     }
     if (options.config === 'npm-scripts') {
@@ -529,7 +527,7 @@ function replaceJestConfig(tree, options) {
     });
 }
 async function normalizeOptions(tree, options) {
-    await (0, project_name_and_root_utils_1.ensureRootProjectName)(options, 'library');
+    await (0, project_name_and_root_utils_1.ensureProjectName)(tree, options, 'library');
     const nxJson = (0, devkit_1.readNxJson)(tree);
     options.addPlugin ??=
         process.env.NX_ADD_PLUGINS !== 'false' &&
@@ -631,7 +629,9 @@ async function normalizeOptions(tree, options) {
     return {
         ...options,
         fileName,
-        name: isUsingTsSolutionConfig && !options.name ? importPath : projectName,
+        name: isUsingTsSolutionConfig
+            ? (0, get_import_path_1.getImportPath)(tree, projectName)
+            : projectName,
         projectNames,
         projectRoot,
         parsedTags,
@@ -719,7 +719,9 @@ function createProjectTsConfigs(tree, options) {
             .map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`)
             .join(',\n    '),
         tmpl: '',
-        outDir: 'dist',
+        outDir: options.bundler === 'tsc'
+            ? 'dist'
+            : `out-tsc/${options.projectRoot.split('/').pop()}`,
         emitDeclarationOnly: options.bundler === 'tsc' ? false : true,
     });
     // tsconfig.json
@@ -732,12 +734,6 @@ function createProjectTsConfigs(tree, options) {
                 json.references.push({
                     path: './tsconfig.lib.json',
                 });
-                // If using `tsc` to build, then we do not want a typecheck target that duplicates the work, since both run `tsc`.
-                // This applies to `@nx/js/typescript` plugin only.
-                if (options.bundler === 'tsc') {
-                    json['nx'] ??= {};
-                    json['nx'].addTypecheckTarget = false;
-                }
                 return json;
             });
         }
@@ -749,12 +745,6 @@ function createProjectTsConfigs(tree, options) {
                 include: [],
                 references: [{ path: './tsconfig.lib.json' }],
             };
-            // If using `tsc` to build, then we do not want a typecheck target that duplicates the work, since both run `tsc`.
-            // This applies to `@nx/js/typescript` plugin only.
-            if (options.bundler === 'tsc') {
-                tsconfig['nx'] ??= {};
-                tsconfig['nx'].addTypecheckTarget = false;
-            }
             (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), tsconfig);
             // update root project tsconfig.json references with the new lib tsconfig
             (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {

package/src/generators/release-version/release-version.js

@@ -666,10 +666,7 @@ To fix this you will either need to add a package.json file at that location, or
                     deletedFiles.push(...(await cb(opts.dryRun)));
                 }
                 const cwd = tree.root;
-                changedFiles.push(...(await (0, update_lock_file_1.updateLockFile)(cwd, {
-                    ...opts,
-                    useLegacyVersioning: true,
-                })));
+                changedFiles.push(...(await (0, update_lock_file_1.updateLockFile)(cwd, opts)));
                 return { changedFiles, deletedFiles };
             },
         };

package/src/generators/release-version/schema.d.ts

@@ -1 +1 @@
-export { ReleaseVersionGeneratorSchema } from 'nx/src/command-line/release/version-legacy';
+export { ReleaseVersionGeneratorSchema } from 'nx/src/command-line/release/version';

package/src/generators/release-version/schema.json

@@ -8,8 +8,6 @@
   "properties": {
     "projects": {
       "type": "array",
-      "hidden": true,
-      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "The ProjectGraphProjectNodes being versioned in the current execution.",
       "items": {
         "type": "object"
@@ -17,33 +15,16 @@
     },
     "projectGraph": {
       "type": "object",
-      "hidden": true,
-      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "ProjectGraph instance"
     },
-    "releaseGroup": {
-      "type": "object",
-      "hidden": true,
-      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
-      "description": "The resolved release group configuration, including name, relevant to all projects in the current execution."
-    },
-    "conventionalCommitsConfig": {
-      "type": "object",
-      "hidden": true,
-      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
-      "description": "The conventional commits configuration to use when determining the next version of the project.",
-      "default": {}
-    },
-    "firstRelease": {
-      "type": "boolean",
-      "hidden": true,
-      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
-      "description": "Whether this is the first release of the project (which skips some validation within the generator)."
-    },
     "specifier": {
       "type": "string",
       "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
     },
+    "releaseGroup": {
+      "type": "object",
+      "description": "The resolved release group configuration, including name, relevant to all projects in the current execution."
+    },
     "specifierSource": {
       "type": "string",
       "default": "prompt",

package/src/generators/release-version/utils/update-lock-file.d.ts

@@ -1,10 +1,5 @@
-export declare function updateLockFile(cwd: string, { dryRun, verbose, useLegacyVersioning, options, }: {
+export declare function updateLockFile(cwd: string, { dryRun, verbose, generatorOptions, }: {
     dryRun?: boolean;
     verbose?: boolean;
-    useLegacyVersioning?: boolean;
-    options?: {
-        skipLockFileUpdate?: boolean;
-        installArgs?: string;
-        installIgnoreScripts?: boolean;
-    };
+    generatorOptions?: Record<string, unknown>;
 }): Promise<string[]>;

package/src/generators/release-version/utils/update-lock-file.js

@@ -7,8 +7,8 @@ const client_1 = require("nx/src/daemon/client/client");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const semver_1 = require("semver");
-async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, options, }) {
-    if (options?.skipLockFileUpdate) {
+async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
+    if (generatorOptions?.skipLockFileUpdate) {
         if (verbose) {
             console.log('\nSkipped lock file update because skipLockFileUpdate was set.');
         }
@@ -36,10 +36,10 @@ async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, optio
         await client_1.daemonClient.stop();
     }
     const packageManagerCommands = (0, devkit_1.getPackageManagerCommand)(packageManager);
-    let installArgs = options?.installArgs || '';
+    let installArgs = generatorOptions?.installArgs || '';
     devkit_1.output.logSingleLine(`Updating ${packageManager} lock file`);
     let env = {};
-    if (options?.installIgnoreScripts) {
+    if (generatorOptions?.installIgnoreScripts) {
         if (packageManager === 'yarn') {
             env = { YARN_ENABLE_SCRIPTS: 'false' };
         }
@@ -62,7 +62,7 @@ async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, optio
     if (dryRun) {
         return [];
     }
-    execLockFileUpdate(command, cwd, env, useLegacyVersioning);
+    execLockFileUpdate(command, cwd, env);
     if (isDaemonEnabled) {
         try {
             await client_1.daemonClient.startInBackground();
@@ -79,7 +79,7 @@ async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, optio
     }
     return [lockFile];
 }
-function execLockFileUpdate(command, cwd, env, useLegacyVersioning) {
+function execLockFileUpdate(command, cwd, env = {}) {
     try {
         const LARGE_BUFFER = 1024 * 1000000;
         (0, child_process_1.execSync)(command, {
@@ -93,16 +93,13 @@ function execLockFileUpdate(command, cwd, env, useLegacyVersioning) {
         });
     }
     catch (e) {
-        const configPathStart = useLegacyVersioning
-            ? 'release.version.generatorOptions'
-            : 'release.version.versionActionsOptions';
         devkit_1.output.error({
             title: `Error updating lock file with command '${command}'`,
             bodyLines: [
                 `Verify that '${command}' succeeds when run from the workspace root.`,
-                `To configure a string of arguments to be passed to this command, set the '${configPathStart}.installArgs' property in nx.json.`,
-                `To ignore install lifecycle scripts, set '${configPathStart}.installIgnoreScripts' to true in nx.json.`,
-                `To disable this step entirely, set '${configPathStart}.skipLockFileUpdate' to true in nx.json.`,
+                `To configure a string of arguments to be passed to this command, set the 'release.version.generatorOptions.installArgs' property in nx.json.`,
+                `To ignore install lifecycle scripts, set 'release.version.generatorOptions.installIgnoreScripts' to true in nx.json.`,
+                `To disable this step entirely, set 'release.version.generatorOptions.skipLockFileUpdate' to true in nx.json.`,
             ],
         });
         throw e;

package/src/plugins/typescript/plugin.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.createNodesV2 = exports.PLUGIN_NAME = exports.createDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
 const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
-const picomatch = require("picomatch");
+const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const posix = require("node:path/posix");
@@ -178,9 +178,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
     const tsConfig = retrieveTsConfigFromCache(configFilePath, context.workspaceRoot);
     let internalProjectReferences;
     // Typecheck target
-    if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' &&
-        options.typecheck &&
-        tsConfig.raw?.['nx']?.addTypecheckTarget !== false) {
+    if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' && options.typecheck) {
         internalProjectReferences = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const targetName = options.typecheck.targetName;
@@ -216,7 +214,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
     // Build target
     if (options.build &&
         (0, node_path_1.basename)(configFilePath) === options.build.configName &&
-        (0, util_1.isValidPackageJsonBuildConfig)(tsConfig, context.workspaceRoot, projectRoot)) {
+        isValidPackageJsonBuildConfig(tsConfig, context.workspaceRoot, projectRoot)) {
         internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const targetName = options.build.targetName;
         targets[targetName] = {
@@ -278,8 +276,8 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
             });
             const normalize = (p) => (p.startsWith('./') ? p.slice(2) : p);
             config.raw.exclude.forEach((excludePath) => {
-                if (!otherFilesInclude.some((includePath) => picomatch(normalize(excludePath))(normalize(includePath)) ||
-                    picomatch(normalize(includePath))(normalize(excludePath)))) {
+                if (!otherFilesInclude.some((includePath) => (0, minimatch_1.minimatch)(normalize(includePath), normalize(excludePath)) ||
+                    (0, minimatch_1.minimatch)(normalize(excludePath), normalize(includePath)))) {
                     excludePaths.add(excludePath);
                 }
             });
@@ -371,6 +369,87 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
     });
     return Array.from(outputs);
 }
+/**
+ * Validates the build configuration of a `package.json` file by ensuring that paths in the `exports`, `module`,
+ * and `main` fields reference valid output paths within the `outDir` defined in the TypeScript configuration.
+ * Priority is given to the `exports` field, specifically the `.` export if defined. If `exports` is not defined,
+ * the function falls back to validating `main` and `module` fields. If `outFile` is specified, it validates that the file
+ * is located within the output directory.
+ * If no `package.json` file exists, it assumes the configuration is valid.
+ *
+ * @param tsConfig The TypeScript configuration object.
+ * @param workspaceRoot The workspace root path.
+ * @param projectRoot The project root path.
+ * @returns `true` if the package has a valid build configuration; otherwise, `false`.
+ */
+function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
+    const packageJsonPath = (0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json');
+    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        // If the package.json file does not exist.
+        // Assume it's valid because it would be using `project.json` instead.
+        return true;
+    }
+    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    const outDir = tsConfig.options.outFile
+        ? (0, node_path_1.dirname)(tsConfig.options.outFile)
+        : tsConfig.options.outDir;
+    const resolvedOutDir = outDir
+        ? (0, node_path_1.resolve)(workspaceRoot, projectRoot, outDir)
+        : undefined;
+    const isPathSourceFile = (path) => {
+        if (resolvedOutDir) {
+            const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, projectRoot, path);
+            return !pathToCheck.startsWith(resolvedOutDir);
+        }
+        const ext = (0, node_path_1.extname)(path);
+        // Check that the file extension is a TS file extension. As the source files are in the same directory as the output files.
+        return ['.ts', '.tsx', '.cts', '.mts'].includes(ext);
+    };
+    // Checks if the value is a path within the `src` directory.
+    const containsInvalidPath = (value) => {
+        if (typeof value === 'string') {
+            return isPathSourceFile(value);
+        }
+        else if (typeof value === 'object') {
+            return Object.entries(value).some(([currentKey, subValue]) => {
+                // Skip types field
+                if (currentKey === 'types') {
+                    return false;
+                }
+                if (typeof subValue === 'string') {
+                    return isPathSourceFile(subValue);
+                }
+                return false;
+            });
+        }
+        return false;
+    };
+    const exports = packageJson?.exports;
+    // Check the `.` export if `exports` is defined.
+    if (exports) {
+        if (typeof exports === 'string') {
+            return !isPathSourceFile(exports);
+        }
+        if (typeof exports === 'object' && '.' in exports) {
+            return !containsInvalidPath(exports['.']);
+        }
+        // Check other exports if `.` is not defined or valid.
+        for (const key in exports) {
+            if (key !== '.' && containsInvalidPath(exports[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // If `exports` is not defined, fallback to `main` and `module` fields.
+    const buildPaths = ['main', 'module'];
+    for (const field of buildPaths) {
+        if (packageJson[field] && isPathSourceFile(packageJson[field])) {
+            return false;
+        }
+    }
+    return true;
+}
 function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     const fullProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
     const fullPath = (0, node_path_1.resolve)(workspaceRoot, path);
@@ -475,7 +554,7 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
     return false;
 }
 function isExternalProjectReference(refTsConfigPath, workspaceRoot, projectRoot) {
-    const relativePath = posixRelative(workspaceRoot, refTsConfigPath);
+    const relativePath = posix.relative(workspaceRoot, refTsConfigPath);
     if (cache.isExternalProjectReference[relativePath] !== undefined) {
         return cache.isExternalProjectReference[relativePath];
     }
@@ -505,7 +584,7 @@ function getTsConfigDirName(tsConfigPath) {
         : (0, node_path_1.normalize)(tsConfigPath);
 }
 function retrieveTsConfigFromCache(tsConfigPath, workspaceRoot) {
-    const relativePath = posixRelative(workspaceRoot, tsConfigPath);
+    const relativePath = posix.relative(workspaceRoot, tsConfigPath);
     // we don't need to check the hash if it's in the cache, because we've already
     // checked it when we initially populated the cache
     return tsConfigCache[relativePath]
@@ -521,7 +600,7 @@ function initializeTsConfigCache(configFilePaths, workspaceRoot) {
     }
 }
 function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
-    const relativePath = posixRelative(workspaceRoot, tsConfigPath);
+    const relativePath = posix.relative(workspaceRoot, tsConfigPath);
     const hash = getFileHash(tsConfigPath, workspaceRoot);
     let extendedFilesHash;
     if (tsConfigCache[relativePath] &&
@@ -637,7 +716,7 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
     }
 }
 function getFileHash(filePath, workspaceRoot) {
-    const relativePath = posixRelative(workspaceRoot, filePath);
+    const relativePath = posix.relative(workspaceRoot, filePath);
     if (!cache.fileHashes[relativePath]) {
         const content = readFile(filePath, workspaceRoot);
         cache.fileHashes[relativePath] = (0, file_hasher_1.hashArray)([content]);
@@ -645,7 +724,7 @@ function getFileHash(filePath, workspaceRoot) {
     return cache.fileHashes[relativePath];
 }
 function readFile(filePath, workspaceRoot) {
-    const relativePath = posixRelative(workspaceRoot, filePath);
+    const relativePath = posix.relative(workspaceRoot, filePath);
     if (!cache.rawFiles[relativePath]) {
         const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
         cache.rawFiles[relativePath] = content;
@@ -658,9 +737,6 @@ function toAbsolutePaths(cache, workspaceRoot) {
         updatedCache[key] = {
             data: {
                 options: { noEmit: data.options.noEmit },
-                raw: {
-                    nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
-                },
                 extendedConfigFile: data.extendedConfigFile,
             },
             extendedFilesHash,
@@ -693,38 +769,29 @@ function toRelativePaths(cache, workspaceRoot) {
         updatedCache[key] = {
             data: {
                 options: { noEmit: data.options.noEmit },
-                raw: {
-                    nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
-                },
                 extendedConfigFile: data.extendedConfigFile,
             },
             extendedFilesHash,
             hash,
         };
         if (data.options.rootDir) {
-            updatedCache[key].data.options.rootDir = posixRelative(workspaceRoot, data.options.rootDir);
+            updatedCache[key].data.options.rootDir = posix.relative(workspaceRoot, data.options.rootDir);
         }
         if (data.options.outDir) {
-            updatedCache[key].data.options.outDir = posixRelative(workspaceRoot, data.options.outDir);
+            updatedCache[key].data.options.outDir = posix.relative(workspaceRoot, data.options.outDir);
         }
         if (data.options.outFile) {
-            updatedCache[key].data.options.outFile = posixRelative(workspaceRoot, data.options.outFile);
+            updatedCache[key].data.options.outFile = posix.relative(workspaceRoot, data.options.outFile);
         }
         if (data.options.tsBuildInfoFile) {
-            updatedCache[key].data.options.tsBuildInfoFile = posixRelative(workspaceRoot, data.options.tsBuildInfoFile);
+            updatedCache[key].data.options.tsBuildInfoFile = posix.relative(workspaceRoot, data.options.tsBuildInfoFile);
         }
         if (data.extendedConfigFile?.filePath) {
-            updatedCache[key].data.extendedConfigFile.filePath = posixRelative(workspaceRoot, data.extendedConfigFile.filePath);
+            updatedCache[key].data.extendedConfigFile.filePath = posix.relative(workspaceRoot, data.extendedConfigFile.filePath);
         }
         if (data.projectReferences) {
-            updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({
-                ...ref,
-                path: posixRelative(workspaceRoot, ref.path),
-            }));
+            updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({ ...ref, path: posix.relative(workspaceRoot, ref.path) }));
         }
     }
     return updatedCache;
 }
-function posixRelative(workspaceRoot, path) {
-    return posix.normalize((0, node_path_1.relative)(workspaceRoot, path));
-}

package/src/plugins/typescript/util.d.ts

@@ -1,12 +1,5 @@
 import { type TargetConfiguration } from '@nx/devkit';
 import { type PackageManagerCommands } from 'nx/src/utils/package-manager';
-import { type ParsedCommandLine } from 'typescript';
-export type ParsedTsconfigData = Pick<ParsedCommandLine, 'options' | 'projectReferences' | 'raw'> & {
-    extendedConfigFile: {
-        filePath: string;
-        externalPackage?: string;
-    } | null;
-};
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
  */
@@ -14,4 +7,3 @@ export declare function addBuildAndWatchDepsTargets(workspaceRoot: string, proje
     buildDepsTargetName?: string;
     watchDepsTargetName?: string;
 }, pmc: PackageManagerCommands): void;
-export declare function isValidPackageJsonBuildConfig(tsConfig: ParsedTsconfigData, workspaceRoot: string, projectRoot: string): boolean;

package/src/plugins/typescript/util.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addBuildAndWatchDepsTargets = addBuildAndWatchDepsTargets;
-exports.isValidPackageJsonBuildConfig = isValidPackageJsonBuildConfig;
 const devkit_1 = require("@nx/devkit");
 const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const path_1 = require("path");
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
@@ -29,79 +27,9 @@ function addBuildAndWatchDepsTargets(workspaceRoot, projectRoot, targets, option
             dependsOn: ['^build'],
         };
         targets[options.watchDepsTargetName ?? 'watch-deps'] = {
+            continuous: true,
             dependsOn: [buildDepsTargetName],
             command: `${pmc.exec} nx watch --projects ${projectName} --includeDependentProjects -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
         };
     }
 }
-function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
-    const resolvedProjectPath = (0, node_path_1.isAbsolute)(projectRoot)
-        ? (0, node_path_1.relative)(workspaceRoot, projectRoot)
-        : projectRoot;
-    const packageJsonPath = (0, path_1.join)(workspaceRoot, resolvedProjectPath, 'package.json');
-    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
-        // If the package.json file does not exist.
-        // Assume it's valid because it would be using `project.json` instead.
-        return true;
-    }
-    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
-    const outDir = tsConfig.options.outFile
-        ? (0, node_path_1.dirname)(tsConfig.options.outFile)
-        : tsConfig.options.outDir;
-    const resolvedOutDir = outDir
-        ? (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, outDir)
-        : undefined;
-    const isPathSourceFile = (path) => {
-        if (resolvedOutDir) {
-            const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, path);
-            return !pathToCheck.startsWith(resolvedOutDir);
-        }
-        const ext = (0, node_path_1.extname)(path);
-        // Check that the file extension is a TS file extension. As the source files are in the same directory as the output files.
-        return ['.ts', '.tsx', '.cts', '.mts'].includes(ext);
-    };
-    // Checks if the value is a path within the `src` directory.
-    const containsInvalidPath = (value) => {
-        if (typeof value === 'string') {
-            return isPathSourceFile(value);
-        }
-        else if (typeof value === 'object') {
-            return Object.entries(value).some(([currentKey, subValue]) => {
-                // Skip types field
-                if (currentKey === 'types') {
-                    return false;
-                }
-                if (typeof subValue === 'string') {
-                    return isPathSourceFile(subValue);
-                }
-                return false;
-            });
-        }
-        return false;
-    };
-    const exports = packageJson?.exports;
-    // Check the `.` export if `exports` is defined.
-    if (exports) {
-        if (typeof exports === 'string') {
-            return !isPathSourceFile(exports);
-        }
-        if (typeof exports === 'object' && '.' in exports) {
-            return !containsInvalidPath(exports['.']);
-        }
-        // Check other exports if `.` is not defined or valid.
-        for (const key in exports) {
-            if (key !== '.' && containsInvalidPath(exports[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // If `exports` is not defined, fallback to `main` and `module` fields.
-    const buildPaths = ['main', 'module'];
-    for (const field of buildPaths) {
-        if (packageJson[field] && isPathSourceFile(packageJson[field])) {
-            return false;
-        }
-    }
-    return true;
-}

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopyAssetsHandler = exports.defaultFileEventHandler = void 0;
-const picomatch = require("picomatch");
+const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const pathPosix = require("node:path/posix");
 const path = require("node:path");
@@ -9,7 +9,6 @@ const ignore_1 = require("ignore");
 const tinyglobby_1 = require("tinyglobby");
 const devkit_1 = require("@nx/devkit");
 const client_1 = require("nx/src/daemon/client/client");
-const picocolors_1 = require("picocolors");
 const defaultFileEventHandler = (events) => {
     const dirs = new Set(events.map((event) => path.dirname(event.dest)));
     dirs.forEach((d) => (0, node_fs_1.mkdirSync)(d, { recursive: true }));
@@ -25,9 +24,6 @@ const defaultFileEventHandler = (events) => {
         else {
             devkit_1.logger.error(`Unknown file event: ${event.type}`);
         }
-        const eventDir = path.dirname(event.src);
-        const relativeDest = path.relative(eventDir, event.dest);
-        devkit_1.logger.log(`\n${(0, picocolors_1.dim)(relativeDest)}`);
     });
 };
 exports.defaultFileEventHandler = defaultFileEventHandler;
@@ -119,12 +115,10 @@ class CopyAssetsHandler {
     async processWatchEvents(events) {
         const fileEvents = [];
         for (const event of events) {
-            const pathFromRoot = event.path.startsWith(this.rootDir)
-                ? path.relative(this.rootDir, event.path)
-                : event.path;
+            const pathFromRoot = path.relative(this.rootDir, event.path);
             for (const ag of this.assetGlobs) {
-                if (picomatch(ag.pattern)(pathFromRoot) &&
-                    !ag.ignore?.some((ig) => picomatch(ig)(pathFromRoot)) &&
+                if ((0, minimatch_1.minimatch)(pathFromRoot, ag.pattern) &&
+                    !ag.ignore?.some((ig) => (0, minimatch_1.minimatch)(pathFromRoot, ig)) &&
                     !this.ignore.ignores(pathFromRoot)) {
                     const relPath = path.relative(ag.input, pathFromRoot);
                     const destPath = relPath.startsWith('..') ? pathFromRoot : relPath;
@@ -143,7 +137,7 @@ class CopyAssetsHandler {
     }
     filesToEvent(files, assetGlob) {
         return files.reduce((acc, src) => {
-            if (!assetGlob.ignore?.some((ig) => picomatch(ig)(src)) &&
+            if (!assetGlob.ignore?.some((ig) => (0, minimatch_1.minimatch)(src, ig)) &&
                 !this.ignore.ignores(src)) {
                 const relPath = path.relative(assetGlob.input, src);
                 const dest = relPath.startsWith('..') ? src : relPath;

package/src/utils/buildable-libs-utils.js

@@ -16,8 +16,6 @@ const fileutils_1 = require("nx/src/utils/fileutils");
 const output_1 = require("nx/src/utils/output");
 const path_1 = require("path");
 const ts_config_1 = require("./typescript/ts-config");
-const crypto_1 = require("crypto");
-const project_graph_1 = require("nx/src/config/project-graph");
 function isBuildable(target, node) {
     return (node.data.targets &&
         node.data.targets[target] &&
@@ -50,7 +48,7 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
         .map(({ name: dep, isTopLevel }) => {
         let project = null;
         const depNode = projGraph.nodes[dep] || projGraph.externalNodes[dep];
-        if ((0, project_graph_1.isProjectGraphProjectNode)(depNode) && depNode.type === 'lib') {
+        if (depNode.type === 'lib') {
             if (isBuildable(targetName, depNode)) {
                 const libPackageJsonPath = (0, path_1.join)(root, depNode.data.root, 'package.json');
                 project = {
@@ -69,7 +67,7 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
                 nonBuildableDependencies.push(dep);
             }
         }
-        else if ((0, project_graph_1.isProjectGraphExternalNode)(depNode)) {
+        else if (depNode.type === 'npm') {
             project = {
                 name: depNode.data.packageName,
                 outputs: [],
@@ -231,7 +229,7 @@ function computeCompilerOptionsPaths(tsConfig, dependencies) {
     return paths;
 }
 function createTmpTsConfig(tsconfigPath, workspaceRoot, projectRoot, dependencies, useWorkspaceAsBaseUrl = false) {
-    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', `tsconfig.generated.${(0, crypto_1.randomUUID)()}.json`);
+    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json');
     if (tsconfigPath === tmpTsConfigPath) {
         return tsconfigPath;
     }
@@ -285,9 +283,10 @@ function findMissingBuildDependencies(root, projectName, targetName, projectDepe
 function updatePaths(dependencies, paths) {
     const pathsKeys = Object.keys(paths);
     // For each registered dependency
-    dependencies
-        .filter((dep) => (0, project_graph_1.isProjectGraphProjectNode)(dep.node))
-        .forEach((dep) => {
+    dependencies.forEach((dep) => {
+        if (dep.node.type === 'npm') {
+            return;
+        }
         // If there are outputs
         if (dep.outputs && dep.outputs.length > 0) {
             // Directly map the dependency name to the output paths (dist/packages/..., etc.)
@@ -351,8 +350,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
             !hasDependency(packageJson, 'peerDependencies', packageName)) {
             try {
                 let depVersion;
-                if ((0, project_graph_1.isProjectGraphProjectNode)(entry.node) &&
-                    entry.node.type === 'lib') {
+                if (entry.node.type === 'lib') {
                     const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({
                         project: projectName,
                         target: targetName,

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

@@ -1,7 +1,6 @@
 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 getPackageManagerWorkspacesPatterns(tree: Tree): string[];
 export declare function isUsingPackageManagerWorkspaces(tree: Tree): boolean;
 export declare function isWorkspacesEnabled(tree: Tree): boolean;
 export declare function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState, workspaceRoot: string): GeneratorCallback;

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

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectPackageManagerWorkspaceState = getProjectPackageManagerWorkspaceState;
-exports.getPackageManagerWorkspacesPatterns = getPackageManagerWorkspacesPatterns;
 exports.isUsingPackageManagerWorkspaces = isUsingPackageManagerWorkspaces;
 exports.isWorkspacesEnabled = isWorkspacesEnabled;
 exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageManagerWorkspaceStateWarningTask;
 const devkit_1 = require("@nx/devkit");
-const picomatch = require("picomatch");
+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");
@@ -14,21 +13,17 @@ function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     if (!isUsingPackageManagerWorkspaces(tree)) {
         return 'no-workspaces';
     }
-    const patterns = getPackageManagerWorkspacesPatterns(tree);
-    const isIncluded = patterns.some((p) => picomatch(p)((0, posix_1.join)(projectRoot, 'package.json')));
+    const patterns = (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }));
+    const isIncluded = patterns.some((p) => (0, minimatch_1.minimatch)((0, posix_1.join)(projectRoot, 'package.json'), p));
     return isIncluded ? 'included' : 'excluded';
 }
-function getPackageManagerWorkspacesPatterns(tree) {
-    return (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }), (path) => {
-        const content = tree.read(path, 'utf-8');
-        const { load } = require('@zkochan/js-yaml');
-        return load(content, { filename: path });
-    }, (path) => tree.exists(path));
-}
 function isUsingPackageManagerWorkspaces(tree) {
     return isWorkspacesEnabled(tree);
 }
-function isWorkspacesEnabled(tree) {
+function isWorkspacesEnabled(tree
+// packageManager: PackageManager = detectPackageManager(),
+// root: string = workspaceRoot
+) {
     const packageManager = (0, devkit_1.detectPackageManager)(tree.root);
     if (packageManager === 'pnpm') {
         return tree.exists('pnpm-workspace.yaml');

package/src/utils/typescript/plugin.d.ts

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

package/src/utils/typescript/plugin.js

@@ -3,7 +3,7 @@ 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, buildTargetName) {
+function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, buildTargetName = 'build') {
     nxJson.plugins ??= [];
     let isIncluded = false;
     let index = 0;
@@ -13,17 +13,12 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
             continue;
         }
         if (typeof registration === 'string') {
-            if (buildTargetName) {
-                // 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
-                nxJson.plugins[index] = {
-                    plugin: '@nx/js/typescript',
-                    exclude: [`${projectRoot}/*`],
-                };
-            }
-            else {
-                isIncluded = true;
-            }
+            // 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
+            nxJson.plugins[index] = {
+                plugin: '@nx/js/typescript',
+                exclude: [`${projectRoot}/*`],
+            };
         }
         else {
             // check if the project would be included by the plugin registration
@@ -32,7 +27,7 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
                 // it's included by the plugin registration, check if the user-specified options would result
                 // in the appropriate build task being inferred, if not, we need to exclude it
                 if (registration.options?.typecheck !== false &&
-                    matchesBuildTargetDefinition(registration.options?.build, buildTargetName)) {
+                    matchesBuildTarget(registration.options?.build, buildTargetName)) {
                     // it has the desired options, do nothing, but continue processing
                     // other registrations to exclude as needed
                     isIncluded = true;
@@ -45,7 +40,7 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
             }
             else if (!isIncluded &&
                 registration.options?.typecheck !== false &&
-                matchesBuildTargetDefinition(registration.options?.build, buildTargetName)) {
+                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
@@ -71,20 +66,17 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
     if (!isIncluded) {
         // 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
-        const registration = {
+        nxJson.plugins.push({
             plugin: '@nx/js/typescript',
             include: [`${projectRoot}/*`],
             options: {
                 typecheck: { targetName: 'typecheck' },
+                build: {
+                    targetName: buildTargetName,
+                    configName: 'tsconfig.lib.json',
+                },
             },
-        };
-        if (buildTargetName) {
-            registration.options.build = {
-                targetName: buildTargetName,
-                configName: 'tsconfig.lib.json',
-            };
-        }
-        nxJson.plugins.push(registration);
+        });
     }
 }
 function ensureProjectIsExcludedFromPluginRegistrations(nxJson, projectRoot) {
@@ -123,11 +115,8 @@ function isTypeScriptPluginRegistration(plugin) {
     return ((typeof plugin === 'string' && plugin === '@nx/js/typescript') ||
         (typeof plugin !== 'string' && plugin.plugin === '@nx/js/typescript'));
 }
-function matchesBuildTargetDefinition(buildOptions, buildTargetName) {
+function matchesBuildTarget(buildOptions, buildTargetName) {
     if (buildOptions === undefined || buildOptions === false) {
-        return !buildTargetName;
-    }
-    if (!buildTargetName) {
         return false;
     }
     if (buildOptions === true && buildTargetName === 'build') {

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

@@ -2,8 +2,7 @@ import { type Tree } from '@nx/devkit';
 export declare function isUsingTypeScriptPlugin(tree: Tree): boolean;
 export declare function isUsingTsSolutionSetup(tree?: Tree): boolean;
 export declare function assertNotUsingTsSolutionSetup(tree: Tree, pluginName: string, generatorName: string): void;
-export declare function findRuntimeTsConfigName(projectRoot: string, tree?: Tree): string | null;
+export declare function findRuntimeTsConfigName(tree: Tree, projectRoot: string): string | null;
 export declare function updateTsconfigFiles(tree: Tree, projectRoot: string, runtimeTsconfigFileName: string, compilerOptions: Record<string, string | boolean | string[]>, exclude?: string[], rootDir?: string): void;
-export declare function addProjectToTsSolutionWorkspace(tree: Tree, projectDir: string): Promise<void>;
+export declare function addProjectToTsSolutionWorkspace(tree: Tree, projectDir: string): void;
 export declare function getProjectType(tree: Tree, projectRoot: string, projectType?: 'library' | 'application'): 'library' | 'application';
-export declare function getProjectSourceRoot(tree: Tree, projectSourceRoot: string | undefined, projectRoot: string): string | undefined;

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

@@ -7,7 +7,6 @@ exports.findRuntimeTsConfigName = findRuntimeTsConfigName;
 exports.updateTsconfigFiles = updateTsconfigFiles;
 exports.addProjectToTsSolutionWorkspace = addProjectToTsSolutionWorkspace;
 exports.getProjectType = getProjectType;
-exports.getProjectSourceRoot = getProjectSourceRoot;
 const devkit_1 = require("@nx/devkit");
 const posix_1 = require("node:path/posix");
 const tree_1 = require("nx/src/generators/tree");
@@ -72,8 +71,7 @@ function assertNotUsingTsSolutionSetup(tree, pluginName, generatorName) {
     });
     throw new Error(`The ${artifactString} doesn't yet support the existing TypeScript setup. See the error above.`);
 }
-function findRuntimeTsConfigName(projectRoot, tree) {
-    tree ??= new tree_1.FsTree(devkit_1.workspaceRoot, false);
+function findRuntimeTsConfigName(tree, projectRoot) {
     if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.app.json')))
         return 'tsconfig.app.json';
     if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.lib.json')))
@@ -92,7 +90,9 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
             json.extends = (0, devkit_1.joinPathFragments)(offset, 'tsconfig.base.json');
             json.compilerOptions = {
                 ...json.compilerOptions,
-                outDir: 'dist',
+                // Make sure d.ts files from typecheck does not conflict with bundlers.
+                // Other tooling like jest write to "out-tsc/jest" to we just default to "out-tsc/<project-name>".
+                outDir: (0, devkit_1.joinPathFragments)('out-tsc', projectRoot.split('/').at(-1)),
                 rootDir,
                 ...compilerOptions,
             };
@@ -145,29 +145,12 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
         });
     }
 }
-async function addProjectToTsSolutionWorkspace(tree, projectDir) {
-    const state = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(tree, projectDir);
-    if (state === 'included') {
-        return;
-    }
-    // If dir is "libs/foo", we try to use "libs/*" but we only do it if it's
-    // safe to do so. So, we first check if adding that pattern doesn't result
-    // in extra projects being matched. If extra projects are matched, or the
-    // dir is just "foo" then we add it as is.
+function addProjectToTsSolutionWorkspace(tree, projectDir) {
+    // If dir is "libs/foo" then use "libs/*" so we don't need so many entries in the workspace file.
+    // If dir is nested like "libs/shared/foo" then we add "libs/shared/*".
+    // If the dir is just "foo" then we have to add it as is.
     const baseDir = (0, posix_1.dirname)(projectDir);
-    let pattern = projectDir;
-    if (baseDir !== '.') {
-        const patterns = (0, package_manager_workspaces_1.getPackageManagerWorkspacesPatterns)(tree);
-        const projectsBefore = await (0, devkit_1.globAsync)(tree, patterns);
-        patterns.push(`${baseDir}/*/package.json`);
-        const projectsAfter = await (0, devkit_1.globAsync)(tree, patterns);
-        if (projectsBefore.length + 1 === projectsAfter.length) {
-            // Adding the pattern to the parent directory only results in one extra
-            // project being matched, which is the project we're adding. It's safe
-            // to add the pattern to the parent directory.
-            pattern = `${baseDir}/*`;
-        }
-    }
+    const pattern = baseDir === '.' ? projectDir : `${baseDir}/*`;
     if (tree.exists('pnpm-workspace.yaml')) {
         const { load, dump } = require('@zkochan/js-yaml');
         const workspaceFile = tree.read('pnpm-workspace.yaml', 'utf-8');
@@ -206,9 +189,3 @@ function getProjectType(tree, projectRoot, projectType) {
         return 'application';
     return 'library';
 }
-function getProjectSourceRoot(tree, projectSourceRoot, projectRoot) {
-    return (projectSourceRoot ??
-        (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'src'))
-            ? (0, devkit_1.joinPathFragments)(projectRoot, 'src')
-            : projectRoot));
-}

package/src/generators/release-version/version-actions.d.ts

@@ -1,28 +0,0 @@
-import { ProjectGraph, Tree } from '@nx/devkit';
-import { ManifestData, VersionActions } from 'nx/release';
-import type { NxReleaseVersionV2Configuration } from 'nx/src/config/nx-json';
-export default class JsVersionActions extends VersionActions {
-    manifestFilename: string;
-    static createAfterAllProjectsVersionedCallback(cwd: string, opts: {
-        dryRun?: boolean;
-        verbose?: boolean;
-        versionActionsOptions?: Record<string, unknown>;
-    }): () => Promise<{
-        changedFiles: string[];
-        deletedFiles: any[];
-    }>;
-    readSourceManifestData(tree: Tree): Promise<ManifestData>;
-    readCurrentVersionFromSourceManifest(tree: Tree): Promise<string>;
-    readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata']): Promise<{
-        currentVersion: string;
-        logText: string;
-    }>;
-    getCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
-        currentVersion: string | null;
-        dependencyCollection: string | null;
-    }>;
-    isLocalDependencyProtocol(versionSpecifier: string): boolean;
-    writeVersionToManifests(tree: Tree, newVersion: string): Promise<void>;
-    updateDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<void>;
-    private parseDependencies;
-}

package/src/generators/release-version/version-actions.js

@@ -1,213 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const devkit_1 = require("@nx/devkit");
-const node_child_process_1 = require("node:child_process");
-const node_path_1 = require("node:path");
-const release_1 = require("nx/release");
-const npm_config_1 = require("../../utils/npm-config");
-const resolve_version_spec_1 = require("./utils/resolve-version-spec");
-const update_lock_file_1 = require("./utils/update-lock-file");
-const chalk = require("chalk");
-// Cache at the module level to avoid re-detecting the package manager for each instance
-let pm;
-class JsVersionActions extends release_1.VersionActions {
-    constructor() {
-        super(...arguments);
-        this.manifestFilename = 'package.json';
-    }
-    static createAfterAllProjectsVersionedCallback(cwd, opts) {
-        return async () => {
-            return {
-                changedFiles: await (0, update_lock_file_1.updateLockFile)(cwd, {
-                    ...opts,
-                    useLegacyVersioning: false,
-                }),
-                deletedFiles: [],
-            };
-        };
-    }
-    async readSourceManifestData(tree) {
-        const sourcePackageJsonPath = this.getSourceManifestPath();
-        try {
-            const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
-            const dependencies = this.parseDependencies(packageJson);
-            return {
-                name: packageJson.name,
-                currentVersion: packageJson.version,
-                dependencies,
-            };
-        }
-        catch {
-            throw new Error(`Unable to read the package.json file at ${sourcePackageJsonPath}, please ensure that the file exists and is valid`);
-        }
-    }
-    async readCurrentVersionFromSourceManifest(tree) {
-        const sourcePackageJsonPath = this.getSourceManifestPath();
-        try {
-            const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
-            return packageJson.version;
-        }
-        catch {
-            throw new Error(`Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourcePackageJsonPath}, please ensure that the "version" field is set within the package.json file`);
-        }
-    }
-    async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
-        const sourceManifestPath = this.getSourceManifestPath();
-        const sourceManifestRoot = (0, node_path_1.dirname)(sourceManifestPath);
-        const packageJson = (0, devkit_1.readJson)(tree, sourceManifestPath);
-        const packageName = packageJson.name;
-        const metadata = currentVersionResolverMetadata;
-        const registryArg = typeof metadata?.registry === 'string' ? metadata.registry : undefined;
-        const tagArg = typeof metadata?.tag === 'string' ? metadata.tag : undefined;
-        const warnFn = (message) => {
-            console.log(chalk.keyword('orange')(message));
-        };
-        const { registry, tag, registryConfigKey } = await (0, npm_config_1.parseRegistryOptions)(devkit_1.workspaceRoot, {
-            packageRoot: sourceManifestRoot,
-            packageJson,
-        }, {
-            registry: registryArg,
-            tag: tagArg,
-        }, warnFn);
-        let currentVersion = null;
-        try {
-            // Must be non-blocking async to allow spinner to render
-            currentVersion = await new Promise((resolve, reject) => {
-                (0, node_child_process_1.exec)(`npm view ${packageName} version --"${registryConfigKey}=${registry}" --tag=${tag}`, {
-                    windowsHide: false,
-                }, (error, stdout, stderr) => {
-                    if (error) {
-                        return reject(error);
-                    }
-                    if (stderr) {
-                        return reject(stderr);
-                    }
-                    return resolve(stdout.trim());
-                });
-            });
-        }
-        catch { }
-        return {
-            currentVersion,
-            // Make troubleshooting easier by including the registry and tag data in the log text
-            logText: `"${registryConfigKey}=${registry}" tag=${tag}`,
-        };
-    }
-    async getCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
-        const json = (0, devkit_1.readJson)(tree, this.getSourceManifestPath());
-        // Resolve the package name from the project graph metadata, as it may not match the project name
-        const dependencyPackageName = projectGraph.nodes[dependencyProjectName].data.metadata?.js?.packageName;
-        const dependencyTypes = [
-            'dependencies',
-            'devDependencies',
-            'peerDependencies',
-            'optionalDependencies',
-        ];
-        let currentVersion = null;
-        let dependencyCollection = null;
-        for (const depType of dependencyTypes) {
-            if (json[depType] && json[depType][dependencyPackageName]) {
-                currentVersion = json[depType][dependencyPackageName];
-                dependencyCollection = depType;
-                break;
-            }
-        }
-        return {
-            currentVersion,
-            dependencyCollection,
-        };
-    }
-    // NOTE: The TODOs were carried over from the original implementation, they are not yet implemented
-    isLocalDependencyProtocol(versionSpecifier) {
-        const localPackageProtocols = [
-            'file:', // all package managers
-            'workspace:', // not npm
-            // TODO: Support portal protocol at the project graph level before enabling here
-            // 'portal:', // modern yarn only
-        ];
-        // Not using a supported local protocol
-        if (!localPackageProtocols.some((protocol) => versionSpecifier.startsWith(protocol))) {
-            return false;
-        }
-        // Supported by all package managers
-        if (versionSpecifier.startsWith('file:')) {
-            return true;
-        }
-        // Determine specific package manager in use
-        if (!pm) {
-            pm = (0, devkit_1.detectPackageManager)();
-            // pmVersion = getPackageManagerVersion(pm);
-        }
-        if (pm === 'npm' && versionSpecifier.startsWith('workspace:')) {
-            throw new Error(`The "workspace:" protocol is not yet supported by npm (https://github.com/npm/rfcs/issues/765). Please ensure you have a valid setup according to your package manager before attempting to release packages.`);
-        }
-        // TODO: Support portal protocol at the project graph level before enabling here
-        // if (
-        //   version.startsWith('portal:') &&
-        //   (pm !== 'yarn' || lt(pmVersion, '2.0.0'))
-        // ) {
-        //   throw new Error(
-        //     `The "portal:" protocol is only supported by yarn@2.0.0 and above. Please ensure you have a valid setup according to your package manager before attempting to release packages.`
-        //   );
-        // }
-        return true;
-    }
-    async writeVersionToManifests(tree, newVersion) {
-        for (const manifestPath of this.manifestsToUpdate) {
-            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
-                json.version = newVersion;
-                return json;
-            });
-        }
-    }
-    async updateDependencies(tree, projectGraph, dependenciesToUpdate) {
-        for (const manifestPath of this.manifestsToUpdate) {
-            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
-                const dependencyTypes = [
-                    'dependencies',
-                    'devDependencies',
-                    'peerDependencies',
-                    'optionalDependencies',
-                ];
-                for (const depType of dependencyTypes) {
-                    if (json[depType]) {
-                        for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
-                            // Resolve the package name from the project graph metadata, as it may not match the project name
-                            const packageName = projectGraph.nodes[dep].data.metadata?.js?.packageName;
-                            if (!packageName) {
-                                throw new Error(`Unable to determine the package name for project "${dep}" from the project graph metadata, please ensure that the "@nx/js" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/nrwl/nx/issues`);
-                            }
-                            if (json[depType][packageName]) {
-                                json[depType][packageName] = version;
-                            }
-                        }
-                    }
-                }
-                return json;
-            });
-        }
-    }
-    parseDependencies(packageJson) {
-        const result = {};
-        const dependencyCollections = [
-            'dependencies',
-            'devDependencies',
-            'peerDependencies',
-            'optionalDependencies',
-        ];
-        for (const depCollection of dependencyCollections) {
-            if (packageJson[depCollection]) {
-                result[depCollection] = {};
-                for (const [dep, spec] of Object.entries(packageJson[depCollection])) {
-                    const resolvedSpec = (0, resolve_version_spec_1.resolveVersionSpec)(dep, packageJson.version, spec, this.projectGraphNode.data.root);
-                    result[depCollection][dep] = {
-                        resolvedVersion: resolvedSpec,
-                        rawVersionSpec: spec,
-                    };
-                }
-            }
-        }
-        return result;
-    }
-}
-exports.default = JsVersionActions;