@storm-software/workspace-tools/dist/chunk-M2FFEHXU.js

Tools for managing a Storm workspace, including various Nx generators and executors for common development tasks.

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkWD2JTXUIjs = require('./chunk-WD2JTXUI.js');


var _chunkVWERGJQ6js = require('./chunk-VWERGJQ6.js');








var _chunkK7STHRGHjs = require('./chunk-K7STHRGH.js');


var _chunk4WHSR4FKjs = require('./chunk-4WHSR4FK.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/release/utils/update-lock-file');

// ../git-tools/src/types.ts
var DEFAULT_COMMIT_TYPES = {
  /* --- Bumps version when selected --- */
  chore: {
    description: "Other changes that don't modify src or test files",
    title: "Chore",
    emoji: "\u2699\uFE0F  ",
    semverBump: "patch",
    changelog: {
      title: "Miscellaneous",
      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
    }
  },
  feat: {
    description: "A change that adds a new feature to the package",
    title: "Feature",
    emoji: "\u{1F511} ",
    semverBump: "minor",
    changelog: {
      title: "Features",
      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
    }
  },
  refactor: {
    description: "A code change that neither fixes a bug nor adds a feature",
    title: "Code Refactoring",
    emoji: "\u{1F9EA} ",
    semverBump: "patch",
    changelog: {
      title: "Source Code Improvements",
      hidden: false
    }
  },
  style: {
    description: "Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)",
    title: "Style Improvements",
    emoji: "\u{1F48E} ",
    semverBump: "patch",
    changelog: {
      title: "Style Improvements",
      hidden: false
    }
  },
  perf: {
    description: "A code change that improves performance",
    title: "Performance Improvement",
    emoji: "\u23F1\uFE0F  ",
    semverBump: "patch",
    changelog: {
      title: "Performance Improvements",
      hidden: false
    }
  },
  /* --- Does not bump version when selected --- */
  docs: {
    description: "A change that only includes documentation updates",
    title: "Documentation",
    emoji: "\u{1F4DC} ",
    semverBump: "none",
    changelog: {
      title: "Documentation",
      hidden: false
    }
  },
  test: {
    description: "Adding missing tests or correcting existing tests",
    title: "Testing",
    emoji: "\u{1F6A8} ",
    semverBump: "none",
    changelog: {
      title: "Testing",
      hidden: true
    }
  },
  /* --- Not included in commitlint but included in changelog --- */
  deps: {
    description: "Changes that add, update, or remove dependencies. This includes devDependencies and peerDependencies",
    title: "Dependencies",
    emoji: "\u{1F4E6} ",
    hidden: true,
    semverBump: "patch",
    changelog: {
      title: "Dependency Upgrades",
      hidden: false
    }
  },
  /* --- Not included in commitlint or changelog --- */
  build: {
    description: "Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)",
    title: "Build",
    emoji: "\u{1F6E0} ",
    hidden: true,
    semverBump: "none",
    changelog: {
      title: "Build",
      hidden: true
    }
  },
  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: Object.keys(DEFAULT_COMMIT_TYPES).filter(
      (type) => DEFAULT_COMMIT_TYPES[type].hidden !== true
    ).reduce((ret, type) => {
      ret[type] = DEFAULT_COMMIT_TYPES[type];
      return ret;
    }, {}),
    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: (answers) => answers.isBreaking === true,
    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: (answers) => answers.isIssueAffected === true,
    maxLength: 600,
    minLength: 3
  }
};

// ../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 _versionlegacy = require('nx/src/command-line/release/version-legacy');
var _utils = require('nx/src/tasks-runner/utils');
var _semver3 = require('semver');
async function releaseVersionGeneratorFn(tree, options, config) {
  _chunkK7STHRGHjs.writeInfo.call(void 0, `\u26A1 Running the Storm Release Version generator...

`, config);
  const stopwatch = _chunkK7STHRGHjs.getStopwatch.call(void 0, "Storm Release Version generator");
  try {
    const workspaceRoot = _chunk4WHSR4FKjs.findWorkspaceRoot.call(void 0, );
    _chunkK7STHRGHjs.writeDebug.call(void 0, 
      `Loading the Storm Config from environment variables and storm.config.js file...
 - workspaceRoot: ${workspaceRoot}`,
      config
    );
    config = await _chunkVWERGJQ6js.getConfig.call(void 0, workspaceRoot);
    _chunkK7STHRGHjs.writeTrace.call(void 0, 
      `Generator schema options \u2699\uFE0F 
${Object.keys(_nullishCoalesce(options, () => ( {}))).filter(
        (key) => ![
          "projects",
          "releaseGroup",
          "projectGraph",
          "currentVersionResolverMetadata"
        ].includes(key)
      ).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 && _versionlegacy.validReleaseVersionPrefixes.indexOf(
      options.versionPrefix
    ) === -1) {
      throw new Error(
        `Invalid value for version.generatorOptions.versionPrefix: "${options.versionPrefix}"

Valid values are: ${_versionlegacy.validReleaseVersionPrefixes.map((s) => `"${s}"`).join(", ")}`
      );
    }
    options.fallbackCurrentVersionResolver ??= "disk";
    options.currentVersionResolver ??= "git-tag";
    const projects = options.projects;
    const createResolvePackageRoot = (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]), () => ( _chunk4WHSR4FKjs.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
      });
    };
    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]), () => ( _chunk4WHSR4FKjs.findWorkspaceRoot.call(void 0, ))),
        tree.exists(packageJsonPath) ? packageJsonPath : cargoTomlPath
      );
      const log = (msg) => {
        _chunkK7STHRGHjs.writeInfo.call(void 0, `${projectName}: ${msg}`, config);
      };
      _chunkK7STHRGHjs.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 = _chunkWD2JTXUIjs.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 = (log2) => {
              if (options.releaseGroup.name === _config.IMPLICIT_DEFAULT_RELEASE_GROUP) {
                return log2;
              }
              return `${log2} within release group "${options.releaseGroup.name}"`;
            };
            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 = _versionlegacy.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 = _chunkWD2JTXUIjs.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, _chunkWD2JTXUIjs.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 = _chunkWD2JTXUIjs.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"
          );
          _chunkWD2JTXUIjs.modifyCargoTable.call(void 0, 
            dependentPkg,
            dependentProject.dependencyCollection,
            dependentProject.target,
            updatedDependencyData
          );
          tree.write(cargoTomlToUpdate, _chunkWD2JTXUIjs.stringifyCargoToml.call(void 0, dependentPkg));
        }
      }
    }
    await _devkit.formatFiles.call(void 0, tree);
    _chunkK7STHRGHjs.writeSuccess.call(void 0, 
      `Completed running the Storm Release Version generator!
`,
      config
    );
    return {
      data: versionData,
      callback: 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;
      }
    };
  } catch (error) {
    _chunkK7STHRGHjs.writeFatal.call(void 0, 
      "A fatal error occurred while running the Storm Release Version generator - the process was forced to terminate",
      config
    );
    _chunkK7STHRGHjs.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();
  }
}
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";
}
function getGitHubRegistry() {
  if (process.env.STORM_REGISTRY_GITHUB) {
    return process.env.STORM_REGISTRY_GITHUB;
  }
  return "https://npm.pkg.github.com";
}
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;
  }
}
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
  );
}
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 = _chunkWD2JTXUIjs.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;
}




exports.releaseVersionGeneratorFn = releaseVersionGeneratorFn; exports.generator_default = generator_default;