projen
Version:
CDK for software projects
250 lines • 40.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.bump = bump;
const fs_1 = require("fs");
const path_1 = require("path");
const semver_1 = require("semver");
const logging = require("../logging");
const util_1 = require("../util");
const version_1 = require("../version");
const bump_type_1 = require("./bump-type");
const commit_tag_version_1 = require("./commit-tag-version");
/**
* Resolves the latest version from git tags and uses `commit-and-tag-version` to bump
* to the next version based on commits.
*
* This expects `commit-and-tag-version` to be installed in the path.
*
* @param cwd working directory (git repository)
* @param options options
*/
async function bump(cwd, options) {
const versionFile = (0, path_1.join)(cwd, options.versionFile);
const prerelease = options.prerelease;
const major = options.majorVersion;
const minor = options.minorVersion;
const minMajorVersion = options.minMajorVersion;
const tagPrefix = options.tagPrefix ?? "";
const bumpFile = (0, path_1.join)(cwd, options.bumpFile);
const changelogFile = (0, path_1.join)(cwd, options.changelog);
const releaseTagFile = (0, path_1.join)(cwd, options.releaseTagFile);
if (major && minMajorVersion) {
throw new Error(`minMajorVersion and majorVersion cannot be used together.`);
}
if (options.nextVersionCommand && minMajorVersion) {
throw new Error(`minMajorVersion and nextVersionCommand cannot be used together.`);
}
if (minor && !major) {
throw new Error(`minorVersion and majorVersion must be used together.`);
}
await fs_1.promises.mkdir((0, path_1.dirname)(bumpFile), { recursive: true });
await fs_1.promises.mkdir((0, path_1.dirname)(changelogFile), { recursive: true });
await fs_1.promises.mkdir((0, path_1.dirname)(releaseTagFile), { recursive: true });
const { latestVersion, latestTag, isFirstRelease } = determineLatestTag({
cwd,
major,
minor,
prerelease,
prefix: tagPrefix,
});
// Write the current version into the version file so that CATV will know the current version
const { contents, newline } = await tryReadVersionFile(versionFile);
contents.version = latestVersion;
logging.info(`Update ${versionFile} to latest resolved version: ${latestVersion}`);
await fs_1.promises.writeFile(versionFile, JSON.stringify(contents, undefined, 2) + (newline ? "\n" : ""));
// Determine the initial bump status. CATV will always do a patch even if
// there are no commits, so look at commits ourselves first to decide
// if we even should do nothing at all.
const shouldRelease = isFirstRelease
? true
: hasNewInterestingCommits({
cwd,
latestTag,
releasableCommits: options.releasableCommits,
});
const catv = new commit_tag_version_1.CommitAndTagVersion(options.bumpPackage, cwd, {
versionFile,
changelogFile,
prerelease,
configOptions: options.versionrcOptions,
tagPrefix,
});
// We used to translate `isFirstRelease` to the `--first-release` flag of CATV.
// What that does is skip a bump, only generate the changelog.
//
// Our `{ bump: none }` does the same, so we don't need to carry over this
// flag anymore.
let bumpType = shouldRelease && !isFirstRelease
? (0, bump_type_1.relativeBumpType)(latestVersion, await catv.dryRun())
: { bump: "none" };
logging.info(`Bump from commits: ${(0, bump_type_1.renderBumpType)(bumpType)}`);
if (options.nextVersionCommand) {
const nextVersion = (0, util_1.execCapture)(options.nextVersionCommand, {
cwd,
modEnv: {
VERSION: latestVersion,
SUGGESTED_BUMP: (0, bump_type_1.renderBumpType)(bumpType),
...(latestTag ? { LATEST_TAG: latestTag } : {}),
},
})
.toString()
.trim();
if (nextVersion) {
try {
bumpType = (0, bump_type_1.parseBumpType)(nextVersion);
logging.info(`Bump from nextVersionCommand: ${(0, bump_type_1.renderBumpType)(bumpType)}`);
}
catch (e) {
throw new Error(`nextVersionCommand "${options.nextVersionCommand}" returned invalid output: ${e}`);
}
}
}
// Respect minMajorVersion to correct the result of the nextVersionCommand
if (minMajorVersion) {
const bumpedVersion = (0, bump_type_1.performBump)(latestVersion, bumpType);
const [majorVersion] = bumpedVersion.split(".");
const majorVersionNumber = parseInt(majorVersion, 10);
if (majorVersionNumber < minMajorVersion) {
bumpType = { bump: "absolute", absolute: `${minMajorVersion}.0.0` };
}
}
// Invoke CATV with the options we landed on. If we decided not to do a bump,
// we will use this to regenerate the changelog of the most recent version.
const newRelease = bumpType.bump !== "none";
// If we're not doing a new release and this is not the
// first release, we're just regenerating the previous changelog again.
if (!newRelease && !isFirstRelease) {
await catv.regeneratePreviousChangeLog(latestVersion, latestTag);
}
else {
// Otherwise we're either doing a bump + release, or we're releasing the
// first version as 0.0.0 (which is already the number in the file so we
// skip bumping).
await catv.invoke({
releaseAs: newRelease ? (0, bump_type_1.renderBumpType)(bumpType) : undefined,
skipBump: !newRelease,
});
}
// Validate the version that we ended up with
const newVersion = (await tryReadVersionFile(versionFile)).version;
if (!newVersion) {
throw new Error(`bump failed: ${versionFile} does not have a version set`);
}
if (major) {
if (!newVersion.startsWith(`${major}.`)) {
throw new Error(`bump failed: this branch is configured to only publish v${major} releases - bump resulted in ${newVersion}`);
}
}
if (minor) {
if (!newVersion.startsWith(`${major}.${minor}`)) {
throw new Error(`bump failed: this branch is configured to only publish v${major}.${minor} releases - bump resulted in ${newVersion}`);
}
}
// Report curent status into the dist/ directory
const newTag = `${tagPrefix}v${newVersion}`;
await fs_1.promises.writeFile(bumpFile, newVersion);
await fs_1.promises.writeFile(releaseTagFile, newTag);
}
/**
* Determine based on releaseable commits whether we should release or not
*/
function hasNewInterestingCommits(options) {
const findCommits = (options.releasableCommits ?? version_1.ReleasableCommits.everyCommit().cmd).replace("$LATEST_TAG", options.latestTag);
const commitsSinceLastTag = (0, util_1.execOrUndefined)(findCommits, {
cwd: options.cwd,
})?.split("\n");
const numCommitsSinceLastTag = commitsSinceLastTag?.length ?? 0;
logging.info(`Number of commits since ${options.latestTag}: ${numCommitsSinceLastTag}`);
// Nothing to release right now
if (numCommitsSinceLastTag === 0) {
logging.info("No new interesting commits.");
return false;
}
return true;
}
async function tryReadVersionFile(versionFile) {
if (!(0, fs_1.existsSync)(versionFile)) {
return { contents: {}, newline: true };
}
const raw = await fs_1.promises.readFile(versionFile, "utf-8");
const contents = JSON.parse(raw);
return {
contents,
version: contents.version,
newline: raw.endsWith("\n"),
};
}
/**
* Determines the latest release tag.
* @param major (optional) A major version line to select from
* @param prerelease (optional) A pre-release suffix.
* @returns the latest tag, and whether it is the first release or not
*/
function determineLatestTag(options) {
const { cwd, major, minor, prerelease, prefix } = options;
// filter only tags for this prefix and major version if specified (start with "vNN.").
let prefixFilter;
if (major !== undefined && minor !== undefined) {
prefixFilter = `${prefix}v${major}.${minor}.*`;
}
else if (major !== undefined) {
prefixFilter = `${prefix}v${major}.*`;
}
else {
prefixFilter = `${prefix}v*`;
}
const listGitTags = [
"git",
'-c "versionsort.suffix=-"', // makes sure pre-release versions are listed after the primary version
"tag",
'--sort="-version:refname"', // sort as versions and not lexicographically
"--list",
`"${prefixFilter}"`,
].join(" ");
const stdout = (0, util_1.execCapture)(listGitTags, { cwd }).toString("utf8");
let tags = stdout?.split("\n");
// if prerelease is set and there are existing prerelease tags, filter versions that end with "-PRE.ddd".
const prereleaseTags = tags.filter((x) => new RegExp(`-${prerelease}\.[0-9]+$`).test(x));
if (prerelease && prereleaseTags.length > 0) {
/**
* Cover the following case specifically
* 1 - v1.0.0
* 2 - v1.0.1-beta.0
* 3 - v1.0.1-beta.1
* 4 - v1.0.1
* 5 - now publish a new release on the prerelease branch
* by setting the latestTag as v1.0.1 instead of v1.0.1-beta.1
*/
const releaseTags = tags.filter((x) => new RegExp(`^v([0-9]+)\.([0-9]+)\.([0-9]+)$`).test(x));
if (releaseTags.length > 0 &&
(0, semver_1.compare)(releaseTags[0], prereleaseTags[0]) === 1) {
tags = releaseTags;
}
else {
tags = prereleaseTags;
}
}
tags = tags.filter((x) => x);
// if a pre-release tag is used, then add it to the initial version
let isFirstRelease = false;
let latestTag;
if (tags.length > 0) {
latestTag = tags[0];
}
else {
const initial = `${prefix}v${major ?? 0}.${minor ?? 0}.0`;
latestTag = prerelease ? `${initial}-${prerelease}.0` : initial;
isFirstRelease = true;
}
// remove tag prefix (if exists)
let latestVersion = latestTag;
if (prefix && latestVersion.startsWith(prefix)) {
latestVersion = latestVersion.substr(prefix.length);
}
// remove "v" prefix (if exists)
if (latestVersion.startsWith("v")) {
latestVersion = latestVersion.substring(1);
}
return { latestVersion, latestTag, isFirstRelease };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bump-version.js","sourceRoot":"","sources":["../../src/release/bump-version.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs, existsSync } from \"fs\";\nimport { dirname, join } from \"path\";\nimport { Config } from \"conventional-changelog-config-spec\";\nimport { compare } from \"semver\";\nimport * as logging from \"../logging\";\nimport { execCapture, execOrUndefined } from \"../util\";\nimport { ReleasableCommits } from \"../version\";\nimport {\n  BumpType,\n  parseBumpType,\n  performBump,\n  relativeBumpType,\n  renderBumpType,\n} from \"./bump-type\";\nimport { CommitAndTagVersion } from \"./commit-tag-version\";\n\nexport interface BumpOptions {\n  /**\n   * The name of a .json file to set `version`.\n   */\n  readonly versionFile: string;\n\n  /**\n   * The name of the changelog file to generate.\n   */\n  readonly changelog: string;\n\n  /**\n   * Use a pre-release suffix.\n   * @default - normal versioning\n   */\n  readonly prerelease?: string;\n\n  /**\n   * Defines the major version line. This is used to select the latest version\n   * and also enforce that new major versions are not released accidentally.\n   *\n   * Can not be set together with `minMajorVersion`.\n   *\n   * @default - any version is supported\n   */\n  readonly majorVersion?: number;\n\n  /**\n   * Defines the minimal major version. This is used if you want to start with\n   * a specific major version, and increment from there on.\n   * This can be useful to set to 1, as breaking changes before the 1.x major\n   * release are not incrementing the major version number.\n   *\n   * Can not be set together with `majorVersion`.\n   *\n   * @default - No minimum version is being enforced\n   */\n  readonly minMajorVersion?: number;\n\n  /**\n   * Defines the minor version line. This is used to select the latest version\n   * and also enforce that new minor versions are not released accidentally.\n   *\n   * @default - any version is supported\n   */\n  readonly minorVersion?: number;\n\n  /**\n   * The name of a file which will include the output version number (a text file).\n   *\n   * Relative to cwd.\n   *\n   * @example \".version.txt\"\n   */\n  readonly bumpFile: string;\n\n  /**\n   * The name of the file which will include the release tag (a text file).\n   *\n   * Relative to cwd.\n   *\n   * @example \".releasetag.txt\"\n   */\n  readonly releaseTagFile: string;\n\n  /**\n   * The prefix applied to release tags. Bumps will be made based on the latest\n   * version found with this prefix.\n   */\n  readonly tagPrefix?: string;\n\n  /**\n   * Configuration values that would append to versionrc file or overwrite values\n   * coming to that from default one.\n   */\n  readonly versionrcOptions?: Config;\n\n  /**\n   * A shell command to list all release commits since the latest tag.\n   *\n   * A new release will be initiated, if the number of returned commits is greater than zero.\n   *\n   * `$LATEST_TAG` will be replaced with the actual latest tag for the given prefix.\n   *\n   * @default \"git log --oneline $LATEST_TAG..HEAD\"\n   */\n  readonly releasableCommits?: string;\n\n  /**\n   * The `commit-and-tag-version` compatible package used to bump the package version, as a dependency string.\n   *\n   * This can be any compatible package version, including the deprecated `standard-version@9`.\n   *\n   * @default \"commit-and-tag-version@12\"\n   */\n  readonly bumpPackage?: string;\n\n  /**\n   * A shell command to control the next version to release.\n   *\n   * If present, this shell command will be run before the bump is executed, and\n   * it determines what version to release. It will be executed in the following\n   * environment:\n   *\n   * - Working directory: the project directory.\n   * - `$VERSION`: the current version. Looks like `1.2.3`.\n   * - `$LATEST_TAG`: the most recent tag. Looks like `prefix-v1.2.3`, or may be unset.\n   *\n   * The command should print one of the following to `stdout`:\n   *\n   * - Nothing: the next version number will be determined based on commit history.\n   * - `x.y.z`: the next version number will be `x.y.z`.\n   * - `major|minor|patch`: the next version number will be the current version number\n   *   with the indicated component bumped.\n   *\n   * This setting cannot be specified together with `minMajorVersion`; the invoked\n   * script can be used to achieve the effects of `minMajorVersion`.\n   *\n   * @default - The next version will be determined based on the commit history and project settings.\n   */\n  readonly nextVersionCommand?: string;\n}\n\n/**\n * Resolves the latest version from git tags and uses `commit-and-tag-version` to bump\n * to the next version based on commits.\n *\n * This expects `commit-and-tag-version` to be installed in the path.\n *\n * @param cwd working directory (git repository)\n * @param options options\n */\nexport async function bump(cwd: string, options: BumpOptions) {\n  const versionFile = join(cwd, options.versionFile);\n  const prerelease = options.prerelease;\n  const major = options.majorVersion;\n  const minor = options.minorVersion;\n  const minMajorVersion = options.minMajorVersion;\n  const tagPrefix = options.tagPrefix ?? \"\";\n  const bumpFile = join(cwd, options.bumpFile);\n  const changelogFile = join(cwd, options.changelog);\n  const releaseTagFile = join(cwd, options.releaseTagFile);\n\n  if (major && minMajorVersion) {\n    throw new Error(\n      `minMajorVersion and majorVersion cannot be used together.`\n    );\n  }\n  if (options.nextVersionCommand && minMajorVersion) {\n    throw new Error(\n      `minMajorVersion and nextVersionCommand cannot be used together.`\n    );\n  }\n  if (minor && !major) {\n    throw new Error(`minorVersion and majorVersion must be used together.`);\n  }\n\n  await fs.mkdir(dirname(bumpFile), { recursive: true });\n  await fs.mkdir(dirname(changelogFile), { recursive: true });\n  await fs.mkdir(dirname(releaseTagFile), { recursive: true });\n\n  const { latestVersion, latestTag, isFirstRelease } = determineLatestTag({\n    cwd,\n    major,\n    minor,\n    prerelease,\n    prefix: tagPrefix,\n  });\n\n  // Write the current version into the version file so that CATV will know the current version\n  const { contents, newline } = await tryReadVersionFile(versionFile);\n  contents.version = latestVersion;\n  logging.info(\n    `Update ${versionFile} to latest resolved version: ${latestVersion}`\n  );\n  await fs.writeFile(\n    versionFile,\n    JSON.stringify(contents, undefined, 2) + (newline ? \"\\n\" : \"\")\n  );\n\n  // Determine the initial bump status. CATV will always do a patch even if\n  // there are no commits, so look at commits ourselves first to decide\n  // if we even should do nothing at all.\n  const shouldRelease = isFirstRelease\n    ? true\n    : hasNewInterestingCommits({\n        cwd,\n        latestTag,\n        releasableCommits: options.releasableCommits,\n      });\n\n  const catv = new CommitAndTagVersion(options.bumpPackage, cwd, {\n    versionFile,\n    changelogFile,\n    prerelease,\n    configOptions: options.versionrcOptions,\n    tagPrefix,\n  });\n\n  // We used to translate `isFirstRelease` to the `--first-release` flag of CATV.\n  // What that does is skip a bump, only generate the changelog.\n  //\n  // Our `{ bump: none }` does the same, so we don't need to carry over this\n  // flag anymore.\n  let bumpType: BumpType =\n    shouldRelease && !isFirstRelease\n      ? relativeBumpType(latestVersion, await catv.dryRun())\n      : { bump: \"none\" };\n\n  logging.info(`Bump from commits: ${renderBumpType(bumpType)}`);\n  if (options.nextVersionCommand) {\n    const nextVersion = execCapture(options.nextVersionCommand, {\n      cwd,\n      modEnv: {\n        VERSION: latestVersion,\n        SUGGESTED_BUMP: renderBumpType(bumpType),\n        ...(latestTag ? { LATEST_TAG: latestTag } : {}),\n      },\n    })\n      .toString()\n      .trim();\n\n    if (nextVersion) {\n      try {\n        bumpType = parseBumpType(nextVersion);\n        logging.info(\n          `Bump from nextVersionCommand: ${renderBumpType(bumpType)}`\n        );\n      } catch (e) {\n        throw new Error(\n          `nextVersionCommand \"${options.nextVersionCommand}\" returned invalid output: ${e}`\n        );\n      }\n    }\n  }\n\n  // Respect minMajorVersion to correct the result of the nextVersionCommand\n  if (minMajorVersion) {\n    const bumpedVersion = performBump(latestVersion, bumpType);\n    const [majorVersion] = bumpedVersion.split(\".\");\n    const majorVersionNumber = parseInt(majorVersion, 10);\n    if (majorVersionNumber < minMajorVersion) {\n      bumpType = { bump: \"absolute\", absolute: `${minMajorVersion}.0.0` };\n    }\n  }\n\n  // Invoke CATV with the options we landed on. If we decided not to do a bump,\n  // we will use this to regenerate the changelog of the most recent version.\n  const newRelease = bumpType.bump !== \"none\";\n\n  // If we're not doing a new release and this is not the\n  // first release, we're just regenerating the previous changelog again.\n  if (!newRelease && !isFirstRelease) {\n    await catv.regeneratePreviousChangeLog(latestVersion, latestTag);\n  } else {\n    // Otherwise we're either doing a bump + release, or we're releasing the\n    // first version as 0.0.0 (which is already the number in the file so we\n    // skip bumping).\n    await catv.invoke({\n      releaseAs: newRelease ? renderBumpType(bumpType) : undefined,\n      skipBump: !newRelease,\n    });\n  }\n\n  // Validate the version that we ended up with\n  const newVersion = (await tryReadVersionFile(versionFile)).version;\n  if (!newVersion) {\n    throw new Error(`bump failed: ${versionFile} does not have a version set`);\n  }\n  if (major) {\n    if (!newVersion.startsWith(`${major}.`)) {\n      throw new Error(\n        `bump failed: this branch is configured to only publish v${major} releases - bump resulted in ${newVersion}`\n      );\n    }\n  }\n  if (minor) {\n    if (!newVersion.startsWith(`${major}.${minor}`)) {\n      throw new Error(\n        `bump failed: this branch is configured to only publish v${major}.${minor} releases - bump resulted in ${newVersion}`\n      );\n    }\n  }\n\n  // Report curent status into the dist/ directory\n  const newTag = `${tagPrefix}v${newVersion}`;\n  await fs.writeFile(bumpFile, newVersion);\n  await fs.writeFile(releaseTagFile, newTag);\n}\n\n/**\n * Determine based on releaseable commits whether we should release or not\n */\nfunction hasNewInterestingCommits(options: {\n  releasableCommits?: string;\n  latestTag: string;\n  cwd: string;\n}) {\n  const findCommits = (\n    options.releasableCommits ?? ReleasableCommits.everyCommit().cmd\n  ).replace(\"$LATEST_TAG\", options.latestTag);\n\n  const commitsSinceLastTag = execOrUndefined(findCommits, {\n    cwd: options.cwd,\n  })?.split(\"\\n\");\n  const numCommitsSinceLastTag = commitsSinceLastTag?.length ?? 0;\n  logging.info(\n    `Number of commits since ${options.latestTag}: ${numCommitsSinceLastTag}`\n  );\n\n  // Nothing to release right now\n  if (numCommitsSinceLastTag === 0) {\n    logging.info(\"No new interesting commits.\");\n    return false;\n  }\n\n  return true;\n}\n\nasync function tryReadVersionFile(\n  versionFile: string\n): Promise<{ contents: any; version?: string; newline: boolean }> {\n  if (!existsSync(versionFile)) {\n    return { contents: {}, newline: true };\n  }\n  const raw = await fs.readFile(versionFile, \"utf-8\");\n  const contents = JSON.parse(raw);\n\n  return {\n    contents,\n    version: contents.version,\n    newline: raw.endsWith(\"\\n\"),\n  };\n}\n\ninterface LatestTagOptions {\n  /**\n   * Working directory of the git repository.\n   */\n  readonly cwd: string;\n  /**\n   * Major version to select from.\n   */\n  readonly major?: number;\n  /**\n   * Minor version to select from.\n   */\n  readonly minor?: number;\n  /**\n   * A pre-release suffix.\n   */\n  readonly prerelease?: string;\n  /**\n   * A prefix applied to all tags.\n   */\n  readonly prefix: string;\n}\n\n/**\n * Determines the latest release tag.\n * @param major (optional) A major version line to select from\n * @param prerelease (optional) A pre-release suffix.\n * @returns the latest tag, and whether it is the first release or not\n */\nfunction determineLatestTag(options: LatestTagOptions): {\n  latestVersion: string;\n  latestTag: string;\n  isFirstRelease: boolean;\n} {\n  const { cwd, major, minor, prerelease, prefix } = options;\n\n  // filter only tags for this prefix and major version if specified (start with \"vNN.\").\n  let prefixFilter: string;\n  if (major !== undefined && minor !== undefined) {\n    prefixFilter = `${prefix}v${major}.${minor}.*`;\n  } else if (major !== undefined) {\n    prefixFilter = `${prefix}v${major}.*`;\n  } else {\n    prefixFilter = `${prefix}v*`;\n  }\n\n  const listGitTags = [\n    \"git\",\n    '-c \"versionsort.suffix=-\"', // makes sure pre-release versions are listed after the primary version\n    \"tag\",\n    '--sort=\"-version:refname\"', // sort as versions and not lexicographically\n    \"--list\",\n    `\"${prefixFilter}\"`,\n  ].join(\" \");\n\n  const stdout = execCapture(listGitTags, { cwd }).toString(\"utf8\");\n\n  let tags = stdout?.split(\"\\n\");\n\n  // if prerelease is set and there are existing prerelease tags, filter versions that end with \"-PRE.ddd\".\n  const prereleaseTags = tags.filter((x) =>\n    new RegExp(`-${prerelease}\\.[0-9]+$`).test(x)\n  );\n  if (prerelease && prereleaseTags.length > 0) {\n    /**\n     * Cover the following case specifically\n     * 1 - v1.0.0\n     * 2 - v1.0.1-beta.0\n     * 3 - v1.0.1-beta.1\n     * 4 - v1.0.1\n     * 5 - now publish a new release on the prerelease branch\n     *    by setting the latestTag as v1.0.1 instead of v1.0.1-beta.1\n     */\n    const releaseTags = tags.filter((x) =>\n      new RegExp(`^v([0-9]+)\\.([0-9]+)\\.([0-9]+)$`).test(x)\n    );\n    if (\n      releaseTags.length > 0 &&\n      compare(releaseTags[0], prereleaseTags[0]) === 1\n    ) {\n      tags = releaseTags;\n    } else {\n      tags = prereleaseTags;\n    }\n  }\n\n  tags = tags.filter((x) => x);\n\n  // if a pre-release tag is used, then add it to the initial version\n  let isFirstRelease = false;\n  let latestTag;\n\n  if (tags.length > 0) {\n    latestTag = tags[0];\n  } else {\n    const initial = `${prefix}v${major ?? 0}.${minor ?? 0}.0`;\n    latestTag = prerelease ? `${initial}-${prerelease}.0` : initial;\n    isFirstRelease = true;\n  }\n\n  // remove tag prefix (if exists)\n  let latestVersion = latestTag;\n  if (prefix && latestVersion.startsWith(prefix)) {\n    latestVersion = latestVersion.substr(prefix.length);\n  }\n\n  // remove \"v\" prefix (if exists)\n  if (latestVersion.startsWith(\"v\")) {\n    latestVersion = latestVersion.substring(1);\n  }\n\n  return { latestVersion, latestTag, isFirstRelease };\n}\n"]}