release-please 13.0.0-candidate.5 → 13.0.0

package/build/src/manifest.js

@@ -58,6 +58,7 @@ class Manifest {
      *   pull request. Defaults to `[autorelease: tagged]`
      */
     constructor(github, targetBranch, repositoryConfig, releasedVersions, manifestOptions) {
+        var _a;
         this.repository = github.repository;
         this.github = github;
         this.targetBranch = targetBranch;
@@ -65,7 +66,7 @@ class Manifest {
         this.releasedVersions = releasedVersions;
         this.manifestPath =
             (manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.manifestPath) || exports.DEFAULT_RELEASE_PLEASE_MANIFEST;
-        this.separatePullRequests = (manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.separatePullRequests) || false;
+        this.separatePullRequests = (_a = manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.separatePullRequests) !== null && _a !== void 0 ? _a : Object.keys(repositoryConfig).length === 1;
         this.plugins = (manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.plugins) || [];
         this.fork = (manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.fork) || false;
         this.signoffUser = manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.signoff;
@@ -131,7 +132,10 @@ class Manifest {
         if (latestVersion) {
             releasedVersions[path] = latestVersion;
         }
-        return new Manifest(github, targetBranch, repositoryConfig, releasedVersions, manifestOptions);
+        return new Manifest(github, targetBranch, repositoryConfig, releasedVersions, {
+            separatePullRequests: true,
+            ...manifestOptions,
+        });
     }
     /**
      * Build all candidate pull requests for this repository.
@@ -154,7 +158,9 @@ class Manifest {
         const releaseShasByPath = {};
         // Releases by path
         const releasesByPath = {};
-        for await (const release of this.github.releaseIterator(400)) {
+        for await (const release of this.github.releaseIterator({
+            maxResults: 400,
+        })) {
             // logger.debug(release);
             const tagName = tag_name_1.TagName.parse(release.tagName);
             if (!tagName) {
@@ -198,7 +204,10 @@ class Manifest {
         // seen all release commits
         logger_1.logger.info('Collecting commits since all latest releases');
         const commits = [];
-        const commitGenerator = this.github.mergeCommitIterator(this.targetBranch, 500);
+        const commitGenerator = this.github.mergeCommitIterator(this.targetBranch, {
+            maxResults: 500,
+            backfillFiles: true,
+        });
         const releaseShas = new Set(Object.values(releaseShasByPath));
         logger_1.logger.debug(releaseShas);
         const expectedShas = releaseShas.size;
@@ -262,6 +271,7 @@ class Manifest {
             const strategy = strategiesByPath[path];
             let latestRelease = releasesByPath[path];
             if (!latestRelease &&
+                this.releasedVersions[path] &&
                 this.releasedVersions[path].toString() !== '0.0.0') {
                 const version = this.releasedVersions[path];
                 const component = await strategy.getComponent();
@@ -534,7 +544,7 @@ exports.Manifest = Manifest;
  */
 function extractReleaserConfig(config) {
     return {
-        releaseType: config['release-type'] || 'node',
+        releaseType: config['release-type'],
         bumpMinorPreMajor: config['bump-minor-pre-major'],
         bumpPatchForMinorPreMajor: config['bump-patch-for-minor-pre-major'],
         changelogSections: config['changelog-sections'],
@@ -607,11 +617,15 @@ async function latestReleaseVersion(github, targetBranch, prefix, pullRequestTit
             : prefix
         : undefined;
     logger_1.logger.info(`Looking for latest release on branch: ${targetBranch} with prefix: ${prefix}`);
+    // collect set of recent commit SHAs seen to verify that the release
+    // is in the current branch
+    const commitShas = new Set();
     // only look at the last 250 or so commits to find the latest tag - we
     // don't want to scan the entire repository history if this repo has never
     // been released
-    const generator = github.mergeCommitIterator(targetBranch, 250);
+    const generator = github.mergeCommitIterator(targetBranch, { maxResults: 250 });
     for await (const commitWithPullRequest of generator) {
+        commitShas.add(commitWithPullRequest.sha);
         const mergedPullRequest = commitWithPullRequest.pullRequest;
         if (!mergedPullRequest) {
             continue;
@@ -636,23 +650,65 @@ async function latestReleaseVersion(github, targetBranch, prefix, pullRequestTit
         }
         return version;
     }
-    return;
+    // If not found from recent pull requests, look at releases. Iterate
+    // through releases finding valid tags, then cross reference
+    const releaseGenerator = github.releaseIterator();
+    const candidateReleaseVersions = [];
+    for await (const release of releaseGenerator) {
+        const tagName = tag_name_1.TagName.parse(release.tagName);
+        if (!tagName) {
+            continue;
+        }
+        if (tagName.component === branchPrefix) {
+            logger_1.logger.debug(`found release for ${prefix}`, tagName.version);
+            if (!commitShas.has(release.sha)) {
+                logger_1.logger.debug(`SHA not found in recent commits to branch ${targetBranch}, skipping`);
+                continue;
+            }
+            candidateReleaseVersions.push(tagName.version);
+        }
+    }
+    logger_1.logger.debug(`found ${candidateReleaseVersions.length} possible releases.`, candidateReleaseVersions);
+    if (candidateReleaseVersions.length > 0) {
+        // Find largest release number (sort descending then return first)
+        return candidateReleaseVersions.sort((a, b) => b.compare(a))[0];
+    }
+    // If not found from recent pull requests or releases, look at tags. Iterate
+    // through tags and cross reference against SHAs in this branch
+    const tagGenerator = github.tagIterator();
+    const candidateTagVersion = [];
+    for await (const tag of tagGenerator) {
+        const tagName = tag_name_1.TagName.parse(tag.name);
+        if (!tagName) {
+            continue;
+        }
+        if (tagName.component === branchPrefix) {
+            if (!commitShas.has(tag.sha)) {
+                logger_1.logger.debug(`SHA not found in recent commits to branch ${targetBranch}, skipping`);
+                continue;
+            }
+            candidateTagVersion.push(tagName.version);
+        }
+    }
+    logger_1.logger.debug(`found ${candidateTagVersion.length} possible tags.`, candidateTagVersion);
+    // Find largest release number (sort descending then return first)
+    return candidateTagVersion.sort((a, b) => b.compare(a))[0];
 }
 function mergeReleaserConfig(defaultConfig, pathConfig) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     return {
-        releaseType: (_a = pathConfig.releaseType) !== null && _a !== void 0 ? _a : defaultConfig.releaseType,
-        bumpMinorPreMajor: (_b = pathConfig.bumpMinorPreMajor) !== null && _b !== void 0 ? _b : defaultConfig.bumpMinorPreMajor,
-        bumpPatchForMinorPreMajor: (_c = pathConfig.bumpPatchForMinorPreMajor) !== null && _c !== void 0 ? _c : defaultConfig.bumpPatchForMinorPreMajor,
-        changelogSections: (_d = pathConfig.changelogSections) !== null && _d !== void 0 ? _d : defaultConfig.changelogSections,
-        changelogPath: (_e = pathConfig.changelogPath) !== null && _e !== void 0 ? _e : defaultConfig.changelogPath,
-        releaseAs: (_f = pathConfig.releaseAs) !== null && _f !== void 0 ? _f : defaultConfig.releaseAs,
-        skipGithubRelease: (_g = pathConfig.skipGithubRelease) !== null && _g !== void 0 ? _g : defaultConfig.skipGithubRelease,
-        draft: (_h = pathConfig.draft) !== null && _h !== void 0 ? _h : defaultConfig.draft,
-        component: (_j = pathConfig.component) !== null && _j !== void 0 ? _j : defaultConfig.component,
-        packageName: (_k = pathConfig.packageName) !== null && _k !== void 0 ? _k : defaultConfig.packageName,
-        versionFile: (_l = pathConfig.versionFile) !== null && _l !== void 0 ? _l : defaultConfig.versionFile,
-        extraFiles: (_m = pathConfig.extraFiles) !== null && _m !== void 0 ? _m : defaultConfig.extraFiles,
+        releaseType: (_b = (_a = pathConfig.releaseType) !== null && _a !== void 0 ? _a : defaultConfig.releaseType) !== null && _b !== void 0 ? _b : 'node',
+        bumpMinorPreMajor: (_c = pathConfig.bumpMinorPreMajor) !== null && _c !== void 0 ? _c : defaultConfig.bumpMinorPreMajor,
+        bumpPatchForMinorPreMajor: (_d = pathConfig.bumpPatchForMinorPreMajor) !== null && _d !== void 0 ? _d : defaultConfig.bumpPatchForMinorPreMajor,
+        changelogSections: (_e = pathConfig.changelogSections) !== null && _e !== void 0 ? _e : defaultConfig.changelogSections,
+        changelogPath: (_f = pathConfig.changelogPath) !== null && _f !== void 0 ? _f : defaultConfig.changelogPath,
+        releaseAs: (_g = pathConfig.releaseAs) !== null && _g !== void 0 ? _g : defaultConfig.releaseAs,
+        skipGithubRelease: (_h = pathConfig.skipGithubRelease) !== null && _h !== void 0 ? _h : defaultConfig.skipGithubRelease,
+        draft: (_j = pathConfig.draft) !== null && _j !== void 0 ? _j : defaultConfig.draft,
+        component: (_k = pathConfig.component) !== null && _k !== void 0 ? _k : defaultConfig.component,
+        packageName: (_l = pathConfig.packageName) !== null && _l !== void 0 ? _l : defaultConfig.packageName,
+        versionFile: (_m = pathConfig.versionFile) !== null && _m !== void 0 ? _m : defaultConfig.versionFile,
+        extraFiles: (_o = pathConfig.extraFiles) !== null && _o !== void 0 ? _o : defaultConfig.extraFiles,
     };
 }
 /**

package/build/src/plugins/cargo-workspace.js

@@ -25,6 +25,7 @@ const changelog_1 = require("../updaters/changelog");
 const pull_request_title_1 = require("../util/pull-request-title");
 const pull_request_body_1 = require("../util/pull-request-body");
 const branch_name_1 = require("../util/branch-name");
+const versioning_strategy_1 = require("../versioning-strategy");
 /**
  * The plugin analyzed a cargo workspace and will bump dependencies
  * of managed packages if those dependencies are being updated.
@@ -84,8 +85,7 @@ class CargoWorkspace extends workspace_1.WorkspacePlugin {
     }
     bumpVersion(pkg) {
         const version = version_1.Version.parse(pkg.version);
-        version.patch += 1;
-        return version;
+        return new versioning_strategy_1.PatchVersionUpdate().bump(version);
     }
     updateCandidate(existingCandidate, pkg, updatedVersions) {
         const version = updatedVersions.get(pkg.name);

package/build/src/plugins/merge.js

@@ -28,7 +28,7 @@ const composite_1 = require("../updaters/composite");
  */
 class Merge extends plugin_1.ManifestPlugin {
     async run(candidates) {
-        if (candidates.length < 2) {
+        if (candidates.length < 1) {
             return candidates;
         }
         const updatesByPath = {};
@@ -44,6 +44,9 @@ class Merge extends plugin_1.ManifestPlugin {
                     updatesByPath[update.path] = [update];
                 }
             }
+            for (const label of pullRequest.labels) {
+                labels.add(label);
+            }
             releaseData.push(...pullRequest.body.releaseData);
         }
         const updates = [];

package/build/src/plugins/node-workspace.js

@@ -26,6 +26,7 @@ const branch_name_1 = require("../util/branch-name");
 const json_stringify_1 = require("../util/json-stringify");
 const changelog_1 = require("../updaters/changelog");
 const workspace_1 = require("./workspace");
+const versioning_strategy_1 = require("../versioning-strategy");
 class Package extends package_1.Package {
     constructor(rawContent, location, pkg) {
         super(pkg !== null && pkg !== void 0 ? pkg : JSON.parse(rawContent), location);
@@ -92,8 +93,7 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
     }
     bumpVersion(pkg) {
         const version = version_1.Version.parse(pkg.version);
-        version.patch += 1;
-        return version;
+        return new versioning_strategy_1.PatchVersionUpdate().bump(version);
     }
     updateCandidate(existingCandidate, pkg, updatedVersions) {
         var _a;

package/build/src/pull-request.d.ts

@@ -1,10 +1,10 @@
 export interface PullRequest {
-    headBranchName: string;
-    baseBranchName: string;
-    number: number;
-    title: string;
-    body: string;
-    labels: string[];
-    files: string[];
-    sha?: string;
+    readonly headBranchName: string;
+    readonly baseBranchName: string;
+    readonly number: number;
+    readonly title: string;
+    readonly body: string;
+    readonly labels: string[];
+    readonly files: string[];
+    readonly sha?: string;
 }

package/build/src/release-pull-request.d.ts

@@ -3,11 +3,11 @@ import { Version } from './version';
 import { PullRequestBody } from './util/pull-request-body';
 import { PullRequestTitle } from './util/pull-request-title';
 export interface ReleasePullRequest {
-    title: PullRequestTitle;
-    body: PullRequestBody;
+    readonly title: PullRequestTitle;
+    readonly body: PullRequestBody;
+    readonly labels: string[];
+    readonly headRefName: string;
+    readonly version?: Version;
+    readonly draft: boolean;
     updates: Update[];
-    labels: string[];
-    headRefName: string;
-    version?: Version;
-    draft: boolean;
 }

package/build/src/strategies/base.d.ts

@@ -0,0 +1,108 @@
+import { Strategy } from '../strategy';
+import { GitHub } from '../github';
+import { VersioningStrategy } from '../versioning-strategy';
+import { Repository } from '../repository';
+import { ChangelogNotes, ChangelogSection } from '../changelog-notes';
+import { Update } from '../update';
+import { ConventionalCommit, Commit } from '../commit';
+import { Version, VersionsMap } from '../version';
+import { TagName } from '../util/tag-name';
+import { Release } from '../release';
+import { ReleasePullRequest } from '../release-pull-request';
+import { PullRequest } from '../pull-request';
+export interface BuildUpdatesOptions {
+    changelogEntry: string;
+    newVersion: Version;
+    versionsMap: VersionsMap;
+    latestVersion?: Version;
+}
+export interface BaseStrategyOptions {
+    path?: string;
+    bumpMinorPreMajor?: boolean;
+    bumpPatchForMinorPreMajor?: boolean;
+    github: GitHub;
+    component?: string;
+    packageName?: string;
+    versioningStrategy?: VersioningStrategy;
+    targetBranch: string;
+    changelogPath?: string;
+    changelogSections?: ChangelogSection[];
+    commitPartial?: string;
+    headerPartial?: string;
+    mainTemplate?: string;
+    tagSeparator?: string;
+    skipGitHubRelease?: boolean;
+    releaseAs?: string;
+    changelogNotes?: ChangelogNotes;
+    includeComponentInTag?: boolean;
+    pullRequestTitlePattern?: string;
+}
+/**
+ * A strategy is responsible for determining which files are
+ * necessary to update in a release pull request.
+ */
+export declare abstract class BaseStrategy implements Strategy {
+    readonly path: string;
+    protected github: GitHub;
+    protected component?: string;
+    protected packageName?: string;
+    readonly versioningStrategy: VersioningStrategy;
+    protected targetBranch: string;
+    protected repository: Repository;
+    protected changelogPath: string;
+    protected tagSeparator?: string;
+    private skipGitHubRelease;
+    private releaseAs?;
+    private includeComponentInTag;
+    private pullRequestTitlePattern?;
+    readonly changelogNotes: ChangelogNotes;
+    protected changelogSections?: ChangelogSection[];
+    constructor(options: BaseStrategyOptions);
+    /**
+     * Specify the files necessary to update in a release pull request.
+     * @param {BuildUpdatesOptions} options
+     */
+    protected abstract buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    /**
+     * Return the component for this strategy. This may be a computed field.
+     * @returns {string}
+     */
+    getComponent(): Promise<string | undefined>;
+    getDefaultComponent(): Promise<string | undefined>;
+    getDefaultPackageName(): Promise<string | undefined>;
+    protected normalizeComponent(component: string | undefined): string;
+    /**
+     * Override this method to post process commits
+     * @param {ConventionalCommit[]} commits parsed commits
+     * @returns {ConventionalCommit[]} modified commits
+     */
+    protected postProcessCommits(commits: ConventionalCommit[]): ConventionalCommit[];
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;
+    /**
+     * 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.
+     */
+    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    protected changelogEmpty(changelogEntry: string): boolean;
+    protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
+    protected buildNewVersion(conventionalCommits: ConventionalCommit[], latestRelease?: Release): Promise<Version>;
+    protected buildVersionsMap(_conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
+    /**
+     * Given a merged pull request, build the candidate release.
+     * @param {PullRequest} mergedPullRequest The merged release pull request.
+     * @returns {Release} The candidate release.
+     */
+    buildRelease(mergedPullRequest: PullRequest): Promise<Release | undefined>;
+    /**
+     * Override this to handle the initial version of a new library.
+     */
+    protected initialReleaseVersion(): Version;
+    protected addPath(file: string): string;
+}

package/build/src/strategies/base.js

@@ -0,0 +1,253 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStrategy = void 0;
+const manifest_1 = require("../manifest");
+const default_1 = require("../versioning-strategies/default");
+const default_2 = require("../changelog-notes/default");
+const commit_1 = require("../commit");
+const version_1 = require("../version");
+const tag_name_1 = require("../util/tag-name");
+const logger_1 = require("../util/logger");
+const pull_request_title_1 = require("../util/pull-request-title");
+const branch_name_1 = require("../util/branch-name");
+const pull_request_body_1 = require("../util/pull-request-body");
+const DEFAULT_CHANGELOG_PATH = 'CHANGELOG.md';
+/**
+ * A strategy is responsible for determining which files are
+ * necessary to update in a release pull request.
+ */
+class BaseStrategy {
+    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;
+    }
+    /**
+     * Return the component for this strategy. This may be a computed field.
+     * @returns {string}
+     */
+    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.BaseStrategy = BaseStrategy;
+//# sourceMappingURL=base.js.map

package/build/src/strategies/dart.d.ts

@@ -1,6 +1,6 @@
-import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { BaseStrategy, BuildUpdatesOptions } from './base';
 import { Update } from '../update';
-export declare class Dart extends Strategy {
+export declare class Dart extends BaseStrategy {
     private pubspecYmlContents?;
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
     getDefaultPackageName(): Promise<string | undefined>;

package/build/src/strategies/dart.js

@@ -19,8 +19,8 @@ const changelog_1 = require("../updaters/changelog");
 const yaml = require("js-yaml");
 // pubspec
 const pubspec_yaml_1 = require("../updaters/dart/pubspec-yaml");
-const strategy_1 = require("../strategy");
-class Dart extends strategy_1.Strategy {
+const base_1 = require("./base");
+class Dart extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;

package/build/src/strategies/elixir.d.ts

@@ -1,5 +1,5 @@
-import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { BaseStrategy, BuildUpdatesOptions } from './base';
 import { Update } from '../update';
-export declare class Elixir extends Strategy {
+export declare class Elixir extends BaseStrategy {
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
 }

package/build/src/strategies/elixir.js

@@ -18,8 +18,8 @@ exports.Elixir = void 0;
 const changelog_1 = require("../updaters/changelog");
 // mix.exs support
 const elixir_mix_exs_1 = require("../updaters/elixir/elixir-mix-exs");
-const strategy_1 = require("../strategy");
-class Elixir extends strategy_1.Strategy {
+const base_1 = require("./base");
+class Elixir extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;