@nx/js 21.0.0-beta.1 → 21.0.0-beta.2

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

@@ -50,7 +50,10 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
         options.format = ['cjs'];
     }
     // update package specific settings
-    packageJson = getUpdatedPackageJsonContent(packageJson, options);
+    packageJson = getUpdatedPackageJsonContent(packageJson, {
+        skipDevelopmentExports: true,
+        ...options,
+    });
     // save files
     (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
     if (options.generateLockfile) {
@@ -146,6 +149,19 @@ function getUpdatedPackageJsonContent(packageJson, options) {
         packageJson.exports ??=
             typeof packageJson.exports === 'string' ? {} : { ...packageJson.exports };
         packageJson.exports['./package.json'] ??= './package.json';
+        if (!options.skipDevelopmentExports && (hasCjsFormat || hasEsmFormat)) {
+            packageJson.exports['.'] ??= {};
+            const developmentExports = getDevelopmentExports(options);
+            for (const [exportEntry, filePath] of Object.entries(developmentExports)) {
+                if (!packageJson.exports[exportEntry]) {
+                    packageJson.exports[exportEntry] ??= {};
+                    packageJson.exports[exportEntry]['development'] ??= filePath;
+                }
+                else if (typeof packageJson.exports[exportEntry] === 'object') {
+                    packageJson.exports[exportEntry].development ??= filePath;
+                }
+            }
+        }
     }
     if (!options.skipTypings) {
         const mainFile = (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
@@ -215,6 +231,31 @@ function getUpdatedPackageJsonContent(packageJson, options) {
     }
     return packageJson;
 }
+function getDevelopmentExports(options) {
+    const mainRelativeDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(options.main, options.projectRoot);
+    const exports = {
+        '.': mainRelativeDir + (0, path_1.basename)(options.main),
+    };
+    if (options.additionalEntryPoints?.length) {
+        const jsRegex = /\.[jt]sx?$/;
+        for (const file of options.additionalEntryPoints) {
+            const { ext: fileExt, name: fileName, base: baseName } = (0, path_1.parse)(file);
+            if (!jsRegex.test(fileExt)) {
+                continue;
+            }
+            const relativeDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(file, options.projectRoot);
+            const sourceFilePath = relativeDir + baseName;
+            const entryRelativeDir = relativeDir.replace(/^\.\/src\//, './');
+            const entryFilePath = entryRelativeDir + fileName;
+            if (fileName === 'index') {
+                const barrelEntry = entryRelativeDir.replace(/\/$/, '');
+                exports[barrelEntry] = sourceFilePath;
+            }
+            exports[entryFilePath] = sourceFilePath;
+        }
+    }
+    return exports;
+}
 function getOutputDir(options) {
     const packageJsonDir = options.packageJsonPath
         ? (0, path_1.dirname)(options.packageJsonPath)

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,11 +1,12 @@
 "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 minimatch_1 = require("minimatch");
+const picomatch = require("picomatch");
 const posix_1 = require("node:path/posix");
 const package_json_1 = require("nx/src/plugins/package-json");
 const semver_1 = require("semver");
@@ -13,17 +14,21 @@ 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 }));
-    const isIncluded = patterns.some((p) => (0, minimatch_1.minimatch)((0, posix_1.join)(projectRoot, 'package.json'), p));
+    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));
+}
 function isUsingPackageManagerWorkspaces(tree) {
     return isWorkspacesEnabled(tree);
 }
-function isWorkspacesEnabled(tree
-// packageManager: PackageManager = detectPackageManager(),
-// root: string = workspaceRoot
-) {
+function isWorkspacesEnabled(tree) {
     const packageManager = (0, devkit_1.detectPackageManager)(tree.root);
     if (packageManager === 'pnpm') {
         return tree.exists('pnpm-workspace.yaml');

package/src/utils/swc/add-swc-config.d.ts

@@ -1,4 +1,4 @@
 import { type Tree } from '@nx/devkit';
 export declare const defaultExclude: string[];
-export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;
+export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean, swcName?: string, additionalExcludes?: string[]): void;
 export declare function addSwcTestConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;

package/src/utils/swc/add-swc-config.js

@@ -43,11 +43,11 @@ const swcOptionsString = (type = 'commonjs', exclude, supportTsx) => `{
   "exclude": ${JSON.stringify(exclude)}
 }
 `;
-function addSwcConfig(tree, projectDir, type = 'commonjs', supportTsx = false) {
-    const swcrcPath = (0, path_1.join)(projectDir, '.swcrc');
+function addSwcConfig(tree, projectDir, type = 'commonjs', supportTsx = false, swcName = '.swcrc', additionalExcludes = []) {
+    const swcrcPath = (0, path_1.join)(projectDir, swcName);
     if (tree.exists(swcrcPath))
         return;
-    tree.write(swcrcPath, swcOptionsString(type, exports.defaultExclude, supportTsx));
+    tree.write(swcrcPath, swcOptionsString(type, [...exports.defaultExclude, ...additionalExcludes], supportTsx));
 }
 function addSwcTestConfig(tree, projectDir, type = 'commonjs', supportTsx = false) {
     const swcrcPath = (0, path_1.join)(projectDir, '.spec.swcrc');

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): void;
+export declare function ensureProjectIsIncludedInPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string, buildTargetName: string | null): 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 = 'build') {
+function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, buildTargetName) {
     nxJson.plugins ??= [];
     let isIncluded = false;
     let index = 0;
@@ -13,12 +13,17 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
             continue;
         }
         if (typeof registration === 'string') {
-            // if it's a string all projects are included but the are no user-specified options
-            // and the build task is not inferred by default, so we need to exclude it
-            nxJson.plugins[index] = {
-                plugin: '@nx/js/typescript',
-                exclude: [`${projectRoot}/*`],
-            };
+            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;
+            }
         }
         else {
             // check if the project would be included by the plugin registration
@@ -27,7 +32,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 &&
-                    matchesBuildTarget(registration.options?.build, buildTargetName)) {
+                    matchesBuildTargetDefinition(registration.options?.build, buildTargetName)) {
                     // it has the desired options, do nothing, but continue processing
                     // other registrations to exclude as needed
                     isIncluded = true;
@@ -40,7 +45,7 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
             }
             else if (!isIncluded &&
                 registration.options?.typecheck !== false &&
-                matchesBuildTarget(registration.options?.build, buildTargetName)) {
+                matchesBuildTargetDefinition(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
@@ -66,17 +71,20 @@ 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
-        nxJson.plugins.push({
+        const registration = {
             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) {
@@ -115,8 +123,11 @@ function isTypeScriptPluginRegistration(plugin) {
     return ((typeof plugin === 'string' && plugin === '@nx/js/typescript') ||
         (typeof plugin !== 'string' && plugin.plugin === '@nx/js/typescript'));
 }
-function matchesBuildTarget(buildOptions, buildTargetName) {
+function matchesBuildTargetDefinition(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,7 +2,8 @@ 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(tree: Tree, projectRoot: string): string | null;
+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

@@ -7,6 +7,7 @@ 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");
@@ -71,7 +72,8 @@ function assertNotUsingTsSolutionSetup(tree, pluginName, generatorName) {
     });
     throw new Error(`The ${artifactString} doesn't yet support the existing TypeScript setup. See the error above.`);
 }
-function findRuntimeTsConfigName(tree, projectRoot) {
+function findRuntimeTsConfigName(projectRoot, tree) {
+    tree ??= new tree_1.FsTree(devkit_1.workspaceRoot, false);
     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')))
@@ -90,9 +92,7 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
             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)),
+                outDir: 'dist',
                 rootDir,
                 ...compilerOptions,
             };
@@ -145,12 +145,29 @@ 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 nested like "libs/shared/foo" then we add "libs/shared/*".
-    // If the dir is just "foo" then we have to add it as is.
+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.
     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 = patterns.length > 0 ? 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');
@@ -189,3 +206,9 @@ 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/utils/versions.d.ts

@@ -1,13 +1,13 @@
 export declare const nxVersion: any;
 export declare const esbuildVersion = "^0.19.2";
 export declare const prettierVersion = "^2.6.2";
-export declare const swcCliVersion = "~0.3.12";
+export declare const swcCliVersion = "~0.6.0";
 export declare const swcCoreVersion = "~1.5.7";
 export declare const swcHelpersVersion = "~0.5.11";
 export declare const swcNodeVersion = "~1.9.1";
 export declare const tsLibVersion = "^2.3.0";
 export declare const typesNodeVersion = "18.16.9";
-export declare const verdaccioVersion = "^5.0.4";
+export declare const verdaccioVersion = "^6.0.5";
 export declare const typescriptVersion = "~5.7.2";
 /**
  * The minimum version is currently determined from the lowest version

package/src/utils/versions.js

@@ -4,13 +4,13 @@ exports.supportedTypescriptVersions = exports.typescriptVersion = exports.verdac
 exports.nxVersion = require('../../package.json').version;
 exports.esbuildVersion = '^0.19.2';
 exports.prettierVersion = '^2.6.2';
-exports.swcCliVersion = '~0.3.12';
+exports.swcCliVersion = '~0.6.0';
 exports.swcCoreVersion = '~1.5.7';
 exports.swcHelpersVersion = '~0.5.11';
 exports.swcNodeVersion = '~1.9.1';
 exports.tsLibVersion = '^2.3.0';
 exports.typesNodeVersion = '18.16.9';
-exports.verdaccioVersion = '^5.0.4';
+exports.verdaccioVersion = '^6.0.5';
 // Typescript
 exports.typescriptVersion = '~5.7.2';
 /**

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

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

package/src/utils/typescript/tsnode-register.d.ts

@@ -1 +0,0 @@
-export declare function tsNodeRegister(file: string, tsConfig?: string): void;

package/src/utils/typescript/tsnode-register.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsNodeRegister = tsNodeRegister;
-function tsNodeRegister(file, tsConfig) {
-    if (!file?.endsWith('.ts'))
-        return;
-    // Register TS compiler lazily
-    require('ts-node').register({
-        project: tsConfig,
-        compilerOptions: {
-            module: 'CommonJS',
-            types: ['node'],
-        },
-    });
-    if (!tsConfig)
-        return;
-    // Register paths in tsConfig
-    const tsconfigPaths = require('tsconfig-paths');
-    const { absoluteBaseUrl: baseUrl, paths } = tsconfigPaths.loadConfig(tsConfig);
-    if (baseUrl && paths) {
-        tsconfigPaths.register({ baseUrl, paths });
-    }
-}