@nx/devkit 0.0.0-pr-32869-39cffae → 0.0.0-pr-32978-3904cbf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "0.0.0-pr-32869-39cffae",
+  "version": "0.0.0-pr-32978-3904cbf",
   "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,10 +38,10 @@
   },
   "devDependencies": {
     "jest": "^29.4.1",
-    "nx": "0.0.0-pr-32869-39cffae"
+    "nx": "0.0.0-pr-32978-3904cbf"
   },
   "peerDependencies": {
-    "nx": "0.0.0-pr-32869-39cffae"
+    "nx": "0.0.0-pr-32978-3904cbf"
   },
   "publishConfig": {
     "access": "public"

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/errors.d.ts

@@ -0,0 +1,10 @@
+import type { CatalogError } from './types';
+export declare class CatalogValidationError extends Error {
+    readonly catalogError: CatalogError;
+    constructor(catalogError: CatalogError, message?: string);
+}
+export declare class CatalogUnsupportedError extends Error {
+    readonly packageManager: string;
+    constructor(packageManager: string, operation: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,qBAAa,sBAAuB,SAAQ,KAAK;aACnB,YAAY,EAAE,YAAY;gBAA1B,YAAY,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM;CAIzE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;aACpB,cAAc,EAAE,MAAM;gBAAtB,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAMtE"}

package/src/utils/catalog/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogUnsupportedError = exports.CatalogValidationError = void 0;
+class CatalogValidationError extends Error {
+    constructor(catalogError, message) {
+        super(message || catalogError.message);
+        this.catalogError = catalogError;
+        this.name = 'CatalogValidationError';
+    }
+}
+exports.CatalogValidationError = CatalogValidationError;
+class CatalogUnsupportedError extends Error {
+    constructor(packageManager, operation) {
+        super(`Tried to ${operation} but Nx doesn't support catalogs for the current package manager (${packageManager})`);
+        this.packageManager = packageManager;
+        this.name = 'CatalogUnsupportedError';
+    }
+}
+exports.CatalogUnsupportedError = CatalogUnsupportedError;

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

@@ -0,0 +1,12 @@
+import { type Tree } from 'nx/src/devkit-exports';
+import { getCatalogManager } from './manager-factory';
+import type { CatalogError } from './types';
+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>;
+export declare function formatCatalogError(error: CatalogError): string;
+//# 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,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,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,CAmCjC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAW9D"}

package/src/utils/catalog/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogManager = void 0;
+exports.getCatalogDependenciesFromPackageJson = getCatalogDependenciesFromPackageJson;
+exports.formatCatalogError = formatCatalogError;
+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;
+    }
+    if (!manager.supportsCatalogs()) {
+        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;
+}
+function formatCatalogError(error) {
+    let message = error.message;
+    if (error.suggestions && error.suggestions.length > 0) {
+        message += '\n\nSuggestions:';
+        error.suggestions.forEach((suggestion) => {
+            message += `\n  • ${suggestion}`;
+        });
+    }
+    return message;
+}

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;
+//# 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;AAShD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,cAAc,CAevE"}

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

@@ -0,0 +1,24 @@
+"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");
+const unsupported_manager_1 = require("./unsupported-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();
+        case 'npm':
+            return new unsupported_manager_1.NpmCatalogManager();
+        case 'yarn':
+            return new unsupported_manager_1.YarnCatalogManager();
+        case 'bun':
+            return new unsupported_manager_1.BunCatalogManager();
+        default:
+            return new unsupported_manager_1.UnknownCatalogManager();
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { Tree } from 'nx/src/devkit-exports';
+import type { PnpmWorkspaceYaml } from 'nx/src/utils/pnpm-workspace';
+import type { CatalogError, CatalogReference } from './types';
+/**
+ * Interface for catalog managers that handle package manager-specific catalog implementations.
+ */
+export interface CatalogManager {
+    readonly name: string;
+    /**
+     * Check if this package manager supports catalogs.
+     */
+    supportsCatalogs(): boolean;
+    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): {
+        isValid: boolean;
+        error?: CatalogError;
+    };
+    validateCatalogReference(tree: Tree, packageName: string, version: string): {
+        isValid: boolean;
+        error?: CatalogError;
+    };
+    /**
+     * 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,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,gBAAgB,IAAI,OAAO,CAAC;IAE5B,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;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;IAC9C,wBAAwB,CACtB,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;IAE9C;;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,26 @@
+import { type Tree } from 'nx/src/devkit-exports';
+import type { PnpmWorkspaceYaml } from 'nx/src/utils/pnpm-workspace';
+import type { CatalogManager } from './manager';
+import { type CatalogError, type CatalogReference } from './types';
+/**
+ * PNPM-specific catalog manager implementation
+ */
+export declare class PnpmCatalogManager implements CatalogManager {
+    readonly name = "pnpm";
+    readonly catalogProtocol = "catalog:";
+    supportsCatalogs(): boolean;
+    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): {
+        isValid: boolean;
+        error?: CatalogError;
+    };
+    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,EACL,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EACtB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IACvD,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,eAAe,cAAc;IAEtC,gBAAgB,IAAI,OAAO;IAI3B,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI5C,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAa/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;IAqBhB,wBAAwB,CACtB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,CAAA;KAAE;IAqH7C,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;CAuER"}

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

@@ -0,0 +1,258 @@
+"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");
+const types_1 = require("./types");
+/**
+ * PNPM-specific catalog manager implementation
+ */
+class PnpmCatalogManager {
+    constructor() {
+        this.name = 'pnpm';
+        this.catalogProtocol = 'catalog:';
+    }
+    supportsCatalogs() {
+        return true;
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length);
+        return {
+            catalogName: catalogName || undefined,
+            isDefaultCatalog: catalogName === '',
+        };
+    }
+    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) {
+            catalogToUse = workspaceConfig.catalog;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return {
+                isValid: false,
+                error: {
+                    type: types_1.CatalogErrorType.INVALID_SYNTAX,
+                    message: `Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`,
+                },
+            };
+        }
+        const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+            return {
+                isValid: false,
+                error: {
+                    type: types_1.CatalogErrorType.WORKSPACE_NOT_FOUND,
+                    message: 'No pnpm-workspace.yaml found in workspace root',
+                    suggestions: [
+                        'Create a pnpm-workspace.yaml file in your workspace root',
+                    ],
+                },
+            };
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = workspaceConfig.catalog;
+            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(', ')}`);
+                }
+                return {
+                    isValid: false,
+                    error: {
+                        type: types_1.CatalogErrorType.CATALOG_NOT_FOUND,
+                        message: '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 || {});
+                const hasDefaultCatalog = !!workspaceConfig.catalog;
+                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 (hasDefaultCatalog) {
+                    suggestions.push('Or use the default catalog: "catalog:"');
+                }
+                return {
+                    isValid: false,
+                    error: {
+                        type: types_1.CatalogErrorType.CATALOG_NOT_FOUND,
+                        message: `Catalog "${catalogRef.catalogName}" not found in pnpm-workspace.yaml`,
+                        catalogName: catalogRef.catalogName,
+                        suggestions,
+                    },
+                };
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog'
+                : `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(', ')}`);
+            }
+            return {
+                isValid: false,
+                error: {
+                    type: types_1.CatalogErrorType.PACKAGE_NOT_FOUND,
+                    message: `Package "${packageName}" not found in ${catalogName}`,
+                    packageName,
+                    catalogName: catalogRef.catalogName,
+                    suggestions,
+                },
+            };
+        }
+        return { isValid: true };
+    }
+    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;
+                let targetCatalog;
+                if (catalogName) {
+                    // Named catalog
+                    workspaceData.catalogs ??= {};
+                    workspaceData.catalogs[catalogName] ??= {};
+                    targetCatalog = workspaceData.catalogs[catalogName];
+                }
+                else {
+                    // Default catalog
+                    workspaceData.catalog ??= {};
+                    targetCatalog = workspaceData.catalog;
+                }
+                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;
+    }
+}

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

@@ -0,0 +1,18 @@
+export interface CatalogReference {
+    catalogName?: string;
+    isDefaultCatalog: boolean;
+}
+export declare enum CatalogErrorType {
+    INVALID_SYNTAX = "INVALID_SYNTAX",
+    WORKSPACE_NOT_FOUND = "WORKSPACE_NOT_FOUND",
+    CATALOG_NOT_FOUND = "CATALOG_NOT_FOUND",
+    PACKAGE_NOT_FOUND = "PACKAGE_NOT_FOUND"
+}
+export interface CatalogError {
+    type: CatalogErrorType;
+    message: string;
+    catalogName?: string;
+    packageName?: string;
+    suggestions?: string[];
+}
+//# 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;AAED,oBAAY,gBAAgB;IAC1B,cAAc,mBAAmB;IACjC,mBAAmB,wBAAwB;IAC3C,iBAAiB,sBAAsB;IACvC,iBAAiB,sBAAsB;CACxC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB"}

package/src/utils/catalog/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogErrorType = void 0;
+var CatalogErrorType;
+(function (CatalogErrorType) {
+    CatalogErrorType["INVALID_SYNTAX"] = "INVALID_SYNTAX";
+    CatalogErrorType["WORKSPACE_NOT_FOUND"] = "WORKSPACE_NOT_FOUND";
+    CatalogErrorType["CATALOG_NOT_FOUND"] = "CATALOG_NOT_FOUND";
+    CatalogErrorType["PACKAGE_NOT_FOUND"] = "PACKAGE_NOT_FOUND";
+})(CatalogErrorType || (exports.CatalogErrorType = CatalogErrorType = {}));

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

@@ -0,0 +1,38 @@
+import type { Tree } from 'nx/src/devkit-exports';
+import type { PnpmWorkspaceYaml } from 'nx/src/utils/pnpm-workspace';
+import type { CatalogManager } from './manager';
+import type { CatalogError, CatalogReference } from './types';
+/**
+ * Base catalog manager for package managers that don't support catalogs
+ */
+declare abstract class UnsupportedCatalogManager implements CatalogManager {
+    abstract readonly name: string;
+    supportsCatalogs(): boolean;
+    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): {
+        isValid: boolean;
+        error?: CatalogError;
+    };
+    updateCatalogVersions(_treeOrRoot: Tree | string, _updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}
+export declare class YarnCatalogManager extends UnsupportedCatalogManager {
+    readonly name = "yarn";
+}
+export declare class BunCatalogManager extends UnsupportedCatalogManager {
+    readonly name = "bun";
+}
+export declare class NpmCatalogManager extends UnsupportedCatalogManager {
+    readonly name = "npm";
+}
+export declare class UnknownCatalogManager extends UnsupportedCatalogManager {
+    readonly name = "unknown";
+}
+export {};
+//# sourceMappingURL=unsupported-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unsupported-manager.d.ts","sourceRoot":"","sources":["../../../../../../packages/devkit/src/utils/catalog/unsupported-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9D;;GAEG;AACH,uBAAe,yBAA0B,YAAW,cAAc;IAChE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAE/B,gBAAgB,IAAI,OAAO;IAI3B,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI7C,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAIhE,qBAAqB,CAAC,WAAW,EAAE,IAAI,GAAG,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAI3E,uBAAuB,CACrB,WAAW,EAAE,IAAI,GAAG,MAAM,EAC1B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI;IAIhB,wBAAwB,CACtB,WAAW,EAAE,IAAI,GAAG,MAAM,EAC1B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,CAAA;KAAE;IAI7C,qBAAqB,CACnB,WAAW,EAAE,IAAI,GAAG,MAAM,EAC1B,QAAQ,EAAE,KAAK,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,GACD,IAAI;CAGR;AAED,qBAAa,kBAAmB,SAAQ,yBAAyB;IAC/D,QAAQ,CAAC,IAAI,UAAU;CACxB;AAED,qBAAa,iBAAkB,SAAQ,yBAAyB;IAC9D,QAAQ,CAAC,IAAI,SAAS;CACvB;AAED,qBAAa,iBAAkB,SAAQ,yBAAyB;IAC9D,QAAQ,CAAC,IAAI,SAAS;CACvB;AAED,qBAAa,qBAAsB,SAAQ,yBAAyB;IAClE,QAAQ,CAAC,IAAI,aAAa;CAC3B"}

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownCatalogManager = exports.NpmCatalogManager = exports.BunCatalogManager = exports.YarnCatalogManager = void 0;
+const errors_1 = require("./errors");
+/**
+ * Base catalog manager for package managers that don't support catalogs
+ */
+class UnsupportedCatalogManager {
+    supportsCatalogs() {
+        return false;
+    }
+    isCatalogReference(_version) {
+        return false;
+    }
+    parseCatalogReference(_version) {
+        return null;
+    }
+    getCatalogDefinitions(_treeOrRoot) {
+        throw new errors_1.CatalogUnsupportedError(this.name, 'get catalog definitions');
+    }
+    resolveCatalogReference(_treeOrRoot, _packageName, _version) {
+        throw new errors_1.CatalogUnsupportedError(this.name, 'resolve catalog references');
+    }
+    validateCatalogReference(_treeOrRoot, _packageName, _version) {
+        throw new errors_1.CatalogUnsupportedError(this.name, 'validate catalog references');
+    }
+    updateCatalogVersions(_treeOrRoot, _updates) {
+        throw new errors_1.CatalogUnsupportedError(this.name, 'update catalog versions');
+    }
+}
+class YarnCatalogManager extends UnsupportedCatalogManager {
+    constructor() {
+        super(...arguments);
+        this.name = 'yarn';
+    }
+}
+exports.YarnCatalogManager = YarnCatalogManager;
+class BunCatalogManager extends UnsupportedCatalogManager {
+    constructor() {
+        super(...arguments);
+        this.name = 'bun';
+    }
+}
+exports.BunCatalogManager = BunCatalogManager;
+class NpmCatalogManager extends UnsupportedCatalogManager {
+    constructor() {
+        super(...arguments);
+        this.name = 'npm';
+    }
+}
+exports.NpmCatalogManager = NpmCatalogManager;
+class UnknownCatalogManager extends UnsupportedCatalogManager {
+    constructor() {
+        super(...arguments);
+        this.name = 'unknown';
+    }
+}
+exports.UnknownCatalogManager = UnknownCatalogManager;

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

@@ -1,4 +1,58 @@
-import { GeneratorCallback, Tree } from 'nx/src/devkit-exports';
+import { type GeneratorCallback, type Tree } from 'nx/src/devkit-exports';
+import type { PackageJson } 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. 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
+ * const reactVersion = getDependencyVersionFromPackageJson(tree, 'react');
+ * // Returns: "^18.0.0" (resolves "catalog:default" if present)
+ *
+ * // Tree-based - from specific package.json
+ * const version = getDependencyVersionFromPackageJson(
+ *   tree,
+ *   '@my/lib',
+ *   'packages/my-lib/package.json'
+ * );
+ *
+ * // Tree-based - with pre-loaded package.json
+ * const packageJson = readJson(tree, 'package.json');
+ * const version = getDependencyVersionFromPackageJson(tree, 'react', packageJson);
+ * ```
+ *
+ * @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
+ * const version = getDependencyVersionFromPackageJson(
+ *   'react',
+ *   '/path/to/workspace',
+ *   'apps/my-app/package.json'
+ * );
+ * ```
+ *
+ * @returns The resolved version string, or `null` if the package is not found in either dependencies or devDependencies
+ */
+export declare function getDependencyVersionFromPackageJson(tree: Tree, packageName: string, packageJsonPath?: string): string | null;
+export declare function getDependencyVersionFromPackageJson(tree: Tree, packageName: string, packageJson?: PackageJson): string | null;
+export declare function getDependencyVersionFromPackageJson(packageName: string, workspaceRootPath?: string, packageJsonPath?: string): string | null;
+export declare function getDependencyVersionFromPackageJson(packageName: string, workspaceRootPath?: string, packageJson?: PackageJson): 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,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAmB7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,MAAM,GACvB,MAAM,GAAG,IAAI,CAAC;AACjB,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,WAAW,GACxB,MAAM,GAAG,IAAI,CAAC;AACjB,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,eAAe,CAAC,EAAE,MAAM,GACvB,MAAM,GAAG,IAAI,CAAC;AACjB,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,MAAM,GAAG,IAAI,CAAC;AAyOjB;;;;;;;;;;;;;;;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;AAuMD;;;;;;;;;;;;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,65 @@ const NON_SEMVER_TAGS = {
     previous: -1,
     legacy: -2,
 };
+function getDependencyVersionFromPackageJson(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot) {
+    if (typeof treeOrPackageName !== 'string') {
+        return getDependencyVersionFromPackageJsonFromTree(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot);
+    }
+    else {
+        return getDependencyVersionFromPackageJsonFromFileSystem(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot);
+    }
+}
+/**
+ * Tree-based implementation for getDependencyVersionFromPackageJson
+ */
+function getDependencyVersionFromPackageJsonFromTree(tree, packageName, packageJsonPathOrObject = 'package.json') {
+    let packageJson;
+    if (typeof packageJsonPathOrObject === 'object') {
+        packageJson = packageJsonPathOrObject;
+    }
+    else if (tree.exists(packageJsonPathOrObject)) {
+        packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPathOrObject);
+    }
+    else {
+        return null;
+    }
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    let version = packageJson.dependencies?.[packageName] ??
+        packageJson.devDependencies?.[packageName] ??
+        null;
+    // Resolve catalog reference if needed
+    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') {
+    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;
+        }
+    }
+    const manager = (0, catalog_1.getCatalogManager)(root);
+    let version = packageJson.dependencies?.[packageName] ??
+        packageJson.devDependencies?.[packageName] ??
+        null;
+    // Resolve catalog reference if needed
+    if (version && manager.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(packageName, version, root);
+    }
+    return version;
+}
 function filterExistingDependencies(dependencies, existingAltDependencies) {
     if (!existingAltDependencies) {
         return dependencies;
@@ -27,17 +89,43 @@ 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)) {
+        if (!manager.supportsCatalogs()) {
+            // If catalog is unsupported, we assume the incoming version is newer
+            return true;
+        }
+        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 +135,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 +145,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 +157,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 +189,143 @@ 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);
+    const existingCatalogDeps = (0, catalog_1.getCatalogDependenciesFromPackageJson)(tree, packageJsonPath, manager);
+    if (!existingCatalogDeps.size) {
+        return {
+            catalogUpdates: [],
+            directDependencies: filteredDependencies,
+            directDevDependencies: filteredDevDependencies,
+        };
+    }
+    const supportsCatalogs = manager.supportsCatalogs();
+    // Check filtered results for catalog references or existing catalog dependencies
+    for (const [packageName, version] of Object.entries(allFilteredUpdates)) {
+        if (!existingCatalogDeps.has(packageName)) {
+            continue;
+        }
+        let shouldUseCatalog = false;
+        let catalogName;
+        if (!supportsCatalogs) {
+            // we're trying to update the version of a package that has a catalog reference
+            // but Nx does not support catalogs for this package manager, we warn the user
+            // and update the dependencies directly to package.json to keep the existing
+            // behavior
+            devkit_exports_1.output.warn({
+                title: 'Nx does not support catalogs for this package manager',
+                bodyLines: [
+                    'Dependencies will be added directly to package.json and might override catalog dependencies.',
+                ],
+            });
+            // bail out early since we'll add the dependencies directly to package.json
+            return {
+                catalogUpdates: [],
+                directDependencies: filteredDependencies,
+                directDevDependencies: filteredDevDependencies,
+            };
+        }
+        catalogName = existingCatalogDeps.get(packageName);
+        const catalogRef = catalogName ? `catalog:${catalogName}` : 'catalog:';
+        try {
+            const manager = (0, catalog_1.getCatalogManager)(tree.root);
+            const { isValid, error } = manager.validateCatalogReference(tree, packageName, catalogRef);
+            if (isValid) {
+                shouldUseCatalog = true;
+            }
+            else {
+                devkit_exports_1.output.error({
+                    title: 'Invalid catalog reference',
+                    bodyLines: [
+                        `Invalid catalog reference "${catalogRef}" for package "${packageName}".`,
+                        ...(error?.message ? [error.message] : []),
+                        ...(error?.suggestions || []),
+                    ],
+                });
+                throw new Error(`Could not update "${packageName}" to version "${version}". See above for more details.`);
+            }
+        }
+        catch (error) {
+            devkit_exports_1.output.error({
+                title: 'Could not update catalog dependency',
+                bodyLines: [
+                    `Unexpected error while updating catalog reference "${catalogRef}" for package "${packageName}".`,
+                    ...(error?.message ? [error.message] : []),
+                    ...(error?.stack ? [error.stack] : []),
+                ],
+            });
+            throw new Error(`Could not update "${packageName}" to version "${version}". See above for more details.`);
+        }
+        if (shouldUseCatalog) {
+            catalogUpdates.push({ packageName, version, catalogName });
+            // Remove from direct updates since this will be handled via catalog
+            delete directDependencies[packageName];
+            delete directDevDependencies[packageName];
+        }
+    }
+    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 +392,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 +402,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 +416,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 +514,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,38 @@
 "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)) {
+        const validation = tree
+            ? manager.validateCatalogReference(tree, pkgName, newVersion)
+            : manager.validateCatalogReference(root, pkgName, newVersion);
+        if (!validation.isValid) {
+            throw new Error(`The catalog reference for ${pkgName} is invalid - (${newVersion})\n${(0, catalog_1.formatCatalogError)(validation.error)}`);
+        }
+        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;
 }