@backstage/cli 0.13.1-next.1 → 0.14.0

package/dist/cjs/build-8fe538f0.cjs.js

@@ -0,0 +1,173 @@
+'use strict';
+
+var chalk = require('chalk');
+var path = require('path');
+var packager = require('./packager-8f82846e.cjs.js');
+var PackageGraph = require('./PackageGraph-d7b9d768.cjs.js');
+var parallel = require('./parallel-d8e5bcbf.cjs.js');
+var index = require('./index-2b8588e8.cjs.js');
+var packageRoles = require('./packageRoles-f375a99e.cjs.js');
+var buildBackend = require('./buildBackend-1727e26d.cjs.js');
+require('fs-extra');
+require('rollup');
+require('rollup-plugin-peer-deps-external');
+require('@rollup/plugin-commonjs');
+require('@rollup/plugin-node-resolve');
+require('rollup-plugin-postcss');
+require('rollup-plugin-esbuild');
+require('@svgr/rollup');
+require('rollup-plugin-dts');
+require('@rollup/plugin-json');
+require('@rollup/plugin-yaml');
+require('rollup-pluginutils');
+require('./svgrTemplate-b7a4ee52.cjs.js');
+require('@manypkg/get-packages');
+require('@backstage/errors');
+require('child_process');
+require('util');
+require('os');
+require('worker_threads');
+require('commander');
+require('semver');
+require('@backstage/cli-common');
+require('@backstage/config/package.json');
+require('zod');
+require('webpack');
+require('fork-ts-checker-webpack-plugin');
+require('html-webpack-plugin');
+require('react-dev-utils/ModuleScopePlugin');
+require('run-script-webpack-plugin');
+require('webpack-node-externals');
+require('./paths-8e0b151d.cjs.js');
+require('mini-css-extract-plugin');
+require('./run-d3528c59.cjs.js');
+require('eslint-webpack-plugin');
+require('lodash/pickBy');
+require('./bundle-cfe3be2c.cjs.js');
+require('yn');
+require('react-dev-utils/FileSizeReporter');
+require('react-dev-utils/formatWebpackMessages');
+require('webpack-dev-server');
+require('react-dev-utils/openBrowser');
+require('./config-147bac17.cjs.js');
+require('@backstage/config-loader');
+require('@backstage/config');
+require('tar');
+require('./createDistWorkspace-59a08943.cjs.js');
+require('lodash/partition');
+require('npm-packlist');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+
+function createScriptOptionsParser(anyCmd, commandPath) {
+  let rootCmd = anyCmd;
+  while (rootCmd.parent) {
+    rootCmd = rootCmd.parent;
+  }
+  let targetCmd = rootCmd;
+  for (const name of commandPath) {
+    targetCmd = targetCmd == null ? void 0 : targetCmd.commands.find((c) => c.name() === name);
+  }
+  if (!targetCmd) {
+    throw new Error(`Could not find package command '${commandPath.join(" ")}'`);
+  }
+  const cmd = targetCmd;
+  const expectedScript = `backstage-cli ${commandPath.join(" ")}`;
+  return (scriptStr) => {
+    if (!scriptStr || !scriptStr.startsWith(expectedScript)) {
+      return void 0;
+    }
+    const argsStr = scriptStr.slice(expectedScript.length).trim();
+    const currentOpts = cmd._optionValues;
+    const currentStore = cmd._storeOptionsAsProperties;
+    const result = {};
+    cmd._storeOptionsAsProperties = false;
+    cmd._optionValues = result;
+    cmd.parseOptions(argsStr.split(" "));
+    cmd._storeOptionsAsProperties = currentOpts;
+    cmd._optionValues = currentStore;
+    return result;
+  };
+}
+async function command(cmd) {
+  const packages = await PackageGraph.PackageGraph.listTargetPackages();
+  const apps = new Array();
+  const backends = new Array();
+  const parseBuildScript = createScriptOptionsParser(cmd, ["package", "build"]);
+  const options = packages.flatMap((pkg) => {
+    var _a, _b, _c;
+    const role = (_b = (_a = pkg.packageJson.backstage) == null ? void 0 : _a.role) != null ? _b : packageRoles.detectRoleFromPackage(pkg.packageJson);
+    if (!role) {
+      console.warn(`Ignored ${pkg.packageJson.name} because it has no role`);
+      return [];
+    }
+    if (role === "frontend") {
+      apps.push(pkg);
+      return [];
+    } else if (role === "backend") {
+      backends.push(pkg);
+      return [];
+    }
+    const outputs = packager.getOutputsForRole(role);
+    if (outputs.size === 0) {
+      console.warn(`Ignored ${pkg.packageJson.name} because it has no output`);
+      return [];
+    }
+    const buildOptions = parseBuildScript((_c = pkg.packageJson.scripts) == null ? void 0 : _c.build);
+    if (!buildOptions) {
+      console.warn(`Ignored ${pkg.packageJson.name} because it does not have a matching build script`);
+      return [];
+    }
+    return {
+      targetDir: pkg.dir,
+      outputs,
+      logPrefix: `${chalk__default["default"].cyan(path.relative(index.paths.targetRoot, pkg.dir))}: `,
+      minify: buildOptions.minify,
+      useApiExtractor: buildOptions.experimentalTypeBuild
+    };
+  });
+  console.log("Building packages");
+  await packager.buildPackages(options);
+  if (cmd.all) {
+    console.log("Building apps");
+    await parallel.runParallelWorkers({
+      items: apps,
+      parallelismFactor: 1 / 2,
+      worker: async (pkg) => {
+        var _a, _b;
+        const buildOptions = parseBuildScript((_a = pkg.packageJson.scripts) == null ? void 0 : _a.build);
+        if (!buildOptions) {
+          console.warn(`Ignored ${pkg.packageJson.name} because it does not have a matching build script`);
+          return;
+        }
+        await buildBackend.buildFrontend({
+          targetDir: pkg.dir,
+          configPaths: (_b = buildOptions.config) != null ? _b : [],
+          writeStats: Boolean(buildOptions.stats)
+        });
+      }
+    });
+    console.log("Building backends");
+    await parallel.runParallelWorkers({
+      items: backends,
+      parallelismFactor: 1 / 2,
+      worker: async (pkg) => {
+        var _a;
+        const buildOptions = parseBuildScript((_a = pkg.packageJson.scripts) == null ? void 0 : _a.build);
+        if (!buildOptions) {
+          console.warn(`Ignored ${pkg.packageJson.name} because it does not have a matching build script`);
+          return;
+        }
+        await buildBackend.buildBackend({
+          targetDir: pkg.dir,
+          skipBuildDependencies: true
+        });
+      }
+    });
+  }
+}
+
+exports.command = command;
+//# sourceMappingURL=build-8fe538f0.cjs.js.map

package/dist/cjs/{build-a0537ac0.cjs.js → build-ef788e26.cjs.js}

@@ -1,11 +1,11 @@
 'use strict';
 
-var packager = require('./packager-89d7686b.cjs.js');
+var packager = require('./packager-8f82846e.cjs.js');
 require('fs-extra');
 require('rollup');
 require('chalk');
 require('path');
-require('./index-db3186f9.cjs.js');
+require('./index-2b8588e8.cjs.js');
 require('commander');
 require('semver');
 require('@backstage/cli-common');
@@ -21,7 +21,12 @@ require('rollup-plugin-dts');
 require('@rollup/plugin-json');
 require('@rollup/plugin-yaml');
 require('rollup-pluginutils');
-require('./svgrTemplate-f19e974c.cjs.js');
+require('./svgrTemplate-b7a4ee52.cjs.js');
+require('./parallel-d8e5bcbf.cjs.js');
+require('os');
+require('worker_threads');
+require('./packageRoles-f375a99e.cjs.js');
+require('zod');
 
 var build = async (cmd) => {
   await packager.buildPackage({
@@ -32,4 +37,4 @@ var build = async (cmd) => {
 };
 
 exports["default"] = build;
-//# sourceMappingURL=build-a0537ac0.cjs.js.map
+//# sourceMappingURL=build-ef788e26.cjs.js.map

package/dist/cjs/buildBackend-1727e26d.cjs.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+require('webpack');
+require('chalk');
+require('fork-ts-checker-webpack-plugin');
+require('html-webpack-plugin');
+require('react-dev-utils/ModuleScopePlugin');
+require('run-script-webpack-plugin');
+require('webpack-node-externals');
+require('@backstage/cli-common');
+require('@manypkg/get-packages');
+require('./paths-8e0b151d.cjs.js');
+require('mini-css-extract-plugin');
+require('./index-2b8588e8.cjs.js');
+require('./run-d3528c59.cjs.js');
+require('eslint-webpack-plugin');
+require('lodash/pickBy');
+var bundle = require('./bundle-cfe3be2c.cjs.js');
+require('webpack-dev-server');
+require('react-dev-utils/openBrowser');
+var parallel = require('./parallel-d8e5bcbf.cjs.js');
+var config = require('./config-147bac17.cjs.js');
+var os = require('os');
+var tar = require('tar');
+var createDistWorkspace = require('./createDistWorkspace-59a08943.cjs.js');
+var packager = require('./packager-8f82846e.cjs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+var tar__default = /*#__PURE__*/_interopDefaultLegacy(tar);
+
+async function buildFrontend(options) {
+  const { targetDir, writeStats, configPaths } = options;
+  const { name } = await fs__default["default"].readJson(path.resolve(targetDir, "package.json"));
+  await bundle.buildBundle({
+    targetDir,
+    entry: "src/index",
+    parallelism: parallel.getEnvironmentParallelism(),
+    statsJsonEnabled: writeStats,
+    ...await config.loadCliConfig({
+      args: configPaths,
+      fromPackage: name
+    })
+  });
+}
+
+const BUNDLE_FILE = "bundle.tar.gz";
+const SKELETON_FILE = "skeleton.tar.gz";
+async function buildBackend(options) {
+  const { targetDir, skipBuildDependencies } = options;
+  const pkg = await fs__default["default"].readJson(path.resolve(targetDir, "package.json"));
+  await packager.buildPackage({ outputs: /* @__PURE__ */ new Set([packager.Output.cjs]) });
+  const tmpDir = await fs__default["default"].mkdtemp(path.resolve(os__default["default"].tmpdir(), "backstage-bundle"));
+  try {
+    await createDistWorkspace.createDistWorkspace([pkg.name], {
+      targetDir: tmpDir,
+      buildDependencies: !skipBuildDependencies,
+      buildExcludes: [pkg.name],
+      parallelism: parallel.getEnvironmentParallelism(),
+      skeleton: SKELETON_FILE
+    });
+    const distDir = path.resolve(targetDir, "dist");
+    await fs__default["default"].remove(distDir);
+    await fs__default["default"].mkdir(distDir);
+    await fs__default["default"].move(path.resolve(tmpDir, SKELETON_FILE), path.resolve(distDir, SKELETON_FILE));
+    await tar__default["default"].create({
+      file: path.resolve(distDir, BUNDLE_FILE),
+      cwd: tmpDir,
+      portable: true,
+      noMtime: true,
+      gzip: true
+    }, [""]);
+  } finally {
+    await fs__default["default"].remove(tmpDir);
+  }
+}
+
+exports.buildBackend = buildBackend;
+exports.buildFrontend = buildFrontend;
+//# sourceMappingURL=buildBackend-1727e26d.cjs.js.map

package/dist/cjs/buildWorkspace-cdb5a92d.cjs.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var fs = require('fs-extra');
+var createDistWorkspace = require('./createDistWorkspace-59a08943.cjs.js');
+require('chalk');
+require('path');
+require('os');
+require('tar');
+require('lodash/partition');
+require('./index-2b8588e8.cjs.js');
+require('commander');
+require('semver');
+require('@backstage/cli-common');
+require('@backstage/config/package.json');
+require('@backstage/errors');
+require('./run-d3528c59.cjs.js');
+require('child_process');
+require('util');
+require('./PackageGraph-d7b9d768.cjs.js');
+require('@manypkg/get-packages');
+require('./packager-8f82846e.cjs.js');
+require('rollup');
+require('rollup-plugin-peer-deps-external');
+require('@rollup/plugin-commonjs');
+require('@rollup/plugin-node-resolve');
+require('rollup-plugin-postcss');
+require('rollup-plugin-esbuild');
+require('@svgr/rollup');
+require('rollup-plugin-dts');
+require('@rollup/plugin-json');
+require('@rollup/plugin-yaml');
+require('rollup-pluginutils');
+require('./svgrTemplate-b7a4ee52.cjs.js');
+require('./parallel-d8e5bcbf.cjs.js');
+require('worker_threads');
+require('./packageRoles-f375a99e.cjs.js');
+require('zod');
+require('npm-packlist');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+var buildWorkspace = async (dir, _cmd, packages) => {
+  if (!await fs__default["default"].pathExists(dir)) {
+    throw new Error(`Target workspace directory doesn't exist, '${dir}'`);
+  }
+  await createDistWorkspace.createDistWorkspace(packages, {
+    targetDir: dir
+  });
+};
+
+exports["default"] = buildWorkspace;
+//# sourceMappingURL=buildWorkspace-cdb5a92d.cjs.js.map

package/dist/cjs/bump-3e73eb63.cjs.js

@@ -0,0 +1,348 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var ora = require('ora');
+var semver = require('semver');
+var minimatch = require('minimatch');
+var errors = require('@backstage/errors');
+var path = require('path');
+var run = require('./run-d3528c59.cjs.js');
+var index = require('./index-2b8588e8.cjs.js');
+var Lockfile = require('./Lockfile-35661afa.cjs.js');
+var packages = require('./packages-572642d7.cjs.js');
+var lint = require('./lint-a9e3c169.cjs.js');
+var cliCommon = require('@backstage/cli-common');
+var parallel = require('./parallel-d8e5bcbf.cjs.js');
+var releaseManifests = require('@backstage/release-manifests');
+require('child_process');
+require('util');
+require('commander');
+require('@backstage/config/package.json');
+require('@yarnpkg/lockfile');
+require('@manypkg/get-packages');
+require('lodash/partition');
+require('os');
+require('worker_threads');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+var ora__default = /*#__PURE__*/_interopDefaultLegacy(ora);
+var semver__default = /*#__PURE__*/_interopDefaultLegacy(semver);
+var minimatch__default = /*#__PURE__*/_interopDefaultLegacy(minimatch);
+
+const DEP_TYPES = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const DEFAULT_PATTERN_GLOB = "@backstage/*";
+var bump = async (cmd) => {
+  var _a;
+  const lockfilePath = index.paths.resolveTargetRoot("yarn.lock");
+  const lockfile = await Lockfile.Lockfile.load(lockfilePath);
+  let pattern = cmd.pattern;
+  if (!pattern) {
+    console.log(`Using default pattern glob ${DEFAULT_PATTERN_GLOB}`);
+    pattern = DEFAULT_PATTERN_GLOB;
+  } else {
+    console.log(`Using custom pattern glob ${pattern}`);
+  }
+  let findTargetVersion;
+  let releaseManifest;
+  if (semver__default["default"].valid(cmd.release)) {
+    releaseManifest = await releaseManifests.getManifestByVersion({ version: cmd.release });
+    findTargetVersion = createStrictVersionFinder({
+      releaseManifest
+    });
+  } else {
+    if (cmd.release === "next") {
+      const next = await releaseManifests.getManifestByReleaseLine({
+        releaseLine: "next"
+      });
+      const main = await releaseManifests.getManifestByReleaseLine({
+        releaseLine: "main"
+      });
+      releaseManifest = semver__default["default"].gt(next.releaseVersion, main.releaseVersion) ? next : main;
+    } else {
+      releaseManifest = await releaseManifests.getManifestByReleaseLine({
+        releaseLine: cmd.release
+      });
+    }
+    findTargetVersion = createVersionFinder({
+      releaseLine: cmd.releaseLine,
+      releaseManifest
+    });
+  }
+  const dependencyMap = await packages.mapDependencies(index.paths.targetDir, pattern);
+  const versionBumps = /* @__PURE__ */ new Map();
+  const unlocked = Array();
+  await parallel.runParallelWorkers({
+    parallelismFactor: 4,
+    items: dependencyMap.entries(),
+    async worker([name, pkgs]) {
+      var _a2, _b;
+      let target;
+      try {
+        target = await findTargetVersion(name);
+      } catch (error) {
+        if (errors.isError(error) && error.name === "NotFoundError") {
+          console.log(`Package info not found, ignoring package ${name}`);
+          return;
+        }
+        throw error;
+      }
+      for (const pkg of pkgs) {
+        if (semver__default["default"].satisfies(target, pkg.range)) {
+          if (((_a2 = semver__default["default"].minVersion(pkg.range)) == null ? void 0 : _a2.version) !== target) {
+            unlocked.push({ name, range: pkg.range, target });
+          }
+          continue;
+        }
+        versionBumps.set(pkg.name, ((_b = versionBumps.get(pkg.name)) != null ? _b : []).concat({
+          name,
+          location: pkg.location,
+          range: `^${target}`,
+          target
+        }));
+      }
+    }
+  });
+  const filter = (name) => minimatch__default["default"](name, pattern);
+  await parallel.runParallelWorkers({
+    parallelismFactor: 4,
+    items: lockfile.keys(),
+    async worker(name) {
+      var _a2;
+      if (!filter(name)) {
+        return;
+      }
+      let target;
+      try {
+        target = await findTargetVersion(name);
+      } catch (error) {
+        if (errors.isError(error) && error.name === "NotFoundError") {
+          console.log(`Package info not found, ignoring package ${name}`);
+          return;
+        }
+        throw error;
+      }
+      for (const entry of (_a2 = lockfile.get(name)) != null ? _a2 : []) {
+        if (!semver__default["default"].satisfies(target, entry.range)) {
+          continue;
+        }
+        unlocked.push({ name, range: entry.range, target });
+      }
+    }
+  });
+  console.log();
+  if (versionBumps.size === 0 && unlocked.length === 0) {
+    console.log(chalk__default["default"].green("All Backstage packages are up to date!"));
+  } else {
+    console.log(chalk__default["default"].yellow("Some packages are outdated, updating"));
+    console.log();
+    if (unlocked.length > 0) {
+      const removed = /* @__PURE__ */ new Set();
+      for (const { name, range, target } of unlocked) {
+        const existingEntry = (_a = lockfile.get(name)) == null ? void 0 : _a.find((e) => e.range === range);
+        if ((existingEntry == null ? void 0 : existingEntry.version) === target) {
+          continue;
+        }
+        const key = JSON.stringify({ name, range });
+        if (!removed.has(key)) {
+          removed.add(key);
+          console.log(`${chalk__default["default"].magenta("unlocking")} ${name}@${chalk__default["default"].yellow(range)} ~> ${chalk__default["default"].yellow(target)}`);
+          lockfile.remove(name, range);
+        }
+      }
+      await lockfile.save();
+    }
+    const breakingUpdates = /* @__PURE__ */ new Map();
+    await parallel.runParallelWorkers({
+      parallelismFactor: 4,
+      items: versionBumps.entries(),
+      async worker([name, deps]) {
+        var _a2;
+        const pkgPath = path.resolve(deps[0].location, "package.json");
+        const pkgJson = await fs__default["default"].readJson(pkgPath);
+        for (const dep of deps) {
+          console.log(`${chalk__default["default"].cyan("bumping")} ${dep.name} in ${chalk__default["default"].cyan(name)} to ${chalk__default["default"].yellow(dep.range)}`);
+          for (const depType of DEP_TYPES) {
+            if (depType in pkgJson && dep.name in pkgJson[depType]) {
+              const oldRange = pkgJson[depType][dep.name];
+              pkgJson[depType][dep.name] = dep.range;
+              const lockfileEntry = (_a2 = lockfile.get(dep.name)) == null ? void 0 : _a2.find((entry) => entry.range === oldRange);
+              if (lockfileEntry) {
+                const from = lockfileEntry.version;
+                const to = dep.target;
+                if (!semver__default["default"].satisfies(to, `^${from}`)) {
+                  breakingUpdates.set(dep.name, { from, to });
+                }
+              }
+            }
+          }
+        }
+        await fs__default["default"].writeJson(pkgPath, pkgJson, { spaces: 2 });
+      }
+    });
+    console.log();
+    if (pattern === DEFAULT_PATTERN_GLOB) {
+      await bumpBackstageJsonVersion(releaseManifest.releaseVersion);
+    } else {
+      console.log(chalk__default["default"].yellow(`Skipping backstage.json update as custom pattern is used`));
+    }
+    await runYarnInstall();
+    if (breakingUpdates.size > 0) {
+      console.log();
+      console.log(chalk__default["default"].yellow("\u26A0\uFE0F  The following packages may have breaking changes:"));
+      console.log();
+      for (const [name, { from, to }] of Array.from(breakingUpdates.entries()).sort()) {
+        console.log(`  ${chalk__default["default"].yellow(name)} : ${chalk__default["default"].yellow(from)} ~> ${chalk__default["default"].yellow(to)}`);
+        let path;
+        if (name.startsWith("@backstage/plugin-")) {
+          path = `plugins/${name.replace("@backstage/plugin-", "")}`;
+        } else if (name.startsWith("@backstage/")) {
+          path = `packages/${name.replace("@backstage/", "")}`;
+        }
+        if (path) {
+          console.log(`    https://github.com/backstage/backstage/blob/master/${path}/CHANGELOG.md`);
+        }
+        console.log();
+      }
+    } else {
+      console.log();
+    }
+    console.log(chalk__default["default"].green("Version bump complete!"));
+  }
+  console.log();
+  const dedupLockfile = await Lockfile.Lockfile.load(lockfilePath);
+  const result = dedupLockfile.analyze({
+    filter
+  });
+  if (result.newVersions.length > 0) {
+    throw new Error("Duplicate versions present after package bump");
+  }
+  const forbiddenNewRanges = result.newRanges.filter(({ name }) => lint.forbiddenDuplicatesFilter(name));
+  if (forbiddenNewRanges.length > 0) {
+    throw new Error(`Version bump failed for ${forbiddenNewRanges.map((i) => i.name).join(", ")}`);
+  }
+};
+function createStrictVersionFinder(options) {
+  const releasePackages = new Map(options.releaseManifest.packages.map((p) => [p.name, p.version]));
+  return async function findTargetVersion(name) {
+    console.log(`Checking for updates of ${name}`);
+    const manifestVersion = releasePackages.get(name);
+    if (manifestVersion) {
+      return manifestVersion;
+    }
+    throw new errors.NotFoundError(`Package ${name} not found in release manifest`);
+  };
+}
+function createVersionFinder(options) {
+  const {
+    releaseLine = "latest",
+    packageInfoFetcher = packages.fetchPackageInfo,
+    releaseManifest
+  } = options;
+  const distTag = releaseLine === "main" ? "latest" : releaseLine;
+  const found = /* @__PURE__ */ new Map();
+  const releasePackages = new Map(releaseManifest == null ? void 0 : releaseManifest.packages.map((p) => [p.name, p.version]));
+  return async function findTargetVersion(name) {
+    const existing = found.get(name);
+    if (existing) {
+      return existing;
+    }
+    console.log(`Checking for updates of ${name}`);
+    const manifestVersion = releasePackages.get(name);
+    if (manifestVersion) {
+      return manifestVersion;
+    }
+    const info = await packageInfoFetcher(name);
+    const latestVersion = info["dist-tags"].latest;
+    if (!latestVersion) {
+      throw new Error(`No target 'latest' version found for ${name}`);
+    }
+    const taggedVersion = info["dist-tags"][distTag];
+    if (distTag === "latest" || !taggedVersion) {
+      found.set(name, latestVersion);
+      return latestVersion;
+    }
+    const latestVersionDateStr = info.time[latestVersion];
+    const taggedVersionDateStr = info.time[taggedVersion];
+    if (!latestVersionDateStr) {
+      throw new Error(`No time available for version '${latestVersion}' of ${name}`);
+    }
+    if (!taggedVersionDateStr) {
+      throw new Error(`No time available for version '${taggedVersion}' of ${name}`);
+    }
+    const latestVersionRelease = new Date(latestVersionDateStr).getTime();
+    const taggedVersionRelease = new Date(taggedVersionDateStr).getTime();
+    if (latestVersionRelease > taggedVersionRelease) {
+      found.set(name, latestVersion);
+      return latestVersion;
+    }
+    found.set(name, taggedVersion);
+    return taggedVersion;
+  };
+}
+async function bumpBackstageJsonVersion(version) {
+  const backstageJsonPath = index.paths.resolveTargetRoot(cliCommon.BACKSTAGE_JSON);
+  const backstageJson = await fs__default["default"].readJSON(backstageJsonPath).catch((e) => {
+    if (e.code === "ENOENT") {
+      return;
+    }
+    throw e;
+  });
+  const prevVersion = backstageJson == null ? void 0 : backstageJson.version;
+  if (prevVersion === version) {
+    return;
+  }
+  const { yellow, cyan, green } = chalk__default["default"];
+  if (prevVersion) {
+    const from = encodeURIComponent(prevVersion);
+    const to = encodeURIComponent(version);
+    const link = `https://backstage.github.io/upgrade-helper/?from=${from}&to=${to}`;
+    console.log(yellow(`Upgraded from release ${green(prevVersion)} to ${green(version)}, please review these template changes:`));
+    console.log();
+    console.log(`  ${cyan(link)}`);
+    console.log();
+  } else {
+    console.log(yellow(`Your project is now at version ${version}, which has been written to ${cliCommon.BACKSTAGE_JSON}`));
+  }
+  await fs__default["default"].writeJson(backstageJsonPath, { ...backstageJson, version }, {
+    spaces: 2,
+    encoding: "utf8"
+  });
+}
+async function runYarnInstall() {
+  const spinner = ora__default["default"]({
+    prefixText: `Running ${chalk__default["default"].blue("yarn install")} to install new versions`,
+    spinner: "arc",
+    color: "green"
+  }).start();
+  const installOutput = new Array();
+  try {
+    await run.run("yarn", ["install"], {
+      env: {
+        FORCE_COLOR: "true",
+        ...Object.fromEntries(Object.entries(process.env).map(([name, value]) => name.startsWith("npm_") ? [name, void 0] : [name, value]))
+      },
+      stdoutLogFunc: (data) => installOutput.push(data),
+      stderrLogFunc: (data) => installOutput.push(data)
+    });
+    spinner.succeed();
+  } catch (error) {
+    spinner.fail();
+    process.stdout.write(Buffer.concat(installOutput));
+    throw error;
+  }
+}
+
+exports.bumpBackstageJsonVersion = bumpBackstageJsonVersion;
+exports.createStrictVersionFinder = createStrictVersionFinder;
+exports.createVersionFinder = createVersionFinder;
+exports["default"] = bump;
+//# sourceMappingURL=bump-3e73eb63.cjs.js.map