release-please 12.3.0 → 13.0.0-candidate.0

package/build/src/manifest.js

@@ -13,545 +13,641 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Manifest = void 0;
-const commit_split_1 = require("./commit-split");
-const constants_1 = require("./constants");
+exports.Manifest = exports.MANIFEST_PULL_REQUEST_TITLE_PATTERN = exports.ROOT_PROJECT_PATH = exports.DEFAULT_RELEASE_PLEASE_MANIFEST = exports.DEFAULT_RELEASE_PLEASE_CONFIG = void 0;
+const version_1 = require("./version");
+const logger_1 = require("./util/logger");
+const commit_split_1 = require("./util/commit-split");
+const tag_name_1 = require("./util/tag-name");
 const branch_name_1 = require("./util/branch-name");
-const _1 = require(".");
+const pull_request_title_1 = require("./util/pull-request-title");
+const factory_1 = require("./factory");
+const pull_request_body_1 = require("./util/pull-request-body");
+const merge_1 = require("./plugins/merge");
 const release_please_manifest_1 = require("./updaters/release-please-manifest");
-const checkpoint_1 = require("./util/checkpoint");
-const github_release_1 = require("./github-release");
-const plugins_1 = require("./plugins");
-const signoff_commit_message_1 = require("./util/signoff-commit-message");
+exports.DEFAULT_RELEASE_PLEASE_CONFIG = 'release-please-config.json';
+exports.DEFAULT_RELEASE_PLEASE_MANIFEST = '.release-please-manifest.json';
+exports.ROOT_PROJECT_PATH = '.';
+const DEFAULT_COMPONENT_NAME = '';
+const DEFAULT_LABELS = ['autorelease: pending'];
+const DEFAULT_RELEASE_LABELS = ['autorelease: tagged'];
+exports.MANIFEST_PULL_REQUEST_TITLE_PATTERN = 'chore: release ${branch}';
 class Manifest {
-    constructor(options) {
-        this.gh = options.github;
-        this.configFileName = options.configFile || constants_1.RELEASE_PLEASE_CONFIG;
-        this.manifestFileName = options.manifestFile || constants_1.RELEASE_PLEASE_MANIFEST;
-        this.checkpoint = options.checkpoint || checkpoint_1.checkpoint;
-        this.signoff = options.signoff;
+    /**
+     * Create a Manifest from explicit config in code. This assumes that the
+     * repository has a single component at the root path.
+     *
+     * @param {GitHub} github GitHub client
+     * @param {string} targetBranch The releaseable base branch
+     * @param {RepositoryConfig} repositoryConfig Parsed configuration of path => release configuration
+     * @param {ReleasedVersions} releasedVersions Parsed versions of path => latest release version
+     * @param {ManifestOptions} manifestOptions Optional. Manifest options
+     * @param {string} manifestOptions.bootstrapSha If provided, use this SHA
+     *   as the point to consider commits after
+     * @param {boolean} manifestOptions.alwaysLinkLocal Option for the node-workspace
+     *   plugin
+     * @param {boolean} manifestOptions.separatePullRequests If true, create separate pull
+     *   requests instead of a single manifest release pull request
+     * @param {PluginType[]} manifestOptions.plugins Any plugins to use for this repository
+     * @param {boolean} manifestOptions.fork If true, create pull requests from a fork. Defaults
+     *   to `false`
+     * @param {string} manifestOptions.signoff Add a Signed-off-by annotation to the commit
+     * @param {string} manifestOptions.manifestPath Path to the versions manifest
+     * @param {string[]} manifestOptions.labels Labels that denote a pending, untagged release
+     *   pull request. Defaults to `[autorelease: pending]`
+     * @param {string[]} manifestOptions.releaseLabels Labels to apply to a tagged release
+     *   pull request. Defaults to `[autorelease: tagged]`
+     */
+    constructor(github, targetBranch, repositoryConfig, releasedVersions, manifestOptions) {
+        this.repository = github.repository;
+        this.github = github;
+        this.targetBranch = targetBranch;
+        this.repositoryConfig = repositoryConfig;
+        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.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;
+        this.releaseLabels =
+            (manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.releaseLabels) || DEFAULT_RELEASE_LABELS;
+        this.labels = (manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.labels) || DEFAULT_LABELS;
+        this.bootstrapSha = manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.bootstrapSha;
+        this.lastReleaseSha = manifestOptions === null || manifestOptions === void 0 ? void 0 : manifestOptions.lastReleaseSha;
     }
-    async getBranchName() {
-        return branch_name_1.BranchName.ofTargetBranch(await this.gh.getDefaultBranch());
+    /**
+     * Create a Manifest from config files in the repository.
+     *
+     * @param {GitHub} github GitHub client
+     * @param {string} targetBranch The releaseable base branch
+     * @param {string} configFile Optional. The path to the manifest config file
+     * @param {string} manifestFile Optional. The path to the manifest versions file
+     * @returns {Manifest}
+     */
+    static async fromManifest(github, targetBranch, configFile = exports.DEFAULT_RELEASE_PLEASE_CONFIG, manifestFile = exports.DEFAULT_RELEASE_PLEASE_MANIFEST, manifestOptionOverrides = {}) {
+        const [{ config: repositoryConfig, options: manifestOptions }, releasedVersions,] = await Promise.all([
+            parseConfig(github, configFile, targetBranch),
+            parseReleasedVersions(github, manifestFile, targetBranch),
+        ]);
+        return new Manifest(github, targetBranch, repositoryConfig, releasedVersions, { ...manifestOptions, ...manifestOptionOverrides });
     }
-    async getFileJson(fileName, sha) {
-        let content;
-        try {
-            if (sha) {
-                content = await this.gh.getFileContentsWithSimpleAPI(fileName, sha, false);
-            }
-            else {
-                content = await this.gh.getFileContents(fileName);
-            }
-        }
-        catch (e) {
-            this.checkpoint(`Failed to get ${fileName} at ${sha !== null && sha !== void 0 ? sha : 'HEAD'}: ${e.status}`, checkpoint_1.CheckpointType.Failure);
-            // If a sha is provided this is a request for the manifest file at the
-            // last merged Release PR. The only reason it would not exist is if a user
-            // checkedout that branch and deleted the manifest file right before
-            // merging. There is no recovery from that so we'll fall back to using
-            // the manifest at the tip of the defaultBranch.
-            if (sha === undefined) {
-                // !sha means this is a request against the tip of the defaultBranch and
-                // we require that the manifest and config exist there. If they don't,
-                // they can be added and this exception will not be thrown.
-                throw e;
-            }
-            return;
+    /**
+     * Create a Manifest from explicit config in code. This assumes that the
+     * repository has a single component at the root path.
+     *
+     * @param {GitHub} github GitHub client
+     * @param {string} targetBranch The releaseable base branch
+     * @param {ReleaserConfig} config Release strategy options
+     * @param {ManifestOptions} manifestOptions Optional. Manifest options
+     * @param {string} manifestOptions.bootstrapSha If provided, use this SHA
+     *   as the point to consider commits after
+     * @param {boolean} manifestOptions.alwaysLinkLocal Option for the node-workspace
+     *   plugin
+     * @param {boolean} manifestOptions.separatePullRequests If true, create separate pull
+     *   requests instead of a single manifest release pull request
+     * @param {PluginType[]} manifestOptions.plugins Any plugins to use for this repository
+     * @param {boolean} manifestOptions.fork If true, create pull requests from a fork. Defaults
+     *   to `false`
+     * @param {string} manifestOptions.signoff Add a Signed-off-by annotation to the commit
+     * @param {string} manifestOptions.manifestPath Path to the versions manifest
+     * @param {string[]} manifestOptions.labels Labels that denote a pending, untagged release
+     *   pull request. Defaults to `[autorelease: pending]`
+     * @param {string[]} manifestOptions.releaseLabels Labels to apply to a tagged release
+     *   pull request. Defaults to `[autorelease: tagged]`
+     * @returns {Manifest}
+     */
+    static async fromConfig(github, targetBranch, config, manifestOptions, path = exports.ROOT_PROJECT_PATH) {
+        const repositoryConfig = {};
+        repositoryConfig[path] = config;
+        const strategy = await factory_1.buildStrategy({
+            github,
+            ...config,
+        });
+        const component = await strategy.getComponent();
+        const releasedVersions = {};
+        const latestVersion = await latestReleaseVersion(github, targetBranch, component);
+        if (latestVersion) {
+            releasedVersions[path] = latestVersion;
         }
-        return JSON.parse(content.parsedContent);
+        return new Manifest(github, targetBranch, repositoryConfig, releasedVersions, manifestOptions);
     }
-    async getManifestJson(sha) {
-        // cache headManifest since it's loaded in validate() as well as later on
-        // and we never write to it.
-        let manifest;
-        if (sha === undefined) {
-            if (!this.headManifest) {
-                this.headManifest = await this.getFileJson(this.manifestFileName);
+    /**
+     * Build all candidate pull requests for this repository.
+     *
+     * Iterates through each path and builds a candidate pull request for component.
+     * Applies any configured plugins.
+     *
+     * @returns {ReleasePullRequest[]} The candidate pull requests to open or update.
+     */
+    async buildPullRequests() {
+        logger_1.logger.info('Building pull requests');
+        const pathsByComponent = await this.getPathsByComponent();
+        const strategiesByPath = await this.getStrategiesByPath();
+        // Collect all the SHAs of the latest release packages
+        logger_1.logger.info('Collecting release commit SHAs');
+        let releasesFound = 0;
+        const expectedReleases = Object.keys(strategiesByPath).length;
+        // SHAs by path
+        const releaseShasByPath = {};
+        // Releases by path
+        const releasesByPath = {};
+        for await (const release of this.github.releaseIterator(400)) {
+            // logger.debug(release);
+            const tagName = tag_name_1.TagName.parse(release.tagName);
+            if (!tagName) {
+                logger_1.logger.warn(`Unable to parse release name: ${release.name}`);
+                continue;
             }
-            manifest = this.headManifest;
-        }
-        else {
-            manifest = await this.getFileJson(this.manifestFileName, sha);
-        }
-        return manifest;
-    }
-    async getManifestVersions(sha, newPaths) {
-        let manifestJson;
-        const defaultBranch = await this.gh.getDefaultBranch();
-        const bootstrapMsg = `Bootstrapping from ${this.manifestFileName} ` +
-            `at tip of ${defaultBranch}`;
-        if (sha === undefined) {
-            this.checkpoint(bootstrapMsg, checkpoint_1.CheckpointType.Failure);
-        }
-        if (sha === false) {
-            this.checkpoint(`${bootstrapMsg} for missing paths [${newPaths.join(', ')}]`, checkpoint_1.CheckpointType.Failure);
-        }
-        let atSha = 'tip';
-        if (!sha) {
-            manifestJson = await this.getManifestJson();
-        }
-        else {
-            // try to retrieve manifest from last release sha.
-            const maybeManifestJson = await this.getManifestJson(sha);
-            atSha = sha;
-            if (maybeManifestJson === undefined) {
-                // user deleted manifest from last release PR before merging.
-                this.checkpoint(bootstrapMsg, checkpoint_1.CheckpointType.Failure);
-                manifestJson = await this.getManifestJson();
-                atSha = 'tip';
+            const component = tagName.component || DEFAULT_COMPONENT_NAME;
+            const path = pathsByComponent[component];
+            if (!path) {
+                logger_1.logger.warn(`Found release tag with component '${component}', but not configured in manifest`);
+                continue;
             }
-            else {
-                manifestJson = maybeManifestJson;
+            const expectedVersion = this.releasedVersions[path];
+            if (!expectedVersion) {
+                logger_1.logger.warn(`Unable to find expected version for path '${path}' in manifest`);
+                continue;
             }
-        }
-        const parsed = new Map(Object.entries(manifestJson));
-        if (sha === false) {
-            return parsed;
-        }
-        else {
-            return [parsed, atSha];
-        }
-    }
-    async getConfigJson() {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        // cache config since it's loaded in validate() as well as later on and we
-        // never write to it.
-        if (!this.configFile) {
-            const config = await this.getFileJson(this.configFileName);
-            const packages = [];
-            for (const pkgPath in config.packages) {
-                const pkgCfg = config.packages[pkgPath];
-                const pkg = {
-                    path: pkgPath,
-                    releaseType: (_b = (_a = pkgCfg['release-type']) !== null && _a !== void 0 ? _a : config['release-type']) !== null && _b !== void 0 ? _b : 'node',
-                    packageName: pkgCfg['package-name'],
-                    bumpMinorPreMajor: (_c = pkgCfg['bump-minor-pre-major']) !== null && _c !== void 0 ? _c : config['bump-minor-pre-major'],
-                    bumpPatchForMinorPreMajor: (_d = pkgCfg['bump-patch-for-minor-pre-major']) !== null && _d !== void 0 ? _d : config['bump-patch-for-minor-pre-major'],
-                    changelogSections: (_e = pkgCfg['changelog-sections']) !== null && _e !== void 0 ? _e : config['changelog-sections'],
-                    changelogPath: pkgCfg['changelog-path'],
-                    releaseAs: this.resolveReleaseAs(pkgCfg['release-as'], config['release-as']),
-                    draft: (_f = pkgCfg['draft']) !== null && _f !== void 0 ? _f : config['draft'],
-                    skipGithubRelease: (_h = (_g = pkgCfg['skip-github-release']) !== null && _g !== void 0 ? _g : config['skip-github-release']) !== null && _h !== void 0 ? _h : false,
+            if (expectedVersion.toString() === tagName.version.toString()) {
+                logger_1.logger.debug(`Found release for path ${path}, ${release.tagName}`);
+                releaseShasByPath[path] = release.sha;
+                releasesByPath[path] = {
+                    tag: tagName,
+                    sha: release.sha,
+                    notes: release.notes || '',
                 };
-                packages.push(pkg);
+                releasesFound += 1;
+            }
+            if (releasesFound >= expectedReleases) {
+                break;
             }
-            this.configFile = { parsedPackages: packages, ...config };
-        }
-        return this.configFile;
-    }
-    // Default release-as only considered if non-empty string.
-    // Per-pkg release-as may be:
-    //   1. undefined: use default release-as if present, otherwise normal version
-    //      resolution (auto-increment from CC, fallback to defaultInitialVersion)
-    //   1. non-empty string: use this version
-    //   2. empty string: override default release-as if present, otherwise normal
-    //      version resolution.
-    resolveReleaseAs(pkgRA, defaultRA) {
-        let releaseAs;
-        if (defaultRA) {
-            releaseAs = defaultRA;
         }
-        if (pkgRA !== undefined) {
-            releaseAs = pkgRA;
+        const needsBootstrap = releasesFound < expectedReleases;
+        if (releasesFound < expectedReleases) {
+            logger_1.logger.warn(`Expected ${expectedReleases} releases, only found ${releasesFound}`);
+        }
+        for (const path in releasesByPath) {
+            const release = releasesByPath[path];
+            logger_1.logger.debug(`release for path: ${path}, version: ${release.tag.version.toString()}, sha: ${release.sha}`);
+        }
+        // iterate through commits and collect commits until we have
+        // 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 releaseShas = new Set(Object.values(releaseShasByPath));
+        logger_1.logger.debug(releaseShas);
+        const expectedShas = releaseShas.size;
+        // sha => release pull request
+        const releasePullRequestsBySha = {};
+        let releaseCommitsFound = 0;
+        for await (const commit of commitGenerator) {
+            if (releaseShas.has(commit.sha)) {
+                if (commit.pullRequest) {
+                    releasePullRequestsBySha[commit.sha] = commit.pullRequest;
+                }
+                else {
+                    logger_1.logger.warn(`Release SHA ${commit.sha} did not have an associated pull request`);
+                }
+                releaseCommitsFound += 1;
+            }
+            if (this.lastReleaseSha && this.lastReleaseSha === commit.sha) {
+                logger_1.logger.info(`Using configured lastReleaseSha ${this.lastReleaseSha} as last commit.`);
+                break;
+            }
+            else if (needsBootstrap && commit.sha === this.bootstrapSha) {
+                logger_1.logger.info(`Needed bootstrapping, found configured bootstrapSha ${this.bootstrapSha}`);
+                break;
+            }
+            else if (!needsBootstrap && releaseCommitsFound >= expectedShas) {
+                // found enough commits
+                break;
+            }
+            commits.push({
+                sha: commit.sha,
+                message: commit.message,
+                files: commit.files,
+            });
         }
-        if (!releaseAs) {
-            releaseAs = undefined;
+        if (releaseCommitsFound < expectedShas) {
+            logger_1.logger.warn(`Expected ${expectedShas} commits, only found ${releaseCommitsFound}`);
         }
-        return releaseAs;
-    }
-    async getPackagesToRelease(allCommits, sha) {
-        const packages = (await this.getConfigJson()).parsedPackages;
-        const [manifestVersions, atSha] = await this.getManifestVersions(sha);
+        // split commits by path
+        logger_1.logger.info(`Splitting ${commits.length} commits by path`);
         const cs = new commit_split_1.CommitSplit({
             includeEmpty: true,
-            packagePaths: packages.map(p => p.path),
+            packagePaths: Object.keys(this.repositoryConfig),
         });
-        const commitsPerPath = cs.split(allCommits);
-        const packagesToRelease = {};
-        const missingVersionPaths = [];
-        const defaultBranch = await this.gh.getDefaultBranch();
-        for (const pkg of packages) {
-            // The special path of '.' indicates the root module is being released
-            // in this case, use the entire list of commits:
-            const commits = pkg.path === '.' ? allCommits : commitsPerPath[pkg.path];
-            if (!commits || commits.length === 0) {
+        const commitsPerPath = cs.split(commits);
+        let newReleasePullRequests = [];
+        for (const path in this.repositoryConfig) {
+            const config = this.repositoryConfig[path];
+            logger_1.logger.info(`Building candidate release pull request for path: ${path}`);
+            logger_1.logger.debug(`type: ${config.releaseType}`);
+            logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
+            const pathCommits = commitsAfterSha(path === exports.ROOT_PROJECT_PATH ? commits : commitsPerPath[path], releaseShasByPath[path]);
+            if (!pathCommits || pathCommits.length === 0) {
+                logger_1.logger.info(`No commits for path: ${path}, skipping`);
                 continue;
             }
-            const lastVersion = manifestVersions.get(pkg.path);
-            if (!lastVersion) {
-                this.checkpoint(`Failed to find version for ${pkg.path} in ` +
-                    `${this.manifestFileName} at ${atSha} of ${defaultBranch}`, checkpoint_1.CheckpointType.Failure);
-                missingVersionPaths.push(pkg.path);
-            }
-            else {
-                this.checkpoint(`Found version ${lastVersion} for ${pkg.path} in ` +
-                    `${this.manifestFileName} at ${atSha} of ${defaultBranch}`, checkpoint_1.CheckpointType.Success);
+            logger_1.logger.debug(`commits: ${pathCommits.length}`);
+            const latestReleasePullRequest = releasePullRequestsBySha[releaseShasByPath[path]];
+            if (!latestReleasePullRequest) {
+                logger_1.logger.warn('No latest release pull request found.');
             }
-            packagesToRelease[pkg.path] = {
-                commits,
-                lastVersion,
-                config: pkg,
-            };
-        }
-        if (missingVersionPaths.length > 0) {
-            const headManifestVersions = await this.getManifestVersions(false, missingVersionPaths);
-            for (const missingVersionPath of missingVersionPaths) {
-                const headVersion = headManifestVersions.get(missingVersionPath);
-                if (headVersion === undefined) {
-                    this.checkpoint(`Failed to find version for ${missingVersionPath} in ` +
-                        `${this.manifestFileName} at tip of ${defaultBranch}`, checkpoint_1.CheckpointType.Failure);
+            const strategy = strategiesByPath[path];
+            const latestRelease = releasesByPath[path];
+            const releasePullRequest = await strategy.buildReleasePullRequest(pathCommits, latestRelease, config.draft, this.labels);
+            if (releasePullRequest) {
+                if (releasePullRequest.version) {
+                    const versionsMap = new Map();
+                    versionsMap.set(path, releasePullRequest.version);
+                    releasePullRequest.updates.push({
+                        path: this.manifestPath,
+                        createIfMissing: false,
+                        updater: new release_please_manifest_1.ReleasePleaseManifest({
+                            version: releasePullRequest.version,
+                            versionsMap,
+                        }),
+                    });
                 }
-                packagesToRelease[missingVersionPath].lastVersion = headVersion;
+                newReleasePullRequests.push({
+                    path,
+                    config,
+                    pullRequest: releasePullRequest,
+                });
             }
         }
-        return Object.values(packagesToRelease);
+        // Build plugins
+        const plugins = this.plugins.map(pluginType => factory_1.buildPlugin({
+            type: pluginType,
+            github: this.github,
+            targetBranch: this.targetBranch,
+            repositoryConfig: this.repositoryConfig,
+        }));
+        // Combine pull requests into 1 unless configured for separate
+        // pull requests
+        if (!this.separatePullRequests) {
+            plugins.push(new merge_1.Merge(this.github, this.targetBranch, this.repositoryConfig));
+        }
+        for (const plugin of plugins) {
+            newReleasePullRequests = await plugin.run(newReleasePullRequests);
+        }
+        return newReleasePullRequests.map(pullRequestWithConfig => pullRequestWithConfig.pullRequest);
     }
-    async validateJsonFile(getFileMethod, fileName) {
-        let response = {
-            valid: false,
-            obj: undefined,
-        };
-        try {
-            const obj = await this[getFileMethod]();
-            if (obj.constructor.name === 'Object') {
-                response = { valid: true, obj: obj };
+    /**
+     * Opens/updates all candidate release pull requests for this repository.
+     *
+     * @returns {number[]} Pull request numbers of release pull requests
+     */
+    async createPullRequests() {
+        const candidatePullRequests = await this.buildPullRequests();
+        if (candidatePullRequests.length === 0) {
+            return [];
+        }
+        // if there are any merged, pending release pull requests, don't open
+        // any new release PRs
+        const mergedPullRequestsGenerator = this.findMergedReleasePullRequests();
+        for await (const _ of mergedPullRequestsGenerator) {
+            logger_1.logger.warn('There are untagged, merged release PRs outstanding - aborting');
+            return [];
+        }
+        // collect open release pull requests
+        logger_1.logger.info('Looking for open release pull requests');
+        const openPullRequests = [];
+        const generator = this.github.pullRequestIterator(this.targetBranch, 'OPEN');
+        for await (const openPullRequest of generator) {
+            if (hasAllLabels(this.labels, openPullRequest.labels) &&
+                branch_name_1.BranchName.parse(openPullRequest.headBranchName) &&
+                pull_request_body_1.PullRequestBody.parse(openPullRequest.body)) {
+                openPullRequests.push(openPullRequest);
             }
         }
-        catch (e) {
-            let errMsg;
-            if (e instanceof SyntaxError) {
-                errMsg = `Invalid JSON in ${fileName}`;
-            }
-            else {
-                errMsg = `Unable to ${getFileMethod}(${fileName}): ${e.message}`;
-            }
-            this.checkpoint(errMsg, checkpoint_1.CheckpointType.Failure);
+        logger_1.logger.info(`found ${openPullRequests.length} open release pull requests.`);
+        const promises = [];
+        for (const pullRequest of candidatePullRequests) {
+            promises.push(this.createOrUpdatePullRequest(pullRequest, openPullRequests));
         }
-        return response;
+        return await Promise.all(promises);
     }
-    async validate() {
-        var _a;
-        const configValidation = await this.validateJsonFile('getConfigJson', this.configFileName);
-        let validConfig = false;
-        if (configValidation.valid) {
-            const obj = configValidation.obj;
-            validConfig = !!Object.keys((_a = obj.packages) !== null && _a !== void 0 ? _a : {}).length;
-            if (!validConfig) {
-                this.checkpoint(`No packages found: ${this.configFileName}`, checkpoint_1.CheckpointType.Failure);
+    async createOrUpdatePullRequest(pullRequest, openPullRequests) {
+        // look for existing, open pull rquest
+        const existing = openPullRequests.find(openPullRequest => openPullRequest.headBranchName === pullRequest.headRefName);
+        if (existing) {
+            // If unchanged, no need to push updates
+            if (existing.body === pullRequest.body.toString()) {
+                logger_1.logger.info(`PR https://github.com/${this.repository.owner}/${this.repository.repo}/pull/${existing.number} remained the same`);
+                return undefined;
             }
+            const updatedPullRequest = await this.github.updatePullRequest(existing.number, pullRequest, this.targetBranch, {
+                fork: this.fork,
+                signoffUser: this.signoffUser,
+            });
+            return updatedPullRequest.number;
         }
-        const manifestValidation = await this.validateJsonFile('getManifestJson', this.manifestFileName);
-        let validManifest = false;
-        if (manifestValidation.valid) {
-            validManifest = true;
-            const versions = new Map(Object.entries(manifestValidation.obj));
-            for (const [_, version] of versions) {
-                if (typeof version !== 'string') {
-                    validManifest = false;
-                    this.checkpoint(`${this.manifestFileName} must only contain string values`, checkpoint_1.CheckpointType.Failure);
-                    break;
-                }
-            }
+        else {
+            const newPullRequest = await this.github.createReleasePullRequest(pullRequest, this.targetBranch, {
+                fork: this.fork,
+                signoffUser: this.signoffUser,
+            });
+            return newPullRequest.number;
         }
-        return validConfig && validManifest;
     }
-    async getReleasePR(pkg) {
-        const { releaseType, draft, ...options } = pkg;
-        const releaserOptions = {
-            monorepoTags: true,
-            ...options,
-        };
-        const releaserClass = _1.factory.releasePRClass(releaseType);
-        const releasePR = new releaserClass({
-            github: this.gh,
-            skipDependencyUpdates: true,
-            ...releaserOptions,
-        });
-        return [releasePR, draft];
-    }
-    async runReleasers(packagesForReleasers, sha) {
-        const newManifestVersions = new Map();
-        const pkgsWithChanges = [];
-        for (const pkg of packagesForReleasers) {
-            const [releasePR] = await this.getReleasePR(pkg.config);
-            const pkgName = await releasePR.getPackageName();
-            const displayTag = `${releasePR.constructor.name}(${pkgName.name})`;
-            this.checkpoint(`Processing package: ${displayTag}`, checkpoint_1.CheckpointType.Success);
-            if (pkg.lastVersion === undefined) {
-                this.checkpoint(`Falling back to default version for ${displayTag}: ` +
-                    releasePR.defaultInitialVersion(), checkpoint_1.CheckpointType.Failure);
+    async *findMergedReleasePullRequests() {
+        // Find merged release pull requests
+        const pullRequestGenerator = this.github.pullRequestIterator(this.targetBranch, 'MERGED', 200);
+        for await (const pullRequest of pullRequestGenerator) {
+            if (!hasAllLabels(this.labels, pullRequest.labels)) {
+                continue;
             }
-            const openPROptions = await releasePR.getOpenPROptions(pkg.commits, pkg.lastVersion
-                ? {
-                    name: pkgName.getComponent() +
-                        releasePR.tagSeparator() +
-                        'v' +
-                        pkg.lastVersion,
-                    sha: sha !== null && sha !== void 0 ? sha : 'beginning of time',
-                    version: pkg.lastVersion,
-                }
-                : undefined);
-            if (openPROptions) {
-                pkg.config.packageName = (await releasePR.getPackageName()).name;
-                const changes = await this.gh.getChangeSet(openPROptions.updates, await this.gh.getDefaultBranch());
-                pkgsWithChanges.push({
-                    config: pkg.config,
-                    prData: { version: openPROptions.version, changes },
-                });
-                newManifestVersions.set(pkg.config.path, openPROptions.version);
+            logger_1.logger.debug(`Found pull request #${pullRequest.number}: '${pullRequest.title}'`);
+            const pullRequestBody = pull_request_body_1.PullRequestBody.parse(pullRequest.body);
+            if (!pullRequestBody) {
+                logger_1.logger.debug('could not parse pull request body as a release PR');
+                continue;
             }
+            yield pullRequest;
         }
-        return [newManifestVersions, pkgsWithChanges];
     }
-    async getManifestChanges(newManifestVersions) {
-        // TODO: simplify `Update.contents?` to just be a string - no need to
-        // roundtrip through a GitHubFileContents
-        const manifestContents = {
-            sha: '',
-            parsedContent: '',
-            content: Buffer.from(JSON.stringify(await this.getManifestJson())).toString('base64'),
-        };
-        const manifestUpdate = new release_please_manifest_1.ReleasePleaseManifest({
-            changelogEntry: '',
-            packageName: '',
-            path: this.manifestFileName,
-            version: '',
-            versions: newManifestVersions,
-            contents: manifestContents,
-        });
-        return await this.gh.getChangeSet([manifestUpdate], await this.gh.getDefaultBranch());
-    }
-    buildPRBody(pkg) {
-        var _a, _b;
-        const version = pkg.prData.version;
-        let body = '<details><summary>' +
-            `${pkg.config.packageName}: ${version}` +
-            '</summary>';
-        let changelogPath = (_a = pkg.config.changelogPath) !== null && _a !== void 0 ? _a : 'CHANGELOG.md';
-        if (pkg.config.path !== '.') {
-            changelogPath = `${pkg.config.path}/${changelogPath}`;
-        }
-        const changelog = (_b = pkg.prData.changes.get(changelogPath)) === null || _b === void 0 ? void 0 : _b.content;
-        if (!changelog) {
-            this.checkpoint(`Failed to find ${changelogPath}`, checkpoint_1.CheckpointType.Failure);
+    /**
+     * Find merged, untagged releases and build candidate releases to tag.
+     *
+     * @returns {CandidateRelease[]} List of release candidates
+     */
+    async buildReleases() {
+        logger_1.logger.info('Building releases');
+        const strategiesByPath = await this.getStrategiesByPath();
+        // Find merged release pull requests
+        const generator = await this.findMergedReleasePullRequests();
+        const releases = [];
+        for await (const pullRequest of generator) {
+            logger_1.logger.info('Looking at files touched by path');
+            const cs = new commit_split_1.CommitSplit({
+                includeEmpty: true,
+                packagePaths: Object.keys(this.repositoryConfig),
+            });
+            const commits = [
+                {
+                    sha: pullRequest.sha,
+                    message: pullRequest.title,
+                    files: pullRequest.files,
+                },
+            ];
+            const commitsPerPath = cs.split(commits);
+            for (const path in this.repositoryConfig) {
+                const config = this.repositoryConfig[path];
+                logger_1.logger.info(`Building release for path: ${path}`);
+                logger_1.logger.debug(`type: ${config.releaseType}`);
+                logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
+                const pathCommits = path === exports.ROOT_PROJECT_PATH ? commits : commitsPerPath[path];
+                if (!pathCommits || pathCommits.length === 0) {
+                    logger_1.logger.info(`No commits for path: ${path}, skipping`);
+                    continue;
+                }
+                const strategy = strategiesByPath[path];
+                const release = await strategy.buildRelease(pullRequest);
+                if (release) {
+                    releases.push({
+                        ...release,
+                        pullRequest,
+                    });
+                }
+            }
         }
-        else {
-            const match = changelog.match(
-            // changelog entries start like
-            // ## 1.0.0 (1983...
-            // ## [4.0.0](https...
-            // ### [1.2.4](https...
-            RegExp(`.*###? \\[?${version}\\]?.*?\n(?<currentEntry>.*?)` +
-                // either the next changelog or new lines / spaces to the end if
-                // this is the first entry in the changelog
-                '(\n###? [0-9[].*|[\n ]*$)', 's'));
-            if (!match) {
-                this.checkpoint(`Failed to find entry in changelog for ${version}`, checkpoint_1.CheckpointType.Failure);
+        return releases;
+    }
+    /**
+     * Find merged, untagged releases. For each release, create a GitHub release,
+     * comment on the pull request used to generated it and update the pull request
+     * labels.
+     *
+     * @returns {GitHubRelease[]} List of created GitHub releases
+     */
+    async createReleases() {
+        const releasesByPullRequest = {};
+        const pullRequestsByNumber = {};
+        for (const release of await this.buildReleases()) {
+            pullRequestsByNumber[release.pullRequest.number] = release.pullRequest;
+            if (releasesByPullRequest[release.pullRequest.number]) {
+                releasesByPullRequest[release.pullRequest.number].push(release);
             }
             else {
-                const { currentEntry } = match.groups;
-                body += '\n\n\n' + currentEntry.trim() + '\n';
+                releasesByPullRequest[release.pullRequest.number] = [release];
             }
         }
-        body += '</details>\n';
-        return body;
-    }
-    async buildManifestPR(newManifestVersions, 
-    // using version, changes
-    packages) {
-        let body = ':robot: I have created a release \\*beep\\* \\*boop\\*\n---\n';
-        let changes = new Map();
-        for (const pkg of packages) {
-            body += this.buildPRBody(pkg);
-            changes = new Map([...changes, ...pkg.prData.changes]);
+        const promises = [];
+        for (const pullNumber in releasesByPullRequest) {
+            promises.push(this.createReleasesForPullRequest(releasesByPullRequest[pullNumber], pullRequestsByNumber[pullNumber]));
         }
-        const manifestChanges = await this.getManifestChanges(newManifestVersions);
-        changes = new Map([...changes, ...manifestChanges]);
-        body +=
-            '\n\nThis PR was generated with [Release Please]' +
-                `(https://github.com/googleapis/${constants_1.RELEASE_PLEASE}). See [documentation]` +
-                `(https://github.com/googleapis/${constants_1.RELEASE_PLEASE}#${constants_1.RELEASE_PLEASE}).`;
-        return [body, changes];
+        const releases = await Promise.all(promises);
+        return releases.reduce((collection, r) => collection.concat(r), []);
     }
-    async getPlugins() {
-        var _a;
-        const plugins = [];
-        const config = await this.getConfigJson();
-        for (const p of (_a = config.plugins) !== null && _a !== void 0 ? _a : []) {
-            plugins.push(plugins_1.getPlugin(p, this.gh, config));
-        }
-        return plugins;
+    async createReleasesForPullRequest(releases, pullRequest) {
+        // create the release
+        const promises = [];
+        for (const release of releases) {
+            promises.push(this.createRelease(release));
+        }
+        const githubReleases = await Promise.all(promises);
+        // adjust tags on pullRequest
+        await Promise.all([
+            this.github.removeIssueLabels(this.labels, pullRequest.number),
+            this.github.addIssueLabels(this.releaseLabels, pullRequest.number),
+        ]);
+        return githubReleases;
     }
-    async resolveLastReleaseSha(branchName) {
-        const config = await this.getConfigJson();
-        let lastReleaseSha;
-        let source = 'no last release sha found';
-        if (config['last-release-sha']) {
-            lastReleaseSha = config['last-release-sha'];
-            source = 'last-release-sha';
-        }
-        else {
-            const lastMergedPR = await this.gh.lastMergedPRByHeadBranch(branchName);
-            if (lastMergedPR) {
-                lastReleaseSha = lastMergedPR.sha;
-                source = 'last-release-pr';
-            }
-            else if (config['bootstrap-sha']) {
-                lastReleaseSha = config['bootstrap-sha'];
-                source = 'bootstrap-sha';
-            }
-        }
-        this.checkpoint(`Found last release sha "${lastReleaseSha}" using "${source}"`, checkpoint_1.CheckpointType.Success);
-        return lastReleaseSha;
+    async createRelease(release) {
+        const githubRelease = await this.github.createRelease(release);
+        // comment on pull request
+        const comment = `:robot: Release is at ${githubRelease.url} :sunflower:`;
+        await this.github.commentOnIssue(comment, release.pullRequest.number);
+        return githubRelease;
     }
-    async pullRequest() {
-        const valid = await this.validate();
-        if (!valid) {
-            return;
-        }
-        const branchName = (await this.getBranchName()).toString();
-        const lastReleaseSha = await this.resolveLastReleaseSha(branchName);
-        const commits = await this.gh.commitsSinceShaRest(lastReleaseSha);
-        const packagesForReleasers = await this.getPackagesToRelease(commits, lastReleaseSha);
-        let [newManifestVersions, pkgsWithChanges] = await this.runReleasers(packagesForReleasers, lastReleaseSha);
-        if (pkgsWithChanges.length === 0) {
-            this.checkpoint('No user facing changes to release', checkpoint_1.CheckpointType.Success);
-            return;
-        }
-        for (const plugin of await this.getPlugins()) {
-            [newManifestVersions, pkgsWithChanges] = await plugin.run(newManifestVersions, pkgsWithChanges);
-        }
-        const [body, changes] = await this.buildManifestPR(newManifestVersions, pkgsWithChanges);
-        const title = `chore: release ${await this.gh.getDefaultBranch()}`;
-        // Sign-off message if signoff option is enabled
-        const message = this.signoff
-            ? signoff_commit_message_1.signoffCommitMessage(title, this.signoff)
-            : title;
-        const pr = await this.gh.openPR({
-            branch: branchName,
-            title,
-            message,
-            body: body,
-            updates: [],
-            labels: constants_1.DEFAULT_LABELS,
-            changes,
-        });
-        if (pr) {
-            await this.gh.addLabels(constants_1.DEFAULT_LABELS, pr);
+    async getStrategiesByPath() {
+        if (!this._strategiesByPath) {
+            logger_1.logger.info('Building strategies by path');
+            this._strategiesByPath = {};
+            for (const path in this.repositoryConfig) {
+                const config = this.repositoryConfig[path];
+                logger_1.logger.debug(`${path}: ${config.releaseType}`);
+                const strategy = await factory_1.buildStrategy({
+                    ...config,
+                    github: this.github,
+                    path,
+                    targetBranch: this.targetBranch,
+                });
+                this._strategiesByPath[path] = strategy;
+            }
         }
-        return pr;
+        return this._strategiesByPath;
     }
-    async githubRelease() {
-        var _a;
-        const valid = await this.validate();
-        if (!valid) {
-            return;
-        }
-        const branchName = (await this.getBranchName()).toString();
-        const lastMergedPR = await this.gh.lastMergedPRByHeadBranch(branchName);
-        if (lastMergedPR === undefined) {
-            this.checkpoint('Unable to find last merged Manifest PR for tagging', checkpoint_1.CheckpointType.Failure);
-            return;
-        }
-        if (lastMergedPR.labels.includes(github_release_1.GITHUB_RELEASE_LABEL)) {
-            this.checkpoint('Releases already created for last merged release PR', checkpoint_1.CheckpointType.Success);
-            return;
-        }
-        if (!lastMergedPR.labels.includes(constants_1.DEFAULT_LABELS[0])) {
-            this.checkpoint(`Warning: last merged PR(#${lastMergedPR.number}) is missing ` +
-                `label "${constants_1.DEFAULT_LABELS[0]}" but has not yet been ` +
-                `labeled "${github_release_1.GITHUB_RELEASE_LABEL}". If PR(#${lastMergedPR.number}) ` +
-                'is meant to be a release PR, please apply the ' +
-                `label "${constants_1.DEFAULT_LABELS[0]}".`, checkpoint_1.CheckpointType.Failure);
-            return;
-        }
-        const packagesForReleasers = await this.getPackagesToRelease(
-        // use the lastMergedPR.sha as a Commit: lastMergedPR.files will inform
-        // getPackagesToRelease() what packages had changes (i.e. at least one
-        // file under their path changed in the lastMergedPR such as
-        // "packages/mypkg/package.json"). These are exactly the packages we want
-        // to create releases/tags for.
-        [{ sha: lastMergedPR.sha, message: '', files: lastMergedPR.files }], lastMergedPR.sha);
-        const releases = {};
-        let allReleasesCreated = !!packagesForReleasers.length;
-        for (const pkg of packagesForReleasers) {
-            const [releasePR, draft] = await this.getReleasePR(pkg.config);
-            const pkgName = (await releasePR.getPackageName()).name;
-            const pkgLogDisp = `${releasePR.constructor.name}(${pkgName})`;
-            if (!pkg.lastVersion) {
-                // a user manually modified the manifest file on the release branch
-                // right before merging it and deleted the entry for this pkg.
-                this.checkpoint(`Unable to find last version for ${pkgLogDisp}.`, checkpoint_1.CheckpointType.Failure);
-                releases[pkg.config.path] = undefined;
-                continue;
-            }
-            if (pkg.config.skipGithubRelease) {
-                this.gh.commentOnIssue(`:robot: ${pkgName} not configured for release :no_entry_sign:`, lastMergedPR.number);
-                releases[pkg.config.path] = undefined;
-                continue;
-            }
-            this.checkpoint('Creating release for ' + `${pkgLogDisp}@${pkg.lastVersion}`, checkpoint_1.CheckpointType.Success);
-            const releaser = new github_release_1.GitHubRelease({
-                github: this.gh,
-                releasePR,
-                draft,
-            });
-            let release;
-            try {
-                release = await releaser.createRelease(pkg.lastVersion, lastMergedPR);
-            }
-            catch (err) {
-                // There is no transactional bulk create releases API. Previous runs
-                // may have failed due to transient infrastructure problems part way
-                // through creating releases. Here we skip any releases that were
-                // already successfully created.
-                //
-                // Note about `draft` releases: The GitHub API Release unique key is
-                // `tag_name`. However, if `draft` is true, no git tag is created. Thus
-                // multiple `draft` releases can be created with the exact same inputs.
-                // (It's a tad confusing because `tag_name` still comes back populated
-                // in these calls but the tag doesn't actually exist).
-                // A draft release can even be created with a `tag_name` referring to an
-                // existing tag referenced by another release.
-                // However, GitHub will prevent "publishing" any draft release that
-                // would cause a duplicate tag to be created. release-please manifest
-                // users specifying the "release-draft" option could run into this
-                // duplicate releases scenario. It's easy enough to just delete the
-                // duplicate draft entries in the UI (or API).
-                if (err.status === 422 && ((_a = err.errors) === null || _a === void 0 ? void 0 : _a.length)) {
-                    if (err.errors[0].code === 'already_exists' &&
-                        err.errors[0].field === 'tag_name') {
-                        this.checkpoint(`Release for ${pkgLogDisp}@${pkg.lastVersion} already exists`, checkpoint_1.CheckpointType.Success);
-                    }
-                }
-                else {
-                    // PR will not be tagged with GITHUB_RELEASE_LABEL so another run
-                    // can try again.
-                    allReleasesCreated = false;
-                    await this.gh.commentOnIssue(`:robot: Failed to create release for ${pkgName} :cloud:`, lastMergedPR.number);
-                    this.checkpoint('Failed to create release for ' +
-                        `${pkgLogDisp}@${pkg.lastVersion}: ${err.message}`, checkpoint_1.CheckpointType.Failure);
+    async getPathsByComponent() {
+        if (!this._pathsByComponent) {
+            this._pathsByComponent = {};
+            const strategiesByPath = await this.getStrategiesByPath();
+            for (const path in this.repositoryConfig) {
+                const strategy = strategiesByPath[path];
+                const component = strategy.component || (await strategy.getDefaultComponent()) || '';
+                if (this._pathsByComponent[component]) {
+                    logger_1.logger.warn(`Multiple paths for ${component}: ${this._pathsByComponent[component]}, ${path}`);
                 }
-                releases[pkg.config.path] = undefined;
-                continue;
-            }
-            if (release) {
-                await this.gh.commentOnIssue(`:robot: Release for ${pkgName} is at ${release.html_url} :sunflower:`, lastMergedPR.number);
-                releases[pkg.config.path] = releaser.releaseResponse({
-                    release,
-                    version: pkg.lastVersion,
-                    sha: lastMergedPR.sha,
-                    number: lastMergedPR.number,
-                });
+                this._pathsByComponent[component] = path;
+                logger_1.logger.info(this._pathsByComponent);
             }
         }
-        if (allReleasesCreated) {
-            await this.gh.addLabels([github_release_1.GITHUB_RELEASE_LABEL], lastMergedPR.number);
-            await this.gh.removeLabels(constants_1.DEFAULT_LABELS, lastMergedPR.number);
-        }
-        return releases;
+        return this._pathsByComponent;
     }
 }
 exports.Manifest = Manifest;
+/**
+ * Helper to convert parsed JSON releaser config into ReleaserConfig for
+ * the Manifest.
+ *
+ * @param {ReleaserPackageConfig} config Parsed configuration from JSON file.
+ * @returns {ReleaserConfig}
+ */
+function extractReleaserConfig(config) {
+    return {
+        releaseType: config['release-type'] || 'node',
+        bumpMinorPreMajor: config['bump-minor-pre-major'],
+        bumpPatchForMinorPreMajor: config['bump-patch-for-minor-pre-major'],
+        changelogSections: config['changelog-sections'],
+        changelogPath: config['changelog-path'],
+        releaseAs: config['release-as'],
+        skipGithubRelease: config['skip-github-release'],
+        draft: config.draft,
+        component: config['component'],
+        packageName: config['package-name'],
+        versionFile: config['version-file'],
+        extraFiles: config['extra-files'],
+    };
+}
+/**
+ * Helper to convert fetch the manifest config from the repository and
+ * parse into configuration for the Manifest.
+ *
+ * @param {GitHub} github GitHub client
+ * @param {string} configFile Path in the repository to the manifest config
+ * @param {string} branch Branch to fetch the config file from
+ */
+async function parseConfig(github, configFile, branch) {
+    const config = await github.getFileJson(configFile, branch);
+    const defaultConfig = extractReleaserConfig(config);
+    const repositoryConfig = {};
+    for (const path in config.packages) {
+        repositoryConfig[path] = mergeReleaserConfig(defaultConfig, extractReleaserConfig(config.packages[path]));
+    }
+    const manifestOptions = {
+        bootstrapSha: config['bootstrap-sha'],
+        lastReleaseSha: config['last-release-sha'],
+        alwaysLinkLocal: config['always-link-local'],
+        separatePullRequests: config['separate-pull-requests'],
+        plugins: config['plugins'],
+    };
+    return { config: repositoryConfig, options: manifestOptions };
+}
+/**
+ * Helper to parse the manifest versions file.
+ *
+ * @param {GitHub} github GitHub client
+ * @param {string} manifestFile Path in the repository to the versions file
+ * @param {string} branch Branch to fetch the versions file from
+ */
+async function parseReleasedVersions(github, manifestFile, branch) {
+    const manifestJson = await github.getFileJson(manifestFile, branch);
+    const releasedVersions = {};
+    for (const path in manifestJson) {
+        releasedVersions[path] = version_1.Version.parse(manifestJson[path]);
+    }
+    return releasedVersions;
+}
+/**
+ * Find the most recent matching release tag on the branch we're
+ * configured for.
+ *
+ * @param {string} prefix - Limit the release to a specific component.
+ * @param {boolean} preRelease - Whether or not to return pre-release
+ *   versions. Defaults to false.
+ */
+async function latestReleaseVersion(github, targetBranch, prefix) {
+    var _a;
+    const branchPrefix = prefix
+        ? prefix.endsWith('-')
+            ? prefix.replace(/-$/, '')
+            : prefix
+        : undefined;
+    logger_1.logger.info(`Looking for latest release on branch: ${targetBranch} with prefix: ${prefix}`);
+    // 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);
+    for await (const commitWithPullRequest of generator) {
+        const mergedPullRequest = commitWithPullRequest.pullRequest;
+        if (!mergedPullRequest) {
+            continue;
+        }
+        const branchName = branch_name_1.BranchName.parse(mergedPullRequest.headBranchName);
+        if (!branchName) {
+            continue;
+        }
+        // If branchPrefix is specified, ensure it is found in the branch name.
+        // If branchPrefix is not specified, component should also be undefined.
+        if (branchName.getComponent() !== branchPrefix) {
+            continue;
+        }
+        const pullRequestTitle = pull_request_title_1.PullRequestTitle.parse(mergedPullRequest.title);
+        if (!pullRequestTitle) {
+            continue;
+        }
+        const version = pullRequestTitle.getVersion();
+        if ((_a = version === null || version === void 0 ? void 0 : version.preRelease) === null || _a === void 0 ? void 0 : _a.includes('SNAPSHOT')) {
+            // FIXME, don't hardcode this
+            continue;
+        }
+        return version;
+    }
+    return;
+}
+function mergeReleaserConfig(defaultConfig, pathConfig) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    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,
+    };
+}
+/**
+ * Helper to compare if a list of labels fully contains another list of labels
+ * @param {string[]} expected List of labels expected to be contained
+ * @param {string[]} existing List of existing labels to consider
+ */
+function hasAllLabels(expected, existing) {
+    const existingSet = new Set(existing);
+    for (const label of expected) {
+        if (!existingSet.has(label)) {
+            return false;
+        }
+    }
+    return true;
+}
+function commitsAfterSha(commits, lastReleaseSha) {
+    if (!commits) {
+        return [];
+    }
+    const index = commits.findIndex(commit => commit.sha === lastReleaseSha);
+    if (index === -1) {
+        return commits;
+    }
+    return commits.slice(0, index);
+}
 //# sourceMappingURL=manifest.js.map