nx 21.2.0-canary.20250605-5ffd82e → 21.2.0-canary.20250606-c43d2f2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.2.0-canary.20250605-5ffd82e",
+  "version": "21.2.0-canary.20250606-c43d2f2",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-darwin-x64": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-freebsd-x64": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-linux-arm-gnueabihf": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-linux-arm64-gnu": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-linux-arm64-musl": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-linux-x64-gnu": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-linux-x64-musl": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-win32-arm64-msvc": "21.2.0-canary.20250605-5ffd82e",
-    "@nx/nx-win32-x64-msvc": "21.2.0-canary.20250605-5ffd82e"
+    "@nx/nx-darwin-arm64": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-darwin-x64": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-freebsd-x64": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-linux-arm-gnueabihf": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-linux-arm64-gnu": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-linux-arm64-musl": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-linux-x64-gnu": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-linux-x64-musl": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-win32-arm64-msvc": "21.2.0-canary.20250606-c43d2f2",
+    "@nx/nx-win32-x64-msvc": "21.2.0-canary.20250606-c43d2f2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/plugins/js/utils/register.d.ts

@@ -1,3 +1,4 @@
+import type { TsConfigOptions } from 'ts-node';
 import type { CompilerOptions } from 'typescript';
 /**
  * Optionally, if swc-node and tsconfig-paths are available in the current workspace, apply the require
@@ -23,7 +24,7 @@ export declare function registerTsProject(tsConfigPath: string): () => void;
  */
 export declare function registerTsProject(path: string, configFilename: string): any;
 export declare function getSwcTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
-export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
+export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions, tsNodeOptions?: TsConfigOptions): (...args: unknown[]) => unknown;
 export declare function getTranspiler(compilerOptions: CompilerOptions, tsConfigRaw?: unknown): () => (...args: unknown[]) => unknown;
 /**
  * Register ts-node or swc-node given a set of compiler options.
@@ -33,7 +34,7 @@ export declare function getTranspiler(compilerOptions: CompilerOptions, tsConfig
  *
  * @returns cleanup method
  */
-export declare function registerTranspiler(compilerOptions: CompilerOptions): () => void;
+export declare function registerTranspiler(compilerOptions: CompilerOptions, tsConfigRaw?: unknown): () => void;
 /**
  * @param tsConfigPath Adds the paths from a tsconfig file into node resolutions
  * @returns cleanup function

package/src/plugins/js/utils/register.js

@@ -9,6 +9,7 @@ exports.registerTsConfigPaths = registerTsConfigPaths;
 exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
 const path_1 = require("path");
 const logger_1 = require("../../../utils/logger");
+const typescript_1 = require("./typescript");
 const swcNodeInstalled = packageIsInstalled('@swc-node/register');
 const tsNodeInstalled = packageIsInstalled('ts-node/register');
 let ts;
@@ -53,10 +54,10 @@ function registerTsProject(path, configFilename) {
         return () => { };
     }
     const tsConfigPath = configFilename ? (0, path_1.join)(path, configFilename) : path;
-    const compilerOptions = readCompilerOptions(tsConfigPath);
+    const { compilerOptions, tsConfigRaw } = readCompilerOptions(tsConfigPath);
     const cleanupFunctions = [
         registerTsConfigPaths(tsConfigPath),
-        registerTranspiler(compilerOptions),
+        registerTranspiler(compilerOptions, tsConfigRaw),
     ];
     // Add ESM support for `.ts` files.
     // NOTE: There is no cleanup function for this, as it's not possible to unregister the loader.
@@ -90,12 +91,16 @@ function getSwcTranspiler(compilerOptions) {
     const cleanupFn = register(compilerOptions);
     return typeof cleanupFn === 'function' ? cleanupFn : () => { };
 }
-function getTsNodeTranspiler(compilerOptions) {
+function getTsNodeTranspiler(compilerOptions, tsNodeOptions) {
     const { register } = require('ts-node');
     // ts-node doesn't provide a cleanup method
     const service = register({
+        ...tsNodeOptions,
         transpileOnly: true,
-        compilerOptions: getTsNodeCompilerOptions(compilerOptions),
+        compilerOptions: getTsNodeCompilerOptions({
+            ...tsNodeOptions?.compilerOptions,
+            ...compilerOptions,
+        }),
         // we already read and provide the compiler options, so prevent ts-node from reading them again
         skipProject: true,
     });
@@ -165,21 +170,30 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
     compilerOptions.target = ts.ScriptTarget.ES2021;
     compilerOptions.inlineSourceMap = true;
     compilerOptions.skipLibCheck = true;
+    let _getTranspiler;
+    let registrationKey = JSON.stringify(compilerOptions);
+    let tsNodeOptions;
+    if (swcNodeInstalled && !preferTsNode) {
+        _getTranspiler = getSwcTranspiler;
+    }
+    else if (tsNodeInstalled) {
+        // We can fall back on ts-node if it's available
+        _getTranspiler = getTsNodeTranspiler;
+        tsNodeOptions = filterRecognizedTsConfigTsNodeOptions(tsConfigRaw?.['ts-node']).recognized;
+        // include ts-node options in the registration key
+        registrationKey += JSON.stringify(tsNodeOptions);
+    }
+    else {
+        _getTranspiler = undefined;
+    }
     // Just return if transpiler was already registered before.
-    const registrationKey = JSON.stringify(compilerOptions);
     const registrationEntry = registered.get(registrationKey);
     if (registered.has(registrationKey)) {
         registrationEntry.refCount++;
         return registrationEntry.cleanup;
     }
-    const _getTranspiler = swcNodeInstalled && !preferTsNode
-        ? getSwcTranspiler
-        : tsNodeInstalled
-            ? // We can fall back on ts-node if it's available
-                getTsNodeTranspiler
-            : undefined;
     if (_getTranspiler) {
-        const transpilerCleanup = _getTranspiler(compilerOptions);
+        const transpilerCleanup = _getTranspiler(compilerOptions, tsNodeOptions);
         const currRegistrationEntry = {
             refCount: 1,
             cleanup: () => {
@@ -204,9 +218,9 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
  *
  * @returns cleanup method
  */
-function registerTranspiler(compilerOptions) {
+function registerTranspiler(compilerOptions, tsConfigRaw) {
     // Function to register transpiler that returns cleanup function
-    const transpiler = getTranspiler(compilerOptions);
+    const transpiler = getTranspiler(compilerOptions, tsConfigRaw);
     if (!transpiler) {
         warnNoTranspiler();
         return () => { };
@@ -245,7 +259,9 @@ function registerTsConfigPaths(tsConfigPath) {
 function readCompilerOptions(tsConfigPath) {
     const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
     if (swcNodeInstalled && !preferTsNode) {
-        return readCompilerOptionsWithSwc(tsConfigPath);
+        return {
+            compilerOptions: readCompilerOptionsWithSwc(tsConfigPath),
+        };
     }
     else {
         return readCompilerOptionsWithTypescript(tsConfigPath);
@@ -261,16 +277,14 @@ function readCompilerOptionsWithSwc(tsConfigPath) {
     return compilerOptions;
 }
 function readCompilerOptionsWithTypescript(tsConfigPath) {
-    if (!ts) {
-        ts = require('typescript');
-    }
-    const { readConfigFile, parseJsonConfigFileContent, sys } = ts;
-    const jsonContent = readConfigFile(tsConfigPath, sys.readFile);
-    const { options } = parseJsonConfigFileContent(jsonContent.config, sys, (0, path_1.dirname)(tsConfigPath));
+    const { options, raw } = (0, typescript_1.readTsConfigWithoutFiles)(tsConfigPath);
     // This property is returned in compiler options for some reason, but not part of the typings.
     // ts-node fails on unknown props, so we have to remove it.
     delete options.configFilePath;
-    return options;
+    return {
+        compilerOptions: options,
+        tsConfigRaw: raw,
+    };
 }
 function loadTsConfigPaths() {
     try {

package/src/plugins/js/utils/typescript.d.ts

@@ -1,6 +1,7 @@
 import type * as ts from 'typescript';
 import type { Node, SyntaxKind } from 'typescript';
-export declare function readTsConfig(tsConfigPath: string): ts.ParsedCommandLine;
+export declare function readTsConfig(tsConfigPath: string, sys?: ts.System): ts.ParsedCommandLine;
+export declare function readTsConfigWithoutFiles(tsConfigPath: string): ts.ParsedCommandLine;
 export declare function readTsConfigOptions(tsConfigPath: string): ts.CompilerOptions;
 /**
  * Find a module based on its import

package/src/plugins/js/utils/typescript.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readTsConfig = readTsConfig;
+exports.readTsConfigWithoutFiles = readTsConfigWithoutFiles;
 exports.readTsConfigOptions = readTsConfigOptions;
 exports.resolveModuleByImport = resolveModuleByImport;
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
@@ -11,25 +12,29 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const normalizedAppRoot = workspace_root_1.workspaceRoot.replace(/\\/g, '/');
 let tsModule;
-function readTsConfig(tsConfigPath) {
+function readTsConfig(tsConfigPath, sys) {
     if (!tsModule) {
         tsModule = require('typescript');
     }
-    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
-    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+    sys ??= tsModule.sys;
+    const readResult = tsModule.readConfigFile(tsConfigPath, sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, sys, (0, path_1.dirname)(tsConfigPath));
 }
-function readTsConfigOptions(tsConfigPath) {
+function readTsConfigWithoutFiles(tsConfigPath) {
     if (!tsModule) {
         tsModule = require('typescript');
     }
-    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
     // We only care about options, so we don't need to scan source files, and thus
     // `readDirectory` is stubbed for performance.
-    const host = {
+    const sys = {
         ...tsModule.sys,
         readDirectory: () => [],
     };
-    return tsModule.parseJsonConfigFileContent(readResult.config, host, (0, path_1.dirname)(tsConfigPath)).options;
+    return readTsConfig(tsConfigPath, sys);
+}
+function readTsConfigOptions(tsConfigPath) {
+    const { options } = readTsConfigWithoutFiles(tsConfigPath);
+    return options;
 }
 let compilerHost;
 /**

package/src/project-graph/plugins/transpiler.js

@@ -6,9 +6,9 @@ exports.pluginTranspilerIsRegistered = pluginTranspilerIsRegistered;
 exports.cleanupPluginTSTranspiler = cleanupPluginTSTranspiler;
 const node_fs_1 = require("node:fs");
 const posix_1 = require("node:path/posix");
-const workspace_root_1 = require("../../utils/workspace-root");
 const register_1 = require("../../plugins/js/utils/register");
 const typescript_1 = require("../../plugins/js/utils/typescript");
+const workspace_root_1 = require("../../utils/workspace-root");
 exports.unregisterPluginTSTranspiler = null;
 /**
  * Register swc-node or ts-node if they are not currently registered
@@ -23,16 +23,16 @@ function registerPluginTSTranspiler() {
     if (!tsConfigName) {
         return;
     }
-    const tsConfigOptions = tsConfigName
-        ? (0, typescript_1.readTsConfigOptions)(tsConfigName)
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfigWithoutFiles)(tsConfigName)
         : {};
     const cleanupFns = [
         (0, register_1.registerTsConfigPaths)(tsConfigName),
         (0, register_1.registerTranspiler)({
             experimentalDecorators: true,
             emitDecoratorMetadata: true,
-            ...tsConfigOptions,
-        }),
+            ...tsConfig.options,
+        }, tsConfig.raw),
     ];
     exports.unregisterPluginTSTranspiler = () => {
         cleanupFns.forEach((fn) => fn?.());