@nx/esbuild 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250418-8619c1d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/esbuild",
-  "version": "21.0.0-canary.20250206-8bd0bcd",
+  "version": "21.0.0-canary.20250418-8619c1d",
   "private": false,
   "description": "The Nx Plugin for esbuild contains executors and generators that support building applications using esbuild",
   "repository": {
@@ -31,15 +31,15 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "21.0.0-canary.20250206-8bd0bcd",
-    "@nx/js": "21.0.0-canary.20250206-8bd0bcd",
-    "tinyglobby": "^0.2.10",
+    "@nx/devkit": "21.0.0-canary.20250418-8619c1d",
+    "@nx/js": "21.0.0-canary.20250418-8619c1d",
+    "tinyglobby": "^0.2.12",
     "picocolors": "^1.1.0",
     "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "esbuild": "~0.19.2"
+    "esbuild": "^0.19.2"
   },
   "peerDependenciesMeta": {
     "esbuild": {

package/src/executors/esbuild/lib/build-esbuild-options.d.ts

@@ -2,6 +2,12 @@ import * as esbuild from 'esbuild';
 import { ExecutorContext, ProjectGraphProjectNode } from '@nx/devkit';
 import { NormalizedEsBuildExecutorOptions } from '../schema';
 export declare function buildEsbuildOptions(format: 'cjs' | 'esm', options: NormalizedEsBuildExecutorOptions, context: ExecutorContext): esbuild.BuildOptions;
+/**
+ * When using TS project references we need to map the paths to the referenced projects.
+ * This is necessary because esbuild does not support project references out of the box.
+ * @param context ExecutorContext
+ */
+export declare function createPathsFromTsConfigReferences(context: ExecutorContext): Record<string, string[]>;
 export declare function getOutExtension(format: 'cjs' | 'esm', options: Pick<NormalizedEsBuildExecutorOptions, 'userDefinedBuildOptions'>): '.cjs' | '.mjs' | '.js';
 export declare function getOutfile(format: 'cjs' | 'esm', options: NormalizedEsBuildExecutorOptions, context: ExecutorContext): string;
 export declare function getRegisterFileContent(project: ProjectGraphProjectNode, paths: Record<string, string[]>, mainFile: string, outExtension?: string): string;

package/src/executors/esbuild/lib/build-esbuild-options.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildEsbuildOptions = buildEsbuildOptions;
+exports.createPathsFromTsConfigReferences = createPathsFromTsConfigReferences;
 exports.getOutExtension = getOutExtension;
 exports.getOutfile = getOutfile;
 exports.getRegisterFileContent = getRegisterFileContent;
@@ -60,7 +61,9 @@ function buildEsbuildOptions(format, options, context) {
     else if (options.platform === 'node' && format === 'cjs') {
         // When target platform Node and target format is CJS, then also transpile workspace libs used by the app.
         // Provide a `require` override in the main entry file so workspace libs can be loaded when running the app.
-        const paths = getTsConfigCompilerPaths(context);
+        const paths = options.isTsSolutionSetup
+            ? createPathsFromTsConfigReferences(context)
+            : getTsConfigCompilerPaths(context);
         const entryPointsFromProjects = (0, get_entry_points_1.getEntryPoints)(context.projectName, context, {
             initialTsConfigFileName: options.tsConfig,
             initialEntryPoints: entryPoints,
@@ -103,6 +106,87 @@ function buildEsbuildOptions(format, options, context) {
     }
     return esbuildOptions;
 }
+/**
+ * When using TS project references we need to map the paths to the referenced projects.
+ * This is necessary because esbuild does not support project references out of the box.
+ * @param context ExecutorContext
+ */
+function createPathsFromTsConfigReferences(context) {
+    const { findAllProjectNodeDependencies, } = require('nx/src/utils/project-graph-utils');
+    const { isValidPackageJsonBuildConfig, } = require('@nx/js/src/plugins/typescript/util');
+    const { readTsConfig } = require('@nx/js');
+    const { findRuntimeTsConfigName, } = require('@nx/js/src/utils/typescript/ts-solution-setup');
+    const deps = findAllProjectNodeDependencies(context.projectName, context.projectGraph);
+    const tsConfig = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(context.root, 'tsconfig.json'));
+    const referencesAsPaths = new Set(tsConfig.references.reduce((acc, ref) => {
+        if (!ref.path)
+            return acc;
+        const fullPath = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, ref.path);
+        try {
+            if ((0, fs_1.lstatSync)(fullPath).isDirectory()) {
+                acc.push(fullPath);
+            }
+        }
+        catch {
+            // Ignore errors (e.g., path doesn't exist)
+        }
+        return acc;
+    }, []));
+    // for each dep we check if it contains a build target
+    // we only want to add the paths for projects that do not have a build target
+    return deps.reduce((acc, dep) => {
+        const projectNode = context.projectGraph.nodes[dep];
+        const projectPath = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectNode.data.root);
+        const resolvedTsConfigPath = findRuntimeTsConfigName(projectPath) ?? 'tsconfig.json';
+        const projTsConfig = readTsConfig(resolvedTsConfigPath);
+        const projectPkgJson = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(projectPath, 'package.json'));
+        if (projTsConfig &&
+            !isValidPackageJsonBuildConfig(projTsConfig, devkit_1.workspaceRoot, projectPath) &&
+            projectPkgJson?.name) {
+            const entryPoint = getProjectEntryPoint(projectPkgJson, projectPath);
+            if (referencesAsPaths.has(projectPath)) {
+                acc[projectPkgJson.name] = [path.relative(devkit_1.workspaceRoot, entryPoint)];
+            }
+        }
+        return acc;
+    }, {});
+}
+// Get the entry point for the project
+function getProjectEntryPoint(projectPkgJson, projectPath) {
+    let entryPoint = null;
+    if (typeof projectPkgJson.exports === 'string') {
+        // If exports is a string, use it as the entry point
+        entryPoint = path.relative(devkit_1.workspaceRoot, (0, devkit_1.joinPathFragments)(projectPath, projectPkgJson.exports));
+    }
+    else if (typeof projectPkgJson.exports === 'object' &&
+        projectPkgJson.exports['.']) {
+        // If exports is an object and has a '.' key, process it
+        const exportEntry = projectPkgJson.exports['.'];
+        if (typeof exportEntry === 'object') {
+            entryPoint =
+                exportEntry.import ||
+                    exportEntry.require ||
+                    exportEntry.default ||
+                    null;
+        }
+        else if (typeof exportEntry === 'string') {
+            entryPoint = exportEntry;
+        }
+        if (entryPoint) {
+            entryPoint = path.relative(devkit_1.workspaceRoot, (0, devkit_1.joinPathFragments)(projectPath, entryPoint));
+        }
+    }
+    // If no exports were found, fall back to main and module
+    if (!entryPoint) {
+        if (projectPkgJson.main) {
+            entryPoint = path.relative(devkit_1.workspaceRoot, (0, devkit_1.joinPathFragments)(projectPath, projectPkgJson.main));
+        }
+        else if (projectPkgJson.module) {
+            entryPoint = path.relative(devkit_1.workspaceRoot, (0, devkit_1.joinPathFragments)(projectPath, projectPkgJson.module));
+        }
+    }
+    return entryPoint;
+}
 function getOutExtension(format, options) {
     const userDefinedExt = options.userDefinedBuildOptions?.outExtension?.['.js'];
     // Allow users to change the output extensions from default CJS and ESM extensions.

package/src/generators/configuration/configuration.js

@@ -51,10 +51,7 @@ function addBuildTarget(tree, options, isTsSolutionSetup) {
         format: options.format,
     };
     if (isTsSolutionSetup) {
-        buildOptions.declarationRootDir =
-            project.sourceRoot ?? tree.exists(`${project.root}/src`)
-                ? `${project.root}/src`
-                : project.root;
+        buildOptions.declarationRootDir = (0, ts_solution_setup_1.getProjectSourceRoot)(tree, project.sourceRoot, project.root);
     }
     else {
         buildOptions.assets = [];
@@ -116,6 +113,8 @@ function updatePackageJson(tree, options, isTsSolutionSetup) {
         const { declarationRootDir = '.', main, outputPath, outputFileName, 
         // the executor option defaults to [esm]
         format = ['esm'], esbuildOptions, } = mergedTarget.options;
+        // the file must exist in the TS solution setup
+        const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
         // can't use the declarationRootDir as rootDir because it only affects the typings,
         // not the runtime entry point
         packageJson = (0, js_1.getUpdatedPackageJsonContent)(packageJson, {
@@ -135,6 +134,7 @@ function updatePackageJson(tree, options, isTsSolutionSetup) {
             outputFileExtensionForEsm: (0, build_esbuild_options_1.getOutExtension)('esm', {
                 userDefinedBuildOptions: esbuildOptions,
             }),
+            skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
         });
         if (declarationRootDir !== (0, posix_1.dirname)(main)) {
             // the declaration file entry point will be output to a location