@nx/js 21.2.0 → 21.2.2

package/executors.json

@@ -1,6 +1,11 @@
 {
   "$schema": "https://json-schema.org/schema",
   "executors": {
+    "copy-workspace-modules": {
+      "implementation": "./src/executors/copy-workspace-modules/copy-workspace-modules",
+      "schema": "./src/executors/copy-workspace-modules/schema.json",
+      "description": "Copies Workspace Modules into the output directory after a build to prepare it for use with Docker or alternatives."
+    },
     "tsc": {
       "implementation": "./src/executors/tsc/tsc.impl",
       "batchImplementation": "./src/executors/tsc/tsc.batch-impl",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "21.2.0",
+  "version": "21.2.2",
   "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": "21.2.0",
-    "@nx/workspace": "21.2.0",
+    "@nx/devkit": "21.2.2",
+    "@nx/workspace": "21.2.2",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",

package/src/executors/copy-workspace-modules/copy-workspace-modules.d.ts

@@ -0,0 +1,5 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type CopyWorkspaceModulesOptions } from './schema';
+export default function copyWorkspaceModules(schema: CopyWorkspaceModulesOptions, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/copy-workspace-modules/copy-workspace-modules.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = copyWorkspaceModules;
+const devkit_1 = require("@nx/devkit");
+const utils_1 = require("nx/src/tasks-runner/utils");
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const get_workspace_packages_from_graph_1 = require("../../utils/package-json/get-workspace-packages-from-graph");
+async function copyWorkspaceModules(schema, context) {
+    devkit_1.logger.log('Copying Workspace Modules to Build Directory...');
+    const outputDirectory = getOutputDir(schema, context);
+    const packageJson = getPackageJson(schema, context);
+    createWorkspaceModules(outputDirectory);
+    handleWorkspaceModules(outputDirectory, packageJson, context.projectGraph);
+    devkit_1.logger.log('Success!');
+    return { success: true };
+}
+function handleWorkspaceModules(outputDirectory, packageJson, projectGraph) {
+    if (!packageJson.dependencies) {
+        return;
+    }
+    const workspaceModules = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(projectGraph);
+    for (const [pkgName] of Object.entries(packageJson.dependencies)) {
+        if (workspaceModules.has(pkgName)) {
+            devkit_1.logger.verbose(`Copying ${pkgName}.`);
+            const workspaceModuleProject = workspaceModules.get(pkgName);
+            const workspaceModuleRoot = workspaceModuleProject.data.root;
+            const newWorkspaceModulePath = (0, path_1.join)(outputDirectory, 'workspace_modules', pkgName);
+            (0, node_fs_1.mkdirSync)(newWorkspaceModulePath, { recursive: true });
+            (0, node_fs_1.cpSync)(workspaceModuleRoot, newWorkspaceModulePath, {
+                filter: (src) => !src.includes('node_modules'),
+                recursive: true,
+            });
+            devkit_1.logger.verbose(`Copied ${pkgName} successfully.`);
+        }
+    }
+}
+function createWorkspaceModules(outputDirectory) {
+    (0, node_fs_1.mkdirSync)((0, path_1.join)(outputDirectory, 'workspace_modules'), { recursive: true });
+}
+function getPackageJson(schema, context) {
+    const target = (0, devkit_1.parseTargetString)(schema.buildTarget, context);
+    const project = context.projectGraph.nodes[target.project].data;
+    const packageJsonPath = (0, path_1.join)(devkit_1.workspaceRoot, project.root, 'package.json');
+    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        throw new Error(`${packageJsonPath} does not exist.`);
+    }
+    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    return packageJson;
+}
+function getOutputDir(schema, context) {
+    let outputDir = schema.outputPath;
+    if (outputDir) {
+        outputDir = normalizeOutputPath(outputDir);
+        if ((0, node_fs_1.existsSync)(outputDir)) {
+            return outputDir;
+        }
+    }
+    const target = (0, devkit_1.parseTargetString)(schema.buildTarget, context);
+    const project = context.projectGraph.nodes[target.project].data;
+    const buildTarget = project.targets[target.target];
+    let maybeOutputPath = buildTarget.outputs?.[0] ??
+        buildTarget.options.outputPath ??
+        buildTarget.options.outputDir;
+    if (!maybeOutputPath) {
+        throw new Error(`Could not infer an output directory from the '${schema.buildTarget}' target. Please provide 'outputPath'.`);
+    }
+    maybeOutputPath = (0, utils_1.interpolate)(maybeOutputPath, {
+        workspaceRoot: devkit_1.workspaceRoot,
+        projectRoot: project.root,
+        projectName: project.name,
+        options: {
+            ...(buildTarget.options ?? {}),
+        },
+    });
+    outputDir = normalizeOutputPath(maybeOutputPath);
+    if (!(0, node_fs_1.existsSync)(outputDir)) {
+        throw new Error(`The output directory '${outputDir}' inferred from the '${schema.buildTarget}' target does not exist.\nPlease ensure a build has run first, and that the path is correct. Otherwise, please provide 'outputPath'.`);
+    }
+    return outputDir;
+}
+function normalizeOutputPath(outputPath) {
+    if (!outputPath.startsWith(devkit_1.workspaceRoot)) {
+        outputPath = (0, path_1.join)(devkit_1.workspaceRoot, outputPath);
+    }
+    if (!(0, fs_1.lstatSync)(outputPath).isDirectory()) {
+        outputPath = (0, path_1.dirname)(outputPath);
+    }
+    return outputPath;
+}

package/src/executors/copy-workspace-modules/schema.d.ts

@@ -0,0 +1,4 @@
+export interface CopyWorkspaceModulesOptions {
+  buildTarget: string;
+  outputPath?: string;
+}

package/src/executors/copy-workspace-modules/schema.json

@@ -0,0 +1,20 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Copy Workspace Modules",
+  "description": "Copies Workspace Modules into the output directory after a build to prepare it for use with Docker or alternatives.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "buildTarget": {
+      "type": "string",
+      "description": "The build target that produces the output directory to transform.",
+      "default": "build"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "The output path to transform. Usually inferred from the outputs of the buildTarget."
+    }
+  },
+  "required": ["buildTarget"]
+}

package/src/executors/release-publish/release-publish.impl.js

@@ -201,14 +201,9 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
      * to running from the package root directly), then special attention should be paid to the fact that npm/pnpm publish will nest its
      * JSON output under the name of the package in that case (and it would need to be handled below).
      */
+    const pmCommand = (0, devkit_1.getPackageManagerCommand)(pm);
     const publishCommandSegments = [
-        pm === 'bun'
-            ? // Unlike npm, bun publish does not support a custom registryConfigKey option
-                `bun publish --cwd="${packageRoot}" --json --registry="${registry}" --tag=${tag}`
-            : pm === 'pnpm'
-                ? // Unlike npm, pnpm publish does not support a custom registryConfigKey option, and will error on uncommitted changes by default if --no-git-checks is not set
-                    `pnpm publish "${packageRoot}" --json --registry="${registry}" --tag=${tag} --no-git-checks`
-                : `npm publish "${packageRoot}" --json --"${registryConfigKey}=${registry}" --tag=${tag}`,
+        pmCommand.publish(packageRoot, registry, registryConfigKey, tag),
     ];
     if (options.otp) {
         publishCommandSegments.push(`--otp=${options.otp}`);

package/src/generators/library/library.js

@@ -384,14 +384,14 @@ function createFiles(tree, options) {
             hasUnitTestRunner: options.unitTestRunner !== 'none',
         });
     }
-    if (options.bundler === 'swc' || options.bundler === 'rollup') {
+    if (options.includeBabelRc) {
+        addBabelRc(tree, options);
+    }
+    else if (options.bundler === 'swc' || options.bundler === 'rollup') {
         (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot, options.bundler === 'swc' && !options.isUsingTsSolutionConfig
             ? 'commonjs'
             : 'es6');
     }
-    else if (options.includeBabelRc) {
-        addBabelRc(tree, options);
-    }
     if (options.unitTestRunner === 'none') {
         tree.delete((0, path_1.join)(options.projectRoot, 'src/lib', `${options.fileName}.spec.ts`));
         tree.delete((0, path_1.join)(options.projectRoot, 'src/app', `${options.fileName}.spec.ts`));

package/src/plugins/typescript/util.js

@@ -6,6 +6,7 @@ const devkit_1 = require("@nx/devkit");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const path_1 = require("path");
+const picomatch = require("picomatch");
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
  */
@@ -46,22 +47,98 @@ function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
         return true;
     }
     const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
-    const outDir = tsConfig.options.outFile
-        ? (0, node_path_1.dirname)(tsConfig.options.outFile)
-        : tsConfig.options.outDir;
-    const resolvedOutDir = outDir
-        ? (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, outDir)
-        : undefined;
+    const projectAbsolutePath = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath);
+    // Handle outFile first (has precedence over outDir)
+    if (tsConfig.options.outFile) {
+        const outFile = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, tsConfig.options.outFile);
+        const relativeToProject = (0, node_path_1.relative)(projectAbsolutePath, outFile);
+        // If outFile is outside project root: buildable
+        if (relativeToProject.startsWith('..')) {
+            return true;
+        }
+        // If outFile is inside project root: check if entry points point to outFile
+        const isPathSourceFile = (path) => {
+            const normalizedPath = (0, node_path_1.isAbsolute)(path)
+                ? (0, node_path_1.resolve)(workspaceRoot, path.startsWith('/') ? path.slice(1) : path)
+                : (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, path);
+            // For outFile case, check if path points to the specific outFile
+            return normalizedPath === outFile;
+        };
+        // Check if any entry points match the outFile
+        const exports = packageJson?.exports;
+        if (exports) {
+            if (typeof exports === 'string') {
+                return !isPathSourceFile(exports);
+            }
+            if (typeof exports === 'object' && '.' in exports) {
+                const dotExport = exports['.'];
+                if (typeof dotExport === 'string') {
+                    return !isPathSourceFile(dotExport);
+                }
+                else if (typeof dotExport === 'object') {
+                    const hasMatch = Object.entries(dotExport).some(([key, value]) => {
+                        if (key === 'types' || key === 'development')
+                            return false;
+                        return typeof value === 'string' && isPathSourceFile(value);
+                    });
+                    return !hasMatch;
+                }
+            }
+        }
+        const buildPaths = ['main', 'module'];
+        for (const field of buildPaths) {
+            if (packageJson[field] && isPathSourceFile(packageJson[field])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Handle outDir
+    const outDir = tsConfig.options.outDir;
+    let resolvedOutDir;
+    if (outDir) {
+        const potentialOutDir = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, outDir);
+        const relativePath = (0, node_path_1.relative)(projectAbsolutePath, potentialOutDir);
+        // If outDir is outside project root: buildable
+        if (relativePath.startsWith('..')) {
+            return true;
+        }
+        // If outDir is inside project root, then we should check entry points
+        if (!relativePath.startsWith('..')) {
+            resolvedOutDir = potentialOutDir;
+        }
+    }
     const isPathSourceFile = (path) => {
+        const normalizedPath = (0, node_path_1.isAbsolute)(path)
+            ? (0, node_path_1.resolve)(workspaceRoot, path.startsWith('/') ? path.slice(1) : path)
+            : (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, path);
         if (resolvedOutDir) {
-            const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, path);
-            return !pathToCheck.startsWith(resolvedOutDir);
+            // If the path is within the outDir, we assume it's not a source file.
+            const relativePath = (0, node_path_1.relative)(resolvedOutDir, normalizedPath);
+            if (!relativePath.startsWith('..')) {
+                return false;
+            }
         }
-        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);
+        // If no include patterns, TypeScript includes all TS files by default
+        const include = tsConfig.raw?.include;
+        if (!include || !Array.isArray(include)) {
+            const ext = (0, node_path_1.extname)(path);
+            const tsExtensions = ['.ts', '.tsx', '.cts', '.mts'];
+            if (tsExtensions.includes(ext)) {
+                return true;
+            }
+            // If include is not defined and it's not a TS file, assume it's not a source file
+            return false;
+        }
+        const projectAbsolutePath = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath);
+        const relativeToProject = (0, node_path_1.relative)(projectAbsolutePath, normalizedPath);
+        for (const pattern of include) {
+            if (picomatch(pattern)(relativeToProject)) {
+                return true;
+            }
+        }
+        return false;
     };
-    // Checks if the value is a path within the `src` directory.
     const containsInvalidPath = (value) => {
         if (typeof value === 'string') {
             return isPathSourceFile(value);

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

@@ -52,16 +52,19 @@ class CopyAssetsHandler {
             let input;
             let output;
             let ignore = null;
+            const resolvedOutputDir = path.isAbsolute(opts.outputDir)
+                ? opts.outputDir
+                : path.resolve(opts.rootDir, opts.outputDir);
             if (typeof f === 'string') {
                 pattern = f;
                 input = path.relative(opts.rootDir, opts.projectDir);
-                output = path.relative(opts.rootDir, opts.outputDir);
+                output = path.relative(opts.rootDir, resolvedOutputDir);
             }
             else {
                 isGlob = true;
                 pattern = pathPosix.join(f.input, f.glob);
                 input = f.input;
-                output = pathPosix.join(path.relative(opts.rootDir, opts.outputDir), f.output);
+                output = pathPosix.join(path.relative(opts.rootDir, resolvedOutputDir), f.output);
                 if (f.ignore)
                     ignore = f.ignore.map((ig) => pathPosix.join(f.input, ig));
             }

package/src/utils/package-json/get-workspace-packages-from-graph.d.ts

@@ -0,0 +1,2 @@
+import { type ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
+export declare function getWorkspacePackagesFromGraph(graph: ProjectGraph): Map<string, ProjectGraphProjectNode>;

package/src/utils/package-json/get-workspace-packages-from-graph.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspacePackagesFromGraph = getWorkspacePackagesFromGraph;
+function getWorkspacePackagesFromGraph(graph) {
+    const workspacePackages = new Map();
+    for (const [projectName, project] of Object.entries(graph.nodes)) {
+        const pkgName = project.data?.metadata?.js?.packageName;
+        if (pkgName) {
+            workspacePackages.set(pkgName, project);
+        }
+    }
+    return workspacePackages;
+}