nx 21.0.0-canary.20250501-8f50358 → 21.0.0-canary.20250502-110614d

package/src/daemon/server/watcher.js

@@ -5,16 +5,10 @@ exports.watchOutputFiles = watchOutputFiles;
 exports.convertChangeEventsToLogMessage = convertChangeEventsToLogMessage;
 const workspace_root_1 = require("../../utils/workspace-root");
 const path_1 = require("path");
-const socket_utils_1 = require("../socket-utils");
 const shutdown_utils_1 = require("./shutdown-utils");
 const path_2 = require("../../utils/path");
-const ignore_1 = require("../../utils/ignore");
 const cache_1 = require("../cache");
 const server_1 = require("./server");
-const ALWAYS_IGNORE = [
-    ...(0, ignore_1.getAlwaysIgnore)(workspace_root_1.workspaceRoot),
-    (0, socket_utils_1.getFullOsSocketPath)(),
-];
 async function watchWorkspace(server, cb) {
     const { Watcher } = await Promise.resolve().then(() => require('../../native'));
     const watcher = new Watcher(workspace_root_1.workspaceRoot);

package/src/executors/run-commands/running-tasks.d.ts

@@ -17,7 +17,7 @@ export declare class ParallelRunningTasks implements RunningTask {
     onOutput(cb: (terminalOutput: string) => void): void;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): Promise<void>;
+    kill(signal?: NodeJS.Signals): Promise<void>;
     private run;
 }
 export declare class SeriallyRunningTasks implements RunningTask {
@@ -36,7 +36,7 @@ export declare class SeriallyRunningTasks implements RunningTask {
     onExit(cb: (code: number, terminalOutput: string) => void): void;
     onOutput(cb: (terminalOutput: string) => void): void;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void | Promise<void>;
+    kill(signal?: NodeJS.Signals): void | Promise<void>;
     private run;
     private createProcess;
 }

package/src/executors/run-commands/running-tasks.js

@@ -231,14 +231,24 @@ class RunningNodeProcess {
     }
     kill(signal) {
         return new Promise((res, rej) => {
-            treeKill(this.childProcess.pid, signal, (err) => {
-                if (err) {
-                    rej(err);
+            if (process.platform === 'win32' || process.platform === 'darwin') {
+                if (this.childProcess.kill(signal)) {
+                    res();
                 }
                 else {
-                    res();
+                    rej('Unable to kill process');
                 }
-            });
+            }
+            else {
+                treeKill(this.childProcess.pid, signal, (err) => {
+                    if (err) {
+                        rej(err);
+                    }
+                    else {
+                        res();
+                    }
+                });
+            }
         });
     }
     triggerOutputListeners(output) {

package/src/generators/utils/nx-json.d.ts

@@ -1,9 +1,8 @@
 import type { NxJsonConfiguration } from '../../config/nx-json';
 import type { Tree } from '../tree';
 /**
- * @deprecated You must pass a {@link Tree}. This will be removed in Nx 21.
+ * Reads nx.json
  */
-export declare function readNxJson(): NxJsonConfiguration | null;
 export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
 /**
  * Update nx.json

package/src/generators/utils/nx-json.js

@@ -4,24 +4,18 @@ exports.readNxJson = readNxJson;
 exports.updateNxJson = updateNxJson;
 const path_1 = require("path");
 const json_1 = require("./json");
-const nx_json_1 = require("../../config/nx-json");
 /**
  * Reads nx.json
  */
 function readNxJson(tree) {
-    if (tree) {
-        if (!tree.exists('nx.json')) {
-            return null;
-        }
-        let nxJson = (0, json_1.readJson)(tree, 'nx.json');
-        if (nxJson.extends) {
-            nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
-        }
-        return nxJson;
+    if (!tree.exists('nx.json')) {
+        return null;
     }
-    else {
-        return (0, nx_json_1.readNxJson)();
+    let nxJson = (0, json_1.readJson)(tree, 'nx.json');
+    if (nxJson.extends) {
+        nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
     }
+    return nxJson;
 }
 /**
  * Update nx.json

package/src/native/index.d.ts

@@ -26,7 +26,7 @@ export declare class AppLifeCycle {
 
 export declare class ChildProcess {
   getParserAndWriter(): ExternalObject<[ParserArc, WriterArc]>
-  kill(): void
+  kill(signal?: NodeJS.Signals): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
   cleanup(): void
@@ -89,12 +89,12 @@ export declare class RunningTasksService {
 
 export declare class RustPseudoTerminal {
   constructor()
-  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, execArgv?: Array<string> | undefined | null, quiet?: boolean | undefined | null, tty?: boolean | undefined | null): ChildProcess
+  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, execArgv?: Array<string> | undefined | null, quiet?: boolean | undefined | null, tty?: boolean | undefined | null, commandLabel?: string | undefined | null): ChildProcess
   /**
    * This allows us to run a pseudoterminal with a fake node ipc channel
    * this makes it possible to be backwards compatible with the old implementation
    */
-  fork(id: string, forkScript: string, pseudoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, execArgv: Array<string> | undefined | null, quiet: boolean): ChildProcess
+  fork(id: string, forkScript: string, pseudoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, execArgv: Array<string> | undefined | null, quiet: boolean, commandLabel?: string | undefined | null): ChildProcess
 }
 
 export declare class TaskDetails {

package/src/tasks-runner/forked-process-task-runner.js

@@ -122,6 +122,7 @@ class ForkedProcessTaskRunner {
             execArgv: process.execArgv,
             jsEnv: env,
             quiet: !streamOutput,
+            commandLabel: `nx run ${task.id}`,
         });
         p.send({
             targetDescription: task.target,

package/src/tasks-runner/is-tui-enabled.js

@@ -28,14 +28,23 @@ function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_S
     if (!isCapable) {
         return false;
     }
-    // The environment variable takes precedence over the nx.json config
-    if (typeof process.env.NX_TUI === 'string') {
-        return process.env.NX_TUI === 'true';
-    }
     if (['static', 'stream', 'dynamic-legacy'].includes(nxArgs.outputStyle)) {
         // If the user has specified a non-TUI output style, we disable the TUI
         return false;
     }
+    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
+        return true;
+    }
+    // The environment variable takes precedence over the nx.json config, but
+    // are lower priority than the CLI args as they are less likely to change
+    // between runs, whereas the CLI args are specified by the user for each run.
+    if (typeof process.env.NX_TUI === 'string') {
+        return process.env.NX_TUI === 'true';
+    }
+    // BELOW THIS LINE ARE "repo specific" checks, instead of "user specific" checks.
+    // "user specific" checks are specified by the current user rather than the repo
+    // settings which are applied for all users of the repo... so they are more specific
+    // and take priority.
     if (
     // Interactive TUI doesn't make sense on CI
     (0, is_ci_1.isCI)() ||
@@ -46,9 +55,6 @@ function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_S
         native_1.IS_WASM) {
         return false;
     }
-    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
-        return true;
-    }
     // Respect user config
     if (typeof nxJson.tui?.enabled === 'boolean') {
         return Boolean(nxJson.tui?.enabled);

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -12,7 +12,7 @@ export declare class PseudoTerminal {
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
-    shutdown(): void;
+    shutdown(s?: NodeJS.Signals): void;
     runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
         cwd?: string;
         execArgv?: string[];
@@ -20,11 +20,12 @@ export declare class PseudoTerminal {
         quiet?: boolean;
         tty?: boolean;
     }): PseudoTtyProcess;
-    fork(id: string, script: string, { cwd, execArgv, jsEnv, quiet, }: {
+    fork(id: string, script: string, { cwd, execArgv, jsEnv, quiet, commandLabel, }: {
         cwd?: string;
         execArgv?: string[];
         jsEnv?: Record<string, string>;
         quiet?: boolean;
+        commandLabel?: string;
     }): Promise<PseudoTtyProcessWithSend>;
     sendMessageToChildren(message: Serializable): void;
     onMessageFromChildren(callback: (message: Serializable) => void): void;
@@ -43,7 +44,7 @@ export declare class PseudoTtyProcess implements RunningTask {
     }>;
     onExit(callback: (code: number) => void): void;
     onOutput(callback: (message: string) => void): void;
-    kill(): void;
+    kill(s?: NodeJS.Signals): void;
     getParserAndWriter(): import("../native").ExternalObject<[ParserArc, WriterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {

package/src/tasks-runner/pseudo-terminal.js

@@ -9,13 +9,13 @@ const pseudo_ipc_1 = require("./pseudo-ipc");
 // Register single event listeners for all pseudo-terminal instances
 const pseudoTerminalShutdownCallbacks = [];
 process.on('SIGINT', () => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb('SIGINT'));
 });
 process.on('SIGTERM', () => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb('SIGTERM'));
 });
 process.on('SIGHUP', () => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb('SIGHUP'));
 });
 process.on('exit', () => {
     pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
@@ -47,10 +47,10 @@ class PseudoTerminal {
         await this.pseudoIPC.init();
         this.initialized = true;
     }
-    shutdown() {
+    shutdown(s) {
         for (const cp of this.childProcesses) {
             try {
-                cp.kill();
+                cp.kill(s);
             }
             catch { }
         }
@@ -63,11 +63,11 @@ class PseudoTerminal {
         this.childProcesses.add(cp);
         return cp;
     }
-    async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
+    async fork(id, script, { cwd, execArgv, jsEnv, quiet, commandLabel, }) {
         if (!this.initialized) {
             throw new Error('Call init() before forking processes');
         }
-        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet, commandLabel), id, this.pseudoIPC);
         this.childProcesses.add(cp);
         await this.pseudoIPC.waitForChildReady(id);
         return cp;
@@ -112,10 +112,10 @@ class PseudoTtyProcess {
     onOutput(callback) {
         this.outputCallbacks.push(callback);
     }
-    kill() {
+    kill(s) {
         if (this.isAlive) {
             try {
-                this.childProcess.kill();
+                this.childProcess.kill(s);
             }
             catch {
                 // when the child process completes before we explicitly call kill, this will throw

package/src/tasks-runner/running-tasks/batch-process.d.ts

@@ -10,5 +10,5 @@ export declare class BatchProcess {
     onResults(cb: (results: BatchResults) => void): void;
     getResults(): Promise<BatchResults>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void;
+    kill(signal?: NodeJS.Signals): void;
 }

package/src/tasks-runner/running-tasks/node-child-process.d.ts

@@ -15,7 +15,7 @@ export declare class NodeChildProcessWithNonDirectOutput implements RunningTask
         terminalOutput: string;
     }>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void;
+    kill(signal?: NodeJS.Signals): void;
 }
 export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     private childProcess;
@@ -33,5 +33,5 @@ export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     }>;
     waitForExit(): Promise<void>;
     getTerminalOutput(): string;
-    kill(signal?: NodeJS.Signals | number): void;
+    kill(signal?: NodeJS.Signals): void;
 }

package/src/tasks-runner/running-tasks/running-task.d.ts

@@ -5,7 +5,7 @@ export declare abstract class RunningTask {
         terminalOutput: string;
     }>;
     abstract onExit(cb: (code: number) => void): void;
-    abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+    abstract kill(signal?: NodeJS.Signals): Promise<void> | void;
     abstract onOutput?(cb: (output: string) => void): void;
     abstract send?(message: Serializable): void;
 }

package/src/utils/ignore.d.ts

@@ -1,8 +1,2 @@
 import ignore from 'ignore';
-/**
- * An array of glob patterns that should always be ignored.
- */
-export declare const ALWAYS_IGNORE: string[];
-export declare function getIgnoredGlobs(root?: string, prependRoot?: boolean): string[];
-export declare function getAlwaysIgnore(root?: string): string[];
 export declare function getIgnoreObject(root?: string): ReturnType<typeof ignore>;

package/src/utils/ignore.js

@@ -1,75 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALWAYS_IGNORE = void 0;
-exports.getIgnoredGlobs = getIgnoredGlobs;
-exports.getAlwaysIgnore = getAlwaysIgnore;
 exports.getIgnoreObject = getIgnoreObject;
-const node_fs_1 = require("node:fs");
 const ignore_1 = require("ignore");
 const fileutils_1 = require("./fileutils");
-const path_1 = require("./path");
 const workspace_root_1 = require("./workspace-root");
-/**
- * An array of glob patterns that should always be ignored.
- */
-exports.ALWAYS_IGNORE = getAlwaysIgnore();
-function getIgnoredGlobs(root = workspace_root_1.workspaceRoot, prependRoot = true) {
-    const files = ['.gitignore', '.nxignore'];
-    if (prependRoot) {
-        return [
-            ...getAlwaysIgnore(root),
-            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f), root)),
-        ];
-    }
-    else {
-        return [
-            ...getAlwaysIgnore(),
-            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f))),
-        ];
-    }
-}
-function getAlwaysIgnore(root) {
-    const paths = [
-        'node_modules',
-        '**/node_modules',
-        '.git',
-        '.nx',
-        '.vscode',
-        '.yarn/cache',
-    ];
-    return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
-}
 function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
     const ig = (0, ignore_1.default)();
     ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.gitignore`));
     ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.nxignore`));
     return ig;
 }
-function getIgnoredGlobsFromFile(file, root) {
-    try {
-        const results = [];
-        const contents = (0, node_fs_1.readFileSync)(file, 'utf-8');
-        const lines = contents.split('\n');
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            else if (trimmed.startsWith('/')) {
-                if (root) {
-                    results.push((0, path_1.joinPathFragments)(root, trimmed));
-                }
-                else {
-                    results.push((0, path_1.joinPathFragments)('.', trimmed));
-                }
-            }
-            else {
-                results.push(trimmed);
-            }
-        }
-        return results;
-    }
-    catch (e) {
-        return [];
-    }
-}

package/src/utils/params.js

@@ -349,15 +349,11 @@ function setDefaultsInObject(opts, properties, definitions) {
     });
 }
 function setPropertyDefault(opts, propName, schema, definitions) {
+    let defaultValueToSet;
     if (schema.$ref) {
         schema = resolveDefinition(schema.$ref, definitions);
     }
-    if (schema.type !== 'object' && schema.type !== 'array') {
-        if (opts[propName] === undefined && schema.default !== undefined) {
-            opts[propName] = schema.default;
-        }
-    }
-    else if (schema.type === 'array') {
+    if (schema.type === 'array') {
         const items = schema.items || {};
         if (opts[propName] &&
             Array.isArray(opts[propName]) &&
@@ -365,19 +361,29 @@ function setPropertyDefault(opts, propName, schema, definitions) {
             opts[propName].forEach((valueInArray) => setDefaultsInObject(valueInArray, items.properties || {}, definitions));
         }
         else if (!opts[propName] && schema.default) {
-            opts[propName] = schema.default;
+            defaultValueToSet = schema.default;
         }
     }
     else {
-        const wasUndefined = opts[propName] === undefined;
-        if (wasUndefined) {
-            // We need an object to set values onto
-            opts[propName] = {};
-        }
-        setDefaultsInObject(opts[propName], schema.properties || {}, definitions);
-        // If the property was initially undefined but no properties were added, we remove it again instead of having an {}
-        if (wasUndefined && Object.keys(opts[propName]).length === 0) {
-            delete opts[propName];
+        if (opts[propName] === undefined && schema.default !== undefined) {
+            defaultValueToSet = schema.default;
+        }
+        if (schema.type === 'object') {
+            const wasUndefined = opts[propName] === undefined;
+            if (!wasUndefined) {
+                setDefaultsInObject(opts[propName], schema.properties || {}, definitions);
+            }
+        }
+    }
+    if (defaultValueToSet !== undefined) {
+        try {
+            validateProperty(propName, defaultValueToSet, schema, definitions);
+            opts[propName] = defaultValueToSet;
+        }
+        catch (e) {
+            // If the default value is invalid, we don't set it...
+            // this should honestly never be needed... but some notable
+            // 3rd party schema's are invalid.
         }
     }
 }