nx 23.2.0-beta.1 → 23.2.0-beta.11

package/dist/src/utils/ignore.js

@@ -1,9 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OXFMT_IGNORE_OPTIONS = void 0;
 exports.getIgnoreObject = getIgnoreObject;
-exports.getIgnoreObjectForTree = getIgnoreObjectForTree;
+exports.createIgnoreChainResolver = createIgnoreChainResolver;
+exports.isIgnoredByChain = isIgnoredByChain;
+exports.createAncestorAwareIgnoreChecker = createAncestorAwareIgnoreChecker;
+exports.isAlwaysIgnored = isAlwaysIgnored;
+exports.createGitIgnoreChecker = createGitIgnoreChecker;
+exports.createPrettierIgnoreChecker = createPrettierIgnoreChecker;
+exports.createOxfmtIgnoreChecker = createOxfmtIgnoreChecker;
+exports.posixDirname = posixDirname;
 exports.addEntryToGitIgnore = addEntryToGitIgnore;
 const ignore = require("ignore");
+const index_1 = require("../native/index");
 const fileutils_1 = require("./fileutils");
 const workspace_root_1 = require("./workspace-root");
 function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
@@ -12,18 +21,261 @@ function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
     ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.nxignore`));
     return ig;
 }
-function getIgnoreObjectForTree(tree) {
-    let ig;
-    if (tree.exists('.gitignore')) {
-        ig = ignore();
-        ig.add('.git');
-        ig.add(tree.read('.gitignore', 'utf-8'));
+/**
+ * Resolves the ignore files that apply to a directory: its own and every one
+ * above it, up to the workspace root.
+ *
+ * Ignore files cascade - a `.gitignore` covers its own directory and below, and
+ * its patterns are relative to *itself*, not to the workspace root. Reading only
+ * the root file, which is what `getIgnoreObject` does, silently misses every
+ * nested one.
+ *
+ * A directory's answer is its own files plus its parent's, so every directory on
+ * the way up is memoized rather than only the one asked for: sibling leaves
+ * share the whole trunk, and a later walk stops at the first directory already
+ * known.
+ *
+ * `read` decides where the files come from - `tree.read` for a generator, disk
+ * for a caller with no tree - and returns an empty string or null when there is
+ * no such file. Paths handed to it are workspace-relative POSIX.
+ *
+ * `merge` decides how the files *within one directory* relate, and the two
+ * consumers genuinely need different rules:
+ *
+ * - `false` is prettier's: one matcher per file, any of them excluding wins, and
+ *   a negation counts only if none excluded. `createIsIgnoredFunction` builds an
+ *   ignorer per `--ignore-path` and ORs them, so a `!x` in `.prettierignore`
+ *   cannot re-include an `x` that `.gitignore` excluded.
+ * - `true` is git's and the native walker's: all files in one matcher, so
+ *   `.nxignore`'s `!x` removes `.gitignore`'s exclusion of `x` outright. It has
+ *   to be a merge rather than a precedence check between separate matchers,
+ *   because a lone `!x` in its own matcher reports an opinion on `x/` but *none*
+ *   on `x/a.ts` (measured), so the exclusion would still reach the children.
+ *   The merge only removes the exclusion within that one directory - a negation
+ *   in a nested file still loses to an ancestor's exclusion.
+ *
+ * When `merge` is true, `filenames` order matters: they go into one matcher in
+ * order and the last matching pattern decides, so list them lowest-authority
+ * first.
+ */
+function createIgnoreChainResolver(read, filenames, merge) {
+    const cache = new Map();
+    const resolve = (dir) => {
+        const cached = cache.get(dir);
+        if (cached) {
+            return cached;
+        }
+        const contents = filenames
+            .map((name) => read(dir ? `${dir}/${name}` : name))
+            .filter((c) => !!c);
+        const matchers = merge
+            ? contents.length > 0
+                ? [contents.reduce((m, c) => m.add(c), ignore())]
+                : []
+            : contents.map((c) => ignore().add(c));
+        const inherited = dir === '' ? [] : resolve(posixDirname(dir));
+        const chain = matchers.length > 0 ? [{ dir, matchers }, ...inherited] : inherited;
+        cache.set(dir, chain);
+        return chain;
+    };
+    return resolve;
+}
+/**
+ * True when the file is ignored, resolving the chain nearest file first.
+ *
+ * Each matcher is tested against the path relative to its own directory, which
+ * is what makes a nested pattern like `/build` mean that directory's `build`
+ * rather than the workspace's.
+ *
+ * Nearest directory with an *opinion* wins, not the first match: a nested
+ * `!keep.log` must override the root's `*.log`, which is git's rule for files.
+ * A nested negation of a *directory* does not reach its children - see the
+ * `merge` note on `createIgnoreChainResolver`.
+ *
+ * How the files of one directory relate is decided when the chain is built - see
+ * that same note. Here they are simply the entry's matchers: any one excluding
+ * wins, and a negation counts only if none excluded.
+ *
+ * Two preconditions, neither enforced here:
+ *
+ * - `filePath` is workspace-relative POSIX and must sit under every `dir` in the
+ *   chain, which holds when the chain came from that file's own directory.
+ * - No ancestor directory of `filePath` may itself be ignored. git refuses to
+ *   re-include a file inside an excluded directory, and this does not implement
+ *   that rule: asked directly about `dist/keep.ts` with a root `dist/` and a
+ *   nested `dist/.gitignore` holding `!keep.ts`, it answers "not ignored" where
+ *   git says ignored (measured). A pruning walk like `visitNotIgnoredFiles`
+ *   satisfies it by never asking about anything under `dist/`; a per-file
+ *   caller cannot, so it goes through `createAncestorAwareIgnoreChecker`,
+ *   which checks the ancestors before asking the chain.
+ */
+function isIgnoredByChain(chain, filePath) {
+    for (const { dir, matchers } of chain) {
+        const relative = dir === '' ? filePath : filePath.slice(dir.length + 1);
+        let unignored = false;
+        for (const matcher of matchers) {
+            const result = matcher.test(relative);
+            if (result.ignored) {
+                return true;
+            }
+            unignored ||= result.unignored;
+        }
+        if (unignored) {
+            return false;
+        }
     }
-    if (tree.exists('.nxignore')) {
-        ig ??= ignore();
-        ig.add(tree.read('.nxignore', 'utf-8'));
+    return false;
+}
+/**
+ * The chain's answers plus git's excluded-ancestor rule: nothing inside an
+ * ignored directory can be re-included, so a nested negation must not
+ * resurrect a file whose ancestor an outer file excluded - the case
+ * `isIgnoredByChain` alone gets wrong (see its second precondition). The
+ * oxfmt CLI follows the same rule (measured against 0.60.0: a scan skips a
+ * nested `!keep.ts` under a root-ignored `dist/`), so every per-file caller -
+ * the cascading tree checkers and the disk-backed resolver in
+ * `formatters/oxfmt.ts` - goes through here.
+ *
+ * A directory's own ignore files cannot un-ignore the directory itself, so
+ * its verdict comes from its parent's chain - probed with a trailing slash,
+ * which is what makes a directory-only pattern like `dist/` match. Verdicts
+ * are memoized per directory, so a batch of files shares its ancestor walks.
+ */
+function createAncestorAwareIgnoreChecker(resolve) {
+    const ignoredDirs = new Map();
+    const isIgnoredDirectory = (dir) => {
+        if (dir === '') {
+            return false;
+        }
+        const cached = ignoredDirs.get(dir);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const parent = posixDirname(dir);
+        const ignored = isIgnoredDirectory(parent) ||
+            isIgnoredByChain(resolve(parent), `${dir}/`);
+        ignoredDirs.set(dir, ignored);
+        return ignored;
+    };
+    return {
+        isIgnoredFile: (filePath) => {
+            const dir = posixDirname(filePath);
+            return (isIgnoredDirectory(dir) || isIgnoredByChain(resolve(dir), filePath));
+        },
+        isIgnoredDirectory,
+    };
+}
+let alwaysIgnored;
+/**
+ * Directories that should never be walked, whatever the workspace's own ignore
+ * files say - `node_modules`, `.git`, the nx caches.
+ *
+ * The list comes from the native walker rather than a second copy here, so a
+ * filesystem walk and a tree walk cannot drift apart.
+ *
+ * Checked ahead of the cascading chain rather than folded into it: these are not
+ * re-includable, and as ordinary patterns a nested negation could resurrect
+ * `node_modules`.
+ */
+function isAlwaysIgnored(path) {
+    alwaysIgnored ??= ignore().add((0, index_1.getHardcodedIgnorePatterns)());
+    return alwaysIgnored.ignores(path);
+}
+/**
+ * What git ignores, which is also what the native walker ignores.
+ *
+ * `.nxignore` outranks `.gitignore` - `walker.rs` registers it with
+ * `add_custom_ignore_filename` - which a merge with `.nxignore` last reproduces.
+ * git itself does not read it.
+ *
+ * Reads from the tree rather than disk because a generator can create or amend
+ * an ignore file in the same run, which would leave the on-disk copy stale.
+ */
+function createGitIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, {
+        filenames: ['.gitignore', '.nxignore'],
+        cascade: true,
+        merge: true,
+    });
+}
+/**
+ * What prettier ignores: the workspace root only, and one ignorer per
+ * `--ignore-path` ORed rather than merged (both measured), so a `!` in
+ * `.prettierignore` cannot re-include what `.gitignore` excluded. That is the
+ * CLI `nx format:check` shells out to.
+ *
+ * Not an exact match for that command: `isAlwaysIgnored` is wider than
+ * prettier's built-ins, and `format.ts` filters its own patterns through
+ * `.nxignore`, which this does not read.
+ *
+ * Reads from the tree rather than disk, as above.
+ */
+function createPrettierIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, {
+        filenames: ['.gitignore', '.prettierignore'],
+        cascade: false,
+        merge: false,
+    });
+}
+/**
+ * What oxfmt ignores: prettier's two files, but resolved from each file's own
+ * directory upwards rather than the workspace root - measured against the
+ * oxfmt 0.60.0 CLI, which differs from prettier on exactly that axis. Still
+ * one matcher per file rather than merged.
+ *
+ * A config's `ignorePatterns` is not an ignore file and is not read here;
+ * `formatFilesWithOxfmt` applies it rooted at that config's directory.
+ */
+function createOxfmtIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, exports.OXFMT_IGNORE_OPTIONS);
+}
+/**
+ * Exported, unlike git's and prettier's, because oxfmt has two consumers:
+ * this tree-backed checker and the disk-backed resolver in
+ * `formatters/oxfmt.ts`. A shared value is the only thing that keeps them
+ * agreeing, so do not restate these three anywhere.
+ *
+ * `satisfies` rather than an annotation keeps the values literal - an
+ * annotation widens `cascade` and `merge` to `boolean` (measured in the
+ * declaration emit).
+ */
+exports.OXFMT_IGNORE_OPTIONS = {
+    filenames: ['.gitignore', '.prettierignore'],
+    cascade: true,
+    merge: false,
+};
+function createTreeIgnoreChecker(tree, { filenames, cascade, merge }) {
+    const resolve = createIgnoreChainResolver((path) => tree.read(path, 'utf-8'), filenames, merge);
+    if (cascade) {
+        // Cascading resolution and the excluded-ancestor rule travel together:
+        // both come from git, and the one cascading tool that is not git - oxfmt -
+        // applies both (measured, see `createAncestorAwareIgnoreChecker`).
+        const checker = createAncestorAwareIgnoreChecker(resolve);
+        return {
+            isIgnoredFile: (path) => isAlwaysIgnored(path) || checker.isIgnoredFile(path),
+            // The trailing slash is what makes a directory-only pattern like `dist/`
+            // match - `ignore` will not match it against the bare `dist`.
+            isIgnoredDirectory: (path) => isAlwaysIgnored(`${path}/`) || checker.isIgnoredDirectory(path),
+        };
     }
-    return ig;
+    // Root-only: the whole chain is the root's, so no ancestor holds ignore
+    // files of its own, and within one matcher `ignore` itself refuses to
+    // re-include under an excluded directory (measured). Nothing is left for an
+    // ancestor walk to add.
+    const check = (probe) => isAlwaysIgnored(probe) || isIgnoredByChain(resolve(''), probe);
+    return {
+        isIgnoredFile: (path) => check(path),
+        isIgnoredDirectory: (path) => check(`${path}/`),
+    };
+}
+/**
+ * `path.dirname` for the workspace-relative POSIX paths the chain is keyed by,
+ * except that the workspace root is `''` rather than `.` - that is the key
+ * `createIgnoreChainResolver` terminates on.
+ */
+function posixDirname(relativePath) {
+    const separator = relativePath.lastIndexOf('/');
+    return separator === -1 ? '' : relativePath.slice(0, separator);
 }
 /**
  * Adds an entry to a .gitignore file if it's not already covered by existing patterns.

package/dist/src/utils/kill-child-on-host-exit.d.ts

@@ -0,0 +1,7 @@
+import type { ChildProcess } from 'node:child_process';
+/**
+ * Kill `cp` (and its descendants) when this process exits, unless it has
+ * already exited on its own.
+ */
+export declare function killChildOnHostExit(cp: ChildProcess): void;
+export declare function killTrackedChildren(): void;

package/dist/src/utils/kill-child-on-host-exit.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killChildOnHostExit = killChildOnHostExit;
+exports.killTrackedChildren = killTrackedChildren;
+const native_1 = require("../native");
+// Children spawned by this process that must not outlive it. Plugin workers
+// are torn down with `process.exit`, which leaves spawned build tools (gradle,
+// maven, ...) orphaned and still holding their project locks.
+const trackedChildren = new Set();
+let exitHookRegistered = false;
+/**
+ * Kill `cp` (and its descendants) when this process exits, unless it has
+ * already exited on its own.
+ */
+function killChildOnHostExit(cp) {
+    if (!cp.pid)
+        return;
+    trackedChildren.add(cp.pid);
+    const untrack = () => {
+        trackedChildren.delete(cp.pid);
+        // Whichever fires first, drop both — otherwise the other stays registered
+        // on a child that is already gone.
+        cp.off('exit', untrack);
+        cp.off('error', untrack);
+    };
+    cp.once('exit', untrack);
+    cp.once('error', untrack);
+    if (!exitHookRegistered) {
+        exitHookRegistered = true;
+        process.once('exit', killTrackedChildren);
+    }
+}
+function killTrackedChildren() {
+    for (const pid of trackedChildren) {
+        try {
+            // 'exit' handlers must be synchronous, so no graceful variant here.
+            (0, native_1.killProcessTree)(pid, 'SIGTERM');
+        }
+        catch { }
+    }
+    trackedChildren.clear();
+}

package/dist/src/utils/long-running-target.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Target names the pre-23 `longRunningTask` guard excluded from caching. Shared
+ * between that guard and the deprecated target-name cache fallback so the two
+ * cannot drift apart.
+ *
+ * The copy in `migrations/update-23-2-0/set-cache-on-executor-target-defaults.ts`
+ * deliberately does not use this: a migration's decision has to freeze at the
+ * semantics it shipped with.
+ */
+export declare function isLongRunningTargetName(targetName: string): boolean;

package/dist/src/utils/long-running-target.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLongRunningTargetName = isLongRunningTargetName;
+/**
+ * Target names the pre-23 `longRunningTask` guard excluded from caching. Shared
+ * between that guard and the deprecated target-name cache fallback so the two
+ * cannot drift apart.
+ *
+ * The copy in `migrations/update-23-2-0/set-cache-on-executor-target-defaults.ts`
+ * deliberately does not use this: a migration's decision has to freeze at the
+ * semantics it shipped with.
+ */
+function isLongRunningTargetName(targetName) {
+    return (targetName.endsWith(':watch') ||
+        targetName.endsWith('-watch') ||
+        targetName === 'serve' ||
+        targetName === 'dev' ||
+        targetName === 'start');
+}

package/dist/src/utils/min-release-age/behavior/bun.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readBunPolicy = readBunPolicy;
 exports.pickBunVersion = pickBunVersion;
-const fs_1 = require("fs");
 const path_1 = require("path");
 const semver_1 = require("semver");
-const smol_toml_1 = require("smol-toml");
+const bunfig_1 = require("../../package-manager-config/bunfig");
 const constants_1 = require("../constants");
 const errors_1 = require("../errors");
 const pick_1 = require("../pick");
@@ -82,23 +81,20 @@ function readLocalBunInstall(root) {
     return readBunInstall((0, path_1.join)(root, 'bunfig.toml'));
 }
 function readGlobalBunInstall() {
-    const xdg = process.env.XDG_CONFIG_HOME;
-    const base = xdg || process.env.HOME;
+    const base = (0, bunfig_1.getBunGlobalConfigBase)(process.env);
     if (!base) {
         return {};
     }
     return readBunInstall((0, path_1.join)(base, '.bunfig.toml'));
 }
 function readBunInstall(path) {
-    if (!(0, fs_1.existsSync)(path)) {
+    const parsed = (0, bunfig_1.readBunfigRaw)(path);
+    // bun skips a bunfig it cannot read and resolves on, so its settings do not
+    // apply. Only a parse failure kills the install.
+    if (parsed === null || parsed === 'unreadable') {
         return {};
     }
-    let parsed;
-    try {
-        parsed = (0, smol_toml_1.parse)((0, fs_1.readFileSync)(path, 'utf-8'));
-    }
-    catch {
-        // Unparseable bunfig makes bun's install die; treat as a hard error.
+    if (parsed === 'invalid') {
         return 'error';
     }
     const install = parsed.install;

package/dist/src/utils/min-release-age/behavior/npm.js

@@ -8,7 +8,7 @@ const path_1 = require("path");
 const semver_1 = require("semver");
 const constants_1 = require("../constants");
 const errors_1 = require("../errors");
-const npmrc_1 = require("../npmrc");
+const npmrc_1 = require("../../package-manager-config/npmrc");
 const pick_1 = require("../pick");
 const RANK_UNKNOWN = 0; // global/builtin/default - not detectable here
 const RANK_USER = 1;
@@ -116,7 +116,10 @@ function detectSurfaces(root, env) {
 }
 function readNpmrcKeys(override, fallback) {
     const present = { minReleaseAge: false, before: false };
-    for (const { key } of (0, npmrc_1.readNpmrcEntries)(override ?? fallback) ?? []) {
+    // npm silently treats an .npmrc it cannot read as absent, so both non-array
+    // states scan nothing.
+    const entries = (0, npmrc_1.readNpmrcEntries)(override ?? fallback);
+    for (const { key } of Array.isArray(entries) ? entries : []) {
         if (key === 'min-release-age') {
             present.minReleaseAge = true;
         }

package/dist/src/utils/min-release-age/packument.js

@@ -16,7 +16,7 @@ function toArray(value) {
  * `dist-tags` carries a hyphen.
  */
 async function fetchRegistryMetadata(pkg) {
-    const raw = await (0, package_manager_1.packageRegistryView)(pkg, '', '--json');
+    const raw = await (0, package_manager_1.packageRegistryView)(pkg, '', ['--json']);
     const parsed = JSON.parse(raw);
     const time = parsed.time ?? null;
     if (time) {

package/dist/src/utils/nx-console-prompt.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureNxConsoleInstalled = ensureNxConsoleInstalled;
-const enquirer_1 = require("enquirer");
+const prompt_helpers_1 = require("./prompt-helpers");
 const os_1 = require("os");
 const output_1 = require("./output");
 const native_1 = require("../native");
@@ -50,13 +50,10 @@ async function promptForNxConsoleInstallation() {
                 '- Explore your workspace visually',
             ],
         });
-        const { shouldInstallNxConsole } = await (0, enquirer_1.prompt)({
-            type: 'confirm',
-            name: 'shouldInstallNxConsole',
+        return await (0, prompt_helpers_1.confirmationPrompt)({
             message: 'Install Nx Console? (you can uninstall anytime)',
-            initial: true,
+            onCancel: () => false,
         });
-        return shouldInstallNxConsole;
     }
     catch (error) {
         return false;

package/dist/src/utils/nx-tmp-dir.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stable root for Nx runtime artifacts that need an OS tmp location. On POSIX a
+ * literal `/tmp`, not `os.tmpdir()`, which honours `$TMPDIR` — per-user on
+ * macOS, rewritten by sandboxes, stripped from the daemon env, so client and
+ * daemon would disagree. Windows has no `/tmp`, and `%TMP%` is already per-user
+ * and stable, so it keeps `os.tmpdir()`.
+ *
+ * Consumed by the native binding loader, so keep this file limited to local
+ * helpers that themselves use Node builtins only.
+ */
+export declare const NX_TMP_DIR: string;
+/**
+ * Owner-only runtime root for the current user. No user segment on Windows —
+ * `%TMP%` is already per-account, and the segment would only cost path length.
+ */
+export declare const NX_USER_TMP_DIR: string;
+/** Runtime root under the user's home, used when the shared container cannot be established. */
+export declare const NX_HOME_TMP_DIR: string;

package/dist/src/utils/nx-tmp-dir.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_HOME_TMP_DIR = exports.NX_USER_TMP_DIR = exports.NX_TMP_DIR = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const owned_private_dir_1 = require("./owned-private-dir");
+/**
+ * Stable root for Nx runtime artifacts that need an OS tmp location. On POSIX a
+ * literal `/tmp`, not `os.tmpdir()`, which honours `$TMPDIR` — per-user on
+ * macOS, rewritten by sandboxes, stripped from the daemon env, so client and
+ * daemon would disagree. Windows has no `/tmp`, and `%TMP%` is already per-user
+ * and stable, so it keeps `os.tmpdir()`.
+ *
+ * Consumed by the native binding loader, so keep this file limited to local
+ * helpers that themselves use Node builtins only.
+ */
+exports.NX_TMP_DIR = (0, node_os_1.platform)() === 'win32' ? (0, node_path_1.join)((0, node_os_1.tmpdir)(), '.nx') : '/tmp/.nx';
+/**
+ * Owner-only runtime root for the current user. No user segment on Windows —
+ * `%TMP%` is already per-account, and the segment would only cost path length.
+ */
+exports.NX_USER_TMP_DIR = (0, node_os_1.platform)() === 'win32' ? exports.NX_TMP_DIR : (0, node_path_1.join)(exports.NX_TMP_DIR, (0, owned_private_dir_1.getUserSegment)());
+/** Runtime root under the user's home, used when the shared container cannot be established. */
+exports.NX_HOME_TMP_DIR = resolveHomeTmpDir();
+/**
+ * Absolute, not merely non-empty: a relative `$HOME` would make `join` return
+ * `.nx`, putting sockets under the cwd and aiming `removeSocketDir`'s recursive
+ * delete at it. A rootless container has no `$HOME` and no passwd entry, so
+ * `homedir()` throws or returns empty — caught here because this runs at module
+ * scope and the native binding loader imports this file.
+ */
+function resolveHomeTmpDir() {
+    try {
+        const home = (0, node_os_1.homedir)();
+        return home && (0, node_path_1.isAbsolute)(home) ? (0, node_path_1.join)(home, '.nx') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}