nx 21.3.0-canary.20250712-18e5d95 → 21.3.0-canary.20250716-46d21c7

package/src/executors/run-commands/run-commands.impl.js

@@ -121,19 +121,26 @@ function normalizeOptions(options) {
     return options;
 }
 function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
+    if (command.indexOf('{args.') > -1 && command.indexOf('{args}') > -1) {
+        throw new Error('Command should not contain both {args} and {args.*} values. Please choose one to use.');
+    }
     if (command.indexOf('{args.') > -1) {
         const regex = /{args\.([^}]+)}/g;
         return command.replace(regex, (_, group) => opts.parsedArgs[group] !== undefined ? opts.parsedArgs[group] : '');
     }
+    else if (command.indexOf('{args}') > -1) {
+        const regex = /{args}/g;
+        const args = [
+            ...unknownOptionsToArgsArray(opts),
+            ...unparsedOptionsToArgsArray(opts),
+        ];
+        const argsString = `${args.join(' ')} ${opts.args ?? ''}`;
+        return command.replace(regex, argsString);
+    }
     else if (forwardAllArgs) {
         let args = '';
         if (Object.keys(opts.unknownOptions ?? {}).length > 0) {
-            const unknownOptionsArgs = Object.keys(opts.unknownOptions)
-                .filter((k) => typeof opts.unknownOptions[k] !== 'object' &&
-                opts.parsedArgs[k] === opts.unknownOptions[k])
-                .map((k) => `--${k}=${opts.unknownOptions[k]}`)
-                .map(wrapArgIntoQuotesIfNeeded)
-                .join(' ');
+            const unknownOptionsArgs = unknownOptionsToArgsArray(opts).join(' ');
             if (unknownOptionsArgs) {
                 args += ` ${unknownOptionsArgs}`;
             }
@@ -142,11 +149,9 @@ function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
             args += ` ${opts.args}`;
         }
         if (opts.__unparsed__?.length > 0) {
-            const filteredParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.parsedArgs);
+            const filteredParsedOptions = unparsedOptionsToArgsArray(opts);
             if (filteredParsedOptions.length > 0) {
-                args += ` ${filteredParsedOptions
-                    .map(wrapArgIntoQuotesIfNeeded)
-                    .join(' ')}`;
+                args += ` ${filteredParsedOptions.join(' ')}`;
             }
         }
         return `${command}${args}`;
@@ -155,6 +160,20 @@ function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
         return command;
     }
 }
+function unknownOptionsToArgsArray(opts) {
+    return Object.keys(opts.unknownOptions ?? {})
+        .filter((k) => typeof opts.unknownOptions[k] !== 'object' &&
+        opts.parsedArgs[k] === opts.unknownOptions[k])
+        .map((k) => `--${k}=${opts.unknownOptions[k]}`)
+        .map(wrapArgIntoQuotesIfNeeded);
+}
+function unparsedOptionsToArgsArray(opts) {
+    const filteredParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.parsedArgs);
+    if (filteredParsedOptions.length > 0) {
+        return filteredParsedOptions.map(wrapArgIntoQuotesIfNeeded);
+    }
+    return [];
+}
 function parseArgs(unparsedCommandArgs, unknownOptions, args) {
     if (!args) {
         return { ...unknownOptions, ...unparsedCommandArgs };

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

@@ -24,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, tsNodeOptions?: TsConfigOptions): (...args: unknown[]) => unknown;
+export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions, tsNodeOptions?: TsConfigOptions, preferTsNode?: boolean): (...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.

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

@@ -91,7 +91,7 @@ function getSwcTranspiler(compilerOptions) {
     const cleanupFn = register(compilerOptions);
     return typeof cleanupFn === 'function' ? cleanupFn : () => { };
 }
-function getTsNodeTranspiler(compilerOptions, tsNodeOptions) {
+function getTsNodeTranspiler(compilerOptions, tsNodeOptions, preferTsNode) {
     const { register } = require('ts-node');
     // ts-node doesn't provide a cleanup method
     const service = register({
@@ -106,7 +106,7 @@ function getTsNodeTranspiler(compilerOptions, tsNodeOptions) {
     });
     const { transpiler, swc } = service.options;
     // Don't warn if a faster transpiler is enabled
-    if (!transpiler && !swc) {
+    if (!transpiler && !swc && !preferTsNode) {
         warnTsNodeUsage();
     }
     return () => {
@@ -170,6 +170,14 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
     compilerOptions.target = ts.ScriptTarget.ES2021;
     compilerOptions.inlineSourceMap = true;
     compilerOptions.skipLibCheck = true;
+    // These options are different per project, and since they are not needed for transpilation, we can remove them so we have more cache hits.
+    compilerOptions.outDir = undefined;
+    compilerOptions.outFile = undefined;
+    compilerOptions.declaration = undefined;
+    compilerOptions.declarationMap = undefined;
+    compilerOptions.composite = undefined;
+    compilerOptions.tsBuildInfoFile = undefined;
+    delete compilerOptions.strict;
     let _getTranspiler;
     let registrationKey = JSON.stringify(compilerOptions);
     let tsNodeOptions;
@@ -193,7 +201,7 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
         return registrationEntry.cleanup;
     }
     if (_getTranspiler) {
-        const transpilerCleanup = _getTranspiler(compilerOptions, tsNodeOptions);
+        const transpilerCleanup = _getTranspiler(compilerOptions, tsNodeOptions, preferTsNode);
         const currRegistrationEntry = {
             refCount: 1,
             cleanup: () => {