release-please 13.0.0-candidate.5 → 13.0.0

package/build/src/strategy.js

@@ -13,237 +13,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Strategy = void 0;
-const version_1 = require("./version");
-const commit_1 = require("./commit");
-const default_1 = require("./versioning-strategies/default");
-const pull_request_title_1 = require("./util/pull-request-title");
-const branch_name_1 = require("./util/branch-name");
-const tag_name_1 = require("./util/tag-name");
-const logger_1 = require("./util/logger");
-const manifest_1 = require("./manifest");
-const pull_request_body_1 = require("./util/pull-request-body");
-const default_2 = require("./changelog-notes/default");
-const DEFAULT_CHANGELOG_PATH = 'CHANGELOG.md';
-/**
- * A strategy is responsible for determining which files are
- * necessary to update in a release pull request.
- */
-class Strategy {
-    constructor(options) {
-        var _a;
-        this.path = options.path || manifest_1.ROOT_PROJECT_PATH;
-        this.github = options.github;
-        this.packageName = options.packageName;
-        this.component =
-            options.component || this.normalizeComponent(this.packageName);
-        this.versioningStrategy =
-            options.versioningStrategy || new default_1.DefaultVersioningStrategy({});
-        this.targetBranch = options.targetBranch;
-        this.repository = options.github.repository;
-        this.changelogPath = options.changelogPath || DEFAULT_CHANGELOG_PATH;
-        this.changelogSections = options.changelogSections;
-        this.tagSeparator = options.tagSeparator;
-        this.skipGitHubRelease = options.skipGitHubRelease || false;
-        this.releaseAs = options.releaseAs;
-        this.changelogNotes =
-            options.changelogNotes || new default_2.DefaultChangelogNotes(options);
-        this.includeComponentInTag = (_a = options.includeComponentInTag) !== null && _a !== void 0 ? _a : true;
-        this.pullRequestTitlePattern = options.pullRequestTitlePattern;
-    }
-    async getComponent() {
-        if (!this.includeComponentInTag) {
-            return '';
-        }
-        return this.component || (await this.getDefaultComponent());
-    }
-    async getDefaultComponent() {
-        return this.normalizeComponent(await this.getDefaultPackageName());
-    }
-    async getDefaultPackageName() {
-        return '';
-    }
-    normalizeComponent(component) {
-        if (!component) {
-            return '';
-        }
-        return component;
-    }
-    /**
-     * Override this method to post process commits
-     * @param {ConventionalCommit[]} commits parsed commits
-     * @returns {ConventionalCommit[]} modified commits
-     */
-    postProcessCommits(commits) {
-        return commits;
-    }
-    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
-        var _a;
-        return await this.changelogNotes.buildNotes(conventionalCommits, {
-            owner: this.repository.owner,
-            repository: this.repository.repo,
-            version: newVersion.toString(),
-            previousTag: (_a = latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag) === null || _a === void 0 ? void 0 : _a.toString(),
-            currentTag: newVersionTag.toString(),
-            targetBranch: this.targetBranch,
-            changelogSections: this.changelogSections,
-        });
-    }
-    /**
-     * Builds a candidate release pull request
-     * @param {Commit[]} commits Raw commits to consider for this release.
-     * @param {Release} latestRelease Optional. The last release for this
-     *   component if available.
-     * @param {boolean} draft Optional. Whether or not to create the pull
-     *   request as a draft. Defaults to `false`.
-     * @returns {ReleasePullRequest | undefined} The release pull request to
-     *   open for this path/component. Returns undefined if we should not
-     *   open a pull request.
-     */
-    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
-        const conventionalCommits = this.postProcessCommits(commit_1.parseConventionalCommits(commits));
-        const newVersion = await this.buildNewVersion(conventionalCommits, latestRelease);
-        const versionsMap = await this.updateVersionsMap(await this.buildVersionsMap(conventionalCommits), conventionalCommits);
-        const component = await this.getComponent();
-        logger_1.logger.debug('component:', component);
-        const newVersionTag = new tag_name_1.TagName(newVersion, this.includeComponentInTag ? component : undefined, this.tagSeparator);
-        logger_1.logger.warn('pull request title pattern:', this.pullRequestTitlePattern);
-        const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion, this.pullRequestTitlePattern);
-        const branchName = component
-            ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
-            : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
-        const releaseNotesBody = await this.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
-        if (this.changelogEmpty(releaseNotesBody)) {
-            logger_1.logger.info(`No user facing commits found since ${latestRelease ? latestRelease.sha : 'beginning of time'} - skipping`);
-            return undefined;
-        }
-        const updates = await this.buildUpdates({
-            changelogEntry: releaseNotesBody,
-            newVersion,
-            versionsMap,
-            latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
-        });
-        const pullRequestBody = new pull_request_body_1.PullRequestBody([
-            {
-                component,
-                version: newVersion,
-                notes: releaseNotesBody,
-            },
-        ]);
-        return {
-            title: pullRequestTitle,
-            body: pullRequestBody,
-            updates,
-            labels,
-            headRefName: branchName.toString(),
-            version: newVersion,
-            draft: draft !== null && draft !== void 0 ? draft : false,
-        };
-    }
-    changelogEmpty(changelogEntry) {
-        return changelogEntry.split('\n').length <= 1;
-    }
-    async updateVersionsMap(versionsMap, conventionalCommits) {
-        for (const versionKey of versionsMap.keys()) {
-            const version = versionsMap.get(versionKey);
-            if (!version) {
-                logger_1.logger.warn(`didn't find version for ${versionKey}`);
-                continue;
-            }
-            const newVersion = await this.versioningStrategy.bump(version, conventionalCommits);
-            versionsMap.set(versionKey, newVersion);
-        }
-        return versionsMap;
-    }
-    async buildNewVersion(conventionalCommits, latestRelease) {
-        if (this.releaseAs) {
-            logger_1.logger.warn(`Setting version for ${this.path} from release-as configuration`);
-            return version_1.Version.parse(this.releaseAs);
-        }
-        else if (latestRelease) {
-            return await this.versioningStrategy.bump(latestRelease.tag.version, conventionalCommits);
-        }
-        else {
-            return this.initialReleaseVersion();
-        }
-    }
-    async buildVersionsMap(_conventionalCommits) {
-        return new Map();
-    }
-    /**
-     * Given a merged pull request, build the candidate release.
-     * @param {PullRequest} mergedPullRequest The merged release pull request.
-     * @returns {Release} The candidate release.
-     */
-    async buildRelease(mergedPullRequest) {
-        if (this.skipGitHubRelease) {
-            logger_1.logger.info('Release skipped from strategy config');
-            return;
-        }
-        if (!mergedPullRequest.sha) {
-            logger_1.logger.error('Pull request should have been merged');
-            return;
-        }
-        const pullRequestTitle = pull_request_title_1.PullRequestTitle.parse(mergedPullRequest.title, this.pullRequestTitlePattern) ||
-            pull_request_title_1.PullRequestTitle.parse(mergedPullRequest.title, manifest_1.MANIFEST_PULL_REQUEST_TITLE_PATTERN);
-        if (!pullRequestTitle) {
-            logger_1.logger.error(`Bad pull request title: '${mergedPullRequest.title}'`);
-            return;
-        }
-        const branchName = branch_name_1.BranchName.parse(mergedPullRequest.headBranchName);
-        if (!branchName) {
-            logger_1.logger.error(`Bad branch name: ${mergedPullRequest.headBranchName}`);
-            return;
-        }
-        const pullRequestBody = pull_request_body_1.PullRequestBody.parse(mergedPullRequest.body);
-        if (!pullRequestBody) {
-            logger_1.logger.error('Could not parse pull request body as a release PR');
-            return;
-        }
-        const component = await this.getComponent();
-        logger_1.logger.info('component:', component);
-        const releaseData = pullRequestBody.releaseData.length === 1 &&
-            !pullRequestBody.releaseData[0].component
-            ? pullRequestBody.releaseData[0]
-            : pullRequestBody.releaseData.find(releaseData => {
-                return (this.normalizeComponent(releaseData.component) ===
-                    this.normalizeComponent(component));
-            });
-        const notes = releaseData === null || releaseData === void 0 ? void 0 : releaseData.notes;
-        if (notes === undefined) {
-            logger_1.logger.warn('Failed to find release notes');
-        }
-        const version = pullRequestTitle.getVersion() || (releaseData === null || releaseData === void 0 ? void 0 : releaseData.version);
-        if (!version) {
-            logger_1.logger.error('Pull request should have included version');
-            return;
-        }
-        const tag = new tag_name_1.TagName(version, this.includeComponentInTag ? component : undefined, this.tagSeparator);
-        return {
-            tag,
-            notes: notes || '',
-            sha: mergedPullRequest.sha,
-        };
-    }
-    /**
-     * Override this to handle the initial version of a new library.
-     */
-    initialReleaseVersion() {
-        return version_1.Version.parse('1.0.0');
-    }
-    addPath(file) {
-        if (this.path === manifest_1.ROOT_PROJECT_PATH) {
-            return file;
-        }
-        file = file.replace(/^[/\\]/, '');
-        if (this.path === undefined) {
-            return file;
-        }
-        else {
-            const path = this.path.replace(/[/\\]$/, '');
-            return `${path}/${file}`;
-        }
-    }
-}
-exports.Strategy = Strategy;
 //# sourceMappingURL=strategy.js.map

package/build/src/updaters/rust/cargo-toml.js

@@ -55,7 +55,11 @@ class CargoToml extends default_1.DefaultUpdater {
                 }
                 const dep = deps[pkgName];
                 if (typeof dep === 'string' || typeof dep.path === 'undefined') {
-                    logger_1.logger.info(`skipping ${depKind}.${pkgName} in`);
+                    logger_1.logger.info(`skipping ${depKind}.${pkgName} (no path set)`);
+                    continue; // to next depKind
+                }
+                if (typeof dep.version === 'undefined') {
+                    logger_1.logger.info(`skipping ${depKind}.${pkgName} (no version set)`);
                     continue; // to next depKind
                 }
                 logger_1.logger.info(`updating ${depKind}.${pkgName} from ${dep.version} to ${pkgVersion}`);

package/build/src/util/commit-split.js

@@ -54,6 +54,9 @@ class CommitSplit {
     split(commits) {
         const splitCommits = {};
         commits.forEach(commit => {
+            if (commit.files === undefined) {
+                throw new Error(`Commit ${commit.sha} is missing files. Did you set "backfillFiles" to "true"?`);
+            }
             const dedupe = new Set();
             for (let i = 0; i < commit.files.length; i++) {
                 const file = commit.files[i];

package/build/src/util/pull-request-title.js

@@ -106,6 +106,7 @@ class PullRequestTitle {
             .replace('${scope}', scope)
             .replace('${component}', component)
             .replace('${version}', version.toString())
+            .replace('${branch}', this.targetBranch || '')
             .trim();
     }
 }

package/build/src/version.d.ts

@@ -1,11 +1,34 @@
+/**
+ * This data class is used to represent a SemVer version.
+ */
 export declare class Version {
-    major: number;
-    minor: number;
-    patch: number;
-    preRelease?: string;
-    build?: string;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly preRelease?: string;
+    readonly build?: string;
     constructor(major: number, minor: number, patch: number, preRelease?: string, build?: string);
+    /**
+     * Parse a version string into a data class.
+     *
+     * @param {string} versionString the input version string
+     * @returns {Version} the parsed version
+     * @throws {Error} if the version string cannot be parsed
+     */
     static parse(versionString: string): Version;
+    /**
+     * Comparator to other Versions to be used in sorting.
+     *
+     * @param {Version} other The other version to compare to
+     * @returns {number} -1 if this version is earlier, 0 if the versions
+     *   are the same, or 1 otherwise.
+     */
+    compare(other: Version): -1 | 0 | 1;
+    /**
+     * Returns a normalized string version of this version.
+     *
+     * @returns {string}
+     */
     toString(): string;
 }
 export declare type VersionsMap = Map<string, Version>;

package/build/src/version.js

@@ -14,7 +14,11 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Version = void 0;
+const semver = require("semver");
 const VERSION_REGEX = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(-(?<preRelease>[^+]+))?(\+(?<build>.*))?/;
+/**
+ * This data class is used to represent a SemVer version.
+ */
 class Version {
     constructor(major, minor, patch, preRelease, build) {
         this.major = major;
@@ -23,6 +27,13 @@ class Version {
         this.preRelease = preRelease;
         this.build = build;
     }
+    /**
+     * Parse a version string into a data class.
+     *
+     * @param {string} versionString the input version string
+     * @returns {Version} the parsed version
+     * @throws {Error} if the version string cannot be parsed
+     */
     static parse(versionString) {
         const match = versionString.match(VERSION_REGEX);
         if (!(match === null || match === void 0 ? void 0 : match.groups)) {
@@ -35,6 +46,21 @@ class Version {
         const build = match.groups.build;
         return new Version(major, minor, patch, preRelease, build);
     }
+    /**
+     * Comparator to other Versions to be used in sorting.
+     *
+     * @param {Version} other The other version to compare to
+     * @returns {number} -1 if this version is earlier, 0 if the versions
+     *   are the same, or 1 otherwise.
+     */
+    compare(other) {
+        return semver.compare(this.toString(), other.toString());
+    }
+    /**
+     * Returns a normalized string version of this version.
+     *
+     * @returns {string}
+     */
     toString() {
         const preReleasePart = this.preRelease ? `-${this.preRelease}` : '';
         const buildPart = this.build ? `+${this.build}` : '';

package/build/src/versioning-strategies/always-bump-patch.d.ts

@@ -2,6 +2,10 @@ import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
 import { DefaultVersioningStrategy } from './default';
 import { VersionUpdater } from '../versioning-strategy';
+/**
+ * This VersioningStrategy always bumps the patch version. This
+ * strategy is useful for backport branches.
+ */
 export declare class AlwaysBumpPatch extends DefaultVersioningStrategy {
     determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
 }

package/build/src/versioning-strategies/always-bump-patch.js

@@ -16,6 +16,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlwaysBumpPatch = void 0;
 const default_1 = require("./default");
 const versioning_strategy_1 = require("../versioning-strategy");
+/**
+ * This VersioningStrategy always bumps the patch version. This
+ * strategy is useful for backport branches.
+ */
 class AlwaysBumpPatch extends default_1.DefaultVersioningStrategy {
     determineReleaseType(_version, _commits) {
         return new versioning_strategy_1.PatchVersionUpdate();

package/build/src/versioning-strategies/default.d.ts

@@ -5,11 +5,42 @@ interface DefaultVersioningStrategyOptions {
     bumpMinorPreMajor?: boolean;
     bumpPatchForMinorPreMajor?: boolean;
 }
+/**
+ * This is the default VersioningStrategy for release-please. Breaking
+ * changes should bump the major, features should bump the minor, and other
+ * significant changes should bump the patch version.
+ */
 export declare class DefaultVersioningStrategy implements VersioningStrategy {
     readonly bumpMinorPreMajor: boolean;
     readonly bumpPatchForMinorPreMajor: boolean;
+    /**
+     * Create a new DefaultVersioningStrategy
+     * @param {DefaultVersioningStrategyOptions} options Configuration options
+     * @param {boolean} options.bumpMinorPreMajor If the current version is less than 1.0.0,
+     *   then bump the minor version for breaking changes
+     * @param {boolean} options.bumpPatchForMinorPreMajor If the current version is less than
+     *   1.0.0, then bump the patch version for features
+     */
     constructor(options?: DefaultVersioningStrategyOptions);
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return a VersionUpdater that knows how to bump the version.
+     *
+     * This is useful for chaining together versioning strategies.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {VersionUpdater} Updater for bumping the next version.
+     */
     determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return the next version.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {Version} The next version
+     */
     bump(version: Version, commits: ConventionalCommit[]): Version;
 }
 export {};

package/build/src/versioning-strategies/default.js

@@ -16,11 +16,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultVersioningStrategy = void 0;
 const versioning_strategy_1 = require("../versioning-strategy");
 const version_1 = require("../version");
+/**
+ * This is the default VersioningStrategy for release-please. Breaking
+ * changes should bump the major, features should bump the minor, and other
+ * significant changes should bump the patch version.
+ */
 class DefaultVersioningStrategy {
+    /**
+     * Create a new DefaultVersioningStrategy
+     * @param {DefaultVersioningStrategyOptions} options Configuration options
+     * @param {boolean} options.bumpMinorPreMajor If the current version is less than 1.0.0,
+     *   then bump the minor version for breaking changes
+     * @param {boolean} options.bumpPatchForMinorPreMajor If the current version is less than
+     *   1.0.0, then bump the patch version for features
+     */
     constructor(options = {}) {
         this.bumpMinorPreMajor = options.bumpMinorPreMajor === true;
         this.bumpPatchForMinorPreMajor = options.bumpPatchForMinorPreMajor === true;
     }
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return a VersionUpdater that knows how to bump the version.
+     *
+     * This is useful for chaining together versioning strategies.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {VersionUpdater} Updater for bumping the next version.
+     */
     determineReleaseType(version, commits) {
         // iterate through list of commits and find biggest commit type
         let breaking = 0;
@@ -59,6 +82,14 @@ class DefaultVersioningStrategy {
         }
         return new versioning_strategy_1.PatchVersionUpdate();
     }
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return the next version.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {Version} The next version
+     */
     bump(version, commits) {
         return this.determineReleaseType(version, commits).bump(version);
     }

package/build/src/versioning-strategies/dependency-manifest.d.ts

@@ -2,6 +2,14 @@ import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
 import { DefaultVersioningStrategy } from './default';
 import { VersionUpdater } from '../versioning-strategy';
+/**
+ * This VersioningStrategy looks at `deps` type commits and tries to
+ * mirror the semantic version bump for that dependency update. For
+ * example, an update to v2, would be treated as a major version bump.
+ *
+ * It also respects the default commit types and will pick the
+ * greatest version bump.
+ */
 export declare class DependencyManifest extends DefaultVersioningStrategy {
     determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
 }

package/build/src/versioning-strategies/dependency-manifest.js

@@ -19,6 +19,14 @@ const semver = require("semver");
 const default_1 = require("./default");
 const versioning_strategy_1 = require("../versioning-strategy");
 const DEPENDENCY_UPDATE_REGEX = /^deps: update dependency (.*) to (v.*)(\s\(#\d+\))?$/m;
+/**
+ * This VersioningStrategy looks at `deps` type commits and tries to
+ * mirror the semantic version bump for that dependency update. For
+ * example, an update to v2, would be treated as a major version bump.
+ *
+ * It also respects the default commit types and will pick the
+ * greatest version bump.
+ */
 class DependencyManifest extends default_1.DefaultVersioningStrategy {
     determineReleaseType(version, commits) {
         const regularBump = super.determineReleaseType(version, commits);

package/build/src/versioning-strategies/java-add-snapshot.d.ts

@@ -1,6 +1,10 @@
 import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
 import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next snapshot version.
+ */
 export declare class JavaAddSnapshot implements VersioningStrategy {
     strategy: VersioningStrategy;
     constructor(strategy: VersioningStrategy);

package/build/src/versioning-strategies/java-add-snapshot.js

@@ -14,6 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaAddSnapshot = void 0;
+const version_1 = require("../version");
 const fakeCommit = {
     message: 'fix: fake fix',
     type: 'fix',
@@ -27,17 +28,17 @@ const fakeCommit = {
 };
 class AddSnapshotVersionUpdate {
     constructor(strategy) {
-        this.name = 'java-snapshot';
         this.strategy = strategy;
     }
     bump(version) {
         const nextPatch = this.strategy.bump(version, [fakeCommit]);
-        nextPatch.preRelease = nextPatch.preRelease
-            ? `${nextPatch.preRelease}-SNAPSHOT`
-            : 'SNAPSHOT';
-        return nextPatch;
+        return new version_1.Version(nextPatch.major, nextPatch.minor, nextPatch.patch, nextPatch.preRelease ? `${nextPatch.preRelease}-SNAPSHOT` : 'SNAPSHOT', nextPatch.build);
     }
 }
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next snapshot version.
+ */
 class JavaAddSnapshot {
     constructor(strategy) {
         this.strategy = strategy;

package/build/src/versioning-strategies/java-snapshot.d.ts

@@ -1,6 +1,10 @@
 import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
 import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next non-snapshot version.
+ */
 export declare class JavaSnapshot implements VersioningStrategy {
     strategy: VersioningStrategy;
     constructor(strategy: VersioningStrategy);

package/build/src/versioning-strategies/java-snapshot.js

@@ -28,7 +28,6 @@ const fakeCommit = {
 };
 class RemoveSnapshotVersionUpdate {
     constructor(parent) {
-        this.name = 'remove-snapshot';
         this.parent = parent;
     }
     bump(version) {
@@ -40,6 +39,10 @@ class RemoveSnapshotVersionUpdate {
             : undefined, version.build);
     }
 }
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next non-snapshot version.
+ */
 class JavaSnapshot {
     constructor(strategy) {
         this.strategy = strategy;

package/build/src/versioning-strategies/service-pack.d.ts

@@ -2,6 +2,11 @@ import { Version } from '../version';
 import { DefaultVersioningStrategy } from './default';
 import { ConventionalCommit } from '../commit';
 import { VersionUpdater } from '../versioning-strategy';
+/**
+ * This VersioningStrategy is used for "service pack" versioning. In this
+ * strategy, we use the pre-release field with a pattern of `sp-\d+` where
+ * the number is an auto-incrementing integer starting with 1.
+ */
 export declare class ServicePackVersioningStrategy extends DefaultVersioningStrategy {
     determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
 }

package/build/src/versioning-strategies/service-pack.js

@@ -17,10 +17,12 @@ exports.ServicePackVersioningStrategy = void 0;
 const version_1 = require("../version");
 const default_1 = require("./default");
 const SERVICE_PACK_PATTERN = /sp\.(\d+)/;
+/**
+ * This version updater knows how to bump from a non-service pack
+ * version to a service pack version and increment the service
+ * pack number in subsequent releases.
+ */
 class ServicePackVersionUpdate {
-    constructor() {
-        this.name = 'service-pack';
-    }
     bump(version) {
         var _a;
         const match = (_a = version.preRelease) === null || _a === void 0 ? void 0 : _a.match(SERVICE_PACK_PATTERN);
@@ -31,6 +33,11 @@ class ServicePackVersionUpdate {
         return new version_1.Version(version.major, version.minor, version.patch, 'sp.1', version.build);
     }
 }
+/**
+ * This VersioningStrategy is used for "service pack" versioning. In this
+ * strategy, we use the pre-release field with a pattern of `sp-\d+` where
+ * the number is an auto-incrementing integer starting with 1.
+ */
 class ServicePackVersioningStrategy extends default_1.DefaultVersioningStrategy {
     determineReleaseType(_version, _commits) {
         return new ServicePackVersionUpdate();