@nx/js 20.5.0-rc.4 → 20.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "20.5.0-rc.4",
+  "version": "20.5.1",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "20.5.0-rc.4",
-    "@nx/workspace": "20.5.0-rc.4",
+    "@nx/devkit": "20.5.1",
+    "@nx/workspace": "20.5.1",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",

package/src/generators/library/library.js

@@ -42,16 +42,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, {

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

@@ -1,6 +1,7 @@
 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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectPackageManagerWorkspaceState = getProjectPackageManagerWorkspaceState;
+exports.getPackageManagerWorkspacesPatterns = getPackageManagerWorkspacesPatterns;
 exports.isUsingPackageManagerWorkspaces = isUsingPackageManagerWorkspaces;
 exports.isWorkspacesEnabled = isWorkspacesEnabled;
 exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageManagerWorkspaceStateWarningTask;
@@ -13,13 +14,16 @@ function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     if (!isUsingPackageManagerWorkspaces(tree)) {
         return 'no-workspaces';
     }
-    const patterns = (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }), (path) => {
+    const patterns = getPackageManagerWorkspacesPatterns(tree);
+    const isIncluded = patterns.some((p) => picomatch(p)((0, posix_1.join)(projectRoot, 'package.json')));
+    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));
-    const isIncluded = patterns.some((p) => picomatch(p)((0, posix_1.join)(projectRoot, 'package.json')));
-    return isIncluded ? 'included' : 'excluded';
 }
 function isUsingPackageManagerWorkspaces(tree) {
     return isWorkspacesEnabled(tree);

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

@@ -4,6 +4,6 @@ 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 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): void;
+export declare function addProjectToTsSolutionWorkspace(tree: Tree, projectDir: string): Promise<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

@@ -145,16 +145,29 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
         });
     }
 }
-function addProjectToTsSolutionWorkspace(tree, projectDir) {
+async function addProjectToTsSolutionWorkspace(tree, projectDir) {
     const state = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(tree, projectDir);
     if (state === 'included') {
         return;
     }
-    // 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.
+    // 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.
     const baseDir = (0, posix_1.dirname)(projectDir);
-    const pattern = baseDir === '.' ? projectDir : `${baseDir}/*`;
+    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}/*`;
+        }
+    }
     if (tree.exists('pnpm-workspace.yaml')) {
         const { load, dump } = require('@zkochan/js-yaml');
         const workspaceFile = tree.read('pnpm-workspace.yaml', 'utf-8');