refactor(esm): converted the package to esm

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# style: prettier
+6964913a3286531f1b3aa0a264feee9e84bb2329

.github/workflows/release.yml

@@ -23,7 +23,8 @@ jobs:
         with:
           node-version: lts/*
           cache: npm
-      - run: npm ci
+      - run: npm clean-install
+      - run: npm audit signatures
       - run: npx semantic-release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -13,8 +13,9 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - 14.17
-          - 16
+          - 18.0.0
+          - 19
+          - 20
         os:
           - ubuntu-latest
           - macos-latest
@@ -27,7 +28,7 @@ jobs:
         with:
           node-version: "${{ matrix.node-version }}"
           cache: npm
-      - run: npm ci
+      - run: npm clean-install
       - run: "npm run test:ci"
   test:
     runs-on: ubuntu-latest
@@ -36,9 +37,13 @@ jobs:
       - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
       - uses: actions/setup-node@64ed1c7eab4cce3362f8c340dee64e5eaeef8f7c # v3
         with:
-          node-version: 16
+          node-version: "lts/*"
           cache: npm
-      - run: npm ci
+      - run: npm clean-install
+      - run: npm audit signatures
       - name: Ensure dependencies are compatible with the engines range
         run: npx ls-engines
       - run: npm run lint
+      # https://github.com/lirantal/lockfile-lint#readme
+      - name: Scan lockfile for security issues
+        run: npx lockfile-lint --path package-lock.json

index.js

@@ -1,20 +1,22 @@
-const {isUndefined} = require('lodash');
-const parser = require('conventional-commits-parser').sync;
-const filter = require('conventional-commits-filter');
-const debug = require('debug')('semantic-release:commit-analyzer');
-const loadParserConfig = require('./lib/load-parser-config.js');
-const loadReleaseRules = require('./lib/load-release-rules.js');
-const analyzeCommit = require('./lib/analyze-commit.js');
-const compareReleaseTypes = require('./lib/compare-release-types.js');
-const RELEASE_TYPES = require('./lib/default-release-types.js');
-const DEFAULT_RELEASE_RULES = require('./lib/default-release-rules.js');
+import { isUndefined } from "lodash-es";
+import { sync as parser } from "conventional-commits-parser";
+import filter from "conventional-commits-filter";
+import debugFactory from "debug";
+import loadParserConfig from "./lib/load-parser-config.js";
+import loadReleaseRules from "./lib/load-release-rules.js";
+import analyzeCommit from "./lib/analyze-commit.js";
+import compareReleaseTypes from "./lib/compare-release-types.js";
+import RELEASE_TYPES from "./lib/default-release-types.js";
+import DEFAULT_RELEASE_RULES from "./lib/default-release-rules.js";
+
+const debug = debugFactory("semantic-release:commit-analyzer");
 
 /**
  * Determine the type of release to create based on a list of commits.
  *
  * @param {Object} pluginConfig The plugin configuration.
  * @param {String} pluginConfig.preset conventional-changelog preset ('angular', 'atom', 'codemirror', 'ember', 'eslint', 'express', 'jquery', 'jscs', 'jshint')
- * @param {String} pluginConfig.config Requirable npm package with a custom conventional-changelog preset
+ * @param {String} pluginConfig.config Requireable npm package with a custom conventional-changelog preset
  * @param {String|Array} pluginConfig.releaseRules A `String` to load an external module or an `Array` of rules.
  * @param {Object} pluginConfig.parserOpts Additional `conventional-changelog-parser` options that will overwrite ones loaded by `preset` or `config`.
  * @param {Object} context The semantic-release context.
@@ -23,43 +25,43 @@ const DEFAULT_RELEASE_RULES = require('./lib/default-release-rules.js');
  *
  * @returns {String|null} the type of release to create based on the list of commits or `null` if no release has to be done.
  */
-async function analyzeCommits(pluginConfig, context) {
-  const {commits, logger} = context;
+export async function analyzeCommits(pluginConfig, context) {
+  const { commits, logger } = context;
   const releaseRules = loadReleaseRules(pluginConfig, context);
   const config = await loadParserConfig(pluginConfig, context);
   let releaseType = null;
 
   filter(
     commits
-      .filter(({message, hash}) => {
+      .filter(({ message, hash }) => {
         if (!message.trim()) {
-          debug('Skip commit %s with empty message', hash);
+          debug("Skip commit %s with empty message", hash);
           return false;
         }
 
         return true;
       })
-      .map(({message, ...commitProps}) => ({rawMsg: message, message, ...commitProps, ...parser(message, config)}))
-  ).every(({rawMsg, ...commit}) => {
+      .map(({ message, ...commitProps }) => ({ rawMsg: message, message, ...commitProps, ...parser(message, config) }))
+  ).every(({ rawMsg, ...commit }) => {
     logger.log(`Analyzing commit: %s`, rawMsg);
     let commitReleaseType;
 
     // Determine release type based on custom releaseRules
     if (releaseRules) {
-      debug('Analyzing with custom rules');
+      debug("Analyzing with custom rules");
       commitReleaseType = analyzeCommit(releaseRules, commit);
     }
 
     // If no custom releaseRules or none matched the commit, try with default releaseRules
     if (isUndefined(commitReleaseType)) {
-      debug('Analyzing with default rules');
+      debug("Analyzing with default rules");
       commitReleaseType = analyzeCommit(DEFAULT_RELEASE_RULES, commit);
     }
 
     if (commitReleaseType) {
-      logger.log('The release type for the commit is %s', commitReleaseType);
+      logger.log("The release type for the commit is %s", commitReleaseType);
     } else {
-      logger.log('The commit should not trigger a release');
+      logger.log("The commit should not trigger a release");
     }
 
     // Set releaseType if commit's release type is higher
@@ -74,9 +76,7 @@ async function analyzeCommits(pluginConfig, context) {
 
     return true;
   });
-  logger.log('Analysis of %s commits complete: %s release', commits.length, releaseType || 'no');
+  logger.log("Analysis of %s commits complete: %s release", commits.length, releaseType || "no");
 
   return releaseType;
 }
-
-module.exports = {analyzeCommits};

lib/analyze-commit.js

@@ -1,22 +1,23 @@
-const {isMatchWith, isString} = require('lodash');
-const micromatch = require('micromatch');
-const debug = require('debug')('semantic-release:commit-analyzer');
-const RELEASE_TYPES = require('./default-release-types.js');
-const compareReleaseTypes = require('./compare-release-types.js');
+import { isMatchWith, isString } from "lodash-es";
+import micromatch from "micromatch";
+import debugFactory from "debug";
+import RELEASE_TYPES from "./default-release-types.js";
+import compareReleaseTypes from "./compare-release-types.js";
 
+const debug = debugFactory("semantic-release:commit-analyzer");
 /**
  * Find all the rules matching and return the highest release type of the matching rules.
  *
  * @param {Array} releaseRules the rules to match the commit against.
  * @param {Commit} commit a parsed commit.
  * @return {string} the highest release type of the matching rules or `undefined` if no rule match the commit.
  */
-module.exports = (releaseRules, commit) => {
+export default (releaseRules, commit) => {
   let releaseType;
 
   releaseRules
     .filter(
-      ({breaking, revert, release, ...rule}) =>
+      ({ breaking, revert, release, ...rule }) =>
         // If the rule is not `breaking` or the commit doesn't have a breaking change note
         (!breaking || (commit.notes && commit.notes.length > 0)) &&
         // If the rule is not `revert` or the commit is not a revert
@@ -29,14 +30,14 @@ module.exports = (releaseRules, commit) => {
     .every((match) => {
       if (compareReleaseTypes(releaseType, match.release)) {
         releaseType = match.release;
-        debug('The rule %o match commit with release type %o', match, releaseType);
+        debug("The rule %o match commit with release type %o", match, releaseType);
         if (releaseType === RELEASE_TYPES[0]) {
-          debug('Release type %o is the highest possible. Stop analysis.', releaseType);
+          debug("Release type %o is the highest possible. Stop analysis.", releaseType);
           return false;
         }
       } else {
         debug(
-          'The rule %o match commit with release type %o but the higher release type %o has already been found for this commit',
+          "The rule %o match commit with release type %o but the higher release type %o has already been found for this commit",
           match,
           match.release,
           releaseType

lib/compare-release-types.js

@@ -1,4 +1,4 @@
-const RELEASE_TYPES = require('./default-release-types.js');
+import RELEASE_TYPES from "./default-release-types.js";
 
 /**
  * Test if a realease type is of higher level than a given one.
@@ -7,5 +7,5 @@ const RELEASE_TYPES = require('./default-release-types.js');
  * @param {string} releaseType the release type to compare with.
  * @return {Boolean} true if `releaseType` is higher than `currentReleaseType`.
  */
-module.exports = (currentReleaseType, releaseType) =>
+export default (currentReleaseType, releaseType) =>
   !currentReleaseType || RELEASE_TYPES.indexOf(releaseType) < RELEASE_TYPES.indexOf(currentReleaseType);

lib/default-release-rules.js

@@ -3,32 +3,32 @@
  *
  * @type {Array}
  */
-module.exports = [
-  {breaking: true, release: 'major'},
-  {revert: true, release: 'patch'},
+export default [
+  { breaking: true, release: "major" },
+  { revert: true, release: "patch" },
   // Angular
-  {type: 'feat', release: 'minor'},
-  {type: 'fix', release: 'patch'},
-  {type: 'perf', release: 'patch'},
+  { type: "feat", release: "minor" },
+  { type: "fix", release: "patch" },
+  { type: "perf", release: "patch" },
   // Atom
-  {emoji: ':racehorse:', release: 'patch'},
-  {emoji: ':bug:', release: 'patch'},
-  {emoji: ':penguin:', release: 'patch'},
-  {emoji: ':apple:', release: 'patch'},
-  {emoji: ':checkered_flag:', release: 'patch'},
+  { emoji: ":racehorse:", release: "patch" },
+  { emoji: ":bug:", release: "patch" },
+  { emoji: ":penguin:", release: "patch" },
+  { emoji: ":apple:", release: "patch" },
+  { emoji: ":checkered_flag:", release: "patch" },
   // Ember
-  {tag: 'BUGFIX', release: 'patch'},
-  {tag: 'FEATURE', release: 'minor'},
-  {tag: 'SECURITY', release: 'patch'},
+  { tag: "BUGFIX", release: "patch" },
+  { tag: "FEATURE", release: "minor" },
+  { tag: "SECURITY", release: "patch" },
   // ESLint
-  {tag: 'Breaking', release: 'major'},
-  {tag: 'Fix', release: 'patch'},
-  {tag: 'Update', release: 'minor'},
-  {tag: 'New', release: 'minor'},
+  { tag: "Breaking", release: "major" },
+  { tag: "Fix", release: "patch" },
+  { tag: "Update", release: "minor" },
+  { tag: "New", release: "minor" },
   // Express
-  {component: 'perf', release: 'patch'},
-  {component: 'deps', release: 'patch'},
+  { component: "perf", release: "patch" },
+  { component: "deps", release: "patch" },
   // JSHint
-  {type: 'FEAT', release: 'minor'},
-  {type: 'FIX', release: 'patch'},
+  { type: "FEAT", release: "minor" },
+  { type: "FIX", release: "patch" },
 ];

lib/default-release-types.js

@@ -3,4 +3,4 @@
  *
  * @type {Array}
  */
-module.exports = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
+export default ["major", "premajor", "minor", "preminor", "patch", "prepatch", "prerelease"];

lib/load-parser-config.js

@@ -1,21 +1,24 @@
-const {promisify} = require('util');
-const {isPlainObject} = require('lodash');
-const importFrom = require('import-from');
-const conventionalChangelogAngular = require('conventional-changelog-angular');
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { isPlainObject } from "lodash-es";
+import importFrom from "import-from";
+import conventionalChangelogAngular from "conventional-changelog-angular";
 
 /**
  * Load `conventional-changelog-parser` options. Handle presets that return either a `Promise<Array>` or a `Promise<Function>`.
  *
  * @param {Object} pluginConfig The plugin configuration.
  * @param {Object} pluginConfig.preset conventional-changelog preset ('angular', 'atom', 'codemirror', 'ember', 'eslint', 'express', 'jquery', 'jscs', 'jshint')
- * @param {String} pluginConfig.config Requirable npm package with a custom conventional-changelog preset
- * @param {Object} pluginConfig.parserOpts Additionnal `conventional-changelog-parser` options that will overwrite ones loaded by `preset` or `config`.
+ * @param {String} pluginConfig.config Requireable npm package with a custom conventional-changelog preset
+ * @param {Object} pluginConfig.parserOpts Additional `conventional-changelog-parser` options that will overwrite ones loaded by `preset` or `config`.
  * @param {Object} context The semantic-release context.
  * @param {String} context.cwd The current working directory.
  * @return {Promise<Object>} a `Promise` that resolve to the `conventional-changelog-parser` options.
  */
-module.exports = async ({preset, config, parserOpts, presetConfig}, {cwd}) => {
+export default async ({ preset, config, parserOpts, presetConfig }, { cwd }) => {
   let loadedConfig;
+  const __dirname = dirname(fileURLToPath(import.meta.url));
 
   if (preset) {
     const presetPackage = `conventional-changelog-${preset.toLowerCase()}`;
@@ -26,11 +29,11 @@ module.exports = async ({preset, config, parserOpts, presetConfig}, {cwd}) => {
     loadedConfig = conventionalChangelogAngular;
   }
 
-  loadedConfig = await (typeof loadedConfig === 'function'
+  loadedConfig = await (typeof loadedConfig === "function"
     ? isPlainObject(presetConfig)
       ? loadedConfig(presetConfig)
       : promisify(loadedConfig)()
     : loadedConfig);
 
-  return {...loadedConfig.parserOpts, ...parserOpts};
+  return { ...loadedConfig.parserOpts, ...parserOpts };
 };

lib/load-release-rules.js

@@ -1,6 +1,8 @@
-const {isUndefined} = require('lodash');
-const importFrom = require('import-from');
-const RELEASE_TYPES = require('./default-release-types.js');
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isUndefined } from "lodash-es";
+import importFrom from "import-from";
+import RELEASE_TYPES from "./default-release-types.js";
 
 /**
  * Load and validate the `releaseRules` rules.
@@ -15,12 +17,13 @@ const RELEASE_TYPES = require('./default-release-types.js');
  *
  * @return {Array} the loaded and validated `releaseRules`.
  */
-module.exports = ({releaseRules}, {cwd}) => {
+export default ({ releaseRules }, { cwd }) => {
   let loadedReleaseRules;
+  const __dirname = dirname(fileURLToPath(import.meta.url));
 
   if (releaseRules) {
     loadedReleaseRules =
-      typeof releaseRules === 'string'
+      typeof releaseRules === "string"
         ? importFrom.silent(__dirname, releaseRules) || importFrom(cwd, releaseRules)
         : releaseRules;