nx 23.2.0-beta.7 → 23.2.0-beta.9

package/dist/src/utils/ignore.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OXFMT_IGNORE_OPTIONS = void 0;
 exports.getIgnoreObject = getIgnoreObject;
 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");
@@ -93,7 +96,7 @@ function createIgnoreChainResolver(read, filenames, merge) {
  * 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, both satisfied by a pruning walk and neither enforced:
+ * 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.
@@ -101,9 +104,10 @@ function createIgnoreChainResolver(read, filenames, merge) {
  *   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). `visitNotIgnoredFiles` never asks, because it
- *   prunes `dist/` before descending - which is what makes its answers match
- *   git, and why that pruning is load-bearing for correctness rather than speed.
+ *   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) {
@@ -122,6 +126,45 @@ function isIgnoredByChain(chain, filePath) {
     }
     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
@@ -174,16 +217,55 @@ function createPrettierIgnoreChecker(tree) {
         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);
-    // `probe` may carry a trailing slash; `path` never does. The chain is keyed by
-    // real directories, and `posixDirname('dist/')` is `'dist'` rather than the
-    // parent, so the lookup always uses the slash-less form.
-    const check = (path, probe) => isAlwaysIgnored(probe) ||
-        isIgnoredByChain(resolve(cascade ? posixDirname(path) : ''), probe);
+    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),
+        };
+    }
+    // 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, path),
-        isIgnoredDirectory: (path) => check(path, `${path}/`),
+        isIgnoredFile: (path) => check(path),
+        isIgnoredDirectory: (path) => check(`${path}/`),
     };
 }
 /**

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/package-manager-config/bunfig.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The directory holding bun's global config files (.bunfig.toml and, for bun's
+ * npmrc support, .npmrc): $XDG_CONFIG_HOME when set, else the home dir (bun's
+ * getHomeConfigPath). Null when neither is set, where bun reads no global
+ * config.
+ */
+export declare function getBunGlobalConfigBase(env: NodeJS.ProcessEnv): string | null;
+/**
+ * Parses a bunfig.toml: null when absent, 'unreadable' when it cannot be read
+ * (bun skips it and resolves on, so most callers collapse the two), 'invalid'
+ * when bun's own TOML parser would reject it (bun hard-errors there, so no
+ * resolution is left for a caller to reproduce).
+ */
+export declare function readBunfigRaw(path: string): Record<string, unknown> | 'unreadable' | 'invalid' | null;

package/dist/src/utils/package-manager-config/bunfig.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBunGlobalConfigBase = getBunGlobalConfigBase;
+exports.readBunfigRaw = readBunfigRaw;
+const fs_1 = require("fs");
+/**
+ * The directory holding bun's global config files (.bunfig.toml and, for bun's
+ * npmrc support, .npmrc): $XDG_CONFIG_HOME when set, else the home dir (bun's
+ * getHomeConfigPath). Null when neither is set, where bun reads no global
+ * config.
+ */
+function getBunGlobalConfigBase(env) {
+    // bun's getenvZ treats a set-but-empty var as present, so an exported empty
+    // XDG_CONFIG_HOME still short-circuits HOME (bun: `XDG_CONFIG_HOME orelse HOME`).
+    if (env.XDG_CONFIG_HOME !== undefined) {
+        return env.XDG_CONFIG_HOME;
+    }
+    // Mirrors bun's platform-specific HOME accessor (env_var.zig).
+    const home = process.platform === 'win32' ? env.USERPROFILE : env.HOME;
+    return home ?? null;
+}
+/**
+ * Parses a bunfig.toml: null when absent, 'unreadable' when it cannot be read
+ * (bun skips it and resolves on, so most callers collapse the two), 'invalid'
+ * when bun's own TOML parser would reject it (bun hard-errors there, so no
+ * resolution is left for a caller to reproduce).
+ */
+function readBunfigRaw(path) {
+    // Outside the try because a parser that will not load is a broken
+    // installation, not a corrupt bunfig.
+    const { parse } = require('smol-toml');
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (error) {
+        // ENOTDIR (a path through a non-directory) is another shape of absent, the
+        // same way the .npmrc reader classifies it.
+        return error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+            ? null
+            : 'unreadable';
+    }
+    try {
+        return parse(raw);
+    }
+    catch {
+        return 'invalid';
+    }
+}

package/dist/src/utils/package-manager-config/npmrc.d.ts

@@ -0,0 +1,23 @@
+export interface NpmrcEntry {
+    key: string;
+    value: string;
+    /** True when the source used ini's `key[]` array-append syntax. */
+    array?: boolean;
+}
+/**
+ * Parses an .npmrc file into its `key = value` entries the way npm/yarn/pnpm do
+ * (via the `ini` package). Returns null when the file is missing, and
+ * 'unreadable' when it exists but cannot be read (permissions, a directory):
+ * package managers diverge on that state, so each caller decides whether to
+ * skip, warn, or abort rather than having it collapsed into "absent" here.
+ */
+export declare function readNpmrcEntries(path: string): NpmrcEntry[] | 'unreadable' | null;
+export declare function parseNpmrcContent(raw: string): NpmrcEntry[];
+/**
+ * Reads an .npmrc-format file into a map with ini's semantics for repeated
+ * keys: scalars last-write-wins, `key[]` values joined. Null and 'unreadable'
+ * pass through from {@link readNpmrcEntries}.
+ */
+export declare function readNpmrcMap(path: string): Map<string, string> | 'unreadable' | null;
+/** Those entries under ini's semantics for repeated keys. */
+export declare function npmrcEntriesToMap(entries: NpmrcEntry[]): Map<string, string>;

package/dist/src/utils/package-manager-config/npmrc.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNpmrcEntries = readNpmrcEntries;
+exports.parseNpmrcContent = parseNpmrcContent;
+exports.readNpmrcMap = readNpmrcMap;
+exports.npmrcEntriesToMap = npmrcEntriesToMap;
+const fs_1 = require("fs");
+/**
+ * Parses an .npmrc file into its `key = value` entries the way npm/yarn/pnpm do
+ * (via the `ini` package). Returns null when the file is missing, and
+ * 'unreadable' when it exists but cannot be read (permissions, a directory):
+ * package managers diverge on that state, so each caller decides whether to
+ * skip, warn, or abort rather than having it collapsed into "absent" here.
+ */
+function readNpmrcEntries(path) {
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (e) {
+        // ENOTDIR (a path through a non-directory) is another shape of absent, not an
+        // unreadable file.
+        return e?.code === 'ENOENT' || e?.code === 'ENOTDIR' ? null : 'unreadable';
+    }
+    return parseNpmrcContent(raw);
+}
+function parseNpmrcContent(raw) {
+    const entries = [];
+    // ini breaks lines on any run of CR/LF, so splitting on `\r?\n` here would
+    // hide everything after a bare CR that npm still reads.
+    for (const line of raw.split(/[\r\n]+/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+            continue;
+        }
+        // ini matches the header on the raw line, so an indented one stays a literal
+        // bare-flag key. Everything after a header nests under it, out of npm's flat
+        // lookup, so stop here.
+        if (/^\[[^\]]*\]\s*$/.test(line)) {
+            break;
+        }
+        // ini reads a valueless line as the flag `true`; dropping it would lose a bare
+        // `always-auth`/`strict-ssl` and flip the credential/TLS decision built on it.
+        const eq = trimmed.indexOf('=');
+        const rawKey = iniUnsafe(eq === -1 ? trimmed : trimmed.slice(0, eq));
+        const value = eq === -1 ? 'true' : iniUnsafe(trimmed.slice(eq + 1));
+        // ini enables bracketedArray by default, so a `key[]` suffix appends under the
+        // bare key instead of making a literal `key[]` entry.
+        if (rawKey.length > 2 && rawKey.endsWith('[]')) {
+            entries.push({ key: rawKey.slice(0, -2), value, array: true });
+        }
+        else {
+            entries.push({ key: rawKey, value });
+        }
+    }
+    return entries;
+}
+/**
+ * Reads an .npmrc-format file into a map with ini's semantics for repeated
+ * keys: scalars last-write-wins, `key[]` values joined. Null and 'unreadable'
+ * pass through from {@link readNpmrcEntries}.
+ */
+function readNpmrcMap(path) {
+    const entries = readNpmrcEntries(path);
+    return Array.isArray(entries) ? npmrcEntriesToMap(entries) : entries;
+}
+/** Those entries under ini's semantics for repeated keys. */
+function npmrcEntriesToMap(entries) {
+    const map = new Map();
+    for (const { key, value, array } of entries) {
+        // ini collects repeated `key[]` values into an array under the bare key, and
+        // npm rebuilds a config array from the env by splitting on a blank line, so
+        // join them that way.
+        const existing = map.get(key);
+        map.set(key, array && existing !== undefined ? `${existing}\n\n${value}` : value);
+    }
+    return map;
+}
+function isQuoted(val) {
+    return (val.length >= 2 &&
+        ((val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))));
+}
+/**
+ * Mirrors the `ini` package's `unsafe()`, except that ini JSON-decodes a
+ * single-quoted value's contents and we keep them verbatim; that only differs
+ * when the contents are valid JSON, never true for a registry, token, or path.
+ * See https://github.com/isaacs/ini/blob/a0c72fe9e335a3f949d734fb5ef13371a850bbe3/lib/ini.js#L230
+ */
+function iniUnsafe(raw) {
+    const val = raw.trim();
+    if (isQuoted(val)) {
+        if (val.startsWith("'")) {
+            return val.slice(1, -1);
+        }
+        try {
+            return JSON.parse(val);
+        }
+        catch {
+            return val;
+        }
+    }
+    let esc = false;
+    let unesc = '';
+    for (const c of val) {
+        if (esc) {
+            unesc += '\\;#'.includes(c) ? c : `\\${c}`;
+            esc = false;
+        }
+        else if (c === ';' || c === '#') {
+            break;
+        }
+        else if (c === '\\') {
+            esc = true;
+        }
+        else {
+            unesc += c;
+        }
+    }
+    if (esc) {
+        unesc += '\\';
+    }
+    return unesc.trim();
+}

package/dist/src/utils/package-manager-config/pnpm-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Mirrors pnpm's getConfigDir. Hosts pnpm's global config.yaml and (v11+)
+ * auth.ini.
+ * See https://github.com/pnpm/pnpm/blob/b7195db5c8469c80908d625c648302b26c2f9977/config/reader/src/dirs.ts#L73-L92
+ */
+export declare function getPnpmConfigDir(env: NodeJS.ProcessEnv): string;
+/**
+ * Reads a pnpm YAML config file (pnpm-workspace.yaml or the global
+ * config.yaml). An absent file returns null so callers can fall through to
+ * lower surfaces; everything else returns 'unusable', which every caller turns
+ * into a throw. pnpm's own reader tolerates ENOENT alone and rethrows the rest,
+ * and it dies the same way on a document it cannot parse or that is not a
+ * mapping, so the two failures need no separate states. Requiring an object
+ * also keeps the sentinel out of the success domain: a returned string can only
+ * ever mean unusable.
+ */
+export declare function readPnpmYamlConfig(path: string): Record<string, unknown> | 'unusable' | null;

package/dist/src/utils/package-manager-config/pnpm-config.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPnpmConfigDir = getPnpmConfigDir;
+exports.readPnpmYamlConfig = readPnpmYamlConfig;
+const os_1 = require("os");
+const path_1 = require("path");
+const fileutils_1 = require("../fileutils");
+/**
+ * Mirrors pnpm's getConfigDir. Hosts pnpm's global config.yaml and (v11+)
+ * auth.ini.
+ * See https://github.com/pnpm/pnpm/blob/b7195db5c8469c80908d625c648302b26c2f9977/config/reader/src/dirs.ts#L73-L92
+ */
+function getPnpmConfigDir(env) {
+    if (env.XDG_CONFIG_HOME) {
+        return (0, path_1.join)(env.XDG_CONFIG_HOME, 'pnpm');
+    }
+    if (process.platform === 'darwin') {
+        return (0, path_1.join)((0, os_1.homedir)(), 'Library/Preferences/pnpm');
+    }
+    if (process.platform !== 'win32') {
+        return (0, path_1.join)((0, os_1.homedir)(), '.config/pnpm');
+    }
+    if (env.LOCALAPPDATA) {
+        return (0, path_1.join)(env.LOCALAPPDATA, 'pnpm/config');
+    }
+    return (0, path_1.join)((0, os_1.homedir)(), '.config/pnpm');
+}
+/**
+ * Reads a pnpm YAML config file (pnpm-workspace.yaml or the global
+ * config.yaml). An absent file returns null so callers can fall through to
+ * lower surfaces; everything else returns 'unusable', which every caller turns
+ * into a throw. pnpm's own reader tolerates ENOENT alone and rethrows the rest,
+ * and it dies the same way on a document it cannot parse or that is not a
+ * mapping, so the two failures need no separate states. Requiring an object
+ * also keeps the sentinel out of the success domain: a returned string can only
+ * ever mean unusable.
+ */
+function readPnpmYamlConfig(path) {
+    let doc;
+    try {
+        doc = (0, fileutils_1.readYamlFile)(path);
+    }
+    catch (e) {
+        // Only ENOENT resolves on, so a path through a non-directory or a file that
+        // will not open is fatal here. Callers whose pnpm counterpart looks the file
+        // up before reading it widen "absent" themselves.
+        if (e?.code === 'ENOENT') {
+            return null;
+        }
+        return 'unusable';
+    }
+    // An empty file declares nothing; pnpm accepts it.
+    if (doc === null || doc === undefined) {
+        return {};
+    }
+    if (typeof doc !== 'object' || Array.isArray(doc)) {
+        return 'unusable';
+    }
+    return doc;
+}

package/dist/src/utils/package-manager.d.ts

@@ -118,14 +118,33 @@ export declare function resolvePackageVersionUsingRegistry(packageName: string,
  * package.json.
  */
 export declare function resolvePackageVersionUsingInstallation(packageName: string, version: string): Promise<string>;
-export declare function packageRegistryView(pkg: string, version: string, args: string, options?: {
+/**
+ * The registry the fetch for `pkg` went to, with its userinfo masked because a
+ * registry URL can carry a bare token. The lookup is spawned the way
+ * `packageRegistryView` spawns the fetch this describes (same manager, same
+ * environment), so a registry the package manager keeps outside the .npmrc
+ * chain and a scope resolved for itself both land on the value that fetch used.
+ * Null where the manager yields no usable registry URL; throws where it cannot be run.
+ */
+export declare function getWorkspaceRegistryUrlForDisplay(pkg: string): string | null;
+export declare function packageRegistryView(pkg: string, version: string, args: string[], options?: {
     forceNpm?: boolean;
 }): Promise<string>;
-export declare function packageRegistryPack(cwd: string, pkg: string, version: string, options?: {
+/**
+ * Only `npm pack` supports downloading a tarball of a specified remote
+ * package. `yarn` packs the active workspace, `pnpm pack` only packs
+ * the local project, and `bun` doesn't support pack.
+ *
+ * @param packDestination Directory passed to npm's `--pack-destination`, where
+ * the `.tgz` is written.
+ * @see https://github.com/nrwl/nx/pull/9667#discussion_r842553994
+ */
+export declare function packageRegistryPack(packDestination: string, pkg: string, version: string, options?: {
     bypassMinReleaseAge?: boolean;
 }): Promise<{
     tarballPath: string;
 }>;
+export declare function clearPackageManagerVersionCache(): void;
 /**
  * Gets the workspaces defined in the package manager configuration.
  * @returns workspaces defined in the package manager configuration, empty array if none are defined