@serpent/common-cli/lib/cjs/version.cjs

通用的 cli 相关的函数

'use strict';

var satisfies = require('./satisfies-2e2ee518.cjs');
var _commonjsHelpers = require('./_commonjsHelpers-ed042b00.cjs');

const { MAX_LENGTH } = satisfies.constants;
const { re, t } = satisfies.reExports;
const SemVer$1 = satisfies.semver;

const parseOptions = satisfies.parseOptions_1;
const parse$2 = (version, options) => {
  options = parseOptions(options);

  if (version instanceof SemVer$1) {
    return version
  }

  if (typeof version !== 'string') {
    return null
  }

  if (version.length > MAX_LENGTH) {
    return null
  }

  const r = options.loose ? re[t.LOOSE] : re[t.FULL];
  if (!r.test(version)) {
    return null
  }

  try {
    return new SemVer$1(version, options)
  } catch (er) {
    return null
  }
};

var parse_1 = parse$2;

var parse$3 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(parse_1);

const parse$1 = parse_1;
const valid = (version, options) => {
  const v = parse$1(version, options);
  return v ? v.version : null
};
var valid_1 = valid;

var valid$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(valid_1);

const SemVer = satisfies.semver;

const inc = (version, release, options, identifier) => {
  if (typeof (options) === 'string') {
    identifier = options;
    options = undefined;
  }

  try {
    return new SemVer(
      version instanceof SemVer ? version.version : version,
      options
    ).inc(release, identifier).version
  } catch (er) {
    return null
  }
};
var inc_1 = inc;

var inc$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(inc_1);

const parse = parse_1;
const prerelease = (version, options) => {
  const parsed = parse(version, options);
  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
};
var prerelease_1 = prerelease;

var prerelease$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(prerelease_1);

/**
 * Compares two versions excluding build identifiers (the bit after `+` in the semantic version string).
 *
 * Sorts in ascending order when passed to `Array.sort()`.
 *
 * @return
 * * v1  <  v2  => -1
 * * v1 === v2  => 0
 * * v1  >  v2  => 1
 */
function compareVersion(v1, v2) {
    return satisfies.compare(v1, v2);
}
/** Return true if the version satisfies the range. */
function satisfiesVersion(version, range) {
    return satisfies.satisfies(version, range);
}
/** 解析 version，生成一个对象 */
function parseVersion(version) {
    return parse$3(version);
}
/**
 * 过滤出需要的版本号
 *
 * - 如果 mode === 'all'， 返回所有有效的版本
 * - 如果 mode === 'major'， 返回所有 A.x.x 的版本，确保 A 唯一
 * - 如果 mode === 'minor'， 返回所有 A.B.x 的版本，确保 A.B 唯一
 * - 如果 mode === 'patch'， 返回所有 A.B.C 的版本，确保 A.B.C 唯一
 * - 如果 mode === 'pre'， 返回所有 A.x.x-pre 的版本，确保 A 唯一
 * - 如果 mode === 'pre&major'， 包含 major 和 pre 场景
 * - 如果 mode === 'pre&minor'， 包含 minor 和 pre 场景
 */
function filterVersions(versions, mode) {
    if (mode === void 0) { mode = 'all'; }
    var map = new Map();
    var targets = versions.map(function (v) { return parseVersion(v); }).filter(function (t) { return t != null; });
    if (mode === 'all')
        return targets.map(function (target) { return target.raw; });
    var update = function (key, target) {
        var prev = map.get(key);
        if (prev) {
            if (target.compare(prev) > 0)
                map.set(key, target.raw);
        }
        else {
            map.set(key, target.raw);
        }
    };
    targets.forEach(function (target) {
        var major = target.major, minor = target.minor, patch = target.patch, prerelease = target.prerelease;
        if (!prerelease.length) {
            if (mode.includes('major'))
                update("".concat(major, ".x.x"), target);
            else if (mode.includes('minor'))
                update("".concat(major, ".").concat(minor, ".x"), target);
            else if (mode.includes('patch'))
                update("".concat(major, ".").concat(minor, ".").concat(patch), target);
        }
    });
    if (mode.includes('pre')) {
        var versions_1 = Array.from(map.values());
        targets.forEach(function (target) {
            var major = target.major, prerelease = target.prerelease;
            // 预发布版本
            // 如果已经存在 2.0.0，则不再需要 2.0.0-rc.1 和 1.0.0-rc.1
            if (prerelease.length && (!versions_1.length || versions_1.every(function (v) { return target.compare(v) > 0; }))) {
                update("".concat(major, ".x.x-pre"), target);
            }
        });
    }
    return Array.from(map.values());
}
/** 版本号排序，默认从大到小排 */
function sortVersions(versions, mode) {
    return versions.sort(function (a, b) { return (mode === 'asc' ? compareVersion(a, b) : compareVersion(b, a)); });
}
/** 判断是否是一个正确的版本号 */
function isValidVersion(version, options) {
    return Boolean(valid$1(version, options));
}
/** 是否是一个有效的版本范围 */
function isValidRange(range) {
    try {
        var r = new satisfies.Range(range);
        return r.set.length > 0;
    }
    catch (e) {
        return false;
    }
}
/** 判断是否是一个 prerelease 版本号 */
function isPrereleaseVersion(version, options) {
    return Boolean(prerelease$1(version, options));
}
var INCREMENT_TAGS = ['patch', 'minor', 'major', 'prepatch', 'preminor', 'premajor', 'prerelease'];
/** 判断某个 tag 是不是一个 increment tag */
function isIncrementTag(tag) {
    return INCREMENT_TAGS.includes(tag);
}
/**
 * 根据指定的 tag ，生成一个新版本号
 */
function increment(version, tag, options) {
    return inc$1(version, tag, options, options === null || options === void 0 ? void 0 : options.identifier);
}

exports.INCREMENT_TAGS = INCREMENT_TAGS;
exports.compareVersion = compareVersion;
exports.filterVersions = filterVersions;
exports.increment = increment;
exports.isIncrementTag = isIncrementTag;
exports.isPrereleaseVersion = isPrereleaseVersion;
exports.isValidRange = isValidRange;
exports.isValidVersion = isValidVersion;
exports.parseVersion = parseVersion;
exports.satisfiesVersion = satisfiesVersion;
exports.sortVersions = sortVersions;