@nx/js 20.2.0-beta.3 → 20.2.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "20.2.0-beta.3",
+  "version": "20.2.0-beta.4",
   "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.2.0-beta.3",
-    "@nx/workspace": "20.2.0-beta.3",
+    "@nx/devkit": "20.2.0-beta.4",
+    "@nx/workspace": "20.2.0-beta.4",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",

package/src/generators/library/library.js

@@ -135,6 +135,10 @@ async function libraryGeneratorInternal(tree, schema) {
             logNxReleaseDocsInfo();
         });
     }
+    // Always run install to link packages.
+    if (options.isUsingTsSolutionConfig) {
+        tasks.push(() => (0, devkit_1.installPackagesTask)(tree));
+    }
     tasks.push(() => {
         (0, log_show_project_command_1.logShowProjectCommand)(options.name);
     });
@@ -816,6 +820,17 @@ function determineEntryFields(options) {
                 // Safest option is to not set a type field.
                 // Allow the user to decide which module format their library is using
                 type: undefined,
+                // For non-buildable libraries, point to source so we can still use them in apps via bundlers like Vite.
+                main: options.isUsingTsSolutionConfig
+                    ? options.js
+                        ? './src/index.js'
+                        : './src/index.ts'
+                    : undefined,
+                types: options.isUsingTsSolutionConfig
+                    ? options.js
+                        ? './src/index.js'
+                        : './src/index.ts'
+                    : undefined,
             };
         }
     }

package/src/generators/library/schema.d.ts

@@ -1,7 +1,4 @@
-import type {
-  ProjectNameAndRootFormat,
-  ProjectNameAndRootOptions,
-} from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { ProjectNameAndRootOptions } from '@nx/devkit/src/generators/project-name-and-root-utils';
 // nx-ignore-next-line
 const { Linter, LinterType } = require('@nx/eslint'); // use require to import to avoid circular dependency
 import type { ProjectPackageManagerWorkspaceState } from '../../utils/package-manager-workspaces';
@@ -12,7 +9,6 @@ export type Bundler = 'swc' | 'tsc' | 'rollup' | 'vite' | 'esbuild' | 'none';
 export interface LibraryGeneratorSchema {
   directory: string;
   name?: string;
-  projectNameAndRootFormat?: ProjectNameAndRootFormat;
   skipFormat?: boolean;
   tags?: string;
   skipTsConfig?: boolean;

package/src/plugins/typescript/plugin.js

@@ -72,12 +72,20 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
         !siblingFiles.includes('tsconfig.json')) {
         return {};
     }
+    // Do not create project for Next.js projects since they are not compatible with
+    // project references and typecheck will fail.
+    if (siblingFiles.includes('next.config.js') ||
+        siblingFiles.includes('next.config.cjs') ||
+        siblingFiles.includes('next.config.mjs') ||
+        siblingFiles.includes('next.config.ts')) {
+        return {};
+    }
     /**
      * The cache key is composed by:
      * - 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
+     *   - referenced config files that are internal to the owning Nx project of the current config file, or is a shallow external reference of the owning Nx project
      *   - lock file
      * - hash of the plugin options
      * - current config file path
@@ -85,11 +93,13 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
     const tsConfig = readCachedTsConfig(fullConfigPath);
     const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, tsConfig);
     const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
+    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
     const nodeHash = (0, file_hasher_1.hashArray)([
         ...[
             fullConfigPath,
             ...extendedConfigFiles.files,
             ...Object.keys(internalReferencedFiles),
+            ...Object.keys(externalProjectReferences),
             (0, node_path_1.join)(context.workspaceRoot, lockFileName),
         ].map(file_hasher_1.hashFile),
         (0, file_hasher_1.hashObject)(options),
@@ -119,14 +129,15 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
     // Typecheck target
     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;
         if (!targets[targetName]) {
             let command = `tsc --build --emitDeclarationOnly --pretty --verbose`;
             if (tsConfig.options.noEmit ||
-                Object.values(internalProjectReferences).some((ref) => ref.options.noEmit)) {
-                // `--emitDeclarationOnly` and `--noEmit` are mutually exclusive, so
-                // we remove `--emitDeclarationOnly` if `--noEmit` is set.
-                command = `tsc --build --pretty --verbose`;
+                Object.values(internalProjectReferences).some((ref) => ref.options.noEmit) ||
+                Object.values(externalProjectReferences).some((ref) => ref.options.noEmit)) {
+                // `tsc --build` does not work with `noEmit: true`
+                command = `echo "The 'typecheck' target is disabled because one or more project references set 'noEmit: true' in their tsconfig. Remove this property to resolve this issue."`;
             }
             targets[targetName] = {
                 dependsOn: [`^${targetName}`],
@@ -321,6 +332,27 @@ function getExtendedConfigFiles(tsConfigPath, tsConfig) {
     };
 }
 function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
+    walkProjectReferences(tsConfig, workspaceRoot, projectRoot, (configPath, config) => {
+        if (isExternalProjectReference(configPath, workspaceRoot, projectRoot)) {
+            return false;
+        }
+        else {
+            projectReferences[configPath] = config;
+        }
+    });
+    return projectReferences;
+}
+function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
+    walkProjectReferences(tsConfig, workspaceRoot, projectRoot, (configPath, config) => {
+        if (isExternalProjectReference(configPath, workspaceRoot, projectRoot)) {
+            projectReferences[configPath] = config;
+        }
+        return false;
+    });
+    return projectReferences;
+}
+function walkProjectReferences(tsConfig, workspaceRoot, projectRoot, visitor, // false stops recursion
+projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return projectReferences;
     }
@@ -334,15 +366,14 @@ function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot,
             // the referenced tsconfig doesn't exist, ignore it
             continue;
         }
-        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
-            continue;
-        }
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
         const refTsConfig = readCachedTsConfig(refConfigPath);
-        projectReferences[refConfigPath] = refTsConfig;
-        resolveInternalProjectReferences(refTsConfig, workspaceRoot, projectRoot, projectReferences);
+        const result = visitor(refConfigPath, refTsConfig);
+        if (result !== false) {
+            walkProjectReferences(refTsConfig, workspaceRoot, projectRoot, visitor);
+        }
     }
     return projectReferences;
 }

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

@@ -2,4 +2,5 @@ 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 isWorkspacesEnabled(tree: Tree): boolean;
 export declare function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState, workspaceRoot: string): GeneratorCallback;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectPackageManagerWorkspaceState = getProjectPackageManagerWorkspaceState;
 exports.isUsingPackageManagerWorkspaces = isUsingPackageManagerWorkspaces;
+exports.isWorkspacesEnabled = isWorkspacesEnabled;
 exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageManagerWorkspaceStateWarningTask;
 const devkit_1 = require("@nx/devkit");
 const minimatch_1 = require("minimatch");
@@ -17,7 +18,19 @@ function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     return isIncluded ? 'included' : 'excluded';
 }
 function isUsingPackageManagerWorkspaces(tree) {
-    return (0, devkit_1.isWorkspacesEnabled)((0, devkit_1.detectPackageManager)(tree.root), tree.root);
+    return 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');
+    }
+    // yarn and npm both use the same 'workspaces' property in package.json
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    return !!packageJson?.workspaces;
 }
 function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState, workspaceRoot) {
     return () => {

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

@@ -2,3 +2,4 @@ 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 updateTsconfigFiles(tree: Tree, projectRoot: string, runtimeTsconfigFileName: string, compilerOptions: Record<string, string | boolean | string[]>, exclude?: string[], rootDir?: string): void;

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

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isUsingTypeScriptPlugin = isUsingTypeScriptPlugin;
 exports.isUsingTsSolutionSetup = isUsingTsSolutionSetup;
 exports.assertNotUsingTsSolutionSetup = assertNotUsingTsSolutionSetup;
+exports.updateTsconfigFiles = updateTsconfigFiles;
 const devkit_1 = require("@nx/devkit");
 const tree_1 = require("nx/src/generators/tree");
 const package_manager_workspaces_1 = require("../package-manager-workspaces");
+const posix_1 = require("node:path/posix");
 function isUsingTypeScriptPlugin(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     return (nxJson?.plugins?.some((p) => typeof p === 'string'
@@ -65,3 +67,63 @@ function assertNotUsingTsSolutionSetup(tree, pluginName, generatorName) {
     });
     process.exit(1);
 }
+function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compilerOptions, exclude = [], rootDir = 'src') {
+    if (!isUsingTsSolutionSetup(tree))
+        return;
+    const offset = (0, devkit_1.offsetFromRoot)(projectRoot);
+    const tsconfig = `${projectRoot}/${runtimeTsconfigFileName}`;
+    const tsconfigSpec = `${projectRoot}/tsconfig.spec.json`;
+    const e2eRoot = `${projectRoot}-e2e`;
+    const tsconfigE2E = `${e2eRoot}/tsconfig.json`;
+    if (tree.exists(tsconfig)) {
+        (0, devkit_1.updateJson)(tree, tsconfig, (json) => {
+            json.extends = (0, devkit_1.joinPathFragments)(offset, 'tsconfig.base.json');
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                // 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,
+            };
+            const excludeSet = json.exclude
+                ? new Set(['dist', ...json.exclude, ...exclude])
+                : new Set(exclude);
+            json.exclude = Array.from(excludeSet);
+            return json;
+        });
+    }
+    if (tree.exists(tsconfigSpec)) {
+        (0, devkit_1.updateJson)(tree, tsconfigSpec, (json) => {
+            json.extends = (0, devkit_1.joinPathFragments)(offset, 'tsconfig.base.json');
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                ...compilerOptions,
+            };
+            const runtimePath = `./${runtimeTsconfigFileName}`;
+            json.references ??= [];
+            if (!json.references.some((x) => x.path === runtimePath))
+                json.references.push({ path: runtimePath });
+            return json;
+        });
+    }
+    if (tree.exists(tsconfigE2E)) {
+        // tsconfig.json for e2e projects need to have references array
+        (0, devkit_1.updateJson)(tree, tsconfigE2E, (json) => {
+            json.references ??= [];
+            const projectPath = (0, posix_1.relative)(e2eRoot, projectRoot);
+            if (!json.references.some((x) => x.path === projectPath))
+                json.references.push({ path: projectPath });
+            return json;
+        });
+    }
+    if (tree.exists('tsconfig.json')) {
+        (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {
+            const projectPath = './' + projectRoot;
+            json.references ??= [];
+            if (!json.references.some((x) => x.path === projectPath))
+                json.references.push({ path: projectPath });
+            return json;
+        });
+    }
+}