@nx/devkit 22.0.0-beta.4 → 22.0.0-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "22.0.0-beta.4",
+  "version": "22.0.0-beta.6",
   "private": false,
   "description": "The Nx Devkit is used to customize Nx for different technologies and use cases. It contains many utility functions for reading and writing files, updating configuration, working with Abstract Syntax Trees(ASTs), and more. Learn more about [extending Nx by leveraging the Nx Devkit](https://nx.dev/extending-nx/intro/getting-started) on our docs.",
   "repository": {
@@ -28,6 +28,7 @@
   },
   "homepage": "https://nx.dev",
   "dependencies": {
+    "@zkochan/js-yaml": "0.0.7",
     "ejs": "^3.1.7",
     "tslib": "^2.3.0",
     "semver": "^7.5.3",
@@ -37,7 +38,7 @@
   },
   "devDependencies": {
     "jest": "^29.4.1",
-    "nx": "22.0.0-beta.4"
+    "nx": "22.0.0-beta.6"
   },
   "peerDependencies": {
     "nx": ">= 21 <= 23"

package/public-api.d.ts

@@ -39,7 +39,7 @@ export { readTargetOptions } from './src/executors/read-target-options';
 /**
  * @category Utils
  */
-export { addDependenciesToPackageJson, removeDependenciesFromPackageJson, ensurePackage, NX_VERSION, } from './src/utils/package-json';
+export { addDependenciesToPackageJson, removeDependenciesFromPackageJson, ensurePackage, getDependencyVersionFromPackageJson, NX_VERSION, } from './src/utils/package-json';
 /**
  * @category Utils
  */

package/public-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-api.d.ts","sourceRoot":"","sources":["../../../packages/devkit/public-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D;;GAEG;AACH,OAAO,EACL,aAAa,EACb,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAEzC;;GAEG;AACH,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;GAEG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAE/E;;GAEG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAEhF,OAAO,EACL,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,qCAAqC,CAAC;AAE7C;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE;;GAEG;AACH,OAAO,EACL,4BAA4B,EAC5B,iCAAiC,EACjC,aAAa,EACb,UAAU,GACX,MAAM,0BAA0B,CAAC;AAElC;;GAEG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAExE;;GAEG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C;;GAEG;AACH,OAAO,EACL,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,kCAAkC,CAAC;AAE1C;;GAEG;AACH,YAAY,EACV,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,2BAA2B,CAAC;AAEnC;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE7E;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;GAEG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEpE;;GAEG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"public-api.d.ts","sourceRoot":"","sources":["../../../packages/devkit/public-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D;;GAEG;AACH,OAAO,EACL,aAAa,EACb,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAEzC;;GAEG;AACH,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;GAEG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAE/E;;GAEG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAEhF,OAAO,EACL,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,qCAAqC,CAAC;AAE7C;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE;;GAEG;AACH,OAAO,EACL,4BAA4B,EAC5B,iCAAiC,EACjC,aAAa,EACb,mCAAmC,EACnC,UAAU,GACX,MAAM,0BAA0B,CAAC;AAElC;;GAEG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAExE;;GAEG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C;;GAEG;AACH,OAAO,EACL,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,kCAAkC,CAAC;AAE1C;;GAEG;AACH,YAAY,EACV,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,2BAA2B,CAAC;AAEnC;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE7E;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;GAEG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEpE;;GAEG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC"}

package/public-api.js

@@ -9,7 +9,7 @@
  *   a. We might need to duplicate code instead of importing from nx until all supported versions of nx contain the file.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.moveFilesToNewDirectory = exports.convertNxExecutor = exports.convertNxGenerator = exports.offsetFromRoot = exports.ChangeType = exports.applyChangesToString = exports.extractLayoutDirectory = exports.getWorkspaceLayout = exports.names = exports.installPackagesTask = exports.NX_VERSION = exports.ensurePackage = exports.removeDependenciesFromPackageJson = exports.addDependenciesToPackageJson = exports.readTargetOptions = exports.targetToTargetString = exports.parseTargetString = exports.visitNotIgnoredFiles = exports.runTasksInSerial = exports.updateTsConfigsToJs = exports.toJS = exports.OverwriteStrategy = exports.generateFiles = exports.formatFiles = void 0;
+exports.moveFilesToNewDirectory = exports.convertNxExecutor = exports.convertNxGenerator = exports.offsetFromRoot = exports.ChangeType = exports.applyChangesToString = exports.extractLayoutDirectory = exports.getWorkspaceLayout = exports.names = exports.installPackagesTask = exports.NX_VERSION = exports.getDependencyVersionFromPackageJson = exports.ensurePackage = exports.removeDependenciesFromPackageJson = exports.addDependenciesToPackageJson = exports.readTargetOptions = exports.targetToTargetString = exports.parseTargetString = exports.visitNotIgnoredFiles = exports.runTasksInSerial = exports.updateTsConfigsToJs = exports.toJS = exports.OverwriteStrategy = exports.generateFiles = exports.formatFiles = void 0;
 /**
  * @category Generators
  */
@@ -56,6 +56,7 @@ var package_json_1 = require("./src/utils/package-json");
 Object.defineProperty(exports, "addDependenciesToPackageJson", { enumerable: true, get: function () { return package_json_1.addDependenciesToPackageJson; } });
 Object.defineProperty(exports, "removeDependenciesFromPackageJson", { enumerable: true, get: function () { return package_json_1.removeDependenciesFromPackageJson; } });
 Object.defineProperty(exports, "ensurePackage", { enumerable: true, get: function () { return package_json_1.ensurePackage; } });
+Object.defineProperty(exports, "getDependencyVersionFromPackageJson", { enumerable: true, get: function () { return package_json_1.getDependencyVersionFromPackageJson; } });
 Object.defineProperty(exports, "NX_VERSION", { enumerable: true, get: function () { return package_json_1.NX_VERSION; } });
 /**
  * @category Utils

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

@@ -0,0 +1,10 @@
+import { type Tree } from 'nx/src/devkit-exports';
+import { getCatalogManager } from './manager-factory';
+import type { CatalogManager } from './manager';
+export { getCatalogManager };
+/**
+ * Detects which packages in a package.json use catalog references
+ * Returns Map of package name -> catalog name (undefined for default catalog)
+ */
+export declare function getCatalogDependenciesFromPackageJson(tree: Tree, packageJsonPath: string, manager: CatalogManager): Map<string, string | undefined>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B;;;GAGG;AACH,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,cAAc,GACtB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CA+BjC"}

package/src/utils/catalog/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogManager = void 0;
+exports.getCatalogDependenciesFromPackageJson = getCatalogDependenciesFromPackageJson;
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const manager_factory_1 = require("./manager-factory");
+Object.defineProperty(exports, "getCatalogManager", { enumerable: true, get: function () { return manager_factory_1.getCatalogManager; } });
+/**
+ * Detects which packages in a package.json use catalog references
+ * Returns Map of package name -> catalog name (undefined for default catalog)
+ */
+function getCatalogDependenciesFromPackageJson(tree, packageJsonPath, manager) {
+    const catalogDeps = new Map();
+    if (!tree.exists(packageJsonPath)) {
+        return catalogDeps;
+    }
+    try {
+        const packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPath);
+        const allDependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+            ...packageJson.peerDependencies,
+            ...packageJson.optionalDependencies,
+        };
+        for (const [packageName, version] of Object.entries(allDependencies || {})) {
+            if (manager.isCatalogReference(version)) {
+                const catalogRef = manager.parseCatalogReference(version);
+                if (catalogRef) {
+                    catalogDeps.set(packageName, catalogRef.catalogName);
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If we can't read the package.json, return empty map
+    }
+    return catalogDeps;
+}

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

@@ -0,0 +1,6 @@
+import type { CatalogManager } from './manager';
+/**
+ * Factory function to get the appropriate catalog manager based on the package manager
+ */
+export declare function getCatalogManager(workspaceRoot: string): CatalogManager | null;
+//# sourceMappingURL=manager-factory.d.ts.map

package/src/utils/catalog/manager-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-factory.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/manager-factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,MAAM,GACpB,cAAc,GAAG,IAAI,CASvB"}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogManager = getCatalogManager;
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const pnpm_manager_1 = require("./pnpm-manager");
+/**
+ * Factory function to get the appropriate catalog manager based on the package manager
+ */
+function getCatalogManager(workspaceRoot) {
+    const packageManager = (0, devkit_exports_1.detectPackageManager)(workspaceRoot);
+    switch (packageManager) {
+        case 'pnpm':
+            return new pnpm_manager_1.PnpmCatalogManager();
+        default:
+            return null;
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { Tree } from 'nx/src/devkit-exports';
+import type { PnpmWorkspaceYaml } from 'nx/src/utils/pnpm-workspace';
+import type { CatalogReference } from './types';
+/**
+ * Interface for catalog managers that handle package manager-specific catalog implementations.
+ */
+export interface CatalogManager {
+    readonly name: string;
+    isCatalogReference(version: string): boolean;
+    parseCatalogReference(version: string): CatalogReference | null;
+    /**
+     * Get catalog definitions from the workspace.
+     */
+    getCatalogDefinitions(workspaceRoot: string): PnpmWorkspaceYaml | null;
+    getCatalogDefinitions(tree: Tree): PnpmWorkspaceYaml | null;
+    /**
+     * Resolve a catalog reference to an actual version.
+     */
+    resolveCatalogReference(workspaceRoot: string, packageName: string, version: string): string | null;
+    resolveCatalogReference(tree: Tree, packageName: string, version: string): string | null;
+    /**
+     * Check that a catalog reference is valid.
+     */
+    validateCatalogReference(workspaceRoot: string, packageName: string, version: string): void;
+    validateCatalogReference(tree: Tree, packageName: string, version: string): void;
+    /**
+     * Updates catalog definitions for specified packages in their respective catalogs.
+     */
+    updateCatalogVersions(tree: Tree, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+    updateCatalogVersions(workspaceRoot: string, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}
+//# sourceMappingURL=manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAE7C,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAEhE;;OAEG;IACH,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAAC;IACvE,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAAC;IAE5D;;OAEG;IACH,uBAAuB,CACrB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAAC;IACjB,uBAAuB,CACrB,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAAC;IAEjB;;OAEG;IACH,wBAAwB,CACtB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,IAAI,CAAC;IACR,wBAAwB,CACtB,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,IAAI,CAAC;IAER;;OAEG;IACH,qBAAqB,CACnB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,KAAK,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,GACD,IAAI,CAAC;IACR,qBAAqB,CACnB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,KAAK,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,GACD,IAAI,CAAC;CACT"}

package/src/utils/catalog/manager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { type Tree } from 'nx/src/devkit-exports';
+import type { PnpmWorkspaceYaml } from 'nx/src/utils/pnpm-workspace';
+import type { CatalogManager } from './manager';
+import { type CatalogReference } from './types';
+/**
+ * PNPM-specific catalog manager implementation
+ */
+export declare class PnpmCatalogManager implements CatalogManager {
+    readonly name = "pnpm";
+    readonly catalogProtocol = "catalog:";
+    isCatalogReference(version: string): boolean;
+    parseCatalogReference(version: string): CatalogReference | null;
+    getCatalogDefinitions(treeOrRoot: Tree | string): PnpmWorkspaceYaml | null;
+    resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
+    updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}
+//# sourceMappingURL=pnpm-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pnpm-manager.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/pnpm-manager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAU,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;GAEG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IACvD,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,eAAe,cAAc;IAEtC,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI5C,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAe/D,qBAAqB,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAe1E,uBAAuB,CACrB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI;IAuBhB,wBAAwB,CACtB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,IAAI;IA0HP,qBAAqB,CACnB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,OAAO,EAAE,KAAK,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,GACD,IAAI;CAgFR"}

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmCatalogManager = void 0;
+const js_yaml_1 = require("@zkochan/js-yaml");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+/**
+ * PNPM-specific catalog manager implementation
+ */
+class PnpmCatalogManager {
+    constructor() {
+        this.name = 'pnpm';
+        this.catalogProtocol = 'catalog:';
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length);
+        // Normalize both "catalog:" and "catalog:default" to the same representation
+        const isDefault = !catalogName || catalogName === 'default';
+        return {
+            catalogName: isDefault ? undefined : catalogName,
+            isDefaultCatalog: isDefault,
+        };
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        if (typeof treeOrRoot === 'string') {
+            const pnpmWorkspacePath = (0, node_path_1.join)(treeOrRoot, 'pnpm-workspace.yaml');
+            if (!(0, node_fs_1.existsSync)(pnpmWorkspacePath)) {
+                return null;
+            }
+            return readYamlFileFromFs(pnpmWorkspacePath);
+        }
+        else {
+            if (!treeOrRoot.exists('pnpm-workspace.yaml')) {
+                return null;
+            }
+            return readYamlFileFromTree(treeOrRoot, 'pnpm-workspace.yaml');
+        }
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            // Check both locations for default catalog
+            catalogToUse =
+                workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    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 workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+            throw new Error(formatCatalogError('Cannot get Pnpm Catalog definitions. No pnpm-workspace.yaml found in workspace root.', ['Create a pnpm-workspace.yaml file in your workspace root']));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            const hasCatalog = !!workspaceConfig.catalog;
+            const hasCatalogsDefault = !!workspaceConfig.catalogs?.default;
+            // Error if both defined (matches pnpm behavior)
+            if (hasCatalog && hasCatalogsDefault) {
+                throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
+            }
+            catalogToUse =
+                workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(workspaceConfig.catalogs || {});
+                const suggestions = [
+                    'Define a default catalog in pnpm-workspace.yaml 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(formatCatalogError('No default catalog defined in pnpm-workspace.yaml', suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(workspaceConfig.catalogs || {}).filter((c) => c !== 'default');
+                const defaultCatalog = !!workspaceConfig.catalog
+                    ? 'catalog'
+                    : !workspaceConfig.catalogs?.default
+                        ? 'catalogs.default'
+                        : null;
+                const suggestions = [
+                    'Define the catalog in pnpm-workspace.yaml under the "catalogs" key',
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                if (defaultCatalog) {
+                    suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
+                }
+                throw new Error(formatCatalogError(`Catalog "${catalogRef.catalogName}" not found in pnpm-workspace.yaml`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            let catalogName;
+            if (catalogRef.isDefaultCatalog) {
+                // Context-aware messaging based on which location exists
+                const hasCatalog = !!workspaceConfig.catalog;
+                catalogName = hasCatalog
+                    ? 'default catalog ("catalog")'
+                    : 'default catalog ("catalogs.default")';
+            }
+            else {
+                catalogName = `catalog '${catalogRef.catalogName}'`;
+            }
+            const availablePackages = Object.keys(catalogToUse);
+            const suggestions = [
+                `Add "${packageName}" to ${catalogName} in pnpm-workspace.yaml`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error(formatCatalogError(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        let checkExists;
+        let readYaml;
+        let writeYaml;
+        if (typeof treeOrRoot === 'string') {
+            const workspaceYamlPath = (0, node_path_1.join)(treeOrRoot, 'pnpm-workspace.yaml');
+            checkExists = () => (0, node_fs_1.existsSync)(workspaceYamlPath);
+            readYaml = () => (0, node_fs_1.readFileSync)(workspaceYamlPath, 'utf-8');
+            writeYaml = (content) => (0, node_fs_1.writeFileSync)(workspaceYamlPath, content, 'utf-8');
+        }
+        else {
+            checkExists = () => treeOrRoot.exists('pnpm-workspace.yaml');
+            readYaml = () => treeOrRoot.read('pnpm-workspace.yaml', 'utf-8');
+            writeYaml = (content) => treeOrRoot.write('pnpm-workspace.yaml', content);
+        }
+        if (!checkExists()) {
+            devkit_exports_1.output.warn({
+                title: 'No pnpm-workspace.yaml found',
+                bodyLines: [
+                    'Cannot update catalog versions without a pnpm-workspace.yaml file.',
+                    'Create a pnpm-workspace.yaml file to use catalogs.',
+                ],
+            });
+            return;
+        }
+        try {
+            const workspaceContent = readYaml();
+            const workspaceData = (0, js_yaml_1.load)(workspaceContent) || {};
+            let hasChanges = false;
+            for (const update of updates) {
+                const { packageName, version, catalogName } = update;
+                const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
+                let targetCatalog;
+                if (!normalizedCatalogName) {
+                    // Default catalog - update whichever exists, prefer catalog over catalogs.default
+                    if (workspaceData.catalog) {
+                        targetCatalog = workspaceData.catalog;
+                    }
+                    else if (workspaceData.catalogs?.default) {
+                        targetCatalog = workspaceData.catalogs.default;
+                    }
+                    else {
+                        // Neither exists, create catalog (shorthand syntax)
+                        workspaceData.catalog ??= {};
+                        targetCatalog = workspaceData.catalog;
+                    }
+                }
+                else {
+                    // Named catalog
+                    workspaceData.catalogs ??= {};
+                    workspaceData.catalogs[normalizedCatalogName] ??= {};
+                    targetCatalog = workspaceData.catalogs[normalizedCatalogName];
+                }
+                if (targetCatalog[packageName] !== version) {
+                    targetCatalog[packageName] = version;
+                    hasChanges = true;
+                }
+            }
+            if (hasChanges) {
+                writeYaml((0, js_yaml_1.dump)(workspaceData, {
+                    indent: 2,
+                    quotingType: '"',
+                    forceQuotes: true,
+                }));
+            }
+        }
+        catch (error) {
+            devkit_exports_1.output.error({
+                title: 'Failed to update catalog versions',
+                bodyLines: [error instanceof Error ? error.message : String(error)],
+            });
+            throw error;
+        }
+    }
+}
+exports.PnpmCatalogManager = PnpmCatalogManager;
+function readYamlFileFromFs(path) {
+    try {
+        return (0, devkit_internals_1.readYamlFile)(path);
+    }
+    catch (error) {
+        devkit_exports_1.output.warn({
+            title: 'Unable to parse pnpm-workspace.yaml',
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function readYamlFileFromTree(tree, path) {
+    const content = tree.read(path, 'utf-8');
+    const { load } = require('@zkochan/js-yaml');
+    try {
+        return load(content, { filename: path });
+    }
+    catch (error) {
+        devkit_exports_1.output.warn({
+            title: 'Unable to parse pnpm-workspace.yaml',
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function formatCatalogError(error, suggestions) {
+    let message = error;
+    if (suggestions && suggestions.length > 0) {
+        message += '\n\nSuggestions:';
+        suggestions.forEach((suggestion) => {
+            message += `\n  • ${suggestion}`;
+        });
+    }
+    return message;
+}

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

@@ -0,0 +1,5 @@
+export interface CatalogReference {
+    catalogName?: string;
+    isDefaultCatalog: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B"}

package/src/utils/catalog/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,82 @@
-import { GeneratorCallback, Tree } from 'nx/src/devkit-exports';
+import { type GeneratorCallback, type Tree } from 'nx/src/devkit-exports';
+import type { PackageJson, PackageJsonDependencySection } from 'nx/src/utils/package-json';
+/**
+ * Get the resolved version of a dependency from package.json.
+ *
+ * Retrieves a package version and automatically resolves PNPM catalog references
+ * (e.g., "catalog:default") to their actual version strings. By default, searches
+ * `dependencies` first, then falls back to `devDependencies`.
+ *
+ * **Tree-based usage** (generators and migrations):
+ * Use when you have a `Tree` object, which is typical in Nx generators and migrations.
+ *
+ * **Filesystem-based usage** (CLI commands and scripts):
+ * Use when reading directly from the filesystem without a `Tree` object.
+ *
+ * @example
+ * ```typescript
+ * // Tree-based - from root package.json (checks dependencies then devDependencies)
+ * const reactVersion = getDependencyVersionFromPackageJson(tree, 'react');
+ * // Returns: "^18.0.0" (resolves "catalog:default" if present)
+ *
+ * // Tree-based - check only dependencies section
+ * const version = getDependencyVersionFromPackageJson(
+ *   tree,
+ *   'react',
+ *   'package.json',
+ *   ['dependencies']
+ * );
+ *
+ * // Tree-based - check only devDependencies section
+ * const version = getDependencyVersionFromPackageJson(
+ *   tree,
+ *   'jest',
+ *   'package.json',
+ *   ['devDependencies']
+ * );
+ *
+ * // Tree-based - custom lookup order
+ * const version = getDependencyVersionFromPackageJson(
+ *   tree,
+ *   'pkg',
+ *   'package.json',
+ *   ['devDependencies', 'dependencies', 'peerDependencies']
+ * );
+ *
+ * // Tree-based - with pre-loaded package.json
+ * const packageJson = readJson(tree, 'package.json');
+ * const version = getDependencyVersionFromPackageJson(
+ *   tree,
+ *   'react',
+ *   packageJson,
+ *   ['dependencies']
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filesystem-based - from current directory
+ * const reactVersion = getDependencyVersionFromPackageJson('react');
+ *
+ * // Filesystem-based - with workspace root
+ * const version = getDependencyVersionFromPackageJson('react', '/path/to/workspace');
+ *
+ * // Filesystem-based - with specific package.json and section
+ * const version = getDependencyVersionFromPackageJson(
+ *   'react',
+ *   '/path/to/workspace',
+ *   'apps/my-app/package.json',
+ *   ['dependencies']
+ * );
+ * ```
+ *
+ * @param dependencyLookup Array of dependency sections to check in order. Defaults to ['dependencies', 'devDependencies']
+ * @returns The resolved version string, or `null` if the package is not found in any of the specified sections
+ */
+export declare function getDependencyVersionFromPackageJson(tree: Tree, packageName: string, packageJsonPath?: string, dependencyLookup?: PackageJsonDependencySection[]): string | null;
+export declare function getDependencyVersionFromPackageJson(tree: Tree, packageName: string, packageJson?: PackageJson, dependencyLookup?: PackageJsonDependencySection[]): string | null;
+export declare function getDependencyVersionFromPackageJson(packageName: string, workspaceRootPath?: string, packageJsonPath?: string, dependencyLookup?: PackageJsonDependencySection[]): string | null;
+export declare function getDependencyVersionFromPackageJson(packageName: string, workspaceRootPath?: string, packageJson?: PackageJson, dependencyLookup?: PackageJsonDependencySection[]): string | null;
 /**
  * Add Dependencies and Dev Dependencies to package.json
  *

package/src/utils/package-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-json.d.ts","sourceRoot":"","sources":["../../../../../packages/devkit/src/utils/package-json.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EAEjB,IAAI,EAGL,MAAM,uBAAuB,CAAC;AAsG/B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACvC,eAAe,GAAE,MAAuB,EACxC,oBAAoB,CAAC,EAAE,OAAO,GAC7B,iBAAiB,CAyFnB;AAgCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,EAAE,EACtB,eAAe,EAAE,MAAM,EAAE,EACzB,eAAe,GAAE,MAAuB,GACvC,iBAAiB,CA6BnB;AA8FD;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,EACX,eAAe,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GACpD,IAAI,CAAC;AAER;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG,EAC/C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,CAAC,CAAC;AA4FL;;GAEG;AACH,eAAO,MAAM,UAAU,QAA0B,CAAC"}
+{"version":3,"file":"package-json.d.ts","sourceRoot":"","sources":["../../../../../packages/devkit/src/utils/package-json.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,iBAAiB,EAItB,KAAK,IAAI,EAGV,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EACV,WAAW,EACX,4BAA4B,EAC7B,MAAM,2BAA2B,CAAC;AAmBnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,MAAM,EACxB,gBAAgB,CAAC,EAAE,4BAA4B,EAAE,GAChD,MAAM,GAAG,IAAI,CAAC;AACjB,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,WAAW,EACzB,gBAAgB,CAAC,EAAE,4BAA4B,EAAE,GAChD,MAAM,GAAG,IAAI,CAAC;AACjB,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,eAAe,CAAC,EAAE,MAAM,EACxB,gBAAgB,CAAC,EAAE,4BAA4B,EAAE,GAChD,MAAM,GAAG,IAAI,CAAC;AACjB,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,WAAW,CAAC,EAAE,WAAW,EACzB,gBAAgB,CAAC,EAAE,4BAA4B,EAAE,GAChD,MAAM,GAAG,IAAI,CAAC;AAqPjB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACvC,eAAe,GAAE,MAAuB,EACxC,oBAAoB,CAAC,EAAE,OAAO,GAC7B,iBAAiB,CAqGnB;AA8JD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,EAAE,EACtB,eAAe,EAAE,MAAM,EAAE,EACzB,eAAe,GAAE,MAAuB,GACvC,iBAAiB,CA6BnB;AAwHD;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,EACX,eAAe,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GACpD,IAAI,CAAC;AAER;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG,EAC/C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,CAAC,CAAC;AA4FL;;GAEG;AACH,eAAO,MAAM,UAAU,QAAyC,CAAC"}

package/src/utils/package-json.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NX_VERSION = void 0;
+exports.getDependencyVersionFromPackageJson = getDependencyVersionFromPackageJson;
 exports.addDependenciesToPackageJson = addDependenciesToPackageJson;
 exports.removeDependenciesFromPackageJson = removeDependenciesFromPackageJson;
 exports.ensurePackage = ensurePackage;
-const semver_1 = require("semver");
+const fs_1 = require("fs");
+const module_1 = require("module");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
 const path_1 = require("path");
+const semver_1 = require("semver");
 const install_packages_task_1 = require("../tasks/install-packages-task");
-const module_1 = require("module");
+const catalog_1 = require("./catalog");
 const UNIDENTIFIED_VERSION = 'UNIDENTIFIED_VERSION';
 const NON_SEMVER_TAGS = {
     '*': 2,
@@ -19,6 +22,81 @@ const NON_SEMVER_TAGS = {
     previous: -1,
     legacy: -2,
 };
+function getDependencyVersionFromPackageJson(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup) {
+    if (typeof treeOrPackageName !== 'string') {
+        return getDependencyVersionFromPackageJsonFromTree(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup);
+    }
+    else {
+        return getDependencyVersionFromPackageJsonFromFileSystem(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup);
+    }
+}
+/**
+ * Tree-based implementation for getDependencyVersionFromPackageJson
+ */
+function getDependencyVersionFromPackageJsonFromTree(tree, packageName, packageJsonPathOrObject = 'package.json', dependencyLookup = [
+    'dependencies',
+    'devDependencies',
+]) {
+    let packageJson;
+    if (typeof packageJsonPathOrObject === 'object') {
+        packageJson = packageJsonPathOrObject;
+    }
+    else if (tree.exists(packageJsonPathOrObject)) {
+        packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPathOrObject);
+    }
+    else {
+        return null;
+    }
+    let version = null;
+    for (const section of dependencyLookup) {
+        const foundVersion = packageJson[section]?.[packageName];
+        if (foundVersion) {
+            version = foundVersion;
+            break;
+        }
+    }
+    // Resolve catalog reference if needed
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    if (version && manager?.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(tree, packageName, version);
+    }
+    return version;
+}
+/**
+ * Filesystem-based implementation for getDependencyVersionFromPackageJson
+ */
+function getDependencyVersionFromPackageJsonFromFileSystem(packageName, root = devkit_exports_1.workspaceRoot, packageJsonPathOrObject = 'package.json', dependencyLookup = [
+    'dependencies',
+    'devDependencies',
+]) {
+    let packageJson;
+    if (typeof packageJsonPathOrObject === 'object') {
+        packageJson = packageJsonPathOrObject;
+    }
+    else {
+        const packageJsonPath = (0, path_1.resolve)(root, packageJsonPathOrObject);
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            packageJson = (0, devkit_exports_1.readJsonFile)(packageJsonPath);
+        }
+        else {
+            return null;
+        }
+    }
+    let version = null;
+    for (const section of dependencyLookup) {
+        const foundVersion = packageJson[section]?.[packageName];
+        if (foundVersion) {
+            version = foundVersion;
+            break;
+        }
+    }
+    // Resolve catalog reference if needed
+    const manager = (0, catalog_1.getCatalogManager)(root);
+    if (version && manager?.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(packageName, version, root);
+    }
+    return version;
+}
 function filterExistingDependencies(dependencies, existingAltDependencies) {
     if (!existingAltDependencies) {
         return dependencies;
@@ -27,17 +105,39 @@ function filterExistingDependencies(dependencies, existingAltDependencies) {
         .filter((d) => !existingAltDependencies[d])
         .reduce((acc, d) => ({ ...acc, [d]: dependencies[d] }), {});
 }
-function cleanSemver(version) {
+function cleanSemver(tree, version, packageName) {
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    if (manager?.isCatalogReference(version)) {
+        const resolvedVersion = manager.resolveCatalogReference(tree, packageName, version);
+        if (!resolvedVersion) {
+            throw new Error(`Failed to resolve catalog reference '${version}' for package '${packageName}'`);
+        }
+        return (0, semver_1.clean)(resolvedVersion) ?? (0, semver_1.coerce)(resolvedVersion);
+    }
     return (0, semver_1.clean)(version) ?? (0, semver_1.coerce)(version);
 }
-function isIncomingVersionGreater(incomingVersion, existingVersion) {
+function isIncomingVersionGreater(tree, incomingVersion, existingVersion, packageName) {
+    // the existing version might be a catalog reference, so we need to resolve
+    // it if that's the case
+    let resolvedExistingVersion = existingVersion;
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    if (manager?.isCatalogReference(existingVersion)) {
+        const resolved = manager.resolveCatalogReference(tree, packageName, existingVersion);
+        if (!resolved) {
+            // catalog is supported, but failed to resolve, we throw an error
+            throw new Error(`Failed to resolve catalog reference '${existingVersion}' for package '${packageName}'`);
+        }
+        resolvedExistingVersion = resolved;
+    }
     // if version is in the format of "latest", "next" or similar - keep it, otherwise try to parse it
     const incomingVersionCompareBy = incomingVersion in NON_SEMVER_TAGS
         ? incomingVersion
-        : cleanSemver(incomingVersion)?.toString() ?? UNIDENTIFIED_VERSION;
-    const existingVersionCompareBy = existingVersion in NON_SEMVER_TAGS
-        ? existingVersion
-        : cleanSemver(existingVersion)?.toString() ?? UNIDENTIFIED_VERSION;
+        : cleanSemver(tree, incomingVersion, packageName)?.toString() ??
+            UNIDENTIFIED_VERSION;
+    const existingVersionCompareBy = resolvedExistingVersion in NON_SEMVER_TAGS
+        ? resolvedExistingVersion
+        : cleanSemver(tree, resolvedExistingVersion, packageName)?.toString() ??
+            UNIDENTIFIED_VERSION;
     if (incomingVersionCompareBy in NON_SEMVER_TAGS &&
         existingVersionCompareBy in NON_SEMVER_TAGS) {
         return (NON_SEMVER_TAGS[incomingVersionCompareBy] >
@@ -47,9 +147,9 @@ function isIncomingVersionGreater(incomingVersion, existingVersion) {
         existingVersionCompareBy in NON_SEMVER_TAGS) {
         return true;
     }
-    return (0, semver_1.gt)(cleanSemver(incomingVersion), cleanSemver(existingVersion));
+    return (0, semver_1.gt)(cleanSemver(tree, incomingVersion, packageName), cleanSemver(tree, resolvedExistingVersion, packageName));
 }
-function updateExistingAltDependenciesVersion(dependencies, existingAltDependencies) {
+function updateExistingAltDependenciesVersion(tree, dependencies, existingAltDependencies, workspaceRootPath) {
     return Object.keys(existingAltDependencies || {})
         .filter((d) => {
         if (!dependencies[d]) {
@@ -57,11 +157,11 @@ function updateExistingAltDependenciesVersion(dependencies, existingAltDependenc
         }
         const incomingVersion = dependencies[d];
         const existingVersion = existingAltDependencies[d];
-        return isIncomingVersionGreater(incomingVersion, existingVersion);
+        return isIncomingVersionGreater(tree, incomingVersion, existingVersion, d);
     })
         .reduce((acc, d) => ({ ...acc, [d]: dependencies[d] }), {});
 }
-function updateExistingDependenciesVersion(dependencies, existingDependencies = {}) {
+function updateExistingDependenciesVersion(tree, dependencies, existingDependencies = {}, workspaceRootPath) {
     return Object.keys(dependencies)
         .filter((d) => {
         if (!existingDependencies[d]) {
@@ -69,7 +169,7 @@ function updateExistingDependenciesVersion(dependencies, existingDependencies =
         }
         const incomingVersion = dependencies[d];
         const existingVersion = existingDependencies[d];
-        return isIncomingVersionGreater(incomingVersion, existingVersion);
+        return isIncomingVersionGreater(tree, incomingVersion, existingVersion, d);
     })
         .reduce((acc, d) => ({ ...acc, [d]: dependencies[d] }), {});
 }
@@ -101,48 +201,111 @@ function addDependenciesToPackageJson(tree, dependencies, devDependencies, packa
     // - dependencies of the same type that have greater version
     // - specified dependencies of the other type that have greater version and are already installed as current type
     filteredDependencies = {
-        ...updateExistingDependenciesVersion(filteredDependencies, currentPackageJson.dependencies),
-        ...updateExistingAltDependenciesVersion(devDependencies, currentPackageJson.dependencies),
+        ...updateExistingDependenciesVersion(tree, filteredDependencies, currentPackageJson.dependencies, tree.root),
+        ...updateExistingAltDependenciesVersion(tree, devDependencies, currentPackageJson.dependencies, tree.root),
     };
     filteredDevDependencies = {
-        ...updateExistingDependenciesVersion(filteredDevDependencies, currentPackageJson.devDependencies),
-        ...updateExistingAltDependenciesVersion(dependencies, currentPackageJson.devDependencies),
+        ...updateExistingDependenciesVersion(tree, filteredDevDependencies, currentPackageJson.devDependencies, tree.root),
+        ...updateExistingAltDependenciesVersion(tree, dependencies, currentPackageJson.devDependencies, tree.root),
     };
     if (keepExistingVersions) {
         filteredDependencies = removeExistingDependencies(filteredDependencies, currentPackageJson.dependencies);
         filteredDevDependencies = removeExistingDependencies(filteredDevDependencies, currentPackageJson.devDependencies);
     }
     else {
-        filteredDependencies = removeLowerVersions(filteredDependencies, currentPackageJson.dependencies);
-        filteredDevDependencies = removeLowerVersions(filteredDevDependencies, currentPackageJson.devDependencies);
+        filteredDependencies = removeLowerVersions(tree, filteredDependencies, currentPackageJson.dependencies, tree.root);
+        filteredDevDependencies = removeLowerVersions(tree, filteredDevDependencies, currentPackageJson.devDependencies, tree.root);
     }
-    if (requiresAddingOfPackages(currentPackageJson, filteredDependencies, filteredDevDependencies)) {
-        (0, devkit_exports_1.updateJson)(tree, packageJsonPath, (json) => {
-            json.dependencies = {
-                ...(json.dependencies || {}),
-                ...filteredDependencies,
-            };
-            json.devDependencies = {
-                ...(json.devDependencies || {}),
-                ...filteredDevDependencies,
-            };
-            json.dependencies = sortObjectByKeys(json.dependencies);
-            json.devDependencies = sortObjectByKeys(json.devDependencies);
-            return json;
-        });
+    if (requiresAddingOfPackages(tree, currentPackageJson, filteredDependencies, filteredDevDependencies, tree.root)) {
+        const { catalogUpdates, directDependencies, directDevDependencies } = splitDependenciesByCatalogType(tree, filteredDependencies, filteredDevDependencies, packageJsonPath);
+        writeCatalogDependencies(tree, catalogUpdates);
+        writeDirectDependencies(tree, packageJsonPath, directDependencies, directDevDependencies);
         return () => {
             (0, install_packages_task_1.installPackagesTask)(tree);
         };
     }
     return () => { };
 }
+function splitDependenciesByCatalogType(tree, filteredDependencies, filteredDevDependencies, packageJsonPath) {
+    const allFilteredUpdates = {
+        ...filteredDependencies,
+        ...filteredDevDependencies,
+    };
+    const catalogUpdates = [];
+    let directDependencies = { ...filteredDependencies };
+    let directDevDependencies = { ...filteredDevDependencies };
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    if (!manager) {
+        return {
+            catalogUpdates: [],
+            directDependencies: filteredDependencies,
+            directDevDependencies: filteredDevDependencies,
+        };
+    }
+    const existingCatalogDeps = (0, catalog_1.getCatalogDependenciesFromPackageJson)(tree, packageJsonPath, manager);
+    if (!existingCatalogDeps.size) {
+        return {
+            catalogUpdates: [],
+            directDependencies: filteredDependencies,
+            directDevDependencies: filteredDevDependencies,
+        };
+    }
+    // Check filtered results for catalog references or existing catalog dependencies
+    for (const [packageName, version] of Object.entries(allFilteredUpdates)) {
+        if (!existingCatalogDeps.has(packageName)) {
+            continue;
+        }
+        let catalogName = existingCatalogDeps.get(packageName);
+        const catalogRef = catalogName ? `catalog:${catalogName}` : 'catalog:';
+        try {
+            manager.validateCatalogReference(tree, packageName, catalogRef);
+            catalogUpdates.push({ packageName, version, catalogName });
+            // Remove from direct updates since this will be handled via catalog
+            delete directDependencies[packageName];
+            delete directDevDependencies[packageName];
+        }
+        catch (error) {
+            devkit_exports_1.output.error({
+                title: 'Invalid catalog reference',
+                bodyLines: [
+                    `Invalid catalog reference "${catalogRef}" for package "${packageName}".`,
+                    error.message,
+                ],
+            });
+            throw new Error(`Could not update "${packageName}" to version "${version}". See above for more details.`);
+        }
+    }
+    return { catalogUpdates, directDependencies, directDevDependencies };
+}
+function writeCatalogDependencies(tree, catalogUpdates) {
+    if (!catalogUpdates.length) {
+        return;
+    }
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    manager.updateCatalogVersions(tree, catalogUpdates);
+}
+function writeDirectDependencies(tree, packageJsonPath, dependencies, devDependencies) {
+    (0, devkit_exports_1.updateJson)(tree, packageJsonPath, (json) => {
+        json.dependencies = {
+            ...(json.dependencies || {}),
+            ...dependencies,
+        };
+        json.devDependencies = {
+            ...(json.devDependencies || {}),
+            ...devDependencies,
+        };
+        json.dependencies = sortObjectByKeys(json.dependencies);
+        json.devDependencies = sortObjectByKeys(json.devDependencies);
+        return json;
+    });
+}
 /**
  * @returns The the incoming dependencies that are higher than the existing verions
  **/
-function removeLowerVersions(incomingDeps, existingDeps) {
+function removeLowerVersions(tree, incomingDeps, existingDeps, workspaceRootPath) {
     return Object.keys(incomingDeps).reduce((acc, d) => {
         if (!existingDeps?.[d] ||
-            isIncomingVersionGreater(incomingDeps[d], existingDeps[d])) {
+            isIncomingVersionGreater(tree, incomingDeps[d], existingDeps[d], d)) {
             acc[d] = incomingDeps[d];
         }
         return acc;
@@ -209,7 +372,7 @@ function sortObjectByKeys(obj) {
  * Verifies whether the given packageJson dependencies require an update
  * given the deps & devDeps passed in
  */
-function requiresAddingOfPackages(packageJsonFile, deps, devDeps) {
+function requiresAddingOfPackages(tree, packageJsonFile, deps, devDeps, workspaceRootPath) {
     let needsDepsUpdate = false;
     let needsDevDepsUpdate = false;
     packageJsonFile.dependencies = packageJsonFile.dependencies || {};
@@ -219,11 +382,11 @@ function requiresAddingOfPackages(packageJsonFile, deps, devDeps) {
             const incomingVersion = deps[entry];
             if (packageJsonFile.dependencies[entry]) {
                 const existingVersion = packageJsonFile.dependencies[entry];
-                return isIncomingVersionGreater(incomingVersion, existingVersion);
+                return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
             }
             if (packageJsonFile.devDependencies[entry]) {
                 const existingVersion = packageJsonFile.devDependencies[entry];
-                return isIncomingVersionGreater(incomingVersion, existingVersion);
+                return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
             }
             return true;
         });
@@ -233,11 +396,11 @@ function requiresAddingOfPackages(packageJsonFile, deps, devDeps) {
             const incomingVersion = devDeps[entry];
             if (packageJsonFile.devDependencies[entry]) {
                 const existingVersion = packageJsonFile.devDependencies[entry];
-                return isIncomingVersionGreater(incomingVersion, existingVersion);
+                return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
             }
             if (packageJsonFile.dependencies[entry]) {
                 const existingVersion = packageJsonFile.dependencies[entry];
-                return isIncomingVersionGreater(incomingVersion, existingVersion);
+                return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
             }
             return true;
         });
@@ -331,10 +494,10 @@ function addToNodePath(dir) {
     // Update the env variable.
     process.env.NODE_PATH = paths.join(delimiter);
 }
-function getPackageVersion(pkg) {
+function getInstalledPackageModuleVersion(pkg) {
     return require((0, path_1.join)(pkg, 'package.json')).version;
 }
 /**
  * @description The version of Nx used by the workspace. Returns null if no version is found.
  */
-exports.NX_VERSION = getPackageVersion('nx');
+exports.NX_VERSION = getInstalledPackageModuleVersion('nx');

package/src/utils/semver.d.ts

@@ -1,2 +1,4 @@
+import { type Tree } from 'nx/src/devkit-exports';
 export declare function checkAndCleanWithSemver(pkgName: string, version: string): string;
+export declare function checkAndCleanWithSemver(tree: Tree, pkgName: string, version: string): string;
 //# sourceMappingURL=semver.d.ts.map

package/src/utils/semver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semver.d.ts","sourceRoot":"","sources":["../../../../../packages/devkit/src/utils/semver.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,MAAM,CAkBR"}
+{"version":3,"file":"semver.d.ts","sourceRoot":"","sources":["../../../../../packages/devkit/src/utils/semver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAIjE,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,MAAM,CAAC;AACV,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,MAAM,CAAC"}

package/src/utils/semver.js

@@ -1,17 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkAndCleanWithSemver = checkAndCleanWithSemver;
+const devkit_exports_1 = require("nx/src/devkit-exports");
 const semver_1 = require("semver");
-function checkAndCleanWithSemver(pkgName, version) {
-    let newVersion = version;
+const catalog_1 = require("./catalog");
+function checkAndCleanWithSemver(treeOrPkgName, pkgNameOrVersion, version) {
+    const tree = typeof treeOrPkgName === 'string' ? undefined : treeOrPkgName;
+    const root = tree?.root ?? devkit_exports_1.workspaceRoot;
+    const pkgName = typeof treeOrPkgName === 'string' ? treeOrPkgName : pkgNameOrVersion;
+    let newVersion = typeof treeOrPkgName === 'string' ? pkgNameOrVersion : version;
+    const manager = (0, catalog_1.getCatalogManager)(root);
+    if (manager?.isCatalogReference(newVersion)) {
+        try {
+            if (tree) {
+                manager.validateCatalogReference(tree, pkgName, newVersion);
+            }
+            else {
+                manager.validateCatalogReference(root, pkgName, newVersion);
+            }
+        }
+        catch (error) {
+            throw new Error(`The catalog reference for ${pkgName} is invalid - (${newVersion})\n${error.message}`);
+        }
+        const resolvedVersion = tree
+            ? manager.resolveCatalogReference(tree, pkgName, newVersion)
+            : manager.resolveCatalogReference(root, pkgName, newVersion);
+        if (!resolvedVersion) {
+            throw new Error(`Could not resolve catalog reference for package ${pkgName}@${newVersion}.`);
+        }
+        newVersion = resolvedVersion;
+    }
     if ((0, semver_1.valid)(newVersion)) {
         return newVersion;
     }
-    if (version.startsWith('~') || version.startsWith('^')) {
-        newVersion = version.substring(1);
+    if (newVersion.startsWith('~') || newVersion.startsWith('^')) {
+        newVersion = newVersion.substring(1);
     }
     if (!(0, semver_1.valid)(newVersion)) {
-        throw new Error(`The package.json lists a version of ${pkgName} that Nx is unable to validate - (${version})`);
+        throw new Error(`The package.json lists a version of ${pkgName} that Nx is unable to validate - (${newVersion})`);
     }
     return newVersion;
 }