@storm-software/workspace-tools 1.228.1 → 1.229.1

package/dist/chunk-7MZQTO7J.js

@@ -0,0 +1,726 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkZMFVKBRMjs = require('./chunk-ZMFVKBRM.js');
+
+
+
+
+
+
+
+
+
+var _chunk36FMHXUDjs = require('./chunk-36FMHXUD.js');
+
+
+var _chunk5MKQX2FEjs = require('./chunk-5MKQX2FE.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/generators/release-version/generator.ts
+var _devkit = require('@nx/devkit');
+var _resolvelocalpackagedependencies = require('@nx/js/src/generators/release-version/utils/resolve-local-package-dependencies');
+var _updatelockfile = require('@nx/js/src/generators/release-version/utils/update-lock-file');
+
+// ../git-tools/src/types.ts
+var DEFAULT_COMMIT_TYPES = {
+  chore: {
+    description: "Other changes that don't modify src or test files",
+    title: "Chore",
+    emoji: "\u2699\uFE0F  ",
+    semverBump: "patch",
+    changelog: {
+      title: "Miscellaneous",
+      hidden: false
+    }
+  },
+  ci: {
+    description: "Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)",
+    title: "Continuous Integration",
+    emoji: "\u{1F9F0} ",
+    semverBump: "patch",
+    changelog: {
+      title: "Continuous Integration",
+      hidden: false
+    }
+  },
+  deps: {
+    description: "Changes that add, update, or remove dependencies. This includes devDependencies and peerDependencies",
+    title: "Dependencies",
+    emoji: "\u{1F4E6} ",
+    semverBump: "patch",
+    changelog: {
+      title: "Dependency Upgrades",
+      hidden: false
+    }
+  },
+  docs: {
+    description: "A change that only includes documentation updates",
+    title: "Documentation",
+    emoji: "\u{1F4DC} ",
+    semverBump: "none",
+    changelog: {
+      title: "Documentation",
+      hidden: true
+    }
+  },
+  feat: {
+    description: "A change that adds a new feature to the package",
+    title: "Feature",
+    emoji: "\u{1F511} ",
+    semverBump: "minor",
+    changelog: {
+      title: "Features",
+      hidden: false
+    }
+  },
+  fix: {
+    description: "A change that resolves an issue previously identified with the package",
+    title: "Bug Fix",
+    emoji: "\u{1FAB2}  ",
+    semverBump: "patch",
+    changelog: {
+      title: "Bug Fixes",
+      hidden: false
+    }
+  },
+  perf: {
+    description: "A code change that improves performance",
+    title: "Performance Improvement",
+    emoji: "\u23F1\uFE0F  ",
+    semverBump: "none",
+    changelog: {
+      title: "Performance Improvements",
+      hidden: false
+    }
+  },
+  refactor: {
+    description: "A code change that neither fixes a bug nor adds a feature",
+    title: "Code Refactoring",
+    emoji: "\u{1F9EA} ",
+    semverBump: "patch",
+    changelog: {
+      title: "Code Improvements",
+      hidden: false
+    }
+  },
+  revert: {
+    description: "Revert a previously committed change",
+    title: "Revert",
+    emoji: "\u{1F5D1}\uFE0F ",
+    semverBump: "patch",
+    changelog: {
+      title: "Reverts",
+      hidden: false
+    }
+  },
+  style: {
+    description: "Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)",
+    title: "Styling",
+    emoji: "\u{1F48E} ",
+    semverBump: "minor",
+    changelog: {
+      title: "Styling",
+      hidden: false
+    }
+  },
+  test: {
+    description: "Adding missing tests or correcting existing tests",
+    title: "Testing",
+    emoji: "\u{1F6A8} ",
+    semverBump: "none",
+    changelog: {
+      title: "Testing",
+      hidden: true
+    }
+  },
+  types: {
+    description: "Changes that affect the project's type definitions",
+    title: "Type Definition",
+    emoji: "\u{1F4D3} ",
+    semverBump: "minor",
+    changelog: {
+      title: "Type Definitions",
+      hidden: false
+    }
+  },
+  release: {
+    description: "Publishing a commit containing a newly released version",
+    title: "Publish Release",
+    emoji: "\u{1F680} ",
+    hidden: true,
+    semverBump: "none",
+    changelog: {
+      title: "Publish Release",
+      hidden: true
+    }
+  }
+};
+var DEFAULT_COMMIT_QUESTIONS = {
+  type: {
+    type: "select",
+    title: "Commit Type",
+    description: "Select the commit type that best describes your changes",
+    enum: DEFAULT_COMMIT_TYPES,
+    defaultValue: "chore",
+    maxLength: 20,
+    minLength: 3
+  },
+  scope: {
+    type: "select",
+    title: "Commit Scope",
+    description: "Select the monorepo project that is primarily impacted by this change",
+    enum: {},
+    defaultValue: "monorepo",
+    maxLength: 50,
+    minLength: 1
+  },
+  subject: {
+    type: "input",
+    title: "Commit Subject",
+    description: "Write a short, imperative tense description of the change",
+    maxLength: 150,
+    minLength: 3
+  },
+  body: {
+    type: "input",
+    title: "Commit Body",
+    description: "Provide a longer description of the change",
+    maxLength: 600
+  },
+  isBreaking: {
+    type: "confirm",
+    title: "Breaking Changes",
+    description: "Are there any breaking changes as a result of this commit?",
+    defaultValue: false
+  },
+  breakingBody: {
+    type: "input",
+    title: "Breaking Changes (Details)",
+    description: "A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit itself",
+    when: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (answers) => answers.isBreaking === true, "when"),
+    maxLength: 600,
+    minLength: 3
+  },
+  isIssueAffected: {
+    type: "confirm",
+    title: "Open Issue Affected",
+    description: "Does this change impact any open issues?",
+    defaultValue: false
+  },
+  issuesBody: {
+    type: "input",
+    title: "Open Issue Affected (Details)",
+    description: "If issues are closed, the commit requires a body. Please enter a longer description of the commit itself",
+    when: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (answers) => answers.isIssueAffected === true, "when"),
+    maxLength: 600,
+    minLength: 3
+  }
+};
+var RuleConfigSeverity;
+(function(RuleConfigSeverity2) {
+  RuleConfigSeverity2[RuleConfigSeverity2["Disabled"] = 0] = "Disabled";
+  RuleConfigSeverity2[RuleConfigSeverity2["Warning"] = 1] = "Warning";
+  RuleConfigSeverity2[RuleConfigSeverity2["Error"] = 2] = "Error";
+})(RuleConfigSeverity || (RuleConfigSeverity = {}));
+
+// ../git-tools/src/release/changelog-renderer.ts
+var _index = require('nx/release/changelog-renderer/index'); var _index2 = _interopRequireDefault(_index);
+
+// ../git-tools/src/release/config.ts
+var DEFAULT_CONVENTIONAL_COMMITS_CONFIG = {
+  questions: DEFAULT_COMMIT_QUESTIONS,
+  types: DEFAULT_COMMIT_TYPES
+};
+
+// src/generators/release-version/generator.ts
+var _child_process = require('child_process');
+var _path = require('path');
+var _config = require('nx/src/command-line/release/config/config');
+var _git = require('nx/src/command-line/release/utils/git');
+var _resolvesemverspecifier = require('nx/src/command-line/release/utils/resolve-semver-specifier');
+var _semver = require('nx/src/command-line/release/utils/semver');
+var _version = require('nx/src/command-line/release/version');
+var _utils = require('nx/src/tasks-runner/utils');
+var _semver3 = require('semver');
+async function releaseVersionGeneratorFn(tree, options, config) {
+  _chunk36FMHXUDjs.writeInfo.call(void 0, `\u26A1 Running the Storm Release Version generator...
+
+`, config);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, "Storm Release Version generator");
+  try {
+    const workspaceRoot = _chunk5MKQX2FEjs.findWorkspaceRoot.call(void 0, );
+    _chunk36FMHXUDjs.writeDebug.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}`, config);
+    config = await _chunk36FMHXUDjs.loadStormConfig.call(void 0, workspaceRoot);
+    _chunk36FMHXUDjs.writeTrace.call(void 0, `Generator schema options \u2699\uFE0F 
+${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`, config);
+    const versionData = {};
+    if (options.specifier) {
+      if (!_semver.isValidSemverSpecifier.call(void 0, options.specifier)) {
+        throw new Error(`The given version specifier "${options.specifier}" is not valid. You provide an exact version or a valid semver keyword such as "major", "minor", "patch", etc.`);
+      }
+      options.specifier = options.specifier.replace(/^v/, "");
+    }
+    if (options.versionPrefix && _version.validReleaseVersionPrefixes.indexOf(options.versionPrefix) === -1) {
+      throw new Error(`Invalid value for version.generatorOptions.versionPrefix: "${options.versionPrefix}"
+
+Valid values are: ${_version.validReleaseVersionPrefixes.map((s) => `"${s}"`).join(", ")}`);
+    }
+    options.fallbackCurrentVersionResolver ??= "disk";
+    const projects = options.projects;
+    const createResolvePackageRoot = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (customPackageRoot) => (projectNode) => {
+      if (_optionalChain([projectNode, 'optionalAccess', _3 => _3.data, 'optionalAccess', _4 => _4.root]) === _optionalChain([config, 'optionalAccess', _5 => _5.workspaceRoot]) || _optionalChain([projectNode, 'optionalAccess', _6 => _6.data, 'optionalAccess', _7 => _7.root]) === ".") {
+        return _nullishCoalesce(_optionalChain([config, 'optionalAccess', _8 => _8.workspaceRoot]), () => ( _chunk5MKQX2FEjs.findWorkspaceRoot.call(void 0, )));
+      }
+      if (!customPackageRoot) {
+        return projectNode.data.root;
+      }
+      return _utils.interpolate.call(void 0, customPackageRoot, {
+        workspaceRoot: "",
+        projectRoot: projectNode.data.root,
+        projectName: projectNode.name
+      });
+    }, "createResolvePackageRoot");
+    const resolvePackageRoot = createResolvePackageRoot(options.packageRoot);
+    const projectNameToPackageRootMap = /* @__PURE__ */ new Map();
+    for (const project of projects) {
+      projectNameToPackageRootMap.set(project.name, resolvePackageRoot(project));
+    }
+    let currentVersion = null;
+    let currentVersionResolvedFromFallback = false;
+    let latestMatchingGitTag = null;
+    let specifier = options.specifier ? options.specifier : void 0;
+    for (const project of projects) {
+      const projectName = project.name;
+      const packageRoot = projectNameToPackageRootMap.get(projectName);
+      const packageJsonPath = _devkit.joinPathFragments.call(void 0, _nullishCoalesce(packageRoot, () => ( "./")), "package.json");
+      const cargoTomlPath = _devkit.joinPathFragments.call(void 0, _nullishCoalesce(packageRoot, () => ( "./")), "Cargo.toml");
+      if (!tree.exists(packageJsonPath) && !tree.exists(cargoTomlPath)) {
+        throw new Error(`The project "${projectName}" does not have a package.json available at ${packageJsonPath} or a Cargo.toml file available at ${cargoTomlPath}.
+
+To fix this you will either need to add a package.json or Cargo.toml file at that location, or configure "release" within your nx.json to exclude "${projectName}" from the current release group, or amend the packageRoot configuration to point to where the package.json should be.`);
+      }
+      const workspaceRelativePackagePath = _path.relative.call(void 0, _nullishCoalesce(_optionalChain([config, 'optionalAccess', _9 => _9.workspaceRoot]), () => ( _chunk5MKQX2FEjs.findWorkspaceRoot.call(void 0, ))), tree.exists(packageJsonPath) ? packageJsonPath : cargoTomlPath);
+      const log = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (msg) => {
+        _chunk36FMHXUDjs.writeInfo.call(void 0, `${projectName}: ${msg}`, config);
+      }, "log");
+      _chunk36FMHXUDjs.writeInfo.call(void 0, `Running release version for project: ${project.name}`, config);
+      let packageName;
+      let currentVersionFromDisk;
+      if (tree.exists(packageJsonPath)) {
+        const projectPackageJson = _devkit.readJson.call(void 0, tree, packageJsonPath);
+        log(`\u{1F50D} Reading data for package "${projectPackageJson.name}" from ${workspaceRelativePackagePath}`);
+        packageName = projectPackageJson.name;
+        currentVersionFromDisk = projectPackageJson.version;
+      } else if (tree.exists(cargoTomlPath)) {
+        const cargoToml = _chunkZMFVKBRMjs.parseCargoToml.call(void 0, _optionalChain([tree, 'access', _10 => _10.read, 'call', _11 => _11(cargoTomlPath), 'optionalAccess', _12 => _12.toString, 'call', _13 => _13("utf-8")]));
+        log(`\u{1F50D} Reading data for package "${cargoToml.package.name}" from ${workspaceRelativePackagePath}`);
+        packageName = cargoToml.package.name;
+        currentVersionFromDisk = cargoToml.package.version;
+        if (options.currentVersionResolver === "registry") {
+          options.currentVersionResolver = "disk";
+        }
+      } else {
+        throw new Error(`The project "${projectName}" does not have a package.json available at ${workspaceRelativePackagePath} or a Cargo.toml file available at ${cargoTomlPath}.
+
+To fix this you will either need to add a package.json or Cargo.toml file at that location, or configure "release" within your nx.json to exclude "${projectName}" from the current release group, or amend the packageRoot configuration to point to where the package.json should be.`);
+      }
+      switch (options.currentVersionResolver) {
+        case "registry": {
+          const metadata = options.currentVersionResolverMetadata;
+          const npmRegistry = await _asyncNullishCoalesce(await _asyncOptionalChain([metadata, 'optionalAccess', async _14 => _14.registry]), async () => ( await getNpmRegistry()));
+          const githubRegistry = await _asyncNullishCoalesce(await _asyncOptionalChain([metadata, 'optionalAccess', async _15 => _15.registry]), async () => ( await getGitHubRegistry()));
+          const tag = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _16 => _16.tag]), () => ( "latest"));
+          if (options.releaseGroup.projectsRelationship === "independent") {
+            try {
+              currentVersion = await new Promise((resolve, reject) => {
+                _child_process.exec.call(void 0, `npm view ${packageName} version --registry=${npmRegistry} --tag=${tag}`, (error, stdout, stderr) => {
+                  if (error) {
+                    return reject(error);
+                  }
+                  if (stderr) {
+                    return reject(stderr);
+                  }
+                  return resolve(stdout.trim());
+                });
+              });
+              log(`\u{1F4C4} Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${npmRegistry}`);
+            } catch (_) {
+              try {
+                currentVersion = await new Promise((resolve, reject) => {
+                  _child_process.exec.call(void 0, `npm view ${packageName} version --registry=${githubRegistry} --tag=${tag}`, (error, stdout, stderr) => {
+                    if (error) {
+                      return reject(error);
+                    }
+                    if (stderr) {
+                      return reject(stderr);
+                    }
+                    return resolve(stdout.trim());
+                  });
+                });
+                log(`\u{1F4C4} Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${githubRegistry}`);
+              } catch (_2) {
+                if (options.fallbackCurrentVersionResolver === "disk") {
+                  log(`\u{1F4C4} Unable to resolve the current version from the registry ${npmRegistry}${githubRegistry ? ` or ${githubRegistry}` : ""}. Falling back to the version on disk of ${currentVersionFromDisk}`);
+                  currentVersion = currentVersionFromDisk;
+                  currentVersionResolvedFromFallback = true;
+                } else {
+                  throw new Error(`Unable to resolve the current version from the registry ${npmRegistry}${githubRegistry ? ` or ${githubRegistry}` : ""}. Please ensure that the package exists in the registry in order to use the "registry" currentVersionResolver. Alternatively, you can use the --first-release option or set "release.version.generatorOptions.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when the registry lookup fails.`);
+                }
+              }
+            }
+          } else {
+            if (currentVersionResolvedFromFallback) {
+              log(`\u{1F4C4} Using the current version ${currentVersion} already resolved from disk fallback.`);
+            } else {
+              log(`\u{1F4C4} Using the current version ${currentVersion} already resolved from the registry ${_nullishCoalesce(npmRegistry, () => ( githubRegistry))}`);
+            }
+          }
+          break;
+        }
+        case "disk":
+          currentVersion = currentVersionFromDisk;
+          log(`\u{1F4C4} Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
+          break;
+        case "git-tag": {
+          if (
+            // We always need to independently resolve the current version from git tag per project if the projects are independent
+            options.releaseGroup.projectsRelationship === "independent"
+          ) {
+            const releaseTagPattern = options.releaseGroup.releaseTagPattern;
+            latestMatchingGitTag = await _git.getLatestGitTagForPattern.call(void 0, releaseTagPattern, {
+              projectName: project.name
+            });
+            if (!latestMatchingGitTag) {
+              if (currentVersionFromDisk) {
+                log(`\u{1F4C4} Unable to resolve the current version from git tag using pattern "${releaseTagPattern}". Falling back to the version on disk of ${currentVersionFromDisk}`);
+                currentVersion = currentVersionFromDisk;
+              } else {
+                log(`No git tags matching pattern "${releaseTagPattern}" for project "${project.name}" were found. This process also could not determine the version by checking the package files on disk, so we will attempt to use the default version value: "0.0.1".`);
+                currentVersion = "0.0.1";
+              }
+              currentVersionResolvedFromFallback = true;
+            } else {
+              currentVersion = latestMatchingGitTag.extractedVersion;
+              log(`\u{1F4C4} Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}".`);
+            }
+          } else {
+            if (currentVersionResolvedFromFallback) {
+              log(`\u{1F4C4} Using the current version ${currentVersion} already resolved from disk fallback.`);
+            } else {
+              log(`\u{1F4C4} Using the current version ${currentVersion} already resolved from git tag "${latestMatchingGitTag.tag}".`);
+            }
+          }
+          break;
+        }
+        default:
+          throw new Error(`Invalid value for options.currentVersionResolver: ${options.currentVersionResolver}`);
+      }
+      if (options.specifier) {
+        log(`\u{1F4C4} Using the provided version specifier "${options.specifier}".`);
+      }
+      if (specifier === void 0 || options.releaseGroup.projectsRelationship === "independent" && !options.specifier) {
+        const specifierSource = options.specifierSource;
+        switch (specifierSource) {
+          case "conventional-commits": {
+            if (options.currentVersionResolver !== "git-tag") {
+              throw new Error(`Invalid currentVersionResolver "${options.currentVersionResolver}" provided for release group "${options.releaseGroup.name}". Must be "git-tag" when "specifierSource" is "conventional-commits"`);
+            }
+            const affectedProjects = options.releaseGroup.projectsRelationship === "independent" ? [
+              projectName
+            ] : projects.map((p) => p.name);
+            let previousVersionRef = _optionalChain([latestMatchingGitTag, 'optionalAccess', _17 => _17.tag]) ? latestMatchingGitTag.tag : await _git.getFirstGitCommit.call(void 0, );
+            if (!previousVersionRef) {
+              log(`Unable to determine previous version ref for the projects ${affectedProjects.join(", ")}. This is likely a bug in Storm's Release Versioning. We will attempt to use the default version value "0.0.1" and continue with the process.`);
+              previousVersionRef = "0.0.1";
+            }
+            specifier = await _asyncNullishCoalesce(await _resolvesemverspecifier.resolveSemverSpecifierFromConventionalCommits.call(void 0, previousVersionRef, options.projectGraph, affectedProjects, DEFAULT_CONVENTIONAL_COMMITS_CONFIG), async () => ( void 0));
+            if (!specifier) {
+              log("\u{1F6AB} No changes were detected using git history and the conventional commits standard.");
+              break;
+            }
+            if (currentVersion && _semver3.prerelease.call(void 0, currentVersion)) {
+              specifier = "prerelease";
+              log(`\u{1F4C4} Resolved the specifier as "${specifier}" since the current version is a prerelease.`);
+            } else {
+              log(`\u{1F4C4} Resolved the specifier as "${specifier}" using git history and the conventional commits standard.`);
+            }
+            break;
+          }
+          case "prompt": {
+            const maybeLogReleaseGroup = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (log2) => {
+              if (options.releaseGroup.name === _config.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                return log2;
+              }
+              return `${log2} within release group "${options.releaseGroup.name}"`;
+            }, "maybeLogReleaseGroup");
+            if (options.releaseGroup.projectsRelationship === "independent") {
+              specifier = await _resolvesemverspecifier.resolveSemverSpecifierFromPrompt.call(void 0, `${maybeLogReleaseGroup(`What kind of change is this for project "${projectName}"`)}?`, `${maybeLogReleaseGroup(`What is the exact version for project "${projectName}"`)}?`);
+            } else {
+              specifier = await _resolvesemverspecifier.resolveSemverSpecifierFromPrompt.call(void 0, `${maybeLogReleaseGroup(`What kind of change is this for the ${projects.length} matched projects(s)`)}?`, `${maybeLogReleaseGroup(`What is the exact version for the ${projects.length} matched project(s)`)}?`);
+            }
+            break;
+          }
+          default:
+            throw new Error(`Invalid specifierSource "${specifierSource}" provided. Must be one of "prompt" or "conventional-commits"`);
+        }
+      }
+      const localPackageDependencies = resolveLocalPackageDependencies(
+        tree,
+        options.projectGraph,
+        projects.filter((project2) => _optionalChain([project2, 'optionalAccess', _18 => _18.data, 'optionalAccess', _19 => _19.root]) && _optionalChain([project2, 'optionalAccess', _20 => _20.data, 'optionalAccess', _21 => _21.root]) !== _optionalChain([config, 'optionalAccess', _22 => _22.workspaceRoot])),
+        projectNameToPackageRootMap,
+        resolvePackageRoot,
+        // includeAll when the release group is independent, as we may be filtering to a specific subset of projects, but we still want to update their dependents
+        options.releaseGroup.projectsRelationship === "independent",
+        tree.exists(packageJsonPath)
+      );
+      const dependentProjects = Object.values(localPackageDependencies).flat().filter((localPackageDependency) => {
+        return localPackageDependency.target === project.name;
+      });
+      if (!currentVersion) {
+        throw new Error(`Unable to determine the current version for project "${projectName}"`);
+      }
+      versionData[projectName] = {
+        currentVersion: currentVersion ? currentVersion : "0.0.1",
+        dependentProjects,
+        newVersion: null
+        // will stay as null in the final result in the case that no changes are detected
+      };
+      if (!specifier) {
+        log(`\u{1F6AB} Skipping versioning "${packageName}" as no changes were detected.`);
+        continue;
+      }
+      const newVersion = _version.deriveNewSemverVersion.call(void 0, currentVersion, specifier, options.preid);
+      if (versionData[projectName]) {
+        versionData[projectName].newVersion = newVersion;
+      }
+      if (tree.exists(packageJsonPath)) {
+        const projectPackageJson = _devkit.readJson.call(void 0, tree, packageJsonPath);
+        _devkit.writeJson.call(void 0, tree, packageJsonPath, {
+          ...projectPackageJson,
+          version: newVersion
+        });
+      } else if (tree.exists(cargoTomlPath)) {
+        const cargoToml = _chunkZMFVKBRMjs.parseCargoToml.call(void 0, _optionalChain([tree, 'access', _23 => _23.read, 'call', _24 => _24(cargoTomlPath), 'optionalAccess', _25 => _25.toString, 'call', _26 => _26("utf-8")]));
+        cargoToml.package ??= {};
+        cargoToml.package.version = newVersion;
+        tree.write(cargoTomlPath, _chunkZMFVKBRMjs.stringifyCargoToml.call(void 0, cargoToml));
+      }
+      log(`\u270D\uFE0F  New version ${newVersion} written to ${workspaceRelativePackagePath}`);
+      if (dependentProjects.length > 0) {
+        log(`\u270D\uFE0F  Applying new version ${newVersion} to ${dependentProjects.length} ${dependentProjects.length > 1 ? "packages which depend" : "package which depends"} on ${project.name}`);
+      }
+      for (const dependentProject of dependentProjects) {
+        const dependentPackageRoot = projectNameToPackageRootMap.get(dependentProject.source);
+        if (!dependentPackageRoot) {
+          throw new Error(`The dependent project "${dependentProject.source}" does not have a packageRoot available.
+
+Projects with packageRoot configured: ${Array.from(projectNameToPackageRootMap.keys()).join(", ")}`);
+        }
+        const dependentPackageJsonPath = _devkit.joinPathFragments.call(void 0, dependentPackageRoot, "package.json");
+        const dependentCargoTomlPath = _devkit.joinPathFragments.call(void 0, dependentPackageRoot, "Cargo.toml");
+        if (tree.exists(dependentPackageJsonPath)) {
+          _devkit.updateJson.call(void 0, tree, dependentPackageJsonPath, (json) => {
+            let versionPrefix = _nullishCoalesce(options.versionPrefix, () => ( "auto"));
+            if (versionPrefix === "auto") {
+              versionPrefix = "";
+              const current = json[dependentProject.dependencyCollection][packageName];
+              if (current) {
+                const prefixMatch = current.match(/^[~^]/);
+                if (prefixMatch) {
+                  versionPrefix = prefixMatch[0];
+                } else {
+                  versionPrefix = "";
+                }
+              }
+            }
+            json[dependentProject.dependencyCollection][packageName] = `${versionPrefix}${newVersion}`;
+            return json;
+          });
+        } else if (tree.exists(dependentCargoTomlPath)) {
+          const dependentPkg = _chunkZMFVKBRMjs.parseCargoTomlWithTree.call(void 0, tree, dependentPackageRoot, dependentProject.source);
+          let versionPrefix = _nullishCoalesce(options.versionPrefix, () => ( "auto"));
+          let updatedDependencyData = "";
+          for (const dependency of Object.entries(_nullishCoalesce(dependentPkg[dependentProject.dependencyCollection], () => ( {})))) {
+            const [dependencyName, dependencyData] = dependency;
+            if (dependencyName !== dependentProject.target) {
+              continue;
+            }
+            if (versionPrefix === "auto") {
+              versionPrefix = "";
+              if (currentVersion) {
+                const dependencyVersion = typeof dependencyData === "string" ? dependencyData : dependencyData.version;
+                const prefixMatch = _optionalChain([dependencyVersion, 'optionalAccess', _27 => _27.match, 'call', _28 => _28(/^[~^=]/)]);
+                if (prefixMatch) {
+                  versionPrefix = prefixMatch[0];
+                } else {
+                  versionPrefix = "";
+                }
+                if (versionPrefix === "^") {
+                  if (typeof dependencyData !== "string" && !_optionalChain([dependencyData, 'access', _29 => _29.version, 'optionalAccess', _30 => _30.startsWith, 'call', _31 => _31("^")])) {
+                    versionPrefix = "";
+                  }
+                }
+              }
+            }
+            const newVersionWithPrefix = `${versionPrefix}${newVersion}`;
+            updatedDependencyData = typeof dependencyData === "string" ? newVersionWithPrefix : {
+              ...dependencyData,
+              version: newVersionWithPrefix
+            };
+            break;
+          }
+          const cargoTomlToUpdate = _devkit.joinPathFragments.call(void 0, dependentPackageRoot, "Cargo.toml");
+          _chunkZMFVKBRMjs.modifyCargoTable.call(void 0, dependentPkg, dependentProject.dependencyCollection, dependentProject.target, updatedDependencyData);
+          tree.write(cargoTomlToUpdate, _chunkZMFVKBRMjs.stringifyCargoToml.call(void 0, dependentPkg));
+        }
+      }
+    }
+    await _devkit.formatFiles.call(void 0, tree);
+    _chunk36FMHXUDjs.writeSuccess.call(void 0, `Completed running the Storm Release Version generator!
+`, config);
+    return {
+      data: versionData,
+      callback: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (tree2, opts) => {
+        _devkit.output.logSingleLine("Updating Cargo.lock file");
+        const cwd = tree2.root;
+        const updatedFiles = await _asyncNullishCoalesce(await _updatelockfile.updateLockFile.call(void 0, cwd, opts), async () => ( []));
+        const updatedCargoPackages = [];
+        for (const [projectName, projectVersionData] of Object.entries(versionData)) {
+          const project = projects.find((proj) => proj.name === projectName);
+          if (projectVersionData.newVersion && _optionalChain([project, 'optionalAccess', _32 => _32.name]) && projectNameToPackageRootMap.get(project.name)) {
+            const projectRoot = projectNameToPackageRootMap.get(project.name);
+            if (projectRoot && tree2.exists(_devkit.joinPathFragments.call(void 0, projectRoot, "Cargo.toml"))) {
+              updatedCargoPackages.push(projectName);
+            }
+          }
+        }
+        if (updatedCargoPackages.length > 0) {
+          _child_process.execSync.call(void 0, `cargo update ${updatedCargoPackages.join(" ")}`, {
+            maxBuffer: 1024 * 1024 * 1024,
+            env: {
+              ...process.env
+            },
+            cwd: tree2.root
+          });
+          if (hasGitDiff("Cargo.lock")) {
+            updatedFiles.push("Cargo.lock");
+          }
+        }
+        return updatedFiles;
+      }, "callback")
+    };
+  } catch (error) {
+    _chunk36FMHXUDjs.writeFatal.call(void 0, "A fatal error occurred while running the Storm Release Version generator - the process was forced to terminate", config);
+    _chunk36FMHXUDjs.writeError.call(void 0, `An exception was thrown in the Storm Release Version generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    throw new Error(`An exception was thrown in the Storm Release Version generator's process 
+ - Details: ${error.message}`, {
+      cause: error
+    });
+  } finally {
+    stopwatch();
+  }
+}
+_chunk3GQAWCBQjs.__name.call(void 0, releaseVersionGeneratorFn, "releaseVersionGeneratorFn");
+var generator_default = releaseVersionGeneratorFn;
+async function getNpmRegistry() {
+  if (process.env.STORM_REGISTRY_NPM) {
+    return process.env.STORM_REGISTRY_NPM;
+  }
+  const registry = await new Promise((resolve, reject) => {
+    _child_process.exec.call(void 0, "npm config get registry", (error, stdout, stderr) => {
+      if (error) {
+        return reject(error);
+      }
+      if (stderr) {
+        return reject(stderr);
+      }
+      return resolve(stdout.trim());
+    });
+  });
+  return registry ? registry : "https://registry.npmjs.org";
+}
+_chunk3GQAWCBQjs.__name.call(void 0, getNpmRegistry, "getNpmRegistry");
+function getGitHubRegistry() {
+  if (process.env.STORM_REGISTRY_GITHUB) {
+    return process.env.STORM_REGISTRY_GITHUB;
+  }
+  return "https://npm.pkg.github.com";
+}
+_chunk3GQAWCBQjs.__name.call(void 0, getGitHubRegistry, "getGitHubRegistry");
+function hasGitDiff(filePath) {
+  try {
+    const result = _child_process.execSync.call(void 0, `git diff --name-only "${filePath}"`).toString();
+    return result.trim() === filePath;
+  } catch (_) {
+    return false;
+  }
+}
+_chunk3GQAWCBQjs.__name.call(void 0, hasGitDiff, "hasGitDiff");
+function resolveLocalPackageDependencies(tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll = false, isNodeProject = true) {
+  if (isNodeProject) {
+    return _resolvelocalpackagedependencies.resolveLocalPackageDependencies.call(void 0, tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll);
+  }
+  return resolveLocalPackageCargoDependencies(tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, resolveLocalPackageDependencies, "resolveLocalPackageDependencies");
+function resolveLocalPackageCargoDependencies(tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll = false) {
+  const localPackageDependencies = {};
+  const projects = includeAll ? Object.values(projectGraph.nodes) : filteredProjects;
+  for (const projectNode of projects) {
+    let packageRoot = projectNameToPackageRootMap.get(projectNode.name);
+    if (!packageRoot && includeAll) {
+      packageRoot = resolvePackageRoot(projectNode);
+      if (!packageRoot) {
+        continue;
+      }
+      projectNameToPackageRootMap.set(projectNode.name, packageRoot);
+    }
+    const cargoTomlPath = _devkit.joinPathFragments.call(void 0, _nullishCoalesce(packageRoot, () => ( "./")), "Cargo.toml");
+    if (!tree.exists(cargoTomlPath)) {
+      continue;
+    }
+    const projectDeps = projectGraph.dependencies[projectNode.name];
+    if (!projectDeps) {
+      continue;
+    }
+    const localPackageDepsForProject = [];
+    for (const dep of projectDeps) {
+      const depProject = projectGraph.nodes[dep.target];
+      if (!depProject) {
+        continue;
+      }
+      const depProjectRoot = projectNameToPackageRootMap.get(dep.target);
+      if (!depProjectRoot) {
+        throw new Error(`The project "${dep.target}" does not have a packageRoot available.`);
+      }
+      const cargoToml = _chunkZMFVKBRMjs.parseCargoTomlWithTree.call(void 0, tree, resolvePackageRoot(projectNode), projectNode.name);
+      const dependencies = _nullishCoalesce(cargoToml.dependencies, () => ( {}));
+      const devDependencies = _nullishCoalesce(cargoToml["dev-dependencies"], () => ( {}));
+      const dependencyCollection = dependencies[depProject.name] ? "dependencies" : devDependencies[depProject.name] ? "dev-dependencies" : null;
+      if (!dependencyCollection) {
+        throw new Error(`The project "${projectNode.name}" does not have a local dependency on "${depProject.name}" in its Cargo.toml`);
+      }
+      localPackageDepsForProject.push({
+        ...dep,
+        dependencyCollection
+      });
+    }
+    localPackageDependencies[projectNode.name] = localPackageDepsForProject;
+  }
+  return localPackageDependencies;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, resolveLocalPackageCargoDependencies, "resolveLocalPackageCargoDependencies");
+
+
+
+
+exports.releaseVersionGeneratorFn = releaseVersionGeneratorFn; exports.generator_default = generator_default;