semantic-release 20.0.0-beta.2 → 20.0.0-beta.4

package/docs/usage/workflow-configuration.md

@@ -1,6 +1,7 @@
 # Workflow configuration
 
 **semantic-release** allow to manage and automate complex release workflow, based on multiple Git branches and distribution channels. This allow to:
+
 - Distribute certain releases to a particular group of users via distribution channels
 - Manage the availability of releases on distribution channels via branches merge
 - Maintain multiple lines of releases in parallel
@@ -12,6 +13,7 @@ The release workflow is configured via the [branches option](./configuration.md#
 Each branch can be defined either as a string, a [glob](https://github.com/micromatch/micromatch#matching-features) or an object. For string and glob definitions each [property](#branches-properties) will be defaulted.
 
 A branch can defined as one of three types:
+
 - [release](#release-branches): to make releases on top of the last version released
 - [maintenance](#maintenance-branches): to make releases on top of an old release
 - [pre-release](#pre-release-branches): to make pre-releases
@@ -21,7 +23,7 @@ The type of the branch is automatically determined based on naming convention an
 ## Branches properties
 
 | Property     | Branch type                               | Description                                                                                                                                                                             | Default                                                                                         |
-|--------------|-------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|
+| ------------ | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
 | `name`       | All                                       | **Required.** The Git branch holding the commits to analyze and the code to release. See [name](#name).                                                                                 | - The value itself if defined as a `String` or the matching branches name if defined as a glob. |
 | `channel`    | All                                       | The distribution channel on which to publish releases from this branch. Set to `false` to force the default distribution channel instead of using the default. See [channel](#channel). | `undefined` for the first release branch, the value of `name` for subsequent ones.              |
 | `range`      | [maintenance](#maintenance-branches) only | **Required unless `name` is formatted like `N.N.x` or `N.x` (`N` is a number).** The range of [semantic versions](https://semver.org) to support on this branch. See [range](#range).   | The value of `name`.                                                                            |
@@ -35,14 +37,15 @@ It can be defined as a [glob](https://github.com/micromatch/micromatch#matching-
 If `name` doesn't match to any branch existing in the repository, the definition will be ignored. For example the default configuration includes the definition `next` and `next-major` which will become active only when the branches `next` and/or `next-major` are created in the repository. This allow to define your workflow once with all potential branches you might use and have the effective configuration evolving as you create new branches.
 
 For example the configuration `['+([0-9])?(.{+([0-9]),x}).x', 'master', 'next']` will be expanded as:
+
 ```js
 {
   branches: [
-    {name: '1.x', range: '1.x', channel: '1.x'}, // Only after the `1.x` is created in the repo
-    {name: '2.x', range: '2.x', channel: '2.x'}, // Only after the `2.x` is created in the repo
-    {name: 'master'},
-    {name: 'next', channel: 'next'}, // Only after the `next` is created in the repo
-  ]
+    { name: "1.x", range: "1.x", channel: "1.x" }, // Only after the `1.x` is created in the repo
+    { name: "2.x", range: "2.x", channel: "2.x" }, // Only after the `2.x` is created in the repo
+    { name: "master" },
+    { name: "next", channel: "next" }, // Only after the `next` is created in the repo
+  ];
 }
 ```
 
@@ -54,12 +57,13 @@ If the `channel` property is set to `false` the default channel will be used.
 The value of `channel`, if defined as a string, is generated with [Lodash template](https://lodash.com/docs#template) with the variable `name` available.
 
 For example the configuration `['master', {name: 'next', channel: 'channel-${name}'}]` will be expanded as:
+
 ```js
 {
   branches: [
-    {name: 'master'}, // `channel` is undefined so the default distribution channel will be used
-    {name: 'next', channel: 'channel-next'}, // `channel` is built with the template `channel-${name}`
-  ]
+    { name: "master" }, // `channel` is undefined so the default distribution channel will be used
+    { name: "next", channel: "channel-next" }, // `channel` is built with the template `channel-${name}`
+  ];
 }
 ```
 
@@ -68,13 +72,14 @@ For example the configuration `['master', {name: 'next', channel: 'channel-${nam
 A `range` only applies to maintenance branches, is required and must be formatted like `N.N.x` or `N.x` (`N` is a number). In case the `name` is formatted as a range (for example `1.x` or `1.5.x`) the branch will be considered a maintenance branch and the `name` value will be used for the `range`.
 
 For example the configuration `['1.1.x', '1.2.x', 'master']` will be expanded as:
+
 ```js
 {
   branches: [
-    {name: '1.1.x', range: '1.1.x', channel: '1.1.x'},
-    {name: '1.2.x', range: '1.2.x', channel: '1.2.x'},
-    {name: 'master'},
-  ]
+    { name: "1.1.x", range: "1.1.x", channel: "1.1.x" },
+    { name: "1.2.x", range: "1.2.x", channel: "1.2.x" },
+    { name: "master" },
+  ];
 }
 ```
 
@@ -86,13 +91,14 @@ If the `prerelease` property is set to `true` the `name` value will be used.
 The value of `prerelease`, if defined as a string, is generated with [Lodash template](https://lodash.com/docs#template) with the variable `name` available.
 
 For example the configuration `['master', {name: 'pre/rc', prerelease: '${name.replace(/^pre\\//g, "")}'}, {name: 'beta', prerelease: true}]` will be expanded as:
+
 ```js
 {
   branches: [
-    {name: 'master'},
-    {name: 'pre/rc', channel: 'pre/rc', prerelease: 'rc'}, // `prerelease` is built with the template `${name.replace(/^pre\\//g, "")}`
-    {name: 'beta', channel: 'beta', prerelease: true}, // `prerelease` is set to `beta` as it is the value of `name`
-  ]
+    { name: "master" },
+    { name: "pre/rc", channel: "pre/rc", prerelease: "rc" }, // `prerelease` is built with the template `${name.replace(/^pre\\//g, "")}`
+    { name: "beta", channel: "beta", prerelease: true }, // `prerelease` is set to `beta` as it is the value of `name`
+  ];
 }
 ```
 
@@ -113,10 +119,12 @@ See [publishing on distribution channels recipe](../recipes/release-workflow/dis
 #### Pushing to a release branch
 
 With the configuration `"branches": ["master", "next"]`, if the last release published from `master` is `1.0.0` and the last one from `next` is `2.0.0` then:
+
 - Only versions in range `1.x.x` can be published from `master`, so only `fix` and `feat` commits can be pushed to `master`
 - Once `next` get merged into `master` the release `2.0.0` will be made available on the channel associated with `master` and both `master` and `next` will accept any commit type
 
 This verification prevent scenario such as:
+
 1. Create a `feat` commit on `next` which triggers the release of version `1.0.0` on the `next` channel
 2. Merge `next` into `master` which adds `1.0.0` on the default channel
 3. Create a `feat` commit on `next` which triggers the release of version `1.1.0` on the `next` channel
@@ -147,6 +155,7 @@ See [publishing maintenance releases recipe](../recipes/release-workflow/mainten
 #### Pushing to a maintenance branch
 
 With the configuration `"branches": ["1.0.x", "1.x", "master"]`, if the last release published from `master` is `1.5.0` then:
+
 - Only versions in range `>=1.0.0 <1.1.0` can be published from `1.0.x`, so only `fix` commits can be pushed to `1.0.x`
 - Only versions in range `>=1.1.0 <1.5.0` can be published from `1.x`, so only `fix` and `feat` commits can be pushed to `1.x` as long the resulting release is lower than `1.5.0`
 - Once `2.0.0` is released from `master`, versions in range `>=1.1.0 <2.0.0` can be published from `1.x`, so any number of `fix` and `feat` commits can be pushed to `1.x`
@@ -154,6 +163,7 @@ With the configuration `"branches": ["1.0.x", "1.x", "master"]`, if the last rel
 #### Merging into a maintenance branch
 
 With the configuration `"branches": ["1.0.x", "1.x", "master"]`, if the last release published from `master` is `1.0.0` then:
+
 - Creating the branch `1.0.x` from `master` will make the `1.0.0` release available on the `1.0.x` distribution channel
 - Pushing a `fix` commit on the `1.0.x` branch will release the version `1.0.1` on the `1.0.x` distribution channel
 - Creating the branch `1.x` from `master` will make the `1.0.0` release available on the `1.x` distribution channel
@@ -176,11 +186,13 @@ See [publishing pre-releases recipe](../recipes/release-workflow/pre-releases.md
 #### Pushing to a pre-release branch
 
 With the configuration `"branches": ["master", {"name": "beta", "prerelease": true}]`, if the last release published from `master` is `1.0.0` then:
+
 - Pushing a `BREAKING CHANGE` commit on the `beta` branch will release the version `2.0.0-beta.1` on the `beta` distribution channel
 - Pushing either a `fix`, `feat` or a `BREAKING CHANGE` commit on the `beta` branch will release the version `2.0.0-beta.2` (then `2.0.0-beta.3`, `2.0.0-beta.4`, etc...) on the `beta` distribution channel
 
 #### Merging into a pre-release branch
 
 With the configuration `"branches": ["master", {"name": "beta", "prerelease": true}]`, if the last release published from `master` is `1.0.0` and the last one published from `beta` is `2.0.0-beta.1` then:
+
 - Pushing a `fix` commit on the `master` branch will release the version `1.0.1` on the default distribution channel
 - Merging the branch `master` into `beta` will release the version `2.0.0-beta.2` on the `beta` distribution channel

package/index.js

@@ -1,33 +1,33 @@
-import {createRequire} from 'node:module';
-import {pick} from 'lodash-es';
-import * as marked from 'marked';
-import envCi from 'env-ci';
-import {hookStd} from 'hook-std';
-import semver from 'semver';
-import AggregateError from 'aggregate-error';
-import hideSensitive from './lib/hide-sensitive.js';
-import getConfig from './lib/get-config.js';
-import verify from './lib/verify.js';
-import getNextVersion from './lib/get-next-version.js';
-import getCommits from './lib/get-commits.js';
-import getLastRelease from './lib/get-last-release.js';
-import getReleaseToAdd from './lib/get-release-to-add.js';
-import {extractErrors, makeTag} from './lib/utils.js';
-import getGitAuthUrl from './lib/get-git-auth-url.js';
-import getBranches from './lib/branches/index.js';
-import getLogger from './lib/get-logger.js';
-import {addNote, getGitHead, getTagHead, isBranchUpToDate, push, pushNotes, tag, verifyAuth} from './lib/git.js';
-import getError from './lib/get-error.js';
-import {COMMIT_EMAIL, COMMIT_NAME} from './lib/definitions/constants.js';
+import { createRequire } from "node:module";
+import { pick } from "lodash-es";
+import * as marked from "marked";
+import envCi from "env-ci";
+import { hookStd } from "hook-std";
+import semver from "semver";
+import AggregateError from "aggregate-error";
+import hideSensitive from "./lib/hide-sensitive.js";
+import getConfig from "./lib/get-config.js";
+import verify from "./lib/verify.js";
+import getNextVersion from "./lib/get-next-version.js";
+import getCommits from "./lib/get-commits.js";
+import getLastRelease from "./lib/get-last-release.js";
+import getReleaseToAdd from "./lib/get-release-to-add.js";
+import { extractErrors, makeTag } from "./lib/utils.js";
+import getGitAuthUrl from "./lib/get-git-auth-url.js";
+import getBranches from "./lib/branches/index.js";
+import getLogger from "./lib/get-logger.js";
+import { addNote, getGitHead, getTagHead, isBranchUpToDate, push, pushNotes, tag, verifyAuth } from "./lib/git.js";
+import getError from "./lib/get-error.js";
+import { COMMIT_EMAIL, COMMIT_NAME } from "./lib/definitions/constants.js";
 
 const require = createRequire(import.meta.url);
-const pkg = require('./package.json');
+const pkg = require("./package.json");
 
 let markedOptionsSet = false;
 async function terminalOutput(text) {
   if (!markedOptionsSet) {
-    const {default: TerminalRenderer} = await import('marked-terminal'); // eslint-disable-line node/no-unsupported-features/es-syntax
-    marked.setOptions({renderer: new TerminalRenderer()});
+    const { default: TerminalRenderer } = await import("marked-terminal"); // eslint-disable-line node/no-unsupported-features/es-syntax
+    marked.setOptions({ renderer: new TerminalRenderer() });
     markedOptionsSet = true;
   }
 
@@ -36,12 +36,12 @@ async function terminalOutput(text) {
 
 /* eslint complexity: off */
 async function run(context, plugins) {
-  const {cwd, env, options, logger, envCi} = context;
-  const {isCi, branch, prBranch, isPr} = envCi;
+  const { cwd, env, options, logger, envCi } = context;
+  const { isCi, branch, prBranch, isPr } = envCi;
   const ciBranch = isPr ? prBranch : branch;
 
   if (!isCi && !options.dryRun && !options.noCi) {
-    logger.warn('This run was not triggered in a known CI environment, running in dry-run mode.');
+    logger.warn("This run was not triggered in a known CI environment, running in dry-run mode.");
     options.dryRun = true;
   } else {
     // When running on CI, set the commits author and committer info and prevent the `git` CLI to prompt for username/password. See #703.
@@ -51,7 +51,7 @@ async function run(context, plugins) {
       GIT_COMMITTER_NAME: COMMIT_NAME,
       GIT_COMMITTER_EMAIL: COMMIT_EMAIL,
       ...env,
-      GIT_ASKPASS: 'echo',
+      GIT_ASKPASS: "echo",
       GIT_TERMINAL_PROMPT: 0,
     });
   }
@@ -64,30 +64,30 @@ async function run(context, plugins) {
   // Verify config
   await verify(context);
 
-  options.repositoryUrl = await getGitAuthUrl({...context, branch: {name: ciBranch}});
+  options.repositoryUrl = await getGitAuthUrl({ ...context, branch: { name: ciBranch } });
   context.branches = await getBranches(options.repositoryUrl, ciBranch, context);
-  context.branch = context.branches.find(({name}) => name === ciBranch);
+  context.branch = context.branches.find(({ name }) => name === ciBranch);
 
   if (!context.branch) {
     logger.log(
       `This test run was triggered on the branch ${ciBranch}, while semantic-release is configured to only publish from ${context.branches
-        .map(({name}) => name)
-        .join(', ')}, therefore a new version won’t be published.`
+        .map(({ name }) => name)
+        .join(", ")}, therefore a new version won’t be published.`
     );
     return false;
   }
 
-  logger[options.dryRun ? 'warn' : 'success'](
+  logger[options.dryRun ? "warn" : "success"](
     `Run automated release from branch ${ciBranch} on repository ${options.originalRepositoryURL}${
-      options.dryRun ? ' in dry-run mode' : ''
+      options.dryRun ? " in dry-run mode" : ""
     }`
   );
 
   try {
     try {
-      await verifyAuth(options.repositoryUrl, context.branch.name, {cwd, env});
+      await verifyAuth(options.repositoryUrl, context.branch.name, { cwd, env });
     } catch (error) {
-      if (!(await isBranchUpToDate(options.repositoryUrl, context.branch.name, {cwd, env}))) {
+      if (!(await isBranchUpToDate(options.repositoryUrl, context.branch.name, { cwd, env }))) {
         logger.log(
           `The local branch ${context.branch.name} is behind the remote one, therefore a new version won't be published.`
         );
@@ -98,7 +98,7 @@ async function run(context, plugins) {
     }
   } catch (error) {
     logger.error(`The command "${error.command}" failed with the error message ${error.stderr}.`);
-    throw getError('EGITNOPERMISSION', context);
+    throw getError("EGITNOPERMISSION", context);
   }
 
   logger.success(`Allowed to push to the Git repository`);
@@ -110,24 +110,27 @@ async function run(context, plugins) {
   const releaseToAdd = getReleaseToAdd(context);
 
   if (releaseToAdd) {
-    const {lastRelease, currentRelease, nextRelease} = releaseToAdd;
+    const { lastRelease, currentRelease, nextRelease } = releaseToAdd;
 
-    nextRelease.gitHead = await getTagHead(nextRelease.gitHead, {cwd, env});
-    currentRelease.gitHead = await getTagHead(currentRelease.gitHead, {cwd, env});
+    nextRelease.gitHead = await getTagHead(nextRelease.gitHead, { cwd, env });
+    currentRelease.gitHead = await getTagHead(currentRelease.gitHead, { cwd, env });
     if (context.branch.mergeRange && !semver.satisfies(nextRelease.version, context.branch.mergeRange)) {
-      errors.push(getError('EINVALIDMAINTENANCEMERGE', {...context, nextRelease}));
+      errors.push(getError("EINVALIDMAINTENANCEMERGE", { ...context, nextRelease }));
     } else {
-      const commits = await getCommits({...context, lastRelease, nextRelease});
-      nextRelease.notes = await plugins.generateNotes({...context, commits, lastRelease, nextRelease});
+      const commits = await getCommits({ ...context, lastRelease, nextRelease });
+      nextRelease.notes = await plugins.generateNotes({ ...context, commits, lastRelease, nextRelease });
 
       if (options.dryRun) {
         logger.warn(`Skip ${nextRelease.gitTag} tag creation in dry-run mode`);
       } else {
-        await addNote({channels: [...currentRelease.channels, nextRelease.channel]}, nextRelease.gitHead, {cwd, env});
-        await push(options.repositoryUrl, {cwd, env});
-        await pushNotes(options.repositoryUrl, {cwd, env});
+        await addNote({ channels: [...currentRelease.channels, nextRelease.channel] }, nextRelease.gitHead, {
+          cwd,
+          env,
+        });
+        await push(options.repositoryUrl, { cwd, env });
+        await pushNotes(options.repositoryUrl, { cwd, env });
         logger.success(
-          `Add ${nextRelease.channel ? `channel ${nextRelease.channel}` : 'default channel'} to tag ${
+          `Add ${nextRelease.channel ? `channel ${nextRelease.channel}` : "default channel"} to tag ${
             nextRelease.gitTag
           }`
         );
@@ -140,9 +143,9 @@ async function run(context, plugins) {
         gitHead: nextRelease.gitHead,
       });
 
-      const releases = await plugins.addChannel({...context, commits, lastRelease, currentRelease, nextRelease});
+      const releases = await plugins.addChannel({ ...context, commits, lastRelease, currentRelease, nextRelease });
       context.releases.push(...releases);
-      await plugins.success({...context, lastRelease, commits, nextRelease, releases});
+      await plugins.success({ ...context, lastRelease, commits, nextRelease, releases });
     }
   }
 
@@ -152,7 +155,7 @@ async function run(context, plugins) {
 
   context.lastRelease = getLastRelease(context);
   if (context.lastRelease.gitHead) {
-    context.lastRelease.gitHead = await getTagHead(context.lastRelease.gitHead, {cwd, env});
+    context.lastRelease.gitHead = await getTagHead(context.lastRelease.gitHead, { cwd, env });
   }
 
   if (context.lastRelease.gitTag) {
@@ -168,11 +171,11 @@ async function run(context, plugins) {
   const nextRelease = {
     type: await plugins.analyzeCommits(context),
     channel: context.branch.channel || null,
-    gitHead: await getGitHead({cwd, env}),
+    gitHead: await getGitHead({ cwd, env }),
   };
   if (!nextRelease.type) {
-    logger.log('There are no relevant changes, so no new version is released.');
-    return context.releases.length > 0 ? {releases: context.releases} : false;
+    logger.log("There are no relevant changes, so no new version is released.");
+    return context.releases.length > 0 ? { releases: context.releases } : false;
   }
 
   context.nextRelease = nextRelease;
@@ -180,11 +183,11 @@ async function run(context, plugins) {
   nextRelease.gitTag = makeTag(options.tagFormat, nextRelease.version);
   nextRelease.name = nextRelease.gitTag;
 
-  if (context.branch.type !== 'prerelease' && !semver.satisfies(nextRelease.version, context.branch.range)) {
-    throw getError('EINVALIDNEXTVERSION', {
+  if (context.branch.type !== "prerelease" && !semver.satisfies(nextRelease.version, context.branch.range)) {
+    throw getError("EINVALIDNEXTVERSION", {
       ...context,
       validBranches: context.branches.filter(
-        ({type, accept}) => type !== 'prerelease' && accept.includes(nextRelease.type)
+        ({ type, accept }) => type !== "prerelease" && accept.includes(nextRelease.type)
       ),
     });
   }
@@ -199,20 +202,20 @@ async function run(context, plugins) {
     logger.warn(`Skip ${nextRelease.gitTag} tag creation in dry-run mode`);
   } else {
     // Create the tag before calling the publish plugins as some require the tag to exists
-    await tag(nextRelease.gitTag, nextRelease.gitHead, {cwd, env});
-    await addNote({channels: [nextRelease.channel]}, nextRelease.gitHead, {cwd, env});
-    await push(options.repositoryUrl, {cwd, env});
-    await pushNotes(options.repositoryUrl, {cwd, env});
+    await tag(nextRelease.gitTag, nextRelease.gitHead, { cwd, env });
+    await addNote({ channels: [nextRelease.channel] }, nextRelease.gitHead, { cwd, env });
+    await push(options.repositoryUrl, { cwd, env });
+    await pushNotes(options.repositoryUrl, { cwd, env });
     logger.success(`Created tag ${nextRelease.gitTag}`);
   }
 
   const releases = await plugins.publish(context);
   context.releases.push(...releases);
 
-  await plugins.success({...context, releases});
+  await plugins.success({ ...context, releases });
 
   logger.success(
-    `Published release ${nextRelease.version} on ${nextRelease.channel ? nextRelease.channel : 'default'} channel`
+    `Published release ${nextRelease.version} on ${nextRelease.channel ? nextRelease.channel : "default"} channel`
   );
 
   if (options.dryRun) {
@@ -222,10 +225,10 @@ async function run(context, plugins) {
     }
   }
 
-  return pick(context, ['lastRelease', 'commits', 'nextRelease', 'releases']);
+  return pick(context, ["lastRelease", "commits", "nextRelease", "releases"]);
 }
 
-async function logErrors({logger, stderr}, err) {
+async function logErrors({ logger, stderr }, err) {
   const errors = extractErrors(err).sort((error) => (error.semanticRelease ? -1 : 0));
   for (const error of errors) {
     if (error.semanticRelease) {
@@ -234,7 +237,7 @@ async function logErrors({logger, stderr}, err) {
         stderr.write(await terminalOutput(error.details)); // eslint-disable-line no-await-in-loop
       }
     } else {
-      logger.error('An error occurred while running semantic-release: %O', error);
+      logger.error("An error occurred while running semantic-release: %O", error);
     }
   }
 }
@@ -243,16 +246,16 @@ async function callFail(context, plugins, err) {
   const errors = extractErrors(err).filter((err) => err.semanticRelease);
   if (errors.length > 0) {
     try {
-      await plugins.fail({...context, errors});
+      await plugins.fail({ ...context, errors });
     } catch (error) {
       await logErrors(context, error);
     }
   }
 }
 
-export default async (cliOptions = {}, {cwd = process.cwd(), env = process.env, stdout, stderr} = {}) => {
-  const {unhook} = hookStd(
-    {silent: false, streams: [process.stdout, process.stderr, stdout, stderr].filter(Boolean)},
+export default async (cliOptions = {}, { cwd = process.cwd(), env = process.env, stdout, stderr } = {}) => {
+  const { unhook } = hookStd(
+    { silent: false, streams: [process.stdout, process.stderr, stdout, stderr].filter(Boolean) },
     hideSensitive(env)
   );
   const context = {
@@ -260,12 +263,12 @@ export default async (cliOptions = {}, {cwd = process.cwd(), env = process.env,
     env,
     stdout: stdout || process.stdout,
     stderr: stderr || process.stderr,
-    envCi: envCi({env, cwd}),
+    envCi: envCi({ env, cwd }),
   };
   context.logger = getLogger(context);
   context.logger.log(`Running ${pkg.name} version ${pkg.version}`);
   try {
-    const {plugins, options} = await getConfig(context, cliOptions);
+    const { plugins, options } = await getConfig(context, cliOptions);
     options.originalRepositoryURL = options.repositoryUrl;
     context.options = options;
     try {
@@ -281,4 +284,4 @@ export default async (cliOptions = {}, {cwd = process.cwd(), env = process.env,
     unhook();
     throw error;
   }
-}
+};

package/lib/get-commits.js

@@ -1,7 +1,7 @@
-import debugCommits from 'debug';
-import {getCommits} from './git.js';
+import debugCommits from "debug";
+import { getCommits } from "./git.js";
 
-const debug = debugCommits('semantic-release:get-commits');
+const debug = debugCommits("semantic-release:get-commits");
 
 /**
  * Retrieve the list of commits on the current branch since the commit sha associated with the last release, or all the commits of the current branch if there is no last released version.
@@ -10,16 +10,22 @@ const debug = debugCommits('semantic-release:get-commits');
  *
  * @return {Promise<Array<Object>>} The list of commits on the branch `branch` since the last release.
  */
-export default async ({cwd, env, lastRelease: {gitHead: from}, nextRelease: {gitHead: to = 'HEAD'} = {}, logger}) => {
+export default async ({
+  cwd,
+  env,
+  lastRelease: { gitHead: from },
+  nextRelease: { gitHead: to = "HEAD" } = {},
+  logger,
+}) => {
   if (from) {
-    debug('Use from: %s', from);
+    debug("Use from: %s", from);
   } else {
-    logger.log('No previous release found, retrieving all commits');
+    logger.log("No previous release found, retrieving all commits");
   }
 
-  const commits = await getCommits(from, to, {cwd, env});
+  const commits = await getCommits(from, to, { cwd, env });
 
   logger.log(`Found ${commits.length} commits since last release`);
-  debug('Parsed commits: %o', commits);
+  debug("Parsed commits: %o", commits);
   return commits;
-}
+};

package/lib/get-config.js

@@ -1,39 +1,39 @@
-import {dirname, resolve} from 'node:path';
-import {fileURLToPath} from 'node:url';
-import {createRequire} from 'node:module';
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
-import {castArray, isNil, isPlainObject, isString, pickBy} from 'lodash-es';
-import {readPackageUp} from 'read-pkg-up';
-import {cosmiconfig} from 'cosmiconfig';
-import resolveFrom from 'resolve-from';
-import debugConfig from 'debug';
-import {repoUrl} from './git.js';
-import PLUGINS_DEFINITIONS from './definitions/plugins.js';
-import plugins from './plugins/index.js';
-import {parseConfig, validatePlugin} from './plugins/utils.js';
+import { castArray, isNil, isPlainObject, isString, pickBy } from "lodash-es";
+import { readPackageUp } from "read-pkg-up";
+import { cosmiconfig } from "cosmiconfig";
+import resolveFrom from "resolve-from";
+import debugConfig from "debug";
+import { repoUrl } from "./git.js";
+import PLUGINS_DEFINITIONS from "./definitions/plugins.js";
+import plugins from "./plugins/index.js";
+import { parseConfig, validatePlugin } from "./plugins/utils.js";
 
-const debug = debugConfig('semantic-release:config');
+const debug = debugConfig("semantic-release:config");
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 
-const CONFIG_NAME = 'release';
+const CONFIG_NAME = "release";
 
 export default async (context, cliOptions) => {
-  const {cwd, env} = context;
-  const {config, filepath} = (await cosmiconfig(CONFIG_NAME).search(cwd)) || {};
+  const { cwd, env } = context;
+  const { config, filepath } = (await cosmiconfig(CONFIG_NAME).search(cwd)) || {};
 
-  debug('load config from: %s', filepath);
+  debug("load config from: %s", filepath);
 
   // Merge config file options and CLI/API options
-  let options = {...config, ...cliOptions};
+  let options = { ...config, ...cliOptions };
 
   const pluginsPath = {};
   let extendPaths;
-  ({extends: extendPaths, ...options} = options);
+  ({ extends: extendPaths, ...options } = options);
   if (extendPaths) {
     // If `extends` is defined, load and merge each shareable config with `options`
     options = {
-      ...await (castArray(extendPaths).reduce(async(eventualResult, extendPath) => {
+      ...(await castArray(extendPaths).reduce(async (eventualResult, extendPath) => {
         const result = await eventualResult;
         const extendsOptions = require(resolveFrom.silent(__dirname, extendPath) || resolveFrom(cwd, extendPath));
 
@@ -43,7 +43,7 @@ export default async (context, cliOptions) => {
           .filter(([, value]) => Boolean(value))
           .reduce((pluginsPath, [option, value]) => {
             castArray(value).forEach((plugin) => {
-              if (option === 'plugins' && validatePlugin(plugin)) {
+              if (option === "plugins" && validatePlugin(plugin)) {
                 pluginsPath[parseConfig(plugin)[0]] = extendPath;
               } else if (
                 PLUGINS_DEFINITIONS[option] &&
@@ -55,7 +55,7 @@ export default async (context, cliOptions) => {
             return pluginsPath;
           }, pluginsPath);
 
-        return {...result, ...extendsOptions};
+        return { ...result, ...extendsOptions };
       }, {})),
       ...options,
     };
@@ -64,36 +64,36 @@ export default async (context, cliOptions) => {
   // Set default options values if not defined yet
   options = {
     branches: [
-      '+([0-9])?(.{+([0-9]),x}).x',
-      'master',
-      'next',
-      'next-major',
-      {name: 'beta', prerelease: true},
-      {name: 'alpha', prerelease: true},
+      "+([0-9])?(.{+([0-9]),x}).x",
+      "master",
+      "next",
+      "next-major",
+      { name: "beta", prerelease: true },
+      { name: "alpha", prerelease: true },
     ],
-    repositoryUrl: (await pkgRepoUrl({normalize: false, cwd})) || (await repoUrl({cwd, env})),
+    repositoryUrl: (await pkgRepoUrl({ normalize: false, cwd })) || (await repoUrl({ cwd, env })),
     tagFormat: `v\${version}`,
     plugins: [
-      '@semantic-release/commit-analyzer',
-      '@semantic-release/release-notes-generator',
-      '@semantic-release/npm',
-      '@semantic-release/github',
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github",
     ],
     // Remove `null` and `undefined` options, so they can be replaced with default ones
     ...pickBy(options, (option) => !isNil(option)),
-    ...(options.branches ? {branches: castArray(options.branches)} : {}),
+    ...(options.branches ? { branches: castArray(options.branches) } : {}),
   };
 
   if (options.ci === false) {
     options.noCi = true;
   }
 
-  debug('options values: %O', options);
+  debug("options values: %O", options);
 
-  return {options, plugins: await plugins({...context, options}, pluginsPath)};
-}
+  return { options, plugins: await plugins({ ...context, options }, pluginsPath) };
+};
 
 async function pkgRepoUrl(options) {
-  const {packageJson} = (await readPackageUp(options)) || {};
+  const { packageJson } = (await readPackageUp(options)) || {};
   return packageJson && (isPlainObject(packageJson.repository) ? packageJson.repository.url : packageJson.repository);
 }

package/lib/get-error.js

@@ -1,7 +1,7 @@
-import SemanticReleaseError from '@semantic-release/error';
-import * as ERROR_DEFINITIONS from './definitions/errors.js';
+import SemanticReleaseError from "@semantic-release/error";
+import * as ERROR_DEFINITIONS from "./definitions/errors.js";
 
 export default (code, ctx = {}) => {
-  const {message, details} = ERROR_DEFINITIONS[code](ctx);
+  const { message, details } = ERROR_DEFINITIONS[code](ctx);
   return new SemanticReleaseError(message, code, details);
-}
+};