nx 23.2.0-beta.1 → 23.2.0-beta.3

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBunCatalogDefinitions = readBunCatalogDefinitions;
+exports.updateBunCatalogVersionsInFile = updateBunCatalogVersionsInFile;
+const jsonc_parser_1 = require("jsonc-parser");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../fileutils");
+const json_1 = require("../json");
+const output_1 = require("../output");
+// Extracts catalog definitions from a parsed bun package.json, normalizing the
+// top-level and `workspaces`-nested locations into a single CatalogDefinitions.
+// Bun treats the locations as all-or-nothing: when either catalog field exists
+// under `workspaces`, the top-level fields are ignored entirely rather than
+// merged.
+function normalizeBunCatalogDefinitions(packageJson) {
+    const nested = packageJson.workspaces && !Array.isArray(packageJson.workspaces)
+        ? packageJson.workspaces
+        : undefined;
+    const source = nested?.catalog !== undefined || nested?.catalogs !== undefined
+        ? nested
+        : packageJson;
+    const { catalog, catalogs } = source;
+    if (!catalog && !catalogs) {
+        return null;
+    }
+    return { catalog, catalogs };
+}
+function readBunCatalogConfigFromFs(filename, fullPath) {
+    try {
+        return normalizeBunCatalogDefinitions((0, fileutils_1.readJsonFile)(fullPath));
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: `Unable to parse ${filename}`,
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function readBunCatalogConfigFromTree(filename, tree) {
+    const content = tree.read(filename, 'utf-8');
+    try {
+        return normalizeBunCatalogDefinitions((0, json_1.parseJson)(content));
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: `Unable to parse ${filename}`,
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+// Mirror of readCatalogDefinitions for bun's package.json-based catalogs: the
+// fs (string-root) branch is cached per pass, the Tree branch stays live.
+function readBunCatalogDefinitions(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)
+            ? readBunCatalogConfigFromFs(filename, configPath)
+            : null;
+        cache.set(treeOrRoot, defs);
+        return defs;
+    }
+    if (!treeOrRoot.exists(filename)) {
+        return null;
+    }
+    return readBunCatalogConfigFromTree(filename, treeOrRoot);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+// Resolves the jsonc path a catalog update should target. Follows the same
+// all-or-nothing routing as the reader: updates land in the `workspaces`
+// location when it holds a catalog field, otherwise at the top level.
+function resolveBunCatalogTargetPath(packageJson, packageName, catalogName) {
+    const nested = packageJson.workspaces && !Array.isArray(packageJson.workspaces)
+        ? packageJson.workspaces
+        : undefined;
+    const nestedIsActive = nested?.catalog !== undefined || nested?.catalogs !== undefined;
+    const prefix = nestedIsActive ? ['workspaces'] : [];
+    return catalogName
+        ? [...prefix, 'catalogs', catalogName, packageName]
+        : [...prefix, 'catalog', packageName];
+}
+// jsonc-parser's `modify` creates missing intermediate objects but throws on
+// null (or other non-object) ones — the JSON counterpart of pnpm's empty
+// `catalog:` placeholder. Walk the target path and, at the first non-object
+// step, replace that node wholesale with the remaining path nested as fresh
+// objects.
+function planBunCatalogEdit(packageJson, targetPath, version) {
+    let node = packageJson;
+    for (let i = 0; i < targetPath.length - 1; i++) {
+        if (!isRecord(node)) {
+            break;
+        }
+        const next = node[targetPath[i]];
+        if (next !== undefined && !isRecord(next)) {
+            const value = targetPath
+                .slice(i + 1)
+                .reduceRight((acc, key) => ({ [key]: acc }), version);
+            return { path: targetPath.slice(0, i + 1), value };
+        }
+        node = next;
+    }
+    return { path: targetPath, value: version };
+}
+function updateBunCatalogVersionsInFile(filename, treeOrRoot, updates) {
+    let checkExists;
+    let readContent;
+    let writeContent;
+    if (typeof treeOrRoot === 'string') {
+        const configPath = (0, node_path_1.join)(treeOrRoot, filename);
+        checkExists = () => (0, node_fs_1.existsSync)(configPath);
+        readContent = () => (0, node_fs_1.readFileSync)(configPath, 'utf-8');
+        writeContent = (content) => (0, node_fs_1.writeFileSync)(configPath, content, 'utf-8');
+    }
+    else {
+        checkExists = () => treeOrRoot.exists(filename);
+        readContent = () => treeOrRoot.read(filename, 'utf-8');
+        writeContent = (content) => treeOrRoot.write(filename, content);
+    }
+    if (!checkExists()) {
+        output_1.output.warn({
+            title: `No ${filename} found`,
+            bodyLines: [
+                `Cannot update catalog versions without a ${filename} file.`,
+                `Create a ${filename} file to use catalogs.`,
+            ],
+        });
+        return;
+    }
+    try {
+        let content = readContent();
+        // parseJson surfaces a genuine syntax error here rather than letting a
+        // broken file be silently rewritten.
+        let packageJson = (0, json_1.parseJson)(content);
+        let hasChanges = false;
+        for (const update of updates) {
+            const { packageName, version, catalogName } = update;
+            const targetPath = resolveBunCatalogTargetPath(packageJson, packageName, catalogName);
+            // `modify` emits an edit even for an identical value, so check first to
+            // keep an already-matching file untouched.
+            const currentValue = targetPath.reduce((node, key) => (isRecord(node) ? node[key] : undefined), packageJson);
+            if (currentValue === version) {
+                continue;
+            }
+            const { path, value } = planBunCatalogEdit(packageJson, targetPath, version);
+            const edits = (0, jsonc_parser_1.modify)(content, path, value, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            });
+            if (edits.length > 0) {
+                content = (0, jsonc_parser_1.applyEdits)(content, edits);
+                // Re-parse so the next update routes against the just-applied edit
+                // (e.g. a null `catalog` placeholder replaced with a fresh map).
+                packageJson = (0, json_1.parseJson)(content);
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            writeContent(content);
+        }
+    }
+    catch (error) {
+        output_1.output.error({
+            title: 'Failed to update catalog versions',
+            bodyLines: [error instanceof Error ? error.message : String(error)],
+        });
+        throw error;
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { Tree } from '../../generators/tree';
+import { type CatalogManager } from './manager';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
+/**
+ * Bun-specific catalog manager implementation.
+ *
+ * Bun declares catalogs in the root package.json `catalog`/`catalogs` fields,
+ * either at the top level or nested under the object form of `workspaces`.
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+export declare class BunCatalogManager implements CatalogManager {
+    readonly name = "bun";
+    readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
+    isCatalogReference(version: string): boolean;
+    parseCatalogReference(version: string): CatalogReference | null;
+    getCatalogDefinitionFilePaths(): string[];
+    getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
+    resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
+    validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
+    updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunCatalogManager = void 0;
+const manager_1 = require("./manager");
+const bun_manager_utils_1 = require("./bun-manager-utils");
+const BUN_CATALOG_FILENAME = 'package.json';
+/**
+ * Bun-specific catalog manager implementation.
+ *
+ * Bun declares catalogs in the root package.json `catalog`/`catalogs` fields,
+ * either at the top level or nested under the object form of `workspaces`.
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+class BunCatalogManager {
+    constructor() {
+        this.name = 'bun';
+        this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readBunCatalogDefinitions.
+        this.definitionsByRoot = new Map();
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length).trim();
+        // Only an empty/whitespace name selects the default catalog; "default" is
+        // a regular named catalog in bun.
+        const isDefault = !catalogName;
+        return {
+            catalogName: isDefault ? undefined : catalogName,
+            isDefaultCatalog: isDefault,
+        };
+    }
+    getCatalogDefinitionFilePaths() {
+        return [BUN_CATALOG_FILENAME];
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        return (0, bun_manager_utils_1.readBunCatalogDefinitions)(BUN_CATALOG_FILENAME, treeOrRoot, this.definitionsByRoot);
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
+    validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            throw new Error((0, manager_1.formatCatalogError)(`Cannot get Bun catalog definitions. No catalog defined in ${BUN_CATALOG_FILENAME}.`, [
+                `Add a "catalog" or "catalogs" field to ${BUN_CATALOG_FILENAME} in your workspace root`,
+            ]));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define a default catalog in ${BUN_CATALOG_FILENAME} under the "catalog" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${BUN_CATALOG_FILENAME}`, suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define the catalog in ${BUN_CATALOG_FILENAME} under the "catalogs" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${BUN_CATALOG_FILENAME}`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
+            const availablePackages = Object.keys(catalogToUse);
+            const suggestions = [
+                `Add "${packageName}" to ${catalogName} in ${BUN_CATALOG_FILENAME}`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        (0, bun_manager_utils_1.updateBunCatalogVersionsInFile)(BUN_CATALOG_FILENAME, treeOrRoot, updates);
+    }
+}
+exports.BunCatalogManager = BunCatalogManager;

package/dist/src/utils/catalog/index.d.ts

@@ -4,7 +4,7 @@ import type { CatalogManager } from './manager';
 import { getCatalogManager } from './manager-factory';
 export { type CatalogManager, getCatalogManager };
 /**
- * Dereferences a pnpm/yarn catalog reference to a concrete version spec. Returns
+ * Dereferences a pnpm/yarn/bun catalog reference to a concrete version spec. Returns
  * the input unchanged when it is not a catalog reference (or no catalog manager
  * applies). Throws when the reference cannot be resolved.
  */

package/dist/src/utils/catalog/index.js

@@ -9,7 +9,7 @@ const workspace_root_1 = require("../workspace-root");
 const manager_factory_1 = require("./manager-factory");
 Object.defineProperty(exports, "getCatalogManager", { enumerable: true, get: function () { return manager_factory_1.getCatalogManager; } });
 /**
- * Dereferences a pnpm/yarn catalog reference to a concrete version spec. Returns
+ * Dereferences a pnpm/yarn/bun catalog reference to a concrete version spec. Returns
  * the input unchanged when it is not a catalog reference (or no catalog manager
  * applies). Throws when the reference cannot be resolved.
  */

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCatalogManager = getCatalogManager;
 const package_manager_1 = require("../package-manager");
+const bun_manager_1 = require("./bun-manager");
 const pnpm_manager_1 = require("./pnpm-manager");
 const yarn_manager_1 = require("./yarn-manager");
 /**
@@ -14,6 +15,8 @@ function getCatalogManager(workspaceRoot) {
             return new pnpm_manager_1.PnpmCatalogManager();
         case 'yarn':
             return new yarn_manager_1.YarnCatalogManager();
+        case 'bun':
+            return new bun_manager_1.BunCatalogManager();
         default:
             return null;
     }

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

@@ -5,4 +5,11 @@ export declare function updateCatalogVersionsInFile(filename: string, treeOrRoot
     packageName: string;
     version: string;
     catalogName?: string;
-}>): void;
+}>, options?: {
+    /**
+     * Treat "default" as an alias for the `catalog` field and route default
+     * updates through a populated `catalogs.default` (pnpm semantics). When
+     * false, "default" is an ordinary named catalog (yarn semantics).
+     */
+    aliasDefaultCatalog?: boolean;
+}): void;

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

@@ -136,7 +136,8 @@ function readCatalogDefinitions(filename, treeOrRoot, cache) {
     }
     return readCatalogConfigFromTree(filename, treeOrRoot);
 }
-function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
+function updateCatalogVersionsInFile(filename, treeOrRoot, updates, options) {
+    const aliasDefaultCatalog = options?.aliasDefaultCatalog ?? true;
     let checkExists;
     let readYaml;
     let writeYaml;
@@ -194,13 +195,17 @@ function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
         let hasChanges = false;
         for (const update of updates) {
             const { packageName, version, catalogName } = update;
-            const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
+            const normalizedCatalogName = aliasDefaultCatalog && catalogName === 'default'
+                ? undefined
+                : catalogName;
             let targetPath;
             if (!normalizedCatalogName) {
                 // An empty `catalog:` placeholder must not claim the default route
                 // when `catalogs.default` is populated; that would create a
-                // duplicate-default config rejected by pnpm.
-                if (isMapAt(doc, ['catalog'])) {
+                // duplicate-default config rejected by pnpm. Without the alias,
+                // "default" is an ordinary named catalog and the default route is
+                // always the `catalog` field.
+                if (!aliasDefaultCatalog || isMapAt(doc, ['catalog'])) {
                     targetPath = ['catalog', packageName];
                 }
                 else if (existsAt(doc, ['catalogs', 'default'])) {

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

@@ -1,6 +1,12 @@
 import type { Tree } from '../../generators/tree';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 export declare function formatCatalogError(error: string, suggestions: string[]): string;
+/**
+ * Shared implementation of getCatalogReferencesForPackage: enumerates the
+ * default and named catalog references and keeps those the manager resolves,
+ * so per-manager default-catalog semantics apply without duplication.
+ */
+export declare function collectCatalogReferencesForPackage(manager: CatalogManager, treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
 /**
  * Interface for catalog managers that handle package manager-specific catalog implementations.
  */
@@ -19,6 +25,12 @@ export interface CatalogManager {
      */
     resolveCatalogReference(workspaceRoot: string, packageName: string, version: string): string | null;
     resolveCatalogReference(tree: Tree, packageName: string, version: string): string | null;
+    /**
+     * Get every catalog reference that resolves to a version for a package,
+     * following the package manager's own default-catalog semantics.
+     */
+    getCatalogReferencesForPackage(workspaceRoot: string, packageName: string): CatalogReferenceMatch[];
+    getCatalogReferencesForPackage(tree: Tree, packageName: string): CatalogReferenceMatch[];
     /**
      * Check that a catalog reference is valid.
      */

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCatalogError = formatCatalogError;
+exports.collectCatalogReferencesForPackage = collectCatalogReferencesForPackage;
 function formatCatalogError(error, suggestions) {
     let message = error;
     if (suggestions.length > 0) {
@@ -11,3 +12,32 @@ function formatCatalogError(error, suggestions) {
     }
     return message;
 }
+/**
+ * Shared implementation of getCatalogReferencesForPackage: enumerates the
+ * default and named catalog references and keeps those the manager resolves,
+ * so per-manager default-catalog semantics apply without duplication.
+ */
+function collectCatalogReferencesForPackage(manager, treeOrRoot, packageName) {
+    // The overload pairs don't accept the Tree | string union directly.
+    const source = treeOrRoot;
+    const catalogDefs = manager.getCatalogDefinitions(source);
+    if (!catalogDefs) {
+        return [];
+    }
+    const catalogRefs = ['catalog:'];
+    for (const name of Object.keys(catalogDefs.catalogs ?? {})) {
+        // Skip names the manager treats as the default catalog (e.g. pnpm's
+        // "default") — already covered by the `catalog:` candidate.
+        if (!manager.parseCatalogReference(`catalog:${name}`)?.isDefaultCatalog) {
+            catalogRefs.push(`catalog:${name}`);
+        }
+    }
+    const matches = [];
+    for (const catalogRef of catalogRefs) {
+        const versionSpec = manager.resolveCatalogReference(source, packageName, catalogRef);
+        if (versionSpec) {
+            matches.push({ catalogRef, versionSpec });
+        }
+    }
+    return matches;
+}

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

@@ -1,6 +1,6 @@
 import type { Tree } from '../../generators/tree';
 import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 /**
  * PNPM-specific catalog manager implementation
  */
@@ -13,6 +13,7 @@ export declare class PnpmCatalogManager implements CatalogManager {
     getCatalogDefinitionFilePaths(): string[];
     getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
     resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
     validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
     updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
         packageName: string;

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

@@ -54,6 +54,9 @@ class PnpmCatalogManager {
         }
         return catalogToUse?.[packageName] || null;
     }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
     validateCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);
         if (!catalogRef) {

package/dist/src/utils/catalog/types.d.ts

@@ -2,6 +2,10 @@ export interface CatalogReference {
     catalogName?: string;
     isDefaultCatalog: boolean;
 }
+export interface CatalogReferenceMatch {
+    catalogRef: string;
+    versionSpec: string;
+}
 export interface CatalogEntry {
     [packageName: string]: string;
 }

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

@@ -1,8 +1,11 @@
 import type { Tree } from '../../generators/tree';
 import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 /**
- * Yarn Berry (v4+) catalog manager implementation
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
  */
 export declare class YarnCatalogManager implements CatalogManager {
     readonly name = "yarn";
@@ -13,6 +16,7 @@ export declare class YarnCatalogManager implements CatalogManager {
     getCatalogDefinitionFilePaths(): string[];
     getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
     resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
     validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
     updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
         packageName: string;

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

@@ -5,7 +5,10 @@ const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const YARNRC_FILENAME = '.yarnrc.yml';
 /**
- * Yarn Berry (v4+) catalog manager implementation
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
  */
 class YarnCatalogManager {
     constructor() {
@@ -22,8 +25,9 @@ class YarnCatalogManager {
             return null;
         }
         const catalogName = version.substring(this.catalogProtocol.length);
-        // Normalize both "catalog:" and "catalog:default" to the same representation
-        const isDefault = !catalogName || catalogName === 'default';
+        // Only an empty name selects the default catalog; unlike pnpm, "default"
+        // is a regular named catalog in yarn.
+        const isDefault = !catalogName;
         return {
             catalogName: isDefault ? undefined : catalogName,
             isDefaultCatalog: isDefault,
@@ -46,14 +50,16 @@ class YarnCatalogManager {
         }
         let catalogToUse;
         if (catalogRef.isDefaultCatalog) {
-            // Check both locations for default catalog
-            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            catalogToUse = catalogDefs.catalog;
         }
         else if (catalogRef.catalogName) {
             catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
         }
         return catalogToUse?.[packageName] || null;
     }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
     validateCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);
         if (!catalogRef) {
@@ -65,13 +71,9 @@ class YarnCatalogManager {
         }
         let catalogToUse;
         if (catalogRef.isDefaultCatalog) {
-            const hasCatalog = !!catalogDefs.catalog;
-            const hasCatalogsDefault = !!catalogDefs.catalogs?.default;
-            // Error if both defined
-            if (hasCatalog && hasCatalogsDefault) {
-                throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
-            }
-            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            // Yarn's default catalog is only the `catalog` field; unlike pnpm,
+            // `catalogs.default` does not act as a fallback.
+            catalogToUse = catalogDefs.catalog;
             if (!catalogToUse) {
                 const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
                 const suggestions = [
@@ -88,12 +90,7 @@ class YarnCatalogManager {
         else if (catalogRef.catalogName) {
             catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
             if (!catalogToUse) {
-                const availableCatalogs = Object.keys(catalogDefs.catalogs || {}).filter((c) => c !== 'default');
-                const defaultCatalog = !!catalogDefs.catalog
-                    ? 'catalog'
-                    : !catalogDefs.catalogs?.default
-                        ? 'catalogs.default'
-                        : null;
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
                 const suggestions = [
                     `Define the catalog in ${YARNRC_FILENAME} under the "catalogs" key`,
                 ];
@@ -102,24 +99,16 @@ class YarnCatalogManager {
                         .map((c) => `"catalog:${c}"`)
                         .join(', ')}`);
                 }
-                if (defaultCatalog) {
-                    suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
                 }
                 throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${YARNRC_FILENAME}`, suggestions));
             }
         }
         if (!catalogToUse[packageName]) {
-            let catalogName;
-            if (catalogRef.isDefaultCatalog) {
-                // Context-aware messaging based on which location exists
-                const hasCatalog = !!catalogDefs.catalog;
-                catalogName = hasCatalog
-                    ? 'default catalog ("catalog")'
-                    : 'default catalog ("catalogs.default")';
-            }
-            else {
-                catalogName = `catalog '${catalogRef.catalogName}'`;
-            }
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
             const availablePackages = Object.keys(catalogToUse);
             const suggestions = [
                 `Add "${packageName}" to ${catalogName} in ${YARNRC_FILENAME}`,
@@ -133,7 +122,9 @@ class YarnCatalogManager {
         }
     }
     updateCatalogVersions(treeOrRoot, updates) {
-        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates);
+        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates, {
+            aliasDefaultCatalog: false,
+        });
     }
 }
 exports.YarnCatalogManager = YarnCatalogManager;