@nx/devkit 23.1.0 → 23.1.2

package/dist/src/utils/nx-ignore-internals.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTHING_IGNORED = void 0;
+exports.assertNxSupportsIgnoreCheckers = assertNxSupportsIgnoreCheckers;
+const devkit_internals_1 = require("nx/src/devkit-internals");
+/**
+ * `@nx/devkit`'s `nx` peer spans a major either side, so an older nx that
+ * predates the ignore checkers can legally be installed alongside it, and a
+ * missing CommonJS named export arrives as `undefined` rather than as a load
+ * error. The two callers want opposite things from that, so they get different
+ * helpers - see `NOTHING_IGNORED` for the other half.
+ *
+ * A tree walk cannot degrade: without a checker nothing would be ignored, and
+ * the walker would descend into `node_modules` and hand a migration every file
+ * in it to rewrite. That is worse than the older nx's own behaviour, which at
+ * least read the root `.gitignore`, so this fails instead - once, by name.
+ */
+function assertNxSupportsIgnoreCheckers() {
+    if (devkit_internals_1.createGitIgnoreChecker) {
+        return;
+    }
+    throw new Error('The installed version of nx does not export the ignore checkers that @nx/devkit needs to decide which files a generator may touch. ' +
+        'This happens when nx and @nx/devkit are on different major versions. Run `nx migrate latest` to bring them into line.');
+}
+/**
+ * The degrade the other way, for formatting.
+ *
+ * Filtering nothing is what devkit did before the checkers existed - with no
+ * `ignorePath`, prettier's own `getFileInfo` never read the workspace's ignore
+ * files either (measured) - so an older nx gets the formatting behaviour it has
+ * always had rather than a generator that refuses to run.
+ */
+exports.NOTHING_IGNORED = {
+    isIgnoredFile: () => false,
+    isIgnoredDirectory: () => false,
+};

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

@@ -12,7 +12,8 @@ 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 catalog_1 = require("./catalog");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports -- nx/src/utils/catalog exists since nx 22.0.0, the whole supported range; swap to the nx/src/devkit-internals re-export in v25
+const catalog_1 = require("nx/src/utils/catalog");
 const UNIDENTIFIED_VERSION = 'UNIDENTIFIED_VERSION';
 const NON_SEMVER_TAGS = {
     '*': 2,
@@ -441,7 +442,11 @@ function ensurePackage(pkgOrTree, requiredVersionOrPackage, maybeRequiredVersion
         return packageMapCache.get(pkg);
     }
     try {
-        return require(pkg);
+        // The workspace comes first so its installed version wins; `__dirname`
+        // keeps the old behaviour as a fallback. A bare `require` would only
+        // resolve from wherever `@nx/devkit` sits, which in a monorepo can be a
+        // different copy of the package than the workspace depends on.
+        return require(require.resolve(pkg, { paths: [devkit_exports_1.workspaceRoot, __dirname] }));
     }
     catch (e) {
         if (e.code === 'ERR_REQUIRE_ESM') {

package/dist/src/utils/semver.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkAndCleanWithSemver = checkAndCleanWithSemver;
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const semver_1 = require("semver");
-const catalog_1 = require("./catalog");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports -- nx/src/utils/catalog exists since nx 22.0.0, the whole supported range; swap to the nx/src/devkit-internals re-export in v25
+const catalog_1 = require("nx/src/utils/catalog");
 function checkAndCleanWithSemver(treeOrPkgName, pkgNameOrVersion, version) {
     const tree = typeof treeOrPkgName === 'string' ? undefined : treeOrPkgName;
     const root = tree?.root ?? devkit_exports_1.workspaceRoot;

package/dist/src/utils/version-floor.d.ts

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/devkit-exports';
+import { type Tree } from 'nx/src/devkit-exports';
 /**
  * Throws a standardized error when a package is installed at a version below
  * a plugin's supported floor.
@@ -15,9 +15,21 @@ export declare function throwForUnsupportedVersion(packageName: string, installe
 /**
  * Asserts that a package detected in the workspace is at or above the
  * plugin's supported floor. No-op when the package is not detected
- * (fresh-install path) or when declared as `latest`/`next`. Throws via
- * `throwForUnsupportedVersion` (with the original declared range for
- * clarity) when below floor.
+ * (fresh-install path) or when declared as `latest`/`next`.
+ *
+ * Resolution order:
+ * - When the installed version satisfies the declared range, the installed
+ *   version decides. This resolves open ranges (e.g. `>=4.8.4 <6.1.0`) to
+ *   what is actually installed.
+ * - An exact declared version is compared to the floor directly.
+ * - A declared range that cannot reach the floor throws as unsupported. A
+ *   range that straddles the floor cannot be judged without an installed
+ *   version (the lockfile may pin either side), so when none resolves it
+ *   throws asking to install dependencies first.
+ *
+ * Prereleases count as their release version throughout (e.g. `6.0.0-rc.1`
+ * as `6.0.0`), for installed versions, exact declared versions, and range
+ * endpoints alike.
  *
  * Use from generator entry points to fail fast on unsupported workspaces
  * before writing any incompatible config.

package/dist/src/utils/version-floor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.throwForUnsupportedVersion = throwForUnsupportedVersion;
 exports.assertSupportedPackageVersion = assertSupportedPackageVersion;
 exports.assertSupportedInstalledPackageVersion = assertSupportedInstalledPackageVersion;
+const devkit_exports_1 = require("nx/src/devkit-exports");
 const semver_1 = require("semver");
 const installed_version_1 = require("./installed-version");
 const package_json_1 = require("./package-json");
@@ -27,9 +28,21 @@ function throwForUnsupportedVersion(packageName, installedVersion, floor) {
 /**
  * Asserts that a package detected in the workspace is at or above the
  * plugin's supported floor. No-op when the package is not detected
- * (fresh-install path) or when declared as `latest`/`next`. Throws via
- * `throwForUnsupportedVersion` (with the original declared range for
- * clarity) when below floor.
+ * (fresh-install path) or when declared as `latest`/`next`.
+ *
+ * Resolution order:
+ * - When the installed version satisfies the declared range, the installed
+ *   version decides. This resolves open ranges (e.g. `>=4.8.4 <6.1.0`) to
+ *   what is actually installed.
+ * - An exact declared version is compared to the floor directly.
+ * - A declared range that cannot reach the floor throws as unsupported. A
+ *   range that straddles the floor cannot be judged without an installed
+ *   version (the lockfile may pin either side), so when none resolves it
+ *   throws asking to install dependencies first.
+ *
+ * Prereleases count as their release version throughout (e.g. `6.0.0-rc.1`
+ * as `6.0.0`), for installed versions, exact declared versions, and range
+ * endpoints alike.
  *
  * Use from generator entry points to fail fast on unsupported workspaces
  * before writing any incompatible config.
@@ -39,11 +52,64 @@ function assertSupportedPackageVersion(tree, packageName, minSupportedVersion) {
     if (!declared || (0, installed_version_1.isNonSemverDistTag)(declared)) {
         return;
     }
-    const cleaned = (0, installed_version_1.normalizeSemver)(declared);
-    if (cleaned && (0, semver_1.lt)(cleaned, minSupportedVersion)) {
+    const installed = (0, installed_version_1.getInstalledPackageVersionFromTree)(tree, packageName) ??
+        getInstalledPackageVersionFromProcess(tree, packageName);
+    if (installed) {
+        // An installed prerelease can match the declared range in either form:
+        // raw (a same-tuple prerelease comparator) or as its release version.
+        const release = (0, semver_1.coerce)(installed)?.version ?? installed;
+        if ((0, semver_1.satisfies)(installed, declared) || (0, semver_1.satisfies)(release, declared)) {
+            if ((0, semver_1.lt)(release, minSupportedVersion)) {
+                throwForUnsupportedVersion(packageName, installed, minSupportedVersion);
+            }
+            return;
+        }
+    }
+    const cleaned = (0, semver_1.clean)(declared);
+    if (cleaned) {
+        // Strip any prerelease so it counts as its release version.
+        const release = (0, semver_1.coerce)(cleaned)?.version ?? cleaned;
+        if ((0, semver_1.lt)(release, minSupportedVersion)) {
+            throwForUnsupportedVersion(packageName, declared, minSupportedVersion);
+        }
+        return;
+    }
+    if ((0, semver_1.validRange)(declared)) {
+        // The `-0` floor comparator admits prereleases of the floor version, so
+        // a range reaching the floor only through its prereleases still counts.
+        if (!(0, semver_1.intersects)(declared, `>=${minSupportedVersion}-0`)) {
+            throwForUnsupportedVersion(packageName, declared, minSupportedVersion);
+        }
+        const min = (0, semver_1.minVersion)(declared);
+        const rangeMinimum = min ? `${min.major}.${min.minor}.${min.patch}` : null;
+        if (rangeMinimum && (0, semver_1.lt)(rangeMinimum, minSupportedVersion)) {
+            throw new Error(`Unable to determine the installed version of \`${packageName}\`.\n\n` +
+                `  Declared: ${declared}\n` +
+                `  Supported: >= ${minSupportedVersion}\n\n` +
+                `The declared range allows versions below the supported minimum. ` +
+                `Install the workspace dependencies so the installed version can be verified, then try again.`);
+        }
+        return;
+    }
+    const coerced = (0, semver_1.coerce)(declared)?.version;
+    if (coerced && (0, semver_1.lt)(coerced, minSupportedVersion)) {
         throwForUnsupportedVersion(packageName, declared, minSupportedVersion);
     }
 }
+/**
+ * Module-resolution fallback for installs without a `node_modules` layout
+ * (e.g. Yarn PnP). Only valid when the tree is the running process's
+ * workspace; unit trees (e.g. rooted at `/virtual`) must not resolve
+ * packages from the process environment. Resolves from the workspace root
+ * only, so a copy hoisted into `.nx/installation` cannot shadow the
+ * workspace's own install.
+ */
+function getInstalledPackageVersionFromProcess(tree, packageName) {
+    if (tree.root !== devkit_exports_1.workspaceRoot) {
+        return null;
+    }
+    return (0, installed_version_1.getInstalledPackageVersion)(packageName, [tree.root]);
+}
 /**
  * Asserts that a package installed in the workspace is at or above the
  * plugin's supported floor. No-op when the package is not resolvable from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "23.1.0",
+  "version": "23.1.2",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -40,6 +40,15 @@
       ],
       "internal-testing-utils": [
         "dist/internal-testing-utils.d.ts"
+      ],
+      "internal-testing-utils/mock-project-graph": [
+        "dist/internal-testing-utils/mock-project-graph.d.ts"
+      ],
+      "internal-testing-utils/mock-fs": [
+        "dist/internal-testing-utils/mock-fs.d.ts"
+      ],
+      "internal-testing-utils/mock-prettier": [
+        "dist/internal-testing-utils/mock-prettier.d.ts"
       ]
     }
   },
@@ -50,18 +59,16 @@
   },
   "homepage": "https://nx.dev",
   "dependencies": {
-    "@zkochan/js-yaml": "0.0.7",
     "ejs": "5.0.1",
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "yargs-parser": "21.1.1",
     "minimatch": "10.2.5",
-    "enquirer": "~2.3.6",
-    "yaml": "^2.8.3"
+    "enquirer": "~2.3.6"
   },
   "devDependencies": {
     "jest": "30.3.0",
-    "nx": "23.1.0"
+    "nx": "23.1.2"
   },
   "peerDependencies": {
     "nx": ">= 22 <= 24 || ^23.0.0-0"
@@ -91,6 +98,21 @@
       "types": "./dist/internal-testing-utils.d.ts",
       "default": "./dist/internal-testing-utils.js"
     },
+    "./internal-testing-utils/mock-project-graph": {
+      "@nx/nx-source": "./internal-testing-utils/mock-project-graph.ts",
+      "types": "./dist/internal-testing-utils/mock-project-graph.d.ts",
+      "default": "./dist/internal-testing-utils/mock-project-graph.js"
+    },
+    "./internal-testing-utils/mock-fs": {
+      "@nx/nx-source": "./internal-testing-utils/mock-fs.ts",
+      "types": "./dist/internal-testing-utils/mock-fs.d.ts",
+      "default": "./dist/internal-testing-utils/mock-fs.js"
+    },
+    "./internal-testing-utils/mock-prettier": {
+      "@nx/nx-source": "./internal-testing-utils/mock-prettier.ts",
+      "types": "./dist/internal-testing-utils/mock-prettier.d.ts",
+      "default": "./dist/internal-testing-utils/mock-prettier.js"
+    },
     "./ngcli-adapter": {
       "@nx/nx-source": "./ngcli-adapter.ts",
       "types": "./dist/ngcli-adapter.d.ts",

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

@@ -1,9 +0,0 @@
-import { type Tree } from 'nx/src/devkit-exports';
-import { getCatalogManager } from './manager-factory';
-import type { CatalogManager } from './manager';
-export { type CatalogManager, 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>;

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

@@ -1,38 +0,0 @@
-"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/dist/src/utils/catalog/manager-factory.d.ts

@@ -1,5 +0,0 @@
-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;

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

@@ -1,20 +0,0 @@
-"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 yarn_manager_1 = require("./yarn-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 'yarn':
-            return new yarn_manager_1.YarnCatalogManager();
-        default:
-            return null;
-    }
-}

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

@@ -1,9 +0,0 @@
-import { type Tree } from 'nx/src/devkit-exports';
-import type { CatalogDefinitions } from './types';
-export declare function readCatalogConfigFromFs(filename: string, fullPath: string): CatalogDefinitions | null;
-export declare function readCatalogConfigFromTree(filename: string, tree: Tree): CatalogDefinitions | null;
-export declare function updateCatalogVersionsInFile(filename: string, treeOrRoot: Tree | string, updates: Array<{
-    packageName: string;
-    version: string;
-    catalogName?: string;
-}>): void;

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

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCatalogConfigFromFs = readCatalogConfigFromFs;
-exports.readCatalogConfigFromTree = readCatalogConfigFromTree;
-exports.updateCatalogVersionsInFile = updateCatalogVersionsInFile;
-// Keep in sync with packages/nx/src/utils/catalog/manager-utils.ts; the body below
-// the imports is duplicated because @nx/devkit supports a range of nx majors and
-// this logic isn't part of the nx surface it can import across that range.
-const js_yaml_1 = require("@zkochan/js-yaml");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const devkit_exports_1 = require("nx/src/devkit-exports");
-const devkit_internals_1 = require("nx/src/devkit-internals");
-const yaml_1 = require("yaml");
-// Walks `path` resolving aliases at every step so structural checks can
-// see through `key: *anchor` references. Neither `doc.getIn` nor
-// `doc.hasIn` traverse aliases on their own. Returns the resolved node, or
-// `undefined` if any ancestor isn't a map.
-function resolveAt(doc, path) {
-    let node = doc.contents;
-    for (let i = 0; i < path.length; i++) {
-        if ((0, yaml_1.isAlias)(node))
-            node = node.resolve(doc);
-        if (!(0, yaml_1.isMap)(node))
-            return undefined;
-        node = node.get(path[i], true);
-    }
-    if ((0, yaml_1.isAlias)(node))
-        node = node.resolve(doc);
-    return node;
-}
-function isMapAt(doc, path) {
-    return (0, yaml_1.isMap)(resolveAt(doc, path));
-}
-function existsAt(doc, path) {
-    return resolveAt(doc, path) !== undefined;
-}
-// `doc.getIn` does not traverse aliases. For aliased paths it returns
-// undefined even when the resolved node has a value. Use the alias-aware
-// walk and unwrap scalar nodes to their JS value.
-function getValueAt(doc, path) {
-    const node = resolveAt(doc, path);
-    return (0, yaml_1.isScalar)(node) ? node.value : node;
-}
-// Walks `targetPath` resolving aliases at every step and mutates the
-// resolved map directly so anchors are preserved. When a step is missing
-// or holds a null placeholder (`key:` with no value), creates a fresh map
-// inside the current parent and carries over the placeholder's comments
-// and anchor so they aren't dropped. A dropped anchor would leave any
-// alias referencing it unresolved and make `String(doc)` throw. Falls back
-// to `doc.setIn` when the current parent isn't a map: an empty-document
-// root gets bootstrapped, while a non-map value where a catalog map was
-// expected makes `setIn` throw, surfacing the malformed config.
-function setThroughAliases(doc, targetPath, value) {
-    let parent = doc.contents;
-    if ((0, yaml_1.isAlias)(parent))
-        parent = parent.resolve(doc);
-    for (let i = 0; i < targetPath.length - 1; i++) {
-        if (!(0, yaml_1.isMap)(parent)) {
-            doc.setIn(targetPath, value);
-            return;
-        }
-        let next = parent.get(targetPath[i], true);
-        const nextWasAlias = (0, yaml_1.isAlias)(next);
-        if ((0, yaml_1.isAlias)(next))
-            next = next.resolve(doc);
-        const placeholder = (0, yaml_1.isScalar)(next) && next.value === null ? next : undefined;
-        if (next === undefined || placeholder) {
-            let cur = parent;
-            for (let j = i; j < targetPath.length - 1; j++) {
-                const fresh = new yaml_1.YAMLMap();
-                if (j === i && placeholder) {
-                    if (placeholder.comment)
-                        fresh.comment = placeholder.comment;
-                    if (placeholder.commentBefore)
-                        fresh.commentBefore = placeholder.commentBefore;
-                    // Copy the anchor only for a directly-held placeholder. When it
-                    // was reached through an alias, the anchor still lives on the
-                    // definition node, so re-emitting it here would duplicate it.
-                    if (!nextWasAlias && placeholder.anchor)
-                        fresh.anchor = placeholder.anchor;
-                }
-                cur.set(targetPath[j], fresh);
-                cur = fresh;
-            }
-            cur.set(targetPath[targetPath.length - 1], value);
-            return;
-        }
-        parent = next;
-    }
-    if (!(0, yaml_1.isMap)(parent)) {
-        doc.setIn(targetPath, value);
-        return;
-    }
-    parent.set(targetPath[targetPath.length - 1], value);
-}
-function readCatalogConfigFromFs(filename, fullPath) {
-    try {
-        return (0, devkit_internals_1.readYamlFile)(fullPath);
-    }
-    catch (error) {
-        devkit_exports_1.output.warn({
-            title: `Unable to parse ${filename}`,
-            bodyLines: [error.toString()],
-        });
-        return null;
-    }
-}
-function readCatalogConfigFromTree(filename, tree) {
-    const content = tree.read(filename, 'utf-8');
-    try {
-        return (0, js_yaml_1.load)(content, { filename });
-    }
-    catch (error) {
-        devkit_exports_1.output.warn({
-            title: `Unable to parse ${filename}`,
-            bodyLines: [error.toString()],
-        });
-        return null;
-    }
-}
-function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
-    let checkExists;
-    let readYaml;
-    let writeYaml;
-    if (typeof treeOrRoot === 'string') {
-        const configPath = (0, node_path_1.join)(treeOrRoot, filename);
-        checkExists = () => (0, node_fs_1.existsSync)(configPath);
-        readYaml = () => (0, node_fs_1.readFileSync)(configPath, 'utf-8');
-        writeYaml = (content) => (0, node_fs_1.writeFileSync)(configPath, content, 'utf-8');
-    }
-    else {
-        checkExists = () => treeOrRoot.exists(filename);
-        readYaml = () => treeOrRoot.read(filename, 'utf-8');
-        writeYaml = (content) => treeOrRoot.write(filename, content);
-    }
-    if (!checkExists()) {
-        devkit_exports_1.output.warn({
-            title: `No ${filename} found`,
-            bodyLines: [
-                `Cannot update catalog versions without a ${filename} file.`,
-                `Create a ${filename} file to use catalogs.`,
-            ],
-        });
-        return;
-    }
-    try {
-        // parseDocument keeps comments and anchors so a catalog bump doesn't
-        // rewrite the user's config file.
-        const lineCounter = new yaml_1.LineCounter();
-        const doc = (0, yaml_1.parseDocument)(readYaml(), { lineCounter });
-        // parseDocument collects syntax errors instead of throwing; surface them
-        // now, with their line/column detail, rather than failing later in
-        // `String(doc)` with a generic message or skipping a no-op write on a
-        // malformed file (the previous js-yaml `load()` threw here).
-        if (doc.errors.length > 0) {
-            throw new Error(doc.errors.map((e) => e.message).join('\n'));
-        }
-        // A dangling alias (`*ref` with no matching `&ref`) is not a syntax error,
-        // so parseDocument leaves it out of doc.errors. Surface it here with the
-        // same line/column detail the old js-yaml `load()` reported; otherwise a
-        // broken reference is silently overwritten or written back untouched.
-        const unresolvedAliases = [];
-        (0, yaml_1.visit)(doc, {
-            Alias(_key, node) {
-                if (node.resolve(doc) !== undefined)
-                    return;
-                const pos = node.range ? lineCounter.linePos(node.range[0]) : undefined;
-                unresolvedAliases.push(pos
-                    ? `Unresolved alias "${node.source}" at line ${pos.line}, column ${pos.col}`
-                    : `Unresolved alias "${node.source}"`);
-            },
-        });
-        if (unresolvedAliases.length > 0) {
-            throw new Error(unresolvedAliases.join('\n'));
-        }
-        let hasChanges = false;
-        for (const update of updates) {
-            const { packageName, version, catalogName } = update;
-            const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
-            let targetPath;
-            if (!normalizedCatalogName) {
-                // An empty `catalog:` placeholder must not claim the default route
-                // when `catalogs.default` is populated; that would create a
-                // duplicate-default config rejected by pnpm.
-                if (isMapAt(doc, ['catalog'])) {
-                    targetPath = ['catalog', packageName];
-                }
-                else if (existsAt(doc, ['catalogs', 'default'])) {
-                    targetPath = ['catalogs', 'default', packageName];
-                }
-                else {
-                    targetPath = ['catalog', packageName];
-                }
-            }
-            else {
-                targetPath = ['catalogs', normalizedCatalogName, packageName];
-            }
-            if (getValueAt(doc, targetPath) !== version) {
-                setThroughAliases(doc, targetPath, version);
-                hasChanges = true;
-            }
-        }
-        if (hasChanges) {
-            writeYaml(String(doc));
-        }
-    }
-    catch (error) {
-        devkit_exports_1.output.error({
-            title: 'Failed to update catalog versions',
-            bodyLines: [error instanceof Error ? error.message : String(error)],
-        });
-        throw error;
-    }
-}

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

@@ -1,40 +0,0 @@
-import type { Tree } from 'nx/src/devkit-exports';
-import type { CatalogDefinitions, CatalogReference } from './types';
-export declare function formatCatalogError(error: string, suggestions: string[]): string;
-/**
- * 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;
-    getCatalogDefinitionFilePaths(): string[];
-    /**
-     * Get catalog definitions from the workspace.
-     */
-    getCatalogDefinitions(workspaceRoot: string): CatalogDefinitions | null;
-    getCatalogDefinitions(tree: Tree): CatalogDefinitions | 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;
-}

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatCatalogError = formatCatalogError;
-function formatCatalogError(error, suggestions) {
-    let message = error;
-    if (suggestions.length > 0) {
-        message += '\n\nSuggestions:';
-        suggestions.forEach((suggestion) => {
-            message += `\n  • ${suggestion}`;
-        });
-    }
-    return message;
-}

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

@@ -1,21 +0,0 @@
-import { type Tree } from 'nx/src/devkit-exports';
-import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, 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;
-    getCatalogDefinitionFilePaths(): string[];
-    getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | 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;
-}