@vortex.so/cli/build/@package/plugins/ship/ship.output.cjs

CLI to interact with Vortex.

'use strict';

const process = require('node:process');
const readline = require('node:readline');
const prompts = require('prompts');
const semver = require('semver');
const c = require('chalk');
require('figures');
require('jiti');
const index = require('../../utils/log/index.cjs');
const ship_release = require('./ship.release.cjs');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

const process__default = /*#__PURE__*/_interopDefaultCompat(process);
const readline__default = /*#__PURE__*/_interopDefaultCompat(readline);
const prompts__default = /*#__PURE__*/_interopDefaultCompat(prompts);
const c__default = /*#__PURE__*/_interopDefaultCompat(c);

const log = new index.Log("Ship");
async function getOutput(operation) {
  const { release } = operation.options;
  const { name, oldVersion, oldBuild } = operation.state;
  log.info(`Evolving ${c__default.bold.green(name)} version...`);
  operation.update({
    newBuild: oldBuild || 0 + 1
  });
  switch (release.type) {
    case "prompt":
      return promptForNewVersion(operation);
    case "version":
      const newSemVer = new semver.SemVer(release.version, true);
      return operation.update({
        newVersion: newSemVer.version
      });
    default:
      return operation.update({
        release: release.type,
        newVersion: getNextVersion(oldVersion, release)
      });
  }
}
function getNextVersion(oldVersion, release) {
  const oldSemVer = new semver.SemVer(oldVersion);
  const newSemVer = oldSemVer.inc(release.type, release.preid);
  if (ship_release.isPrerelease(release.type) && newSemVer.prerelease.length === 2 && newSemVer.prerelease[0] === release.preid && String(newSemVer.prerelease[1]) === "0") {
    newSemVer.prerelease[1] = "1";
    newSemVer.format();
  }
  return newSemVer.version;
}
function getNextVersions(oldVersion, preid) {
  const next = {};
  for (const type of ship_release.releaseTypes) {
    next[type] = getNextVersion(oldVersion, { type, preid });
  }
  return next;
}
async function promptForNewVersion(operation) {
  const { oldVersion, oldBuild } = operation.state;
  const release = operation.options.release;
  const next = getNextVersions(oldVersion, release.preid);
  let isCancelled = false;
  const answers = await prompts__default(
    [
      {
        type: "autocomplete",
        name: "release",
        message: `Current version: ${c__default.bold.dim(oldVersion)}`,
        initial: "patch",
        choices: [
          { value: "major", title: `major - ${c__default.bold.red(next.major)}` },
          { value: "minor", title: `minor - ${c__default.bold.yellow(next.minor)}` },
          { value: "patch", title: `patch - ${c__default.bold.yellow(next.patch)}` },
          {
            value: "premajor",
            title: `pre-release major - ${c__default.bold.green(next.premajor)}`
          },
          {
            value: "preminor",
            title: `pre-release minor - ${c__default.bold.green(next.preminor)}`
          },
          {
            value: "prepatch",
            title: `pre-release patch - ${c__default.bold.green(next.prepatch)}`
          },
          {
            value: "prerelease",
            title: `pre-release - ${c__default.bold.green(next.prerelease)}`
          },
          { value: "none", title: `leave as-is - ${c__default.bold.dim(oldVersion)}` },
          { value: "custom", title: "custom..." }
        ]
      },
      {
        type: (prev) => prev === "custom" ? "text" : null,
        name: "custom",
        message: "Enter the new version number:",
        initial: oldVersion,
        validate: (custom) => {
          if (!semver.valid(custom))
            return "That's not a valid version number!";
          if (semver.lt(custom, oldVersion))
            return "You can't downgrade. Please, grow up.";
          else return true;
        }
      }
    ],
    {
      onCancel() {
        readline__default.moveCursor(process__default.stdout, 0, -2);
        readline__default.clearLine(process__default.stdout, 0);
        readline__default.clearLine(process__default.stdout, 0);
        isCancelled = true;
      }
    }
  );
  if (isCancelled)
    throw new Error("Cancelled!");
  const newVersion = answers.release === "none" ? oldVersion : answers.release === "custom" ? semver.clean(answers.custom) : next[answers.release];
  if (!newVersion) {
    throw new Error("Cancelled, can't get new version.");
  }
  if (newVersion === oldVersion) {
    throw new Error("Cancelled, version stays the same.");
  }
  const newBuild = oldBuild ? oldBuild + 1 : 1;
  switch (answers.release) {
    case "none":
      return operation.update({ newVersion });
    case "custom":
      return operation.update({ newVersion, newBuild });
    default:
      return operation.update({
        release: answers.release,
        newVersion,
        newBuild
      });
  }
}

exports.getOutput = getOutput;
exports.promptForNewVersion = promptForNewVersion;