unbag/dist/cjs/commands/release/bump.cjs

一个专门用来开发npm工具的包

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isReleaseType = exports.isInPrerelease = exports.getCommits = exports.genVersionByCommits = exports.genVersion = exports.bump = exports.VERSIONS = exports.ReleaseBumpConfigDefault = void 0;
var _semver = _interopRequireDefault(require("semver"));
var _index = require("../../utils/message/index.cjs");
var _path = require("../../utils/path.cjs");
var _fs = require("./../../utils/fs.cjs");
var _log = require("./../../utils/log.cjs");
var _conventionalRecommendedBump = require("conventional-recommended-bump");
var _utils = require("./utils.cjs");
var _common = require("./../../utils/common.cjs");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const ReleaseBumpConfigDefault = exports.ReleaseBumpConfigDefault = {
  versionFilePath: "package.json",
  versionFilePathResolve: async ({
    finalUserConfig
  }) => {
    const {
      release: {
        bump: {
          versionFilePath
        }
      },
      root
    } = finalUserConfig;
    const path = (0, _path.usePath)();
    const absolutePath = path.resolve(root, versionFilePath);
    return absolutePath;
  },
  versionFileRead: async ({
    finalUserConfig
  }) => {
    const {
      release: {
        bump: {
          versionFilePathResolve
        }
      }
    } = finalUserConfig;
    const pkgFileAbsolutePath = await versionFilePathResolve({
      finalUserConfig
    });
    const fs = (0, _fs.useFs)();
    const content = await fs.readJson(pkgFileAbsolutePath);
    return content;
  },
  versionFileWrite: async ({
    finalUserConfig,
    bumpRes
  }) => {
    const {
      release: {
        bump: {
          versionFilePathResolve
        }
      }
    } = finalUserConfig;
    const pkgFileAbsolutePath = await versionFilePathResolve({
      finalUserConfig
    });
    const version = bumpRes?.version;
    if (!version) {
      return;
    }
    if (version === bumpRes.oldVersion) {
      return;
    }
    const fs = (0, _fs.useFs)();
    await fs.modifyJson(pkgFileAbsolutePath, value => {
      return {
        ...value,
        version
      };
    });
  }
};
const VERSIONS = exports.VERSIONS = ["major", "minor", "patch"];
const getCommits = async bumper => {
  const commitsStream = bumper.commitsGetter();
  const commits = [];
  let commit;
  for await (commit of commitsStream) {
    commits.push(commit);
  }
  return commits;
};
exports.getCommits = getCommits;
const isReleaseType = value => {
  return _semver.default.RELEASE_TYPES.includes(value);
};
exports.isReleaseType = isReleaseType;
const isInPrerelease = version => {
  return Array.isArray(_semver.default.prerelease(version));
};
exports.isInPrerelease = isInPrerelease;
const genVersionByCommits = async params => {
  const {
    finalUserConfig,
    data
  } = params;
  const log = (0, _log.useLog)({
    finalUserConfig
  });
  const message = (0, _index.useMessage)({
    locale: finalUserConfig.locale
  });
  log.info(message.releaseBumpingByCommits());
  const {
    release: {
      scope,
      preset,
      bump: {
        releasePre,
        releasePreTag
      }
    }
  } = finalUserConfig;
  const tagPrefix = await (0, _utils.useTagPrefix)({
    finalUserConfig
  });
  const {
    oldVersion
  } = data;
  const bumper = new _conventionalRecommendedBump.Bumper();
  bumper.loadPreset({
    name: preset.path,
    ...preset.params
  });
  bumper.tag({
    prefix: tagPrefix
  });
  let commits = await getCommits(bumper);
  log.debug({
    // commits,
    scope,
    tagPrefix
  });
  if (scope?.name) {
    commits = commits.filter(e => e.scope === scope.name);
  }
  log.info(message.releaseBumpCommitsList({
    commits
  }));
  if (commits.length > 0) {
    log.info(commits.map(e => `    ${e.header}`).join("\n"));
  }
  if (commits.length <= 0) {
    log.warn(message.releaseBumpCommitsNoData({
      oldVersion
    }));
    return {
      version: oldVersion,
      oldVersion
    };
  }
  const result = await bumper.whatBump(commits);
  let releaseType = void 0;
  if (result && typeof result.level === "number") {
    releaseType = VERSIONS[result.level];
  }
  if (!releaseType) {
    throw new Error(message.releaseBumpCommitsGenUnValidReleaseType());
  }
  if (releasePre) {
    if (isInPrerelease(oldVersion)) {
      releaseType = "prerelease";
    } else {
      releaseType = `pre${releaseType}`;
    }
  }
  if (!isReleaseType(releaseType)) {
    throw new Error(message.releaseBumpCommitsGenUnValidReleaseType());
  }
  log.info(message.releaseBumpCommitsGenReleaseTypeSuccess({
    releaseType
  }));
  const version = _semver.default.inc(oldVersion, releaseType, releasePreTag);
  if (!version) {
    log.error(message.releaseBumpGenUnValidVersion());
    throw new Error(message.releaseBumpGenUnValidVersion());
  }
  return {
    version,
    oldVersion,
    releaseType,
    commits
  };
};
exports.genVersionByCommits = genVersionByCommits;
const genVersion = async params => {
  const {
    finalUserConfig
  } = params;
  const log = (0, _log.useLog)({
    finalUserConfig
  });
  const message = (0, _index.useMessage)({
    locale: finalUserConfig.locale
  });
  log.info(message.releaseBumping());
  const {
    release: {
      bump: {
        versionFileRead,
        releaseAs,
        releaseType,
        releasePreTag
      }
    }
  } = finalUserConfig;
  const versionFileContent = await (0, _common.unSafeFunctionWrapper)(versionFileRead)({
    finalUserConfig
  });
  if (!versionFileContent) {
    throw new Error(message.releaseBumpNotFoundVersionFile());
  }
  if (!versionFileContent.version) {
    throw new Error(message.release.bump.unValidOldVersion());
  }
  const oldVersion = versionFileContent.version;
  log.info(message.releaseBumpOldVersion({
    oldVersion
  }));
  if (releaseAs) {
    if (!_semver.default.valid(releaseAs)) {
      throw new Error(message.releaseBumpReleaseAsUnValid(releaseAs));
    }
    log.info(message.releaseBumpOldVersion({
      oldVersion
    }));
    return {
      version: releaseAs,
      oldVersion
    };
  }
  if (releaseType) {
    if (!isReleaseType(releaseType)) {
      throw new Error(message.releaseBumpReleaseTypeUnValid(releaseType));
    }
    const version = _semver.default.inc(oldVersion, releaseType, releasePreTag);
    if (!version) {
      throw new Error(message.releaseBumpGenUnValidVersion());
    }
    log.info(message.releaseBumpVersionByReleaseType({
      releaseType,
      version
    }));
    return {
      version,
      oldVersion,
      releaseType
    };
  }
  return await genVersionByCommits({
    finalUserConfig,
    data: {
      oldVersion
    }
  });
};
exports.genVersion = genVersion;
const bump = async params => {
  const {
    finalUserConfig
  } = params;
  const log = (0, _log.useLog)({
    finalUserConfig
  });
  const message = (0, _index.useMessage)({
    locale: finalUserConfig.locale
  });
  const versionResult = await genVersion({
    finalUserConfig
  });
  log.info(message.release.bump.end({
    version: versionResult.version,
    oldVersion: versionResult.oldVersion
  }));
  if (_semver.default.compare(versionResult.oldVersion, versionResult.version) >= 0) {
    throw new Error(message.release.bump.unValidVersionResult());
  }
  const {
    release: {
      dry,
      bump: {
        versionFileWriteDisable,
        versionFileWrite
      }
    }
  } = finalUserConfig;
  let _versionFileWriteDisable = versionFileWriteDisable;
  if (dry) {
    _versionFileWriteDisable = true;
    log.warn(message.release.dry.bump.versionFileWriteDisable());
  }
  if (!_versionFileWriteDisable) {
    await versionFileWrite({
      finalUserConfig,
      bumpRes: versionResult
    });
    log.info(message.releaseBumpVersionFileWriteSuccess({
      version: versionResult.version
    }));
  } else {
    log.warn(message.releaseBumpVersionFileWriteDisable());
  }
  return versionResult;
};
exports.bump = bump;