@nx/js 20.3.0 → 20.4.0-beta.0

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2024 Narwhal Technologies Inc.
+Copyright (c) 2017-2025 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/package.json

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

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

@@ -29,9 +29,7 @@ function normalizeOptions(options, root, sourceRoot, projectRoot) {
         }
     }
     const outputPath = (0, path_1.join)(root, options.outputPath);
-    if (options.skipTypeCheck == null && !isTsSolutionSetup) {
-        options.skipTypeCheck = false;
-    }
+    options.skipTypeCheck ??= !isTsSolutionSetup;
     if (options.watch == null) {
         options.watch = false;
     }

package/src/generators/init/files/ts-solution/tsconfig.base.json__tmpl__

@@ -1,17 +1,9 @@
 {
   "compilerOptions": {
-    "allowJs": false,
-    "allowSyntheticDefaultImports": true,
     "composite": true,
-    "declaration": true,
     "declarationMap": true,
     "emitDeclarationOnly": true,
-    "emitDecoratorMetadata": false,
-    "esModuleInterop": true,
-    "experimentalDecorators": false,
-    "forceConsistentCasingInFileNames": true,
     "importHelpers": true,
-    "incremental": true,
     "isolatedModules": true,
     "lib": ["es2022"],
     "module": "NodeNext",
@@ -21,14 +13,8 @@
     "noImplicitOverride": true,
     "noImplicitReturns": true,
     "noUnusedLocals": true,
-    "pretty": true,
-    "removeComments": false,
-    "resolveJsonModule": false,
-    "skipDefaultLibCheck": false,
     "skipLibCheck": true,
-    "sourceMap": false,
     "strict": true,
-    "target": "es2022",
-    "verbatimModuleSyntax": false
+    "target": "es2022"
   }
 }

package/src/generators/init/init.js

@@ -64,9 +64,24 @@ async function initGeneratorInternal(tree, schema) {
                 { targetName: 'tsc-typecheck' },
             ],
             build: [
-                { targetName: 'build', configName: 'tsconfig.lib.json' },
-                { targetName: 'tsc:build', configName: 'tsconfig.lib.json' },
-                { targetName: 'tsc-build', configName: 'tsconfig.lib.json' },
+                {
+                    targetName: 'build',
+                    configName: 'tsconfig.lib.json',
+                    buildDepsName: 'build-deps',
+                    watchDepsName: 'watch-deps',
+                },
+                {
+                    targetName: 'tsc:build',
+                    configName: 'tsconfig.lib.json',
+                    buildDepsName: 'tsc:build-deps',
+                    watchDepsName: 'tsc:watch-deps',
+                },
+                {
+                    targetName: 'tsc-build',
+                    configName: 'tsconfig.lib.json',
+                    buildDepsName: 'tsc-build-deps',
+                    watchDepsName: 'tsc-watch-deps',
+                },
             ],
         }, schema.updatePackageScripts);
     }

package/src/generators/library/files/lib/src/lib/__fileName__.spec.ts__tmpl__

@@ -1,4 +1,4 @@
-import { <%= propertyName %> } from './<%= fileName %>';
+import { <%= propertyName %> } from './<%= fileNameImport %>';
 
 describe('<%= propertyName %>', () => {
   it('should work', () => {

package/src/generators/library/library.js

@@ -11,18 +11,18 @@ const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-projec
 const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
 const path_1 = require("path");
 const generator_prompts_1 = require("../../utils/generator-prompts");
-const package_manager_workspaces_1 = require("../../utils/package-manager-workspaces");
+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 configuration_1 = require("../../utils/typescript/configuration");
 const create_ts_config_1 = require("../../utils/typescript/create-ts-config");
+const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
 const plugin_1 = require("../../utils/typescript/plugin");
 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 init_1 = require("../init/init");
 const generator_1 = require("../setup-verdaccio/generator");
-const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
@@ -55,7 +55,7 @@ async function libraryGeneratorInternal(tree, schema) {
         await configurationGenerator(tree, {
             project: options.name,
             compiler: 'swc',
-            format: ['cjs', 'esm'],
+            format: options.isUsingTsSolutionConfig ? ['esm'] : ['cjs', 'esm'],
         });
     }
     if (options.bundler === 'vite') {
@@ -101,6 +101,7 @@ async function libraryGeneratorInternal(tree, schema) {
             testEnvironment: options.testEnvironment,
             runtimeTsconfigFileName: 'tsconfig.lib.json',
             compiler: options.compiler === 'swc' ? 'swc' : 'babel',
+            addPlugin: options.addPlugin,
         });
         tasks.push(vitestTask);
         createOrEditViteConfig(tree, {
@@ -120,17 +121,21 @@ async function libraryGeneratorInternal(tree, schema) {
             // add project reference to the runtime tsconfig.lib.json file
             json.references ??= [];
             json.references.push({ path: './tsconfig.lib.json' });
+            if (options.isUsingTsSolutionConfig && options.bundler === 'rollup') {
+                json.compilerOptions.module = 'esnext';
+                json.compilerOptions.moduleResolution = 'bundler';
+            }
             return json;
         });
     }
+    // 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);
+    }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
-    if (!options.skipWorkspacesWarning &&
-        options.isUsingTsSolutionConfig &&
-        options.projectPackageManagerWorkspaceState !== 'included') {
-        tasks.push((0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceStateWarningTask)(options.projectPackageManagerWorkspaceState, tree.root));
-    }
     if (options.publishable) {
         tasks.push(() => {
             logNxReleaseDocsInfo();
@@ -138,7 +143,7 @@ async function libraryGeneratorInternal(tree, schema) {
     }
     // Always run install to link packages.
     if (options.isUsingTsSolutionConfig) {
-        tasks.push(() => (0, devkit_1.installPackagesTask)(tree));
+        tasks.push(() => (0, devkit_1.installPackagesTask)(tree, true));
     }
     tasks.push(() => {
         (0, log_show_project_command_1.logShowProjectCommand)(options.name);
@@ -175,15 +180,13 @@ async function configureProject(tree, options) {
                 tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
             },
         };
-        if (options.bundler === 'esbuild') {
-            projectConfiguration.targets.build.options.format = ['cjs'];
-        }
         if (options.bundler === 'swc' &&
             (options.skipTypeCheck || options.isUsingTsSolutionConfig)) {
             projectConfiguration.targets.build.options.skipTypeCheck = true;
         }
         if (options.isUsingTsSolutionConfig) {
             if (options.bundler === 'esbuild') {
+                projectConfiguration.targets.build.options.format = ['esm'];
                 projectConfiguration.targets.build.options.declarationRootDir = `${options.projectRoot}/src`;
             }
             else if (options.bundler === 'swc') {
@@ -193,6 +196,7 @@ async function configureProject(tree, options) {
         else {
             projectConfiguration.targets.build.options.assets = [];
             if (options.bundler === 'esbuild') {
+                projectConfiguration.targets.build.options.format = ['cjs'];
                 projectConfiguration.targets.build.options.generatePackageJson = true;
             }
             if (!options.minimal) {
@@ -308,7 +312,7 @@ async function addLint(tree, options) {
             }
             else if (options.bundler === 'rollup') {
                 ruleOptions.ignoredFiles ??= [];
-                ruleOptions.ignoredFiles.push('{projectRoot}/rollup.config.{js,ts,mjs,mts}');
+                ruleOptions.ignoredFiles.push('{projectRoot}/rollup.config.{js,ts,mjs,mts,cjs,cts}');
                 o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
             }
             else if (options.bundler === 'esbuild') {
@@ -332,7 +336,7 @@ function createFiles(tree, options) {
     const { className, name, propertyName } = (0, devkit_1.names)(options.projectNames.projectFileName);
     createProjectTsConfigs(tree, options);
     let fileNameImport = options.fileName;
-    if (options.bundler === 'vite') {
+    if (options.bundler === 'vite' || options.isUsingTsSolutionConfig) {
         const tsConfig = (0, ts_config_1.readTsConfigFromTree)(tree, (0, path_1.join)(options.projectRoot, 'tsconfig.lib.json'));
         const ts = (0, ensure_typescript_1.ensureTypescript)();
         if (tsConfig.options.moduleResolution === ts.ModuleResolutionKind.Node16 ||
@@ -376,7 +380,9 @@ function createFiles(tree, options) {
         });
     }
     if (options.bundler === 'swc' || options.bundler === 'rollup') {
-        (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot, options.bundler === 'swc' ? 'commonjs' : 'es6');
+        (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot, options.bundler === 'swc' && !options.isUsingTsSolutionConfig
+            ? 'commonjs'
+            : 'es6');
     }
     else if (options.includeBabelRc) {
         addBabelRc(tree, options);
@@ -405,7 +411,7 @@ function createFiles(tree, options) {
                 // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
                 json.files = ['dist', '!**/*.tsbuildinfo'];
             }
-            return {
+            const updatedPackageJson = {
                 ...json,
                 dependencies: {
                     ...json.dependencies,
@@ -413,10 +419,25 @@ function createFiles(tree, options) {
                 },
                 ...determineEntryFields(options),
             };
+            if (options.bundler === 'none') {
+                updatedPackageJson.type = 'module';
+            }
+            else if (options.bundler !== 'vite' && options.bundler !== 'rollup') {
+                return (0, update_package_json_1.getUpdatedPackageJsonContent)(updatedPackageJson, {
+                    main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
+                    outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
+                    projectRoot: options.projectRoot,
+                    rootDir: (0, path_1.join)(options.projectRoot, 'src'),
+                    generateExportsField: true,
+                    packageJsonPath,
+                    format: ['esm'],
+                });
+            }
+            return updatedPackageJson;
         });
     }
     else {
-        const packageJson = {
+        let packageJson = {
             name: options.importPath,
             version: '0.0.1',
             dependencies: determineDependencies(options),
@@ -430,6 +451,22 @@ function createFiles(tree, options) {
             // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
             packageJson.files = ['dist', '!**/*.tsbuildinfo'];
         }
+        if (options.isUsingTsSolutionConfig) {
+            if (options.bundler === 'none') {
+                packageJson.type = 'module';
+            }
+            else if (options.bundler !== 'vite' && options.bundler !== 'rollup') {
+                packageJson = (0, update_package_json_1.getUpdatedPackageJsonContent)(packageJson, {
+                    main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
+                    outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
+                    projectRoot: options.projectRoot,
+                    rootDir: (0, path_1.join)(options.projectRoot, 'src'),
+                    generateExportsField: true,
+                    packageJsonPath,
+                    format: ['esm'],
+                });
+            }
+        }
         (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
     }
     if (options.config === 'npm-scripts') {
@@ -577,7 +614,6 @@ async function normalizeOptions(tree, options) {
         ? options.tags.split(',').map((s) => s.trim())
         : [];
     options.minimal ??= false;
-    const projectPackageManagerWorkspaceState = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(tree, projectRoot);
     // We default to generate a project.json file if the new setup is not being used
     options.useProjectJson ??= !isUsingTsSolutionConfig;
     return {
@@ -590,7 +626,6 @@ async function normalizeOptions(tree, options) {
         importPath,
         hasPlugin,
         isUsingTsSolutionConfig,
-        projectPackageManagerWorkspaceState,
     };
 }
 function addProjectDependencies(tree, options) {
@@ -774,75 +809,87 @@ function determineDependencies(options) {
 function determineEntryFields(options) {
     switch (options.bundler) {
         case 'tsc':
-            return {
-                type: 'commonjs',
-                main: options.isUsingTsSolutionConfig
-                    ? './dist/index.js'
-                    : './src/index.js',
-                typings: options.isUsingTsSolutionConfig
-                    ? './dist/index.d.ts'
-                    : './src/index.d.ts',
-            };
         case 'swc':
-            return {
-                type: 'commonjs',
-                main: options.isUsingTsSolutionConfig
-                    ? './dist/index.js'
-                    : './src/index.js',
-                typings: options.isUsingTsSolutionConfig
-                    ? './dist/index.d.ts'
-                    : './src/index.d.ts',
-            };
+            if (options.isUsingTsSolutionConfig) {
+                return {
+                    type: 'module',
+                    main: './dist/index.js',
+                    types: './dist/index.d.ts',
+                };
+            }
+            else {
+                return {
+                    type: 'commonjs',
+                    main: './src/index.js',
+                    types: './src/index.d.ts',
+                };
+            }
         case 'rollup':
-            return {
-                // Since we're publishing both formats, skip the type field.
-                // Bundlers or Node will determine the entry point to use.
-                main: options.isUsingTsSolutionConfig
-                    ? './dist/index.cjs'
-                    : './index.cjs',
-                module: options.isUsingTsSolutionConfig
-                    ? './dist/index.js'
-                    : './index.js',
-            };
+            if (options.isUsingTsSolutionConfig) {
+                // the rollup configuration generator already handles this
+                return {};
+            }
+            else {
+                return {
+                    // Since we're publishing both formats, skip the type field.
+                    // Bundlers or Node will determine the entry point to use.
+                    main: './index.cjs',
+                    module: './index.js',
+                };
+            }
         case 'vite':
-            return {
-                type: 'module',
-                main: options.isUsingTsSolutionConfig
-                    ? './dist/index.js'
-                    : './index.js',
-                typings: options.isUsingTsSolutionConfig
-                    ? './dist/index.d.ts'
-                    : './index.d.ts',
-            };
+            if (options.isUsingTsSolutionConfig) {
+                // the vite configuration generator already handle this
+                return {};
+            }
+            else {
+                return {
+                    type: 'module',
+                    main: './index.js',
+                    types: './index.d.ts',
+                };
+            }
         case 'esbuild':
-            // For libraries intended for Node, use CJS.
-            return {
-                type: 'commonjs',
-                main: options.isUsingTsSolutionConfig
-                    ? './dist/index.cjs'
-                    : './index.cjs',
-                typings: options.isUsingTsSolutionConfig
-                    ? './dist/index.d.ts'
-                    : './index.d.ts',
-            };
-        default: {
+            if (options.isUsingTsSolutionConfig) {
+                return {
+                    type: 'module',
+                    main: './dist/index.js',
+                    types: './dist/index.d.ts',
+                };
+            }
+            else {
+                return {
+                    type: 'commonjs',
+                    main: './index.cjs',
+                    types: './index.d.ts',
+                };
+            }
+        case 'none': {
+            if (options.isUsingTsSolutionConfig) {
+                return {
+                    main: options.js ? './src/index.js' : './src/index.ts',
+                    types: options.js ? './src/index.js' : './src/index.ts',
+                    exports: {
+                        '.': options.js
+                            ? './src/index.js'
+                            : {
+                                types: './src/index.ts',
+                                import: './src/index.ts',
+                                default: './src/index.ts',
+                            },
+                        './package.json': './package.json',
+                    },
+                };
+            }
             return {
                 // 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,
             };
         }
+        default: {
+            return {};
+        }
     }
 }
 function projectsConfigMatchesProject(projectsConfig, project) {

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

@@ -33,7 +33,6 @@ export interface LibraryGeneratorSchema {
   simpleName?: boolean;
   addPlugin?: boolean;
   useProjectJson?: boolean;
-  skipWorkspacesWarning?: boolean;
   useTscExecutor?: boolean;
 }
 
@@ -47,5 +46,4 @@ export interface NormalizedLibraryGeneratorOptions
   importPath?: string;
   hasPlugin: boolean;
   isUsingTsSolutionConfig: boolean;
-  projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState;
 }

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

@@ -99,7 +99,7 @@ function execLockFileUpdate(command, cwd, env = {}) {
                 `Verify that '${command}' succeeds when run from the workspace root.`,
                 `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.skipLockFileUpdate' to true in nx.json.`,
+                `To disable this step entirely, set 'release.version.generatorOptions.skipLockFileUpdate' to true in nx.json.`,
             ],
         });
         throw e;

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

@@ -98,7 +98,7 @@ async function setupBuildGenerator(tree, options) {
                 project: options.project,
                 skipFormat: true,
                 skipValidation: true,
-                format: ['cjs'],
+                format: isTsSolutionSetup ? ['esm'] : ['cjs'],
             });
             tasks.push(task);
             break;
@@ -111,7 +111,7 @@ async function setupBuildGenerator(tree, options) {
                 tsConfig: tsConfigFile,
                 project: options.project,
                 compiler: 'tsc',
-                format: ['cjs', 'esm'],
+                format: isTsSolutionSetup ? ['esm'] : ['cjs', 'esm'],
                 addPlugin,
                 skipFormat: true,
                 skipValidation: true,
@@ -165,7 +165,7 @@ async function setupBuildGenerator(tree, options) {
             }
             (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
             tasks.push((0, add_swc_dependencies_1.addSwcDependencies)(tree));
-            (0, add_swc_config_1.addSwcConfig)(tree, project.root, 'commonjs');
+            (0, add_swc_config_1.addSwcConfig)(tree, project.root, isTsSolutionSetup ? 'es6' : 'commonjs');
             if (isTsSolutionSetup) {
                 updatePackageJsonForSwc(tree, options, project);
             }

package/src/generators/typescript-sync/typescript-sync.js

@@ -199,8 +199,9 @@ function updateTsConfigReferences(tree, tsSysFromTree, tsconfigInfoCaches, tsCon
     }
     let hasChanges = false;
     for (const dep of dependencies) {
-        // Ensure the project reference for the target is set
-        let referencePath = dep.data.root;
+        // Ensure the project reference for the target is set if we can find the
+        // relevant tsconfig file
+        let referencePath;
         if (runtimeTsConfigFileName) {
             const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, runtimeTsConfigFileName);
             if (tsconfigExists(tree, tsconfigInfoCaches, runtimeTsConfigPath)) {
@@ -233,6 +234,14 @@ function updateTsConfigReferences(tree, tsSysFromTree, tsconfigInfoCaches, tsCon
                 continue;
             }
         }
+        if (!referencePath) {
+            if (tsconfigExists(tree, tsconfigInfoCaches, (0, devkit_1.joinPathFragments)(dep.data.root, 'tsconfig.json'))) {
+                referencePath = dep.data.root;
+            }
+            else {
+                continue;
+            }
+        }
         const relativePathToTargetRoot = (0, posix_1.relative)(projectRoot, referencePath);
         if (!newReferencesSet.has(relativePathToTargetRoot)) {
             newReferencesSet.add(relativePathToTargetRoot);
@@ -260,8 +269,8 @@ function collectProjectDependencies(tree, projectName, projectGraph, collectedDe
     collectedDependencies.set(projectName, []);
     for (const dep of projectGraph.dependencies[projectName]) {
         const targetProjectNode = projectGraph.nodes[dep.target];
-        if (!targetProjectNode) {
-            // It's an npm dependency
+        if (!targetProjectNode || dep.type === 'implicit') {
+            // It's an npm or an implicit dependency
             continue;
         }
         // Add the target project node to the list of dependencies for the current project
@@ -270,7 +279,7 @@ function collectProjectDependencies(tree, projectName, projectGraph, collectedDe
             .some((d) => d.name === targetProjectNode.name)) {
             collectedDependencies.get(projectName).push(targetProjectNode);
         }
-        if (process.env.NX_DISABLE_TS_SYNC_TRANSITIVE_DEPENDENCIES === 'true') {
+        if (process.env.NX_ENABLE_TS_SYNC_TRANSITIVE_DEPENDENCIES !== 'true') {
             continue;
         }
         // Recursively get the dependencies of the target project

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

@@ -6,6 +6,8 @@ export interface TscPluginOptions {
     build?: boolean | {
         targetName?: string;
         configName?: string;
+        buildDepsName?: string;
+        watchDepsName?: string;
     };
 }
 /**

package/src/plugins/typescript/plugin.js

@@ -11,6 +11,7 @@ const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const ts_config_1 = require("../../utils/typescript/ts-config");
+const util_1 = require("./util");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 function readTargetsCache(cachePath) {
     return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
@@ -94,6 +95,10 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
     const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, tsConfig);
     const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
     const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
+    const packageJson = (0, node_fs_1.existsSync)(packageJsonPath)
+        ? (0, devkit_1.readJsonFile)(packageJsonPath)
+        : null;
     const nodeHash = (0, file_hasher_1.hashArray)([
         ...[
             fullConfigPath,
@@ -103,6 +108,7 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
             (0, node_path_1.join)(context.workspaceRoot, lockFileName),
         ].map(file_hasher_1.hashFile),
         (0, file_hasher_1.hashObject)(options),
+        ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
     ]);
     const cacheKey = `${nodeHash}_${configFilePath}`;
     targetsCache[cacheKey] ??= buildTscTargets(fullConfigPath, projectRoot, options, context);
@@ -163,7 +169,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
     // Build target
     if (options.build &&
         (0, node_path_1.basename)(configFilePath) === options.build.configName &&
-        isValidPackageJsonBuildConfig(tsConfig, context.workspaceRoot, projectRoot, configFilePath)) {
+        isValidPackageJsonBuildConfig(tsConfig, context.workspaceRoot, projectRoot)) {
         internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const targetName = options.build.targetName;
         targets[targetName] = {
@@ -185,6 +191,10 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
                 },
             },
         };
+        (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, {
+            buildDepsTargetName: options.build.buildDepsName,
+            watchDepsTargetName: options.build.watchDepsName,
+        }, pmc);
     }
     return { targets };
 }
@@ -230,6 +240,9 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     });
     const inputs = [];
     if (includePaths.size) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json'))) {
+            inputs.push('{projectRoot}/package.json');
+        }
         inputs.push(...Array.from(configFiles).map((p) => pathToInputOrOutput(p, workspaceRoot, projectRoot)), ...Array.from(includePaths).map((p) => pathToInputOrOutput((0, devkit_1.joinPathFragments)(projectRoot, p), workspaceRoot, projectRoot)));
     }
     else {
@@ -274,10 +287,16 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
         }
         else if (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));
+            if (config.options.tsBuildInfoFile) {
+                if (!(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.options.rootDir && config.options.rootDir !== '.') {
+                // If rootDir is set, then the tsbuildinfo file will be outside the outDir so we need to add it.
+                const relativeRootDir = (0, node_path_1.relative)(config.options.rootDir, (0, node_path_1.join)(workspaceRoot, projectRoot));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, projectRoot));
             }
         }
         else if (config.fileNames.length) {
@@ -304,49 +323,45 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
     return Array.from(outputs);
 }
 /**
- * Checks whether a `package.json` file has a valid build configuration by ensuring
- * that the `main`, `module`, or `exports` do not include paths from the `rootDir`.
- * Or if `outFile` is defined, it should not be within the `rootDir`.
+ * 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.
- * @param tsConfigPath The path to the TypeScript configuration file.
  * @returns `true` if the package has a valid build configuration; otherwise, `false`.
  */
-function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot, tsConfigPath) {
-    if (!(0, node_fs_1.existsSync)((0, devkit_1.joinPathFragments)(projectRoot, 'package.json'))) {
+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)((0, devkit_1.joinPathFragments)(projectRoot, 'package.json'));
-    const rootDir = tsConfig.options.rootDir ?? 'src/';
-    if (!tsConfig.options.rootDir) {
-        console.warn(`The 'rootDir' option is not set in the tsconfig file at ${tsConfigPath}. Assuming 'src/' as the root directory.`);
-    }
-    const isPathWithinSrc = (path) => {
-        const resolvedRootDir = (0, node_path_1.resolve)(workspaceRoot, projectRoot, rootDir);
-        const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, projectRoot, path);
-        return pathToCheck.startsWith(resolvedRootDir);
-    };
-    // If `outFile` is defined, check the validity of the path.
-    if (tsConfig.options.outFile) {
-        if (isPathWithinSrc(tsConfig.options.outFile)) {
-            return false;
+    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 buildPaths = ['main', 'module'];
-    for (const field of buildPaths) {
-        if (packageJson[field] && isPathWithinSrc(packageJson[field])) {
-            return false;
-        }
-    }
-    const exports = packageJson?.exports;
+        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 isPathWithinSrc(value);
+            return isPathSourceFile(value);
         }
         else if (typeof value === 'object') {
             return Object.entries(value).some(([currentKey, subValue]) => {
@@ -355,30 +370,45 @@ function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot, tsC
                     return false;
                 }
                 if (typeof subValue === 'string') {
-                    return isPathWithinSrc(subValue);
+                    return isPathSourceFile(subValue);
                 }
                 return false;
             });
         }
         return false;
     };
-    if (typeof exports === 'string' && isPathWithinSrc(exports)) {
-        return false;
-    }
-    // Check nested exports if `exports` is an object.
-    if (typeof exports === 'object') {
+    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 (containsInvalidPath(exports[key])) {
+            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 pathRelativeToProjectRoot = (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, path));
+    const fullProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+    const fullPath = (0, node_path_1.resolve)(workspaceRoot, path);
+    const pathRelativeToProjectRoot = (0, devkit_1.normalizePath)((0, node_path_1.relative)(fullProjectRoot, fullPath));
     if (pathRelativeToProjectRoot.startsWith('..')) {
-        return (0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, path));
+        return (0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, fullPath));
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
@@ -536,6 +566,8 @@ function normalizePluginOptions(pluginOptions = {}) {
     let build = {
         targetName: defaultBuildTargetName,
         configName: defaultBuildConfigName,
+        buildDepsName: 'build-deps',
+        watchDepsName: 'watch-deps',
     };
     // Build target is not enabled by default
     if (!pluginOptions.build) {
@@ -545,6 +577,8 @@ function normalizePluginOptions(pluginOptions = {}) {
         build = {
             targetName: pluginOptions.build.targetName ?? defaultBuildTargetName,
             configName: pluginOptions.build.configName ?? defaultBuildConfigName,
+            buildDepsName: pluginOptions.build.buildDepsName ?? 'build-deps',
+            watchDepsName: pluginOptions.build.watchDepsName ?? 'watch-deps',
         };
     }
     return {

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

@@ -0,0 +1,9 @@
+import { type TargetConfiguration } from '@nx/devkit';
+import { type PackageManagerCommands } from 'nx/src/utils/package-manager';
+/**
+ * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
+ */
+export declare function addBuildAndWatchDepsTargets(workspaceRoot: string, projectRoot: string, targets: Record<string, TargetConfiguration>, options: {
+    buildDepsTargetName?: string;
+    watchDepsTargetName?: string;
+}, pmc: PackageManagerCommands): void;

package/src/plugins/typescript/util.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBuildAndWatchDepsTargets = addBuildAndWatchDepsTargets;
+const devkit_1 = require("@nx/devkit");
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+/**
+ * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
+ */
+function addBuildAndWatchDepsTargets(workspaceRoot, projectRoot, targets, options, pmc) {
+    let projectName;
+    const projectJsonPath = (0, path_1.join)(workspaceRoot, projectRoot, 'project.json');
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, projectRoot, 'package.json');
+    if ((0, node_fs_1.existsSync)(projectJsonPath)) {
+        const projectJson = (0, devkit_1.readJsonFile)(projectJsonPath);
+        projectName = projectJson.name;
+    }
+    else if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+        projectName = packageJson.nx?.name ?? packageJson.name;
+    }
+    if (!projectName)
+        return;
+    if (projectName) {
+        const buildDepsTargetName = options.buildDepsTargetName ?? 'build-deps';
+        targets[buildDepsTargetName] = {
+            dependsOn: ['^build'],
+        };
+        targets[options.watchDepsTargetName ?? 'watch-deps'] = {
+            dependsOn: [buildDepsTargetName],
+            command: `${pmc.exec} nx watch --projects ${projectName} --includeDependentProjects -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
+        };
+    }
+}

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

@@ -230,6 +230,9 @@ function computeCompilerOptionsPaths(tsConfig, dependencies) {
 }
 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.json');
+    if (tsconfigPath === tmpTsConfigPath) {
+        return tsconfigPath;
+    }
     const parsedTSConfig = readTsConfigWithRemappedPaths(tsconfigPath, tmpTsConfigPath, dependencies, workspaceRoot);
     process.on('exit', () => cleanupTmpTsConfigFile(tmpTsConfigPath));
     if (useWorkspaceAsBaseUrl) {

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

@@ -181,6 +181,9 @@ function getUpdatedPackageJsonContent(packageJson, options) {
                 }
                 else if (typeof packageJson.exports[exportEntry] === 'object') {
                     packageJson.exports[exportEntry].import ??= filePath;
+                    if (!hasCjsFormat) {
+                        packageJson.exports[exportEntry].default ??= filePath;
+                    }
                 }
             }
         }

package/src/utils/swc/compile-swc.js

@@ -52,6 +52,9 @@ function getTypeCheckOptions(normalizedOptions) {
         typeCheckOptions.incremental = true;
         typeCheckOptions.cacheDir = devkit_1.cacheDir;
     }
+    if (normalizedOptions.isTsSolutionSetup && normalizedOptions.skipTypeCheck) {
+        typeCheckOptions.ignoreDiagnostics = true;
+    }
     return typeCheckOptions;
 }
 async function compileSwc(context, normalizedOptions, postCompilationCallback) {
@@ -59,16 +62,25 @@ async function compileSwc(context, normalizedOptions, postCompilationCallback) {
     if (normalizedOptions.clean) {
         (0, node_fs_1.rmSync)(normalizedOptions.outputPath, { recursive: true, force: true });
     }
-    const swcCmdLog = (0, node_child_process_1.execSync)(getSwcCmd(normalizedOptions), {
-        encoding: 'utf8',
-        cwd: normalizedOptions.swcCliOptions.swcCwd,
-        windowsHide: false,
-    });
-    devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
-    const isCompileSuccess = swcCmdLog.includes('Successfully compiled');
-    if (normalizedOptions.skipTypeCheck || normalizedOptions.isTsSolutionSetup) {
+    try {
+        const swcCmdLog = (0, node_child_process_1.execSync)(getSwcCmd(normalizedOptions), {
+            encoding: 'utf8',
+            cwd: normalizedOptions.swcCliOptions.swcCwd,
+            windowsHide: false,
+            stdio: 'pipe',
+        });
+        devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
+    }
+    catch (error) {
+        devkit_1.logger.error('SWC compilation failed');
+        if (error.stderr) {
+            devkit_1.logger.error(error.stderr.toString());
+        }
+        return { success: false };
+    }
+    if (normalizedOptions.skipTypeCheck && !normalizedOptions.isTsSolutionSetup) {
         await postCompilationCallback();
-        return { success: isCompileSuccess };
+        return { success: true };
     }
     const { errors, warnings } = await (0, run_type_check_1.runTypeCheck)(getTypeCheckOptions(normalizedOptions));
     const hasErrors = errors.length > 0;
@@ -78,7 +90,7 @@ async function compileSwc(context, normalizedOptions, postCompilationCallback) {
     }
     await postCompilationCallback();
     return {
-        success: !hasErrors && isCompileSuccess,
+        success: !hasErrors,
         outfile: normalizedOptions.mainOutputPath,
     };
 }

package/src/utils/typescript/run-type-check.d.ts

@@ -14,6 +14,7 @@ interface BaseTypeCheckOptions {
     incremental?: boolean;
     rootDir?: string;
     projectRoot?: string;
+    ignoreDiagnostics?: boolean;
 }
 type Mode = NoEmitMode | EmitDeclarationOnlyMode;
 interface NoEmitMode {

package/src/utils/typescript/run-type-check.js

@@ -18,7 +18,9 @@ async function runTypeCheckWatch(options, callback) {
     };
     const watchProgram = ts.createWatchProgram(host);
     const program = watchProgram.getProgram().getProgram();
-    const diagnostics = ts.getPreEmitDiagnostics(program);
+    const diagnostics = options.ignoreDiagnostics
+        ? []
+        : ts.getPreEmitDiagnostics(program);
     return {
         close: watchProgram.close.bind(watchProgram),
         preEmitErrors: diagnostics
@@ -48,9 +50,9 @@ async function runTypeCheck(options) {
         program = ts.createProgram(config.fileNames, compilerOptions);
     }
     const result = program.emit();
-    const allDiagnostics = ts
-        .getPreEmitDiagnostics(program)
-        .concat(result.diagnostics);
+    const allDiagnostics = options.ignoreDiagnostics
+        ? []
+        : ts.getPreEmitDiagnostics(program).concat(result.diagnostics);
     return getTypeCheckResult(ts, allDiagnostics, workspaceRoot, config.fileNames.length, program.getSourceFiles().length, incremental);
 }
 async function setupTypeScript(options) {

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

@@ -7,9 +7,9 @@ exports.findRuntimeTsConfigName = findRuntimeTsConfigName;
 exports.updateTsconfigFiles = updateTsconfigFiles;
 exports.addProjectToTsSolutionWorkspace = addProjectToTsSolutionWorkspace;
 const devkit_1 = require("@nx/devkit");
+const posix_1 = require("node:path/posix");
 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'
@@ -44,7 +44,7 @@ function isWorkspaceSetupWithTsSolution(tree) {
     const baseTsconfigJson = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
     if (!baseTsconfigJson.compilerOptions ||
         !baseTsconfigJson.compilerOptions.composite ||
-        !baseTsconfigJson.compilerOptions.declaration) {
+        baseTsconfigJson.compilerOptions.declaration === false) {
         return false;
     }
     const { compilerOptions, ...rest } = baseTsconfigJson;
@@ -128,16 +128,6 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
             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;
@@ -149,17 +139,16 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
     }
 }
 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 "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);
-    const pattern = baseDir === '.' ? projectDir : `${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');
-        const yamlData = load(workspaceFile);
-        if (!yamlData?.packages) {
-            yamlData.packages = [];
-        }
+        const yamlData = load(workspaceFile) ?? {};
+        yamlData.packages ??= [];
         if (!yamlData.packages.includes(pattern)) {
             yamlData.packages.push(pattern);
             tree.write('pnpm-workspace.yaml', dump(yamlData, { indent: 2, quotingType: '"', forceQuotes: true }));