release-please 16.0.0 → 16.1.0

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [16.1.0](https://github.com/googleapis/release-please/compare/v16.0.0...v16.1.0) (2023-10-26)
+
+
+### Features
+
+* Implement custom prerelease type ([#2083](https://github.com/googleapis/release-please/issues/2083)) ([97b0542](https://github.com/googleapis/release-please/commit/97b05421168316a23592897c8853893adf08d24c))
+* Update package-lock.json workspace entry versions ([#2088](https://github.com/googleapis/release-please/issues/2088)) ([dbb11bc](https://github.com/googleapis/release-please/commit/dbb11bc62d6c8135b5b168354e8f235398ffab03)), closes [#1993](https://github.com/googleapis/release-please/issues/1993)
+
+
+### Bug Fixes
+
+* Releasable units should use version from pull-request body ([#2102](https://github.com/googleapis/release-please/issues/2102)) ([db035b7](https://github.com/googleapis/release-please/commit/db035b798f33c5ce0ddf2a43dcf2458c170c8fe3)), closes [#2101](https://github.com/googleapis/release-please/issues/2101)
+
 ## [16.0.0](https://github.com/googleapis/release-please/compare/v15.13.0...v16.0.0) (2023-09-18)
 
 

package/README.md

@@ -190,7 +190,7 @@ Release Please automates releases for the following flavors of repositories:
 | `krm-blueprint`     | [A kpt package, with 1 or more KRM files and a CHANGELOG.md](https://github.com/GoogleCloudPlatform/blueprints/tree/main/catalog/project) |
 | `maven`             | [Strategy for Maven projects, generates SNAPSHOT version after each release and updates `pom.xml` automatically](docs/java.md) |
 | `node`              | [A Node.js repository, with a package.json and CHANGELOG.md](https://github.com/yargs/yargs) |
-| `expo`              | [An Expo based React Native repository, with a package.json, app.json and CHANGELOG.md](https://github.com/yargs/yargs) |
+| `expo`              | An Expo based React Native repository, with a package.json, app.json and CHANGELOG.md |
 | `ocaml`             | [An OCaml repository, containing 1 or more opam or esy files and a CHANGELOG.md](https://github.com/grain-lang/binaryen.ml) |
 | `php`               | A repository with a composer.json and a CHANGELOG.md |
 | `python`            | [A Python repository, with a setup.py, setup.cfg, CHANGELOG.md](https://github.com/googleapis/python-storage) and optionally a pyproject.toml and a <project>/\_\_init\_\_.py |

package/build/src/bin/release-please.js

@@ -142,6 +142,10 @@ function pullRequestStrategyOptions(yargs) {
             ' changes prior to the first major release',
         default: false,
         type: 'boolean',
+    })
+        .option('prerelease-type', {
+        describe: 'type of the prerelease, e.g., alpha',
+        type: 'string',
     })
         .option('extra-files', {
         describe: 'extra files for the strategy to consider',
@@ -290,6 +294,7 @@ const createReleasePullRequestCommand = {
                 draftPullRequest: argv.draftPullRequest,
                 bumpMinorPreMajor: argv.bumpMinorPreMajor,
                 bumpPatchForMinorPreMajor: argv.bumpPatchForMinorPreMajor,
+                prereleaseType: argv.prereleaseType,
                 changelogPath: argv.changelogPath,
                 changelogType: argv.changelogType,
                 changelogHost: argv.changelogHost,
@@ -481,6 +486,7 @@ const bootstrapCommand = {
             draftPullRequest: argv.draftPullRequest,
             bumpMinorPreMajor: argv.bumpMinorPreMajor,
             bumpPatchForMinorPreMajor: argv.bumpPatchForMinorPreMajor,
+            prereleaseType: argv.prereleaseType,
             changelogPath: argv.changelogPath,
             changelogHost: argv.changelogHost,
             changelogSections: argv.changelogSections,

package/build/src/factories/versioning-strategy-factory.d.ts

@@ -5,6 +5,7 @@ export interface VersioningStrategyFactoryOptions {
     type?: VersioningStrategyType;
     bumpMinorPreMajor?: boolean;
     bumpPatchForMinorPreMajor?: boolean;
+    prereleaseType?: string;
     github: GitHub;
 }
 export type VersioningStrategyBuilder = (options: VersioningStrategyFactoryOptions) => VersioningStrategy;

package/build/src/factory.js

@@ -109,6 +109,7 @@ async function buildStrategy(options) {
         type: options.versioning,
         bumpMinorPreMajor: options.bumpMinorPreMajor,
         bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+        prereleaseType: options.prereleaseType,
     });
     const changelogNotes = (0, changelog_notes_factory_1.buildChangelogNotes)({
         type: options.changelogType || 'default',

package/build/src/manifest.d.ts

@@ -45,6 +45,7 @@ export interface ReleaserConfig {
     versioning?: VersioningStrategyType;
     bumpMinorPreMajor?: boolean;
     bumpPatchForMinorPreMajor?: boolean;
+    prereleaseType?: string;
     releaseAs?: string;
     skipGithubRelease?: boolean;
     draft?: boolean;
@@ -88,6 +89,7 @@ interface ReleaserConfigJson {
     versioning?: VersioningStrategyType;
     'bump-minor-pre-major'?: boolean;
     'bump-patch-for-minor-pre-major'?: boolean;
+    'prerelease-type'?: string;
     'changelog-sections'?: ChangelogSection[];
     'release-as'?: string;
     'skip-github-release'?: boolean;

package/build/src/manifest.js

@@ -772,6 +772,7 @@ function extractReleaserConfig(config) {
         releaseType: config['release-type'],
         bumpMinorPreMajor: config['bump-minor-pre-major'],
         bumpPatchForMinorPreMajor: config['bump-patch-for-minor-pre-major'],
+        prereleaseType: config['prerelease-type'],
         versioning: config['versioning'],
         changelogSections: config['changelog-sections'],
         changelogPath: config['changelog-path'],
@@ -1010,34 +1011,35 @@ async function latestReleaseVersion(github, targetBranch, releaseFilter, config,
     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, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3;
     return {
         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,
-        versioning: (_e = pathConfig.versioning) !== null && _e !== void 0 ? _e : defaultConfig.versioning,
-        changelogSections: (_f = pathConfig.changelogSections) !== null && _f !== void 0 ? _f : defaultConfig.changelogSections,
-        changelogPath: (_g = pathConfig.changelogPath) !== null && _g !== void 0 ? _g : defaultConfig.changelogPath,
-        changelogHost: (_h = pathConfig.changelogHost) !== null && _h !== void 0 ? _h : defaultConfig.changelogHost,
-        changelogType: (_j = pathConfig.changelogType) !== null && _j !== void 0 ? _j : defaultConfig.changelogType,
-        releaseAs: (_k = pathConfig.releaseAs) !== null && _k !== void 0 ? _k : defaultConfig.releaseAs,
-        skipGithubRelease: (_l = pathConfig.skipGithubRelease) !== null && _l !== void 0 ? _l : defaultConfig.skipGithubRelease,
-        draft: (_m = pathConfig.draft) !== null && _m !== void 0 ? _m : defaultConfig.draft,
-        prerelease: (_o = pathConfig.prerelease) !== null && _o !== void 0 ? _o : defaultConfig.prerelease,
-        component: (_p = pathConfig.component) !== null && _p !== void 0 ? _p : defaultConfig.component,
-        packageName: (_q = pathConfig.packageName) !== null && _q !== void 0 ? _q : defaultConfig.packageName,
-        versionFile: (_r = pathConfig.versionFile) !== null && _r !== void 0 ? _r : defaultConfig.versionFile,
-        extraFiles: (_s = pathConfig.extraFiles) !== null && _s !== void 0 ? _s : defaultConfig.extraFiles,
-        includeComponentInTag: (_t = pathConfig.includeComponentInTag) !== null && _t !== void 0 ? _t : defaultConfig.includeComponentInTag,
-        includeVInTag: (_u = pathConfig.includeVInTag) !== null && _u !== void 0 ? _u : defaultConfig.includeVInTag,
-        tagSeparator: (_v = pathConfig.tagSeparator) !== null && _v !== void 0 ? _v : defaultConfig.tagSeparator,
-        pullRequestTitlePattern: (_w = pathConfig.pullRequestTitlePattern) !== null && _w !== void 0 ? _w : defaultConfig.pullRequestTitlePattern,
-        pullRequestHeader: (_x = pathConfig.pullRequestHeader) !== null && _x !== void 0 ? _x : defaultConfig.pullRequestHeader,
-        separatePullRequests: (_y = pathConfig.separatePullRequests) !== null && _y !== void 0 ? _y : defaultConfig.separatePullRequests,
-        skipSnapshot: (_z = pathConfig.skipSnapshot) !== null && _z !== void 0 ? _z : defaultConfig.skipSnapshot,
-        initialVersion: (_0 = pathConfig.initialVersion) !== null && _0 !== void 0 ? _0 : defaultConfig.initialVersion,
-        extraLabels: (_1 = pathConfig.extraLabels) !== null && _1 !== void 0 ? _1 : defaultConfig.extraLabels,
-        excludePaths: (_2 = pathConfig.excludePaths) !== null && _2 !== void 0 ? _2 : defaultConfig.excludePaths,
+        prereleaseType: (_e = pathConfig.prereleaseType) !== null && _e !== void 0 ? _e : defaultConfig.prereleaseType,
+        versioning: (_f = pathConfig.versioning) !== null && _f !== void 0 ? _f : defaultConfig.versioning,
+        changelogSections: (_g = pathConfig.changelogSections) !== null && _g !== void 0 ? _g : defaultConfig.changelogSections,
+        changelogPath: (_h = pathConfig.changelogPath) !== null && _h !== void 0 ? _h : defaultConfig.changelogPath,
+        changelogHost: (_j = pathConfig.changelogHost) !== null && _j !== void 0 ? _j : defaultConfig.changelogHost,
+        changelogType: (_k = pathConfig.changelogType) !== null && _k !== void 0 ? _k : defaultConfig.changelogType,
+        releaseAs: (_l = pathConfig.releaseAs) !== null && _l !== void 0 ? _l : defaultConfig.releaseAs,
+        skipGithubRelease: (_m = pathConfig.skipGithubRelease) !== null && _m !== void 0 ? _m : defaultConfig.skipGithubRelease,
+        draft: (_o = pathConfig.draft) !== null && _o !== void 0 ? _o : defaultConfig.draft,
+        prerelease: (_p = pathConfig.prerelease) !== null && _p !== void 0 ? _p : defaultConfig.prerelease,
+        component: (_q = pathConfig.component) !== null && _q !== void 0 ? _q : defaultConfig.component,
+        packageName: (_r = pathConfig.packageName) !== null && _r !== void 0 ? _r : defaultConfig.packageName,
+        versionFile: (_s = pathConfig.versionFile) !== null && _s !== void 0 ? _s : defaultConfig.versionFile,
+        extraFiles: (_t = pathConfig.extraFiles) !== null && _t !== void 0 ? _t : defaultConfig.extraFiles,
+        includeComponentInTag: (_u = pathConfig.includeComponentInTag) !== null && _u !== void 0 ? _u : defaultConfig.includeComponentInTag,
+        includeVInTag: (_v = pathConfig.includeVInTag) !== null && _v !== void 0 ? _v : defaultConfig.includeVInTag,
+        tagSeparator: (_w = pathConfig.tagSeparator) !== null && _w !== void 0 ? _w : defaultConfig.tagSeparator,
+        pullRequestTitlePattern: (_x = pathConfig.pullRequestTitlePattern) !== null && _x !== void 0 ? _x : defaultConfig.pullRequestTitlePattern,
+        pullRequestHeader: (_y = pathConfig.pullRequestHeader) !== null && _y !== void 0 ? _y : defaultConfig.pullRequestHeader,
+        separatePullRequests: (_z = pathConfig.separatePullRequests) !== null && _z !== void 0 ? _z : defaultConfig.separatePullRequests,
+        skipSnapshot: (_0 = pathConfig.skipSnapshot) !== null && _0 !== void 0 ? _0 : defaultConfig.skipSnapshot,
+        initialVersion: (_1 = pathConfig.initialVersion) !== null && _1 !== void 0 ? _1 : defaultConfig.initialVersion,
+        extraLabels: (_2 = pathConfig.extraLabels) !== null && _2 !== void 0 ? _2 : defaultConfig.extraLabels,
+        excludePaths: (_3 = pathConfig.excludePaths) !== null && _3 !== void 0 ? _3 : defaultConfig.excludePaths,
     };
 }
 /**

package/build/src/strategies/base.js

@@ -384,7 +384,12 @@ class BaseStrategy {
         if (notes === undefined) {
             this.logger.warn('Failed to find release notes');
         }
-        const version = pullRequestTitle.getVersion() || (releaseData === null || releaseData === void 0 ? void 0 : releaseData.version);
+        let version = pullRequestTitle.getVersion();
+        if (!version ||
+            (pullRequestBody.releaseData.length > 1 && (releaseData === null || releaseData === void 0 ? void 0 : releaseData.version))) {
+            // prioritize pull-request body version for multi-component releases
+            version = releaseData === null || releaseData === void 0 ? void 0 : releaseData.version;
+        }
         if (!version) {
             this.logger.error('Pull request should have included version');
             return;

package/build/src/updaters/node/package-lock-json.js

@@ -29,6 +29,14 @@ class PackageLockJson extends default_1.DefaultUpdater {
         if (parsed.lockfileVersion === 2 || parsed.lockfileVersion === 3) {
             parsed.packages[''].version = this.version.toString();
         }
+        if (this.versionsMap) {
+            for (const [, obj] of Object.entries(parsed.packages)) {
+                const ver = this.versionsMap.get(obj.name);
+                if (ver) {
+                    obj.version = ver.toString();
+                }
+            }
+        }
         return (0, json_stringify_1.jsonStringify)(parsed, content);
     }
 }

package/build/src/version.d.ts

@@ -30,5 +30,6 @@ export declare class Version {
      * @returns {string}
      */
     toString(): string;
+    get isPreMajor(): boolean;
 }
 export type VersionsMap = Map<string, Version>;

package/build/src/version.js

@@ -66,6 +66,9 @@ class Version {
         const buildPart = this.build ? `+${this.build}` : '';
         return `${this.major}.${this.minor}.${this.patch}${preReleasePart}${buildPart}`;
     }
+    get isPreMajor() {
+        return this.major < 1;
+    }
 }
 exports.Version = Version;
 //# sourceMappingURL=version.js.map

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

@@ -2,7 +2,7 @@ import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
 import { ConventionalCommit } from '../commit';
 import { Version } from '../version';
 import { Logger } from '../util/logger';
-interface DefaultVersioningStrategyOptions {
+export interface DefaultVersioningStrategyOptions {
     bumpMinorPreMajor?: boolean;
     bumpPatchForMinorPreMajor?: boolean;
     logger?: Logger;
@@ -46,4 +46,3 @@ export declare class DefaultVersioningStrategy implements VersioningStrategy {
      */
     bump(version: Version, commits: ConventionalCommit[]): Version;
 }
-export {};

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

@@ -66,7 +66,7 @@ class DefaultVersioningStrategy {
             }
         }
         if (breaking > 0) {
-            if (version.major < 1 && this.bumpMinorPreMajor) {
+            if (version.isPreMajor && this.bumpMinorPreMajor) {
                 return new versioning_strategy_1.MinorVersionUpdate();
             }
             else {
@@ -74,7 +74,7 @@ class DefaultVersioningStrategy {
             }
         }
         else if (features > 0) {
-            if (version.major < 1 && this.bumpPatchForMinorPreMajor) {
+            if (version.isPreMajor && this.bumpPatchForMinorPreMajor) {
                 return new versioning_strategy_1.PatchVersionUpdate();
             }
             else {

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

@@ -46,7 +46,7 @@ class DependencyManifest extends default_1.DefaultVersioningStrategy {
         }
         let dependencyBump;
         if (breaking > 0) {
-            if (version.major < 1 && this.bumpMinorPreMajor) {
+            if (version.isPreMajor && this.bumpMinorPreMajor) {
                 dependencyBump = new versioning_strategy_1.MinorVersionUpdate();
             }
             else {
@@ -54,7 +54,7 @@ class DependencyManifest extends default_1.DefaultVersioningStrategy {
             }
         }
         else if (features > 0) {
-            if (version.major < 1 && this.bumpPatchForMinorPreMajor) {
+            if (version.isPreMajor && this.bumpPatchForMinorPreMajor) {
                 dependencyBump = new versioning_strategy_1.PatchVersionUpdate();
             }
             else {

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

@@ -1,12 +1,18 @@
-import { DefaultVersioningStrategy } from './default';
+import { DefaultVersioningStrategyOptions, DefaultVersioningStrategy } from './default';
 import { Version } from '../version';
 import { ConventionalCommit } from '..';
 import { VersionUpdater } from '../versioning-strategy';
+interface PrereleaseVersioningStrategyOptions extends DefaultVersioningStrategyOptions {
+    prereleaseType?: string;
+}
 /**
  * This versioning strategy will increment the pre-release number for patch
  * bumps if there is a pre-release number (preserving any leading 0s).
  * Example: 1.2.3-beta01 -> 1.2.3-beta02.
  */
 export declare class PrereleaseVersioningStrategy extends DefaultVersioningStrategy {
+    readonly prereleaseType?: string;
+    constructor(options?: PrereleaseVersioningStrategyOptions);
     determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
 }
+export {};

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

@@ -17,8 +17,39 @@ exports.PrereleaseVersioningStrategy = void 0;
 const default_1 = require("./default");
 const version_1 = require("../version");
 const versioning_strategy_1 = require("../versioning-strategy");
-const PRERELEASE_PATTERN = /^(?<type>[a-z]+)(?<number>\d+)$/;
-class PrereleasePatchVersionUpdate {
+/**
+ * Regex to match the last set of numbers in a string
+ * Example: 1.2.3-beta01-01 -> 01
+ */
+const PRERELEASE_NUMBER = /(?<number>\d+)(?=\D*$)/;
+class AbstractPrereleaseVersionUpdate {
+    constructor(prereleaseType) {
+        this.prereleaseType = prereleaseType;
+    }
+    /**
+     * Returns the new bumped prerelease version
+     *
+     * That is, if the current version is 1.2.3-beta01, the next prerelease version
+     * will be 1.2.3-beta02. If no number is found, the prerelease version will be
+     * 1.2.3-beta. If multiple numbers are found, the last set of numbers will be
+     * incremented, e.g. 1.2.3-beta01-01 -> 1.2.3-beta01-02.
+     *
+     * @param {prerelease} string The current version
+     * @returns {Version} The bumped version
+     */
+    bumpPrerelease(prerelease) {
+        const match = prerelease.match(PRERELEASE_NUMBER);
+        let nextPrerelease = `${prerelease}.1`;
+        if (match === null || match === void 0 ? void 0 : match.groups) {
+            const numberLength = match.groups.number.length;
+            const nextPrereleaseNumber = Number(match.groups.number) + 1;
+            const paddedNextPrereleaseNumber = `${nextPrereleaseNumber}`.padStart(numberLength, '0');
+            nextPrerelease = prerelease.replace(PRERELEASE_NUMBER, paddedNextPrereleaseNumber);
+        }
+        return nextPrerelease;
+    }
+}
+class PrereleasePatchVersionUpdate extends AbstractPrereleaseVersionUpdate {
     /**
      * Returns the new bumped version
      *
@@ -27,19 +58,13 @@ class PrereleasePatchVersionUpdate {
      */
     bump(version) {
         if (version.preRelease) {
-            const match = version.preRelease.match(PRERELEASE_PATTERN);
-            if (match === null || match === void 0 ? void 0 : match.groups) {
-                const numberLength = match.groups.number.length;
-                const nextPrereleaseNumber = Number(match.groups.number) + 1;
-                const paddedNextPrereleaseNumber = `${nextPrereleaseNumber}`.padStart(numberLength, '0');
-                const nextPrerelease = `${match.groups.type}${paddedNextPrereleaseNumber}`;
-                return new version_1.Version(version.major, version.minor, version.patch, nextPrerelease, version.build);
-            }
+            const nextPrerelease = this.bumpPrerelease(version.preRelease);
+            return new version_1.Version(version.major, version.minor, version.patch, nextPrerelease, version.build);
         }
-        return new version_1.Version(version.major, version.minor, version.patch + 1, version.preRelease, version.build);
+        return new version_1.Version(version.major, version.minor, version.patch + 1, this.prereleaseType, version.build);
     }
 }
-class PrereleaseMinorVersionUpdate {
+class PrereleaseMinorVersionUpdate extends AbstractPrereleaseVersionUpdate {
     /**
      * Returns the new bumped version
      *
@@ -48,28 +73,16 @@ class PrereleaseMinorVersionUpdate {
      */
     bump(version) {
         if (version.preRelease) {
-            const match = version.preRelease.match(PRERELEASE_PATTERN);
-            if (match === null || match === void 0 ? void 0 : match.groups) {
-                const numberLength = match.groups.number.length;
-                const prereleaseNumber = Number(match.groups.number);
-                let nextPrereleaseNumber = 1;
-                let nextMinorNumber = version.minor + 1;
-                let nextPatchNumber = 0;
-                if (version.patch === 0) {
-                    // this is already the next minor candidate, then bump the pre-release number
-                    nextPrereleaseNumber = prereleaseNumber + 1;
-                    nextMinorNumber = version.minor;
-                    nextPatchNumber = version.patch;
-                }
-                const paddedNextPrereleaseNumber = `${nextPrereleaseNumber}`.padStart(numberLength, '0');
-                const nextPrerelease = `${match.groups.type}${paddedNextPrereleaseNumber}`;
-                return new version_1.Version(version.major, nextMinorNumber, nextPatchNumber, nextPrerelease, version.build);
+            if (version.patch === 0) {
+                const nextPrerelease = this.bumpPrerelease(version.preRelease);
+                return new version_1.Version(version.major, version.minor, version.patch, nextPrerelease, version.build);
             }
+            return new versioning_strategy_1.MinorVersionUpdate().bump(version);
         }
-        return new version_1.Version(version.major, version.minor + 1, 0, version.preRelease, version.build);
+        return new version_1.Version(version.major, version.minor + 1, 0, this.prereleaseType, version.build);
     }
 }
-class PrereleaseMajorVersionUpdate {
+class PrereleaseMajorVersionUpdate extends AbstractPrereleaseVersionUpdate {
     /**
      * Returns the new bumped version
      *
@@ -78,27 +91,13 @@ class PrereleaseMajorVersionUpdate {
      */
     bump(version) {
         if (version.preRelease) {
-            const match = version.preRelease.match(PRERELEASE_PATTERN);
-            if (match === null || match === void 0 ? void 0 : match.groups) {
-                const numberLength = match.groups.number.length;
-                const prereleaseNumber = Number(match.groups.number);
-                let nextPrereleaseNumber = 1;
-                let nextMajorNumber = version.major + 1;
-                let nextMinorNumber = 0;
-                let nextPatchNumber = 0;
-                if (version.patch === 0 && version.minor === 0) {
-                    // this is already the next major candidate, then bump the pre-release number
-                    nextPrereleaseNumber = prereleaseNumber + 1;
-                    nextMajorNumber = version.major;
-                    nextMinorNumber = version.minor;
-                    nextPatchNumber = version.patch;
-                }
-                const paddedNextPrereleaseNumber = `${nextPrereleaseNumber}`.padStart(numberLength, '0');
-                const nextPrerelease = `${match.groups.type}${paddedNextPrereleaseNumber}`;
-                return new version_1.Version(nextMajorNumber, nextMinorNumber, nextPatchNumber, nextPrerelease, version.build);
+            if (version.patch === 0 && version.minor === 0) {
+                const nextPrerelease = this.bumpPrerelease(version.preRelease);
+                return new version_1.Version(version.major, version.minor, version.patch, nextPrerelease, version.build);
             }
+            return new versioning_strategy_1.MajorVersionUpdate().bump(version);
         }
-        return new version_1.Version(version.major + 1, 0, 0, version.preRelease, version.build);
+        return new version_1.Version(version.major + 1, 0, 0, this.prereleaseType, version.build);
     }
 }
 /**
@@ -107,6 +106,10 @@ class PrereleaseMajorVersionUpdate {
  * Example: 1.2.3-beta01 -> 1.2.3-beta02.
  */
 class PrereleaseVersioningStrategy extends default_1.DefaultVersioningStrategy {
+    constructor(options = {}) {
+        super(options);
+        this.prereleaseType = options.prereleaseType;
+    }
     determineReleaseType(version, commits) {
         // iterate through list of commits and find biggest commit type
         let breaking = 0;
@@ -126,22 +129,22 @@ class PrereleaseVersioningStrategy extends default_1.DefaultVersioningStrategy {
             }
         }
         if (breaking > 0) {
-            if (version.major < 1 && this.bumpMinorPreMajor) {
-                return new PrereleaseMinorVersionUpdate();
+            if (version.isPreMajor && this.bumpMinorPreMajor) {
+                return new PrereleaseMinorVersionUpdate(this.prereleaseType);
             }
             else {
-                return new PrereleaseMajorVersionUpdate();
+                return new PrereleaseMajorVersionUpdate(this.prereleaseType);
             }
         }
         else if (features > 0) {
-            if (version.major < 1 && this.bumpPatchForMinorPreMajor) {
-                return new PrereleasePatchVersionUpdate();
+            if (version.isPreMajor && this.bumpPatchForMinorPreMajor) {
+                return new PrereleasePatchVersionUpdate(this.prereleaseType);
             }
             else {
-                return new PrereleaseMinorVersionUpdate();
+                return new PrereleaseMinorVersionUpdate(this.prereleaseType);
             }
         }
-        return new PrereleasePatchVersionUpdate();
+        return new PrereleasePatchVersionUpdate(this.prereleaseType);
     }
 }
 exports.PrereleaseVersioningStrategy = PrereleaseVersioningStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "16.0.0",
+  "version": "16.1.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",

package/schemas/config.json

@@ -20,6 +20,10 @@
           "description": "Feature changes only bump semver patch if version < 1.0.0",
           "type": "boolean"
         },
+        "prerelease-type": {
+          "description": "Configuration option for the prerelese versioning strategy. If prerelease strategy used and type set, will set the prerelese part of the version to the provided value in case prerelease part is not present.",
+          "type": "string"
+        },
         "versioning": {
           "description": "Versioning strategy. Defaults to `default`",
           "type": "string"
@@ -290,7 +294,11 @@
                   "type": {
                     "description": "The name of the plugin.",
                     "type": "string",
-                    "enum": ["cargo-workspace", "maven-workspace", "node-workspace"]
+                    "enum": [
+                      "cargo-workspace",
+                      "maven-workspace",
+                      "node-workspace"
+                    ]
                   },
                   "updateAllPackages": {
                     "description": "Whether to force updating all packages regardless of the dependency tree. Defaults to `false`.",