nx 23.1.0 → 23.2.0-beta.0

package/dist/src/utils/catalog/manager-utils.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCatalogConfigFromFs = readCatalogConfigFromFs;
-exports.readCatalogConfigFromTree = readCatalogConfigFromTree;
+exports.readCatalogDefinitions = readCatalogDefinitions;
 exports.updateCatalogVersionsInFile = updateCatalogVersionsInFile;
-// Keep in sync with packages/devkit/src/utils/catalog/manager-utils.ts; the body
-// below the imports is duplicated because @nx/devkit supports a range of nx majors
-// and this logic isn't part of the nx surface it can import across that range.
 const js_yaml_1 = require("@zkochan/js-yaml");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -119,6 +115,27 @@ function readCatalogConfigFromTree(filename, tree) {
         return null;
     }
 }
+// Managers are created per operation (getCatalogManager news one up), so the
+// fs (string-root) branch is cached to read the file once per pass instead of
+// once per catalog reference. The Tree branch stays live since the tree is
+// mutable within a generator.
+function readCatalogDefinitions(filename, treeOrRoot, cache) {
+    if (typeof treeOrRoot === 'string') {
+        if (cache.has(treeOrRoot)) {
+            return cache.get(treeOrRoot);
+        }
+        const configPath = (0, node_path_1.join)(treeOrRoot, filename);
+        const defs = (0, node_fs_1.existsSync)(configPath)
+            ? readCatalogConfigFromFs(filename, configPath)
+            : null;
+        cache.set(treeOrRoot, defs);
+        return defs;
+    }
+    if (!treeOrRoot.exists(filename)) {
+        return null;
+    }
+    return readCatalogConfigFromTree(filename, treeOrRoot);
+}
 function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
     let checkExists;
     let readYaml;

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

@@ -7,6 +7,7 @@ import type { CatalogDefinitions, CatalogReference } from './types';
 export declare class PnpmCatalogManager implements CatalogManager {
     readonly name = "pnpm";
     readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
     isCatalogReference(version: string): boolean;
     parseCatalogReference(version: string): CatalogReference | null;
     getCatalogDefinitionFilePaths(): string[];

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

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PnpmCatalogManager = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const PNPM_WORKSPACE_FILENAME = 'pnpm-workspace.yaml';
@@ -13,6 +11,8 @@ class PnpmCatalogManager {
     constructor() {
         this.name = 'pnpm';
         this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readCatalogDefinitions.
+        this.definitionsByRoot = new Map();
     }
     isCatalogReference(version) {
         return version.startsWith(this.catalogProtocol);
@@ -33,19 +33,7 @@ class PnpmCatalogManager {
         return [PNPM_WORKSPACE_FILENAME];
     }
     getCatalogDefinitions(treeOrRoot) {
-        if (typeof treeOrRoot === 'string') {
-            const configPath = (0, node_path_1.join)(treeOrRoot, PNPM_WORKSPACE_FILENAME);
-            if (!(0, node_fs_1.existsSync)(configPath)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromFs)(PNPM_WORKSPACE_FILENAME, configPath);
-        }
-        else {
-            if (!treeOrRoot.exists(PNPM_WORKSPACE_FILENAME)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromTree)(PNPM_WORKSPACE_FILENAME, treeOrRoot);
-        }
+        return (0, manager_utils_1.readCatalogDefinitions)(PNPM_WORKSPACE_FILENAME, treeOrRoot, this.definitionsByRoot);
     }
     resolveCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);

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

@@ -7,6 +7,7 @@ import type { CatalogDefinitions, CatalogReference } from './types';
 export declare class YarnCatalogManager implements CatalogManager {
     readonly name = "yarn";
     readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
     isCatalogReference(version: string): boolean;
     parseCatalogReference(version: string): CatalogReference | null;
     getCatalogDefinitionFilePaths(): string[];

package/dist/src/utils/catalog/yarn-manager.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YarnCatalogManager = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const YARNRC_FILENAME = '.yarnrc.yml';
@@ -13,6 +11,8 @@ class YarnCatalogManager {
     constructor() {
         this.name = 'yarn';
         this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readCatalogDefinitions.
+        this.definitionsByRoot = new Map();
     }
     isCatalogReference(version) {
         return version.startsWith(this.catalogProtocol);
@@ -33,19 +33,7 @@ class YarnCatalogManager {
         return [YARNRC_FILENAME];
     }
     getCatalogDefinitions(treeOrRoot) {
-        if (typeof treeOrRoot === 'string') {
-            const configPath = (0, node_path_1.join)(treeOrRoot, YARNRC_FILENAME);
-            if (!(0, node_fs_1.existsSync)(configPath)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromFs)(YARNRC_FILENAME, configPath);
-        }
-        else {
-            if (!treeOrRoot.exists(YARNRC_FILENAME)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromTree)(YARNRC_FILENAME, treeOrRoot);
-        }
+        return (0, manager_utils_1.readCatalogDefinitions)(YARNRC_FILENAME, treeOrRoot, this.definitionsByRoot);
     }
     resolveCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);

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

@@ -28,9 +28,7 @@ export declare class GitRepository {
     hasFilterRepoInstalled(): Promise<boolean>;
     filterRepo(source: string, destination: string): Promise<void>;
     filterBranch(source: string, destination: string, branchName: string): Promise<void>;
-    private execAsync;
-    private quotePath;
-    private quoteArg;
+    private execGit;
 }
 export interface VcsRemoteInfo {
     domain: string;
@@ -39,6 +37,7 @@ export interface VcsRemoteInfo {
 export declare function parseVcsRemoteUrl(url: string): VcsRemoteInfo | null;
 export declare function getVcsRemoteInfo(directory?: string): VcsRemoteInfo | null;
 export declare function isGitRepository(directory?: string): boolean;
+export declare function getGitCurrentBranch(directory?: string): string | null;
 export declare function hasUncommittedChanges(directory?: string): boolean;
 export declare function getUncommittedChangesSnapshot(directory?: string): string;
 export declare function commitChanges(commitMessage: string, directory?: string): string | null;

package/dist/src/utils/git-utils.js

@@ -5,6 +5,7 @@ exports.cloneFromUpstream = cloneFromUpstream;
 exports.parseVcsRemoteUrl = parseVcsRemoteUrl;
 exports.getVcsRemoteInfo = getVcsRemoteInfo;
 exports.isGitRepository = isGitRepository;
+exports.getGitCurrentBranch = getGitCurrentBranch;
 exports.hasUncommittedChanges = hasUncommittedChanges;
 exports.getUncommittedChangesSnapshot = getUncommittedChangesSnapshot;
 exports.commitChanges = commitChanges;
@@ -16,9 +17,9 @@ const crypto = tslib_1.__importStar(require("crypto"));
 const fs = tslib_1.__importStar(require("fs"));
 const path_1 = require("path");
 const logger_1 = require("./logger");
-function execAsync(command, execOptions) {
+function execFileAsync(file, args, execOptions) {
     return new Promise((res, rej) => {
-        (0, child_process_1.exec)(command, { ...execOptions, windowsHide: true }, (err, stdout, stderr) => {
+        (0, child_process_1.execFile)(file, args, { ...execOptions, windowsHide: true }, (err, stdout) => {
             if (err) {
                 return rej(err);
             }
@@ -29,7 +30,14 @@ function execAsync(command, execOptions) {
 async function cloneFromUpstream(url, destination, { originName, depth } = {
     originName: 'origin',
 }) {
-    await execAsync(`git clone ${url} ${destination} ${depth ? `--depth ${depth}` : ''} --origin ${originName}`, {
+    await execFileAsync('git', [
+        'clone',
+        url,
+        destination,
+        ...(depth ? ['--depth', `${depth}`] : []),
+        '--origin',
+        originName,
+    ], {
         cwd: (0, path_1.dirname)(destination),
         maxBuffer: 10 * 1024 * 1024,
     });
@@ -41,7 +49,7 @@ class GitRepository {
         this.root = this.getGitRootPath(this.directory);
     }
     getGitRootPath(cwd) {
-        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+        return (0, child_process_1.execFileSync)('git', ['rev-parse', '--show-toplevel'], {
             cwd,
             windowsHide: true,
         })
@@ -49,17 +57,22 @@ class GitRepository {
             .trim();
     }
     async hasUncommittedChanges() {
-        const data = await this.execAsync(`git status --porcelain`);
+        const data = await this.execGit(['status', '--porcelain']);
         return data.trim() !== '';
     }
     async addFetchRemote(remoteName, branch) {
-        return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
+        return await this.execGit([
+            'config',
+            '--add',
+            `remote.${remoteName}.fetch`,
+            `+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}`,
+        ]);
     }
     async showStat() {
-        return await this.execAsync(`git show --stat`);
+        return await this.execGit(['show', '--stat']);
     }
     async listBranches() {
-        return (await this.execAsync(`git ls-remote --heads --quiet`))
+        return (await this.execGit(['ls-remote', '--heads', '--quiet']))
             .trim()
             .split('\n')
             .map((s) => s
@@ -70,45 +83,58 @@ class GitRepository {
     async getGitFiles(path) {
         // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
         // This avoids problems with special characters in file names.
-        return (await this.execAsync(`git ls-files -z ${path}`))
+        return (await this.execGit(['ls-files', '-z', '--', path]))
             .trim()
             .split('\x00')
             .map((s) => s.trim())
             .filter(Boolean);
     }
     async reset(ref) {
-        return await this.execAsync(`git reset ${ref} --hard`);
+        return await this.execGit(['reset', '--hard', ref]);
     }
     async mergeUnrelatedHistories(ref, message) {
-        return await this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+        return await this.execGit([
+            'merge',
+            ref,
+            '-X',
+            'ours',
+            '--allow-unrelated-histories',
+            '-m',
+            message,
+        ]);
     }
     async fetch(remote, ref) {
-        return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+        return await this.execGit(['fetch', remote, ...(ref ? [ref] : [])]);
     }
     async checkout(branch, opts) {
-        return await this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+        return await this.execGit([
+            'checkout',
+            ...(opts.new ? ['-b'] : []),
+            branch,
+            ...(opts.base ? [opts.base] : []),
+        ]);
     }
     async move(path, destination) {
-        return await this.execAsync(`git mv ${this.quotePath(path)} ${this.quotePath(destination)}`);
+        return await this.execGit(['mv', '--', path, destination]);
     }
     async push(ref, remoteName) {
-        return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+        return await this.execGit(['push', '-u', '-f', remoteName, ref]);
     }
     async commit(message) {
-        return await this.execAsync(`git commit -am "${message}"`);
+        return await this.execGit(['commit', '-am', message]);
     }
     async amendCommit() {
-        return await this.execAsync(`git commit --amend -a --no-edit`);
+        return await this.execGit(['commit', '--amend', '-a', '--no-edit']);
     }
     async deleteGitRemote(name) {
-        return await this.execAsync(`git remote rm ${name}`);
+        return await this.execGit(['remote', 'rm', name]);
     }
     async addGitRemote(name, url) {
-        return await this.execAsync(`git remote add ${name} ${url}`);
+        return await this.execGit(['remote', 'add', name, url]);
     }
     async hasFilterRepoInstalled() {
         try {
-            await this.execAsync(`git filter-repo --help`);
+            await this.execGit(['filter-repo', '--help']);
             return true;
         }
         catch {
@@ -121,35 +147,57 @@ class GitRepository {
         // NOTE: filter-repo requires POSIX path to work
         const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
         const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
-        await this.execAsync(`git filter-repo -f ${source !== '' ? `--path ${this.quotePath(sourcePosixPath)}` : ''} ${source !== destination
-            ? `--path-rename ${this.quotePath(sourcePosixPath, true)}:${this.quotePath(destinationPosixPath, true)}`
-            : ''}`);
+        const sourcePath = ensureTrailingSlash(sourcePosixPath);
+        const destinationPath = ensureTrailingSlash(destinationPosixPath);
+        await this.execGit([
+            'filter-repo',
+            '-f',
+            ...(source !== '' ? ['--path', sourcePosixPath] : []),
+            ...(source !== destination
+                ? ['--path-rename', `${sourcePath}:${destinationPath}`]
+                : []),
+        ]);
     }
     async filterBranch(source, destination, branchName) {
         // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
-        await this.execAsync(`git config core.quotepath false`);
+        await this.execGit(['config', 'core.quotepath', 'false']);
         // NOTE: filter-repo requires POSIX path to work
         const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
         const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
         // First, if the source is not a root project, then only include commits relevant to the subdirectory.
         if (source !== '') {
-            const indexFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.index-filter.js')}`);
-            await this.execAsync(`git filter-branch -f --index-filter ${indexFilterCommand} --prune-empty -- ${branchName}`, {
+            const indexFilterCommand = `node ${quoteForShell((0, path_1.join)(__dirname, 'git-utils.index-filter.js'))}`;
+            await this.execGit([
+                'filter-branch',
+                '-f',
+                '--index-filter',
+                indexFilterCommand,
+                '--prune-empty',
+                '--',
+                branchName,
+            ], {
                 NX_IMPORT_SOURCE: sourcePosixPath,
                 NX_IMPORT_DESTINATION: destinationPosixPath,
             });
         }
         // Then, move files to their new location if necessary.
         if (source === '' || source !== destination) {
-            const treeFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.tree-filter.js')}`);
-            await this.execAsync(`git filter-branch -f --tree-filter ${treeFilterCommand} -- ${branchName}`, {
+            const treeFilterCommand = `node ${quoteForShell((0, path_1.join)(__dirname, 'git-utils.tree-filter.js'))}`;
+            await this.execGit([
+                'filter-branch',
+                '-f',
+                '--tree-filter',
+                treeFilterCommand,
+                '--',
+                branchName,
+            ], {
                 NX_IMPORT_SOURCE: sourcePosixPath,
                 NX_IMPORT_DESTINATION: destinationPosixPath,
             });
         }
     }
-    execAsync(command, env) {
-        return execAsync(command, {
+    execGit(args, env) {
+        return execFileAsync('git', args, {
             cwd: this.root,
             maxBuffer: 10 * 1024 * 1024,
             env: {
@@ -158,25 +206,14 @@ class GitRepository {
             },
         });
     }
-    quotePath(path, ensureTrailingSlash) {
-        return this.quoteArg(ensureTrailingSlash && path !== '' && !path.endsWith('/')
-            ? `${path}/`
-            : path);
-    }
-    quoteArg(arg) {
-        return process.platform === 'win32'
-            ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
-                // Bash and other shells will substitute `$` in file names with a variable value.
-                `"${arg
-                    // Need to keep two slashes for Windows or else the path will be invalid.
-                    // e.g. 'C:\Users\bob\projects\repo' is invalid, but 'C:\\Users\\bob\\projects\\repo' is valid
-                    .replaceAll('\\', '\\\\')}"`
-            : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
-                // Using single-quotes prevents this substitution.
-                `'${arg}'`;
-    }
 }
 exports.GitRepository = GitRepository;
+function ensureTrailingSlash(path) {
+    return path !== '' && !path.endsWith('/') ? `${path}/` : path;
+}
+function quoteForShell(arg) {
+    return `'${arg.replaceAll("'", "'\"'\"'")}'`;
+}
 function parseVcsRemoteUrl(url) {
     // Remove whitespace and handle common URL formats
     const cleanUrl = url.trim();
@@ -273,6 +310,23 @@ function isGitRepository(directory) {
         return false;
     }
 }
+// Checked-out branch name, or null when there isn't one to act on: a detached
+// HEAD reports the literal "HEAD" (treated as no branch), and any git error
+// (not a repo, no commits yet) also yields null.
+function getGitCurrentBranch(directory) {
+    try {
+        const branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf8',
+            cwd: directory,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }).trim();
+        return branch && branch !== 'HEAD' ? branch : null;
+    }
+    catch {
+        return null;
+    }
+}
 // Sync companion to `GitRepository.hasUncommittedChanges` for callers that
 // can't drop into the async class (e.g. the migrate orchestrator, which
 // branches on this before spawning subprocesses synchronously).

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

@@ -88,15 +88,17 @@ function readPnpmConfigList(root) {
         return null;
     }
 }
-// Extracts the cooldown keys from pnpm's reported config. pnpm reports the
-// kebab-case keys; the exclude list comes back as a JSON array (set in a yaml
-// surface) or a comma-joined string (set via .npmrc / env).
+// Extracts the cooldown keys from pnpm's reported config. pnpm 11 reports them
+// camelCase; pnpm 10 reported them kebab-case, so read both forms. The exclude
+// list comes back as a JSON array (set in a yaml surface) or a comma-joined
+// string (set via .npmrc / env).
 function parseCooldownConfig(config) {
+    const read = (camelKey, kebabKey) => config[camelKey] ?? config[kebabKey];
     return {
-        windowMinutes: toNumber(config['minimum-release-age']) ?? undefined,
-        excludes: parseExcludeValue(config['minimum-release-age-exclude']),
-        strictExplicit: toBoolean(config['minimum-release-age-strict']),
-        ignoreMissingTimeExplicit: toBoolean(config['minimum-release-age-ignore-missing-time']),
+        windowMinutes: toNumber(read('minimumReleaseAge', 'minimum-release-age')) ?? undefined,
+        excludes: parseExcludeValue(read('minimumReleaseAgeExclude', 'minimum-release-age-exclude')),
+        strictExplicit: toBoolean(read('minimumReleaseAgeStrict', 'minimum-release-age-strict')),
+        ignoreMissingTimeExplicit: toBoolean(read('minimumReleaseAgeIgnoreMissingTime', 'minimum-release-age-ignore-missing-time')),
     };
 }
 function parseExcludeValue(value) {

package/dist/src/utils/provenance.js

@@ -22,8 +22,18 @@ async function ensurePackageHasProvenance(packageName, packageVersion) {
     }
     try {
         const result = await (0, package_manager_1.packageRegistryView)(packageName, packageVersion, '--json --silent');
-        const npmViewResult = JSON.parse(result);
-        const attURL = npmViewResult.dist?.attestations?.url;
+        const parsed = JSON.parse(result);
+        // `npm view <pkg>@<spec> --json` returns a bare object on npm <= 11 but an
+        // array on npm 12 and pnpm, even for a single resolved version. A version
+        // range matches several versions and the registry lists all of them
+        // (including deprecated ones the installer skips), so we cannot tell which
+        // one will actually be installed; refuse rather than verify the wrong
+        // artifact.
+        if (Array.isArray(parsed) && parsed.length > 1) {
+            throw new ProvenanceError(packageName, packageVersion, 'Provenance can only be verified for a single version, but this version resolved to multiple candidates. Specify an exact version.');
+        }
+        const npmViewResult = Array.isArray(parsed) ? parsed[0] : parsed;
+        const attURL = npmViewResult?.dist?.attestations?.url;
         if (!attURL)
             throw new ProvenanceError(packageName, packageVersion, 'No attestation URL found');
         const response = await fetch(attURL);

package/migrations.json

@@ -160,7 +160,13 @@
       "cli": "nx",
       "version": "22.6.0-rc.0",
       "description": "Adds .claude/settings.local.json to .gitignore",
-      "implementation": "./dist/src/migrations/update-17-3-0/update-nxw"
+      "implementation": "./dist/src/migrations/update-22-6-0/add-claude-settings-local-to-git-ignore"
+    },
+    "22-6-0-enable-analytics-prompt": {
+      "cli": "nx",
+      "version": "22.6.0-beta.11",
+      "description": "Prompts to enable usage analytics",
+      "implementation": "./dist/src/migrations/update-22-6-0/enable-analytics-prompt"
     },
     "22-7-0-add-self-healing-to-gitignore": {
       "cli": "nx",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.1.0",
+  "version": "23.2.0-beta.0",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -176,16 +176,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.1.0",
-    "@nx/nx-darwin-x64": "23.1.0",
-    "@nx/nx-freebsd-x64": "23.1.0",
-    "@nx/nx-linux-arm-gnueabihf": "23.1.0",
-    "@nx/nx-linux-arm64-gnu": "23.1.0",
-    "@nx/nx-linux-arm64-musl": "23.1.0",
-    "@nx/nx-linux-x64-gnu": "23.1.0",
-    "@nx/nx-linux-x64-musl": "23.1.0",
-    "@nx/nx-win32-arm64-msvc": "23.1.0",
-    "@nx/nx-win32-x64-msvc": "23.1.0"
+    "@nx/nx-darwin-arm64": "23.2.0-beta.0",
+    "@nx/nx-darwin-x64": "23.2.0-beta.0",
+    "@nx/nx-freebsd-x64": "23.2.0-beta.0",
+    "@nx/nx-linux-arm-gnueabihf": "23.2.0-beta.0",
+    "@nx/nx-linux-arm64-gnu": "23.2.0-beta.0",
+    "@nx/nx-linux-arm64-musl": "23.2.0-beta.0",
+    "@nx/nx-linux-x64-gnu": "23.2.0-beta.0",
+    "@nx/nx-linux-x64-musl": "23.2.0-beta.0",
+    "@nx/nx-win32-arm64-msvc": "23.2.0-beta.0",
+    "@nx/nx-win32-x64-msvc": "23.2.0-beta.0"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/dist/src/migrations/update-17-3-0/nx-release-path.d.ts

@@ -1,3 +0,0 @@
-import { Tree } from '../../generators/tree';
-export default function nxReleasePath(tree: Tree): void;
-export declare function visitNotIgnoredFiles(tree: Tree, dirPath: string, visitor: (path: string) => void): void;

package/dist/src/migrations/update-17-3-0/nx-release-path.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = nxReleasePath;
-exports.visitNotIgnoredFiles = visitNotIgnoredFiles;
-const node_path_1 = require("node:path");
-const ignore_1 = require("../../utils/ignore");
-function nxReleasePath(tree) {
-    visitNotIgnoredFiles(tree, '', (file) => {
-        const contents = tree.read(file).toString('utf-8');
-        if (
-        // the deep import usage should be replaced by the new location
-        contents.includes('nx/src/command-line/release') ||
-            // changelog-renderer has moved into nx/release
-            contents.includes('nx/changelog-renderer')) {
-            const finalContents = contents
-                // replace instances of old changelog renderer location
-                .replace(/nx\/changelog-renderer/g, 'nx/release/changelog-renderer')
-                // replace instances of deep import for programmatic API (only perform the replacement if an actual import by checking for trailing ' or ")
-                .replace(/nx\/src\/command-line\/release(['"])/g, 'nx/release$1');
-            tree.write(file, finalContents);
-        }
-    });
-}
-// Adapted from devkit
-function visitNotIgnoredFiles(tree, dirPath = tree.root, visitor) {
-    const ig = (0, ignore_1.getIgnoreObject)();
-    dirPath = normalizePathRelativeToRoot(dirPath, tree.root);
-    if (dirPath !== '' && ig?.ignores(dirPath)) {
-        return;
-    }
-    for (const child of tree.children(dirPath)) {
-        const fullPath = (0, node_path_1.join)(dirPath, child);
-        if (ig?.ignores(fullPath)) {
-            continue;
-        }
-        if (tree.isFile(fullPath)) {
-            visitor(fullPath);
-        }
-        else {
-            visitNotIgnoredFiles(tree, fullPath, visitor);
-        }
-    }
-}
-// Copied from devkit
-function normalizePathRelativeToRoot(path, root) {
-    return (0, node_path_1.relative)(root, (0, node_path_1.join)(root, path)).split(node_path_1.sep).join('/');
-}