projen
Version:
CDK for software projects
266 lines • 41.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReleasableCommits = exports.Version = exports.CHANGES_SINCE_LAST_RELEASE = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const path_1 = require("path");
const component_1 = require("./component");
const dependencies_1 = require("./dependencies");
const node_package_1 = require("./javascript/node-package");
/**
* This command determines if there were any changes since the last release in a
* cross-platform compatible way. It is used as a condition for both the `bump`
* and the `release` tasks: it exits 0 (proceed) when the most recent commit is
* not a release commit, and non-zero (skip) when the most recent commit is a
* `chore(release):` commit.
*
* Explanation:
* - `git log --oneline -1` the most recent commit, one line
* - `| grep -v "chore(release):"` pass the line through only if it is NOT a release commit
* - `> /dev/null` discard grep's output; only its exit code matters
*
* grep exits 0 when it prints at least one non-matching line (a normal commit,
* so proceed) and 1 when every line matches (a release commit, so skip).
*
* IMPORTANT: do NOT reintroduce `grep -q` here (i.e. do not "optimize" this back
* to `grep -qv`). `grep -q` exits as soon as it has an answer and closes the read
* end of the pipe. When this condition runs through projen's built-in (dax)
* shell, that early close races with `git log` still writing to the pipe, and dax
* surfaces the failed write as a spurious non-zero exit ("stdin pipe broken.
* Invalid state: WritableStream is closed"). The task runtime cannot distinguish
* that from a legitimate skip (dax reports it as a plain non-zero code under
* `.noThrow()`, not as an error), so the bump/release task is silently skipped: a
* release is missed, or a dependent publishes a broken `^0.0.0` version range.
* Plain `grep -v ... > /dev/null` reads to EOF instead of short-circuiting, so it
* never closes the pipe while the writer is active and the race cannot occur. The
* exit semantics are identical to the previous `grep -qv`.
*/
exports.CHANGES_SINCE_LAST_RELEASE = 'git log --oneline -1 | grep -v "chore(release):" > /dev/null';
/**
* The default package to be used for commit-and-tag-version
*/
const COMMIT_AND_TAG_VERSION_DEFAULT = "commit-and-tag-version@^12";
class Version extends component_1.Component {
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.Version", version: "0.103.12" };
bumpTask;
unbumpTask;
/**
* The task that prints the releasable commits since the latest tag. Spawned
* by `bump`; its shell can be overridden via `task.shell`.
*/
releasableCommitsTask;
/**
* The task that runs the user's `nextVersionCommand`, if configured. Spawned
* by `bump`; its shell can be overridden via `task.shell`.
*/
nextVersionTask;
/**
* The name of the changelog file (under `artifactsDirectory`).
*/
changelogFileName;
/**
* The name of the file that contains the version (under `artifactsDirectory`).
*/
versionFileName;
/**
* The name of the file that contains the release tag (under `artifactsDirectory`).
*/
releaseTagFileName;
/**
* The package used to bump package versions, as a dependency string.
* This is a `commit-and-tag-version` compatible package.
*/
bumpPackage;
nextVersionCommand;
constructor(scope, options) {
super(scope);
this.changelogFileName = "changelog.md";
this.versionFileName = "version.txt";
this.releaseTagFileName = "releasetag.txt";
this.bumpPackage = options.bumpPackage ?? COMMIT_AND_TAG_VERSION_DEFAULT;
this.nextVersionCommand = options.nextVersionCommand;
// This component is language independent.
// However, when in the Node.js ecosystem, we can improve the experience by adding a dev dependency on the bump package.
const node = node_package_1.NodePackage.of(this.project);
if (node) {
const { name: bumpName, version: bumpVersion } = dependencies_1.Dependencies.parseDependency(this.bumpPackage);
node.project.deps.requestDependency({
name: bumpName,
version: bumpVersion,
type: dependencies_1.DependencyType.BUILD,
});
}
const versionInputFile = options.versionInputFile;
const changelogFile = path_1.posix.join(options.artifactsDirectory, this.changelogFileName);
const bumpFile = path_1.posix.join(options.artifactsDirectory, this.versionFileName);
const releaseTagFile = path_1.posix.join(options.artifactsDirectory, this.releaseTagFileName);
const commonEnv = {
OUTFILE: versionInputFile,
CHANGELOG: changelogFile,
BUMPFILE: bumpFile,
RELEASETAG: releaseTagFile,
RELEASE_TAG_PREFIX: options.tagPrefix ?? "",
// doesn't work if custom configuration is long
VERSIONRCOPTIONS: JSON.stringify(options.versionrcOptions),
BUMP_PACKAGE: this.bumpPackage,
};
// The command that lists releasable commits, run as its own spawnable task
// so its shell can be configured independently (see `TaskShell`).
// `$LATEST_TAG` is provided by `bump` when spawning it.
this.releasableCommitsTask = this.project.addTask("bump:releasable-commits", {
description: "Print the releasable commits since the latest release",
exec: (options.releasableCommits ?? ReleasableCommits.everyCommit())
.cmd,
});
// The optional command that decides the next version, also its own task.
if (this.nextVersionCommand) {
this.nextVersionTask = this.project.addTask("bump:next-version", {
description: "Determine the next version to release",
exec: this.nextVersionCommand,
});
}
// Orchestrates the release bump as a pipeline of builtins and spawned
// tasks, handing results forward via step `outputEnv` captures.
this.bumpTask = this.project.addTask("bump", {
description: "Bumps version based on latest git tag and generates a changelog entry",
condition: exports.CHANGES_SINCE_LAST_RELEASE,
env: { ...commonEnv },
});
this.bumpTask.addSteps({ builtin: "release/resolve-latest-tag", outputEnv: "LATEST_TAG" },
// On a first release the resolved tag is synthetic and does not exist, so
// there is nothing to diff against - skip listing commits in that case.
{
spawn: "bump:releasable-commits",
outputEnv: "RELEASABLE_COMMITS",
condition: 'git rev-parse --verify --quiet "refs/tags/$LATEST_TAG"',
}, { builtin: "release/suggest-version-bump", outputEnv: "SUGGESTED_BUMP" });
if (this.nextVersionTask) {
// `bump:next-version` receives `$VERSION` (the current version); read it
// from the version file into `VERSION` so it propagates to the spawn.
this.bumpTask.addSteps({
exec: `node -e "process.stdout.write(JSON.parse(require('fs').readFileSync(process.env.OUTFILE,'utf8')).version)"`,
outputEnv: "VERSION",
}, { spawn: "bump:next-version", outputEnv: "BUMP_TYPE" });
}
this.bumpTask.addSteps({ builtin: "release/apply-version-bump" });
// Resets the version in the version file back to 0.0.0 after a bump.
this.unbumpTask = this.project.addTask("unbump", {
description: "Restores version to 0.0.0",
env: { ...commonEnv },
});
this.unbumpTask.builtin("release/reset-version");
this.project.addGitIgnore(`/${changelogFile}`);
this.project.addGitIgnore(`/${bumpFile}`);
this.project.addPackageIgnore(`/${changelogFile}`);
this.project.addPackageIgnore(`/${bumpFile}`);
}
/**
* Return the environment variables to modify the bump command for release branches.
*
* These options are used to modify the behavior of the version bumping script
* for additional branches, by setting environment variables.
*
* No settings are inherited from the base `Version` object (but any parameters that
* control versions do conflict with the use of a `nextVersionCommand`).
*/
envForBranch(branchOptions) {
if (this.nextVersionCommand && branchOptions.minMajorVersion) {
throw new Error("minMajorVersion and nextVersionCommand cannot be used together.");
}
const env = {};
if (branchOptions.majorVersion !== undefined) {
env.MAJOR = branchOptions.majorVersion.toString();
}
if (branchOptions.minMajorVersion !== undefined) {
if (branchOptions.majorVersion !== undefined) {
throw new Error(`minMajorVersion and majorVersion cannot be used together.`);
}
env.MIN_MAJOR = branchOptions.minMajorVersion.toString();
}
if (branchOptions.prerelease) {
env.PRERELEASE = branchOptions.prerelease;
}
if (branchOptions.tagPrefix) {
env.RELEASE_TAG_PREFIX = branchOptions.tagPrefix;
}
return env;
}
}
exports.Version = Version;
/**
* Find commits that should be considered releasable to decide if a release is required.
*
* This setting only controls whether a release is triggered, yes or no. The
* paths used here are independent of the code that controls what commits are inspected
* to determine the version number.
*/
class ReleasableCommits {
cmd;
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.ReleasableCommits", version: "0.103.12" };
/**
* Release every commit
*
* This will only not release if the most recent commit is tagged with the latest matching tag.
*
* @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.
* This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `"."`.
*/
static everyCommit(path) {
const cmd = `git log --oneline $LATEST_TAG..HEAD`;
return new ReleasableCommits(withPath(cmd, path));
}
/**
* Limit commits by their conventional commit type
*
* This will only release commit that match one of the provided types.
* Commits are required to follow the conventional commit spec and will be ignored otherwise.
*
* @param types List of conventional commit types that should be released
* @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.
* This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `"."`.
*/
static ofType(types, path) {
const allowedTypes = types.join("|");
// @see: https://github.com/conventional-commits/parser/blob/eeefb961ebf5b9dfea0fea8b06f8ad34a1e439b9/lib/parser.js
// -E requires this to be POSIX Extended Regular Expression, which comes with certain limitations
// see https://en.wikibooks.org/wiki/Regular_Expressions/POSIX-Extended_Regular_Expressions for details
const cmd = `git log --no-merges --oneline $LATEST_TAG..HEAD -E --grep '^(${allowedTypes}){1}(\\([^()[:space:]]+\\))?(!)?:[[:blank:]]+.+'`;
return new ReleasableCommits(withPath(cmd, path));
}
/**
* Release only features and fixes
*
* Shorthand for `ReleasableCommits.onlyOfType(['feat', 'fix'])`.
*
* @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.
* This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `"."`.
*/
static featuresAndFixes(path) {
return ReleasableCommits.ofType(["feat", "fix"], path);
}
/**
* Use an arbitrary shell command to find releasable commits since the latest tag.
*
* A new release will be initiated, if the number of returned commits is greater than zero.
* Must return a newline separate list of commits that should considered releasable.
* `$LATEST_TAG` is available as an environment variable (set to the actual latest tag for the given prefix).
*
* @example "git log --oneline $LATEST_TAG..HEAD -- ."
*/
static exec(cmd) {
return new ReleasableCommits(cmd);
}
constructor(cmd) {
this.cmd = cmd;
}
}
exports.ReleasableCommits = ReleasableCommits;
/**
* Append a path argument to a git command if one is provided
*/
function withPath(cmd, path) {
if (path !== undefined) {
return `${cmd} -- ${path}`;
}
return cmd;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"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","sourcesContent":["import { posix } from \"path\";\nimport type { IConstruct } from \"constructs\";\nimport { Component } from \"./component\";\nimport { Dependencies, DependencyType } from \"./dependencies\";\nimport { NodePackage } from \"./javascript/node-package\";\nimport type { Task } from \"./task\";\n\n/**\n * This command determines if there were any changes since the last release in a\n * cross-platform compatible way. It is used as a condition for both the `bump`\n * and the `release` tasks: it exits 0 (proceed) when the most recent commit is\n * not a release commit, and non-zero (skip) when the most recent commit is a\n * `chore(release):` commit.\n *\n * Explanation:\n *  - `git log --oneline -1`          the most recent commit, one line\n *  - `| grep -v \"chore(release):\"`   pass the line through only if it is NOT a release commit\n *  - `> /dev/null`                   discard grep's output; only its exit code matters\n *\n * grep exits 0 when it prints at least one non-matching line (a normal commit,\n * so proceed) and 1 when every line matches (a release commit, so skip).\n *\n * IMPORTANT: do NOT reintroduce `grep -q` here (i.e. do not \"optimize\" this back\n * to `grep -qv`). `grep -q` exits as soon as it has an answer and closes the read\n * end of the pipe. When this condition runs through projen's built-in (dax)\n * shell, that early close races with `git log` still writing to the pipe, and dax\n * surfaces the failed write as a spurious non-zero exit (\"stdin pipe broken.\n * Invalid state: WritableStream is closed\"). The task runtime cannot distinguish\n * that from a legitimate skip (dax reports it as a plain non-zero code under\n * `.noThrow()`, not as an error), so the bump/release task is silently skipped: a\n * release is missed, or a dependent publishes a broken `^0.0.0` version range.\n * Plain `grep -v ... > /dev/null` reads to EOF instead of short-circuiting, so it\n * never closes the pipe while the writer is active and the race cannot occur. The\n * exit semantics are identical to the previous `grep -qv`.\n */\nexport const CHANGES_SINCE_LAST_RELEASE =\n  'git log --oneline -1 | grep -v \"chore(release):\" > /dev/null';\n\n/**\n * The default package to be used for commit-and-tag-version\n */\nconst COMMIT_AND_TAG_VERSION_DEFAULT = \"commit-and-tag-version@^12\";\n\n/**\n * Options for `Version`.\n */\nexport interface VersionOptions {\n  /**\n   * A name of a .json file to set the `version` field in after a bump.\n   *\n   * @example \"package.json\"\n   */\n  readonly versionInputFile: string;\n\n  /**\n   * The name of the directory into which `changelog.md` and `version.txt` files\n   * are emitted.\n   */\n  readonly artifactsDirectory: string;\n\n  /**\n   * Custom configuration for versionrc file used by standard-release\n   */\n  readonly versionrcOptions?: Record<string, any>;\n\n  /**\n   * The tag prefix corresponding to this version.\n   */\n  readonly tagPrefix?: string;\n\n  /**\n   * Find commits that should be considered releasable\n   * Used to decide if a release is required.\n   *\n   * @default ReleasableCommits.everyCommit()\n   */\n  readonly releasableCommits?: ReleasableCommits;\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   * - `$SUGGESTED_BUMP`: the suggested bump action based on commits. One of `major|minor|patch|none`.\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   * @default - The next version will be determined based on the commit history and project settings.\n   */\n  readonly nextVersionCommand?: string;\n}\n\nexport class Version extends Component {\n  public readonly bumpTask: Task;\n  public readonly unbumpTask: Task;\n\n  /**\n   * The task that prints the releasable commits since the latest tag. Spawned\n   * by `bump`; its shell can be overridden via `task.shell`.\n   */\n  public readonly releasableCommitsTask: Task;\n\n  /**\n   * The task that runs the user's `nextVersionCommand`, if configured. Spawned\n   * by `bump`; its shell can be overridden via `task.shell`.\n   */\n  public readonly nextVersionTask?: Task;\n\n  /**\n   * The name of the changelog file (under `artifactsDirectory`).\n   */\n  public readonly changelogFileName: string;\n\n  /**\n   * The name of the file that contains the version (under `artifactsDirectory`).\n   */\n  public readonly versionFileName: string;\n\n  /**\n   * The name of the file that contains the release tag (under `artifactsDirectory`).\n   */\n  public readonly releaseTagFileName: string;\n\n  /**\n   * The package used to bump package versions, as a dependency string.\n   * This is a `commit-and-tag-version` compatible package.\n   */\n  public readonly bumpPackage: string;\n\n  private readonly nextVersionCommand?: string;\n\n  constructor(scope: IConstruct, options: VersionOptions) {\n    super(scope);\n\n    this.changelogFileName = \"changelog.md\";\n    this.versionFileName = \"version.txt\";\n    this.releaseTagFileName = \"releasetag.txt\";\n    this.bumpPackage = options.bumpPackage ?? COMMIT_AND_TAG_VERSION_DEFAULT;\n    this.nextVersionCommand = options.nextVersionCommand;\n\n    // This component is language independent.\n    // However, when in the Node.js ecosystem, we can improve the experience by adding a dev dependency on the bump package.\n    const node = NodePackage.of(this.project);\n    if (node) {\n      const { name: bumpName, version: bumpVersion } =\n        Dependencies.parseDependency(this.bumpPackage);\n      node.project.deps.requestDependency({\n        name: bumpName,\n        version: bumpVersion,\n        type: DependencyType.BUILD,\n      });\n    }\n\n    const versionInputFile = options.versionInputFile;\n\n    const changelogFile = posix.join(\n      options.artifactsDirectory,\n      this.changelogFileName,\n    );\n    const bumpFile = posix.join(\n      options.artifactsDirectory,\n      this.versionFileName,\n    );\n    const releaseTagFile = posix.join(\n      options.artifactsDirectory,\n      this.releaseTagFileName,\n    );\n\n    const commonEnv: Record<string, string> = {\n      OUTFILE: versionInputFile,\n      CHANGELOG: changelogFile,\n      BUMPFILE: bumpFile,\n      RELEASETAG: releaseTagFile,\n      RELEASE_TAG_PREFIX: options.tagPrefix ?? \"\",\n      // doesn't work if custom configuration is long\n      VERSIONRCOPTIONS: JSON.stringify(options.versionrcOptions),\n      BUMP_PACKAGE: this.bumpPackage,\n    };\n\n    // The command that lists releasable commits, run as its own spawnable task\n    // so its shell can be configured independently (see `TaskShell`).\n    // `$LATEST_TAG` is provided by `bump` when spawning it.\n    this.releasableCommitsTask = this.project.addTask(\n      \"bump:releasable-commits\",\n      {\n        description: \"Print the releasable commits since the latest release\",\n        exec: (options.releasableCommits ?? ReleasableCommits.everyCommit())\n          .cmd,\n      },\n    );\n\n    // The optional command that decides the next version, also its own task.\n    if (this.nextVersionCommand) {\n      this.nextVersionTask = this.project.addTask(\"bump:next-version\", {\n        description: \"Determine the next version to release\",\n        exec: this.nextVersionCommand,\n      });\n    }\n\n    // Orchestrates the release bump as a pipeline of builtins and spawned\n    // tasks, handing results forward via step `outputEnv` captures.\n    this.bumpTask = this.project.addTask(\"bump\", {\n      description:\n        \"Bumps version based on latest git tag and generates a changelog entry\",\n      condition: CHANGES_SINCE_LAST_RELEASE,\n      env: { ...commonEnv },\n    });\n\n    this.bumpTask.addSteps(\n      { builtin: \"release/resolve-latest-tag\", outputEnv: \"LATEST_TAG\" },\n      // On a first release the resolved tag is synthetic and does not exist, so\n      // there is nothing to diff against - skip listing commits in that case.\n      {\n        spawn: \"bump:releasable-commits\",\n        outputEnv: \"RELEASABLE_COMMITS\",\n        condition: 'git rev-parse --verify --quiet \"refs/tags/$LATEST_TAG\"',\n      },\n      { builtin: \"release/suggest-version-bump\", outputEnv: \"SUGGESTED_BUMP\" },\n    );\n    if (this.nextVersionTask) {\n      // `bump:next-version` receives `$VERSION` (the current version); read it\n      // from the version file into `VERSION` so it propagates to the spawn.\n      this.bumpTask.addSteps(\n        {\n          exec: `node -e \"process.stdout.write(JSON.parse(require('fs').readFileSync(process.env.OUTFILE,'utf8')).version)\"`,\n          outputEnv: \"VERSION\",\n        },\n        { spawn: \"bump:next-version\", outputEnv: \"BUMP_TYPE\" },\n      );\n    }\n    this.bumpTask.addSteps({ builtin: \"release/apply-version-bump\" });\n\n    // Resets the version in the version file back to 0.0.0 after a bump.\n    this.unbumpTask = this.project.addTask(\"unbump\", {\n      description: \"Restores version to 0.0.0\",\n      env: { ...commonEnv },\n    });\n\n    this.unbumpTask.builtin(\"release/reset-version\");\n\n    this.project.addGitIgnore(`/${changelogFile}`);\n    this.project.addGitIgnore(`/${bumpFile}`);\n    this.project.addPackageIgnore(`/${changelogFile}`);\n    this.project.addPackageIgnore(`/${bumpFile}`);\n  }\n\n  /**\n   * Return the environment variables to modify the bump command for release branches.\n   *\n   * These options are used to modify the behavior of the version bumping script\n   * for additional branches, by setting environment variables.\n   *\n   * No settings are inherited from the base `Version` object (but any parameters that\n   * control versions do conflict with the use of a `nextVersionCommand`).\n   */\n  public envForBranch(\n    branchOptions: VersionBranchOptions,\n  ): Record<string, string> {\n    if (this.nextVersionCommand && branchOptions.minMajorVersion) {\n      throw new Error(\n        \"minMajorVersion and nextVersionCommand cannot be used together.\",\n      );\n    }\n\n    const env: Record<string, string> = {};\n    if (branchOptions.majorVersion !== undefined) {\n      env.MAJOR = branchOptions.majorVersion.toString();\n    }\n\n    if (branchOptions.minMajorVersion !== undefined) {\n      if (branchOptions.majorVersion !== undefined) {\n        throw new Error(\n          `minMajorVersion and majorVersion cannot be used together.`,\n        );\n      }\n\n      env.MIN_MAJOR = branchOptions.minMajorVersion.toString();\n    }\n\n    if (branchOptions.prerelease) {\n      env.PRERELEASE = branchOptions.prerelease;\n    }\n\n    if (branchOptions.tagPrefix) {\n      env.RELEASE_TAG_PREFIX = branchOptions.tagPrefix;\n    }\n\n    return env;\n  }\n}\n\n/**\n * Options to pass to `modifyBranchEnvironment`\n */\nexport interface VersionBranchOptions {\n  /**\n   * The major versions released from this branch.\n   */\n  readonly majorVersion?: number;\n\n  /**\n   * The minimum major version to release.\n   */\n  readonly minMajorVersion?: number;\n\n  /**\n   * The minor versions released from this branch.\n   */\n  readonly minorVersion?: number;\n\n  /**\n   * Bump the version as a pre-release tag.\n   *\n   * @default - normal releases\n   */\n  readonly prerelease?: string;\n\n  /**\n   * Automatically add the given prefix to release tags.\n   * Useful if you are releasing on multiple branches with overlapping\n   * version numbers.\n   *\n   * Note: this prefix is used to detect the latest tagged version\n   * when bumping, so if you change this on a project with an existing version\n   * history, you may need to manually tag your latest release\n   * with the new prefix.\n   *\n   * @default - no prefix\n   */\n  readonly tagPrefix?: string;\n}\n\n/**\n * Find commits that should be considered releasable to decide if a release is required.\n *\n * This setting only controls whether a release is triggered, yes or no. The\n * paths used here are independent of the code that controls what commits are inspected\n * to determine the version number.\n */\nexport class ReleasableCommits {\n  /**\n   * Release every commit\n   *\n   * This will only not release if the most recent commit is tagged with the latest matching tag.\n   *\n   * @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.\n   * This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `\".\"`.\n   */\n  static everyCommit(path?: string) {\n    const cmd = `git log --oneline $LATEST_TAG..HEAD`;\n    return new ReleasableCommits(withPath(cmd, path));\n  }\n\n  /**\n   * Limit commits by their conventional commit type\n   *\n   * This will only release commit that match one of the provided types.\n   * Commits are required to follow the conventional commit spec and will be ignored otherwise.\n   *\n   * @param types List of conventional commit types that should be released\n   * @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.\n   * This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `\".\"`.\n   */\n  static ofType(types: string[], path?: string) {\n    const allowedTypes = types.join(\"|\");\n\n    // @see: https://github.com/conventional-commits/parser/blob/eeefb961ebf5b9dfea0fea8b06f8ad34a1e439b9/lib/parser.js\n    // -E requires this to be POSIX Extended Regular Expression, which comes with certain limitations\n    // see https://en.wikibooks.org/wiki/Regular_Expressions/POSIX-Extended_Regular_Expressions for details\n    const cmd = `git log --no-merges --oneline $LATEST_TAG..HEAD -E --grep '^(${allowedTypes}){1}(\\\\([^()[:space:]]+\\\\))?(!)?:[[:blank:]]+.+'`;\n\n    return new ReleasableCommits(withPath(cmd, path));\n  }\n\n  /**\n   * Release only features and fixes\n   *\n   * Shorthand for `ReleasableCommits.onlyOfType(['feat', 'fix'])`.\n   *\n   * @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.\n   * This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `\".\"`.\n   */\n  static featuresAndFixes(path?: string) {\n    return ReleasableCommits.ofType([\"feat\", \"fix\"], path);\n  }\n\n  /**\n   * Use an arbitrary shell command to find releasable commits since the latest tag.\n   *\n   * A new release will be initiated, if the number of returned commits is greater than zero.\n   * Must return a newline separate list of commits that should considered releasable.\n   * `$LATEST_TAG` is available as an environment variable (set to the actual latest tag for the given prefix).\n   *\n   * @example \"git log --oneline $LATEST_TAG..HEAD -- .\"\n   */\n  static exec(cmd: string) {\n    return new ReleasableCommits(cmd);\n  }\n\n  private constructor(public cmd: string) {}\n}\n\n/**\n * Append a path argument to a git command if one is provided\n */\nfunction withPath(cmd: string, path?: string): string {\n  if (path !== undefined) {\n    return `${cmd} -- ${path}`;\n  }\n\n  return cmd;\n}\n"]}