Installing dependencies.

node_modules/semantic-release/lib/branches/expand.js

@@ -0,0 +1,18 @@
+const {isString, remove, omit, mapValues, template} = require('lodash');
+const micromatch = require('micromatch');
+const {getBranches} = require('../git');
+
+module.exports = async (repositoryUrl, {cwd}, branches) => {
+  const gitBranches = await getBranches(repositoryUrl, {cwd});
+
+  return branches.reduce(
+    (branches, branch) => [
+      ...branches,
+      ...remove(gitBranches, (name) => micromatch(gitBranches, branch.name).includes(name)).map((name) => ({
+        name,
+        ...mapValues(omit(branch, 'name'), (value) => (isString(value) ? template(value)({name}) : value)),
+      })),
+    ],
+    []
+  );
+};

node_modules/semantic-release/lib/branches/get-tags.js

@@ -0,0 +1,33 @@
+const {template, escapeRegExp} = require('lodash');
+const semver = require('semver');
+const pReduce = require('p-reduce');
+const debug = require('debug')('semantic-release:get-tags');
+const {getTags, getNote} = require('../../lib/git');
+
+module.exports = async ({cwd, env, options: {tagFormat}}, branches) => {
+  // Generate a regex to parse tags formatted with `tagFormat`
+  // by replacing the `version` variable in the template by `(.+)`.
+  // The `tagFormat` is compiled with space as the `version` as it's an invalid tag character,
+  // so it's guaranteed to no be present in the `tagFormat`.
+  const tagRegexp = `^${escapeRegExp(template(tagFormat)({version: ' '})).replace(' ', '(.+)')}`;
+
+  return pReduce(
+    branches,
+    async (branches, branch) => {
+      const branchTags = await pReduce(
+        await getTags(branch.name, {cwd, env}),
+        async (branchTags, tag) => {
+          const [, version] = tag.match(tagRegexp) || [];
+          return version && semver.valid(semver.clean(version))
+            ? [...branchTags, {gitTag: tag, version, channels: (await getNote(tag, {cwd, env})).channels || [null]}]
+            : branchTags;
+        },
+        []
+      );
+
+      debug('found tags for branch %s: %o', branch.name, branchTags);
+      return [...branches, {...branch, tags: branchTags}];
+    },
+    []
+  );
+};

node_modules/semantic-release/lib/branches/index.js

@@ -0,0 +1,71 @@
+const {isString, isRegExp} = require('lodash');
+const AggregateError = require('aggregate-error');
+const pEachSeries = require('p-each-series');
+const DEFINITIONS = require('../definitions/branches');
+const getError = require('../get-error');
+const {fetch, fetchNotes, verifyBranchName} = require('../git');
+const expand = require('./expand');
+const getTags = require('./get-tags');
+const normalize = require('./normalize');
+
+module.exports = async (repositoryUrl, ciBranch, context) => {
+  const {cwd, env} = context;
+
+  const remoteBranches = await expand(
+    repositoryUrl,
+    context,
+    context.options.branches.map((branch) => (isString(branch) || isRegExp(branch) ? {name: branch} : branch))
+  );
+
+  await pEachSeries(remoteBranches, async ({name}) => {
+    await fetch(repositoryUrl, name, ciBranch, {cwd, env});
+  });
+
+  await fetchNotes(repositoryUrl, {cwd, env});
+
+  const branches = await getTags(context, remoteBranches);
+
+  const errors = [];
+  const branchesByType = Object.entries(DEFINITIONS).reduce(
+    // eslint-disable-next-line unicorn/no-fn-reference-in-iterator
+    (branchesByType, [type, {filter}]) => ({[type]: branches.filter(filter), ...branchesByType}),
+    {}
+  );
+
+  const result = Object.entries(DEFINITIONS).reduce((result, [type, {branchesValidator, branchValidator}]) => {
+    branchesByType[type].forEach((branch) => {
+      if (branchValidator && !branchValidator(branch)) {
+        errors.push(getError(`E${type.toUpperCase()}BRANCH`, {branch}));
+      }
+    });
+
+    const branchesOfType = normalize[type](branchesByType);
+
+    if (!branchesValidator(branchesOfType)) {
+      errors.push(getError(`E${type.toUpperCase()}BRANCHES`, {branches: branchesOfType}));
+    }
+
+    return {...result, [type]: branchesOfType};
+  }, {});
+
+  const duplicates = [...branches]
+    .map((branch) => branch.name)
+    .sort()
+    .filter((_, idx, array) => array[idx] === array[idx + 1] && array[idx] !== array[idx - 1]);
+
+  if (duplicates.length > 0) {
+    errors.push(getError('EDUPLICATEBRANCHES', {duplicates}));
+  }
+
+  await pEachSeries(branches, async (branch) => {
+    if (!(await verifyBranchName(branch.name))) {
+      errors.push(getError('EINVALIDBRANCHNAME', branch));
+    }
+  });
+
+  if (errors.length > 0) {
+    throw new AggregateError(errors);
+  }
+
+  return [...result.maintenance, ...result.release, ...result.prerelease];
+};

node_modules/semantic-release/lib/branches/normalize.js

@@ -0,0 +1,106 @@
+const {sortBy, isNil} = require('lodash');
+const semverDiff = require('semver-diff');
+const {FIRST_RELEASE, RELEASE_TYPE} = require('../definitions/constants');
+const {
+  tagsToVersions,
+  isMajorRange,
+  getUpperBound,
+  getLowerBound,
+  highest,
+  lowest,
+  getLatestVersion,
+  getFirstVersion,
+  getRange,
+} = require('../utils');
+
+function maintenance({maintenance, release}) {
+  return sortBy(
+    maintenance.map(({name, range, channel, ...rest}) => ({
+      ...rest,
+      name,
+      range: range || name,
+      channel: isNil(channel) ? name : channel,
+    })),
+    'range'
+  ).map(({name, range, tags, ...rest}, idx, branches) => {
+    const versions = tagsToVersions(tags);
+    // Find the lower bound based on Maintenance branches
+    const maintenanceMin =
+      // If the current branch has a major range (1.x or 1.x.x) and the previous doesn't
+      isMajorRange(range) && branches[idx - 1] && !isMajorRange(branches[idx - 1].range)
+        ? // Then the lowest bound is the upper bound of the previous branch range
+          getUpperBound(branches[idx - 1].range)
+        : // Otherwise the lowest bound is the lowest bound of the current branch range
+          getLowerBound(range);
+    // The actual lower bound is the highest version between the current branch last release and `maintenanceMin`
+    const min = highest(getLatestVersion(versions) || FIRST_RELEASE, maintenanceMin);
+    // Determine the first release of the default branch not present in any maintenance branch
+    const base =
+      (release[0] &&
+        (getFirstVersion(tagsToVersions(release[0].tags), branches) ||
+          getLatestVersion(tagsToVersions(release[0].tags)))) ||
+      FIRST_RELEASE;
+    // The upper bound is the lowest version between the `base` version and the upper bound of the current branch range
+    const max = lowest(base, getUpperBound(range));
+    const diff = semverDiff(min, max);
+    return {
+      ...rest,
+      type: 'maintenance',
+      name,
+      tags,
+      range: getRange(min, max),
+      accept: diff ? RELEASE_TYPE.slice(0, RELEASE_TYPE.indexOf(diff)) : [],
+      mergeRange: getRange(maintenanceMin, getUpperBound(range)),
+    };
+  });
+}
+
+function release({release}) {
+  if (release.length === 0) {
+    return release;
+  }
+
+  // The intial lastVersion is the last release from the base branch of `FIRST_RELEASE` (1.0.0)
+  let lastVersion = getLatestVersion(tagsToVersions(release[0].tags)) || FIRST_RELEASE;
+
+  return release.map(({name, tags, channel, ...rest}, idx) => {
+    const versions = tagsToVersions(tags);
+    // The new lastVersion is the highest version between the current branch last release and the previous branch lastVersion
+    lastVersion = highest(getLatestVersion(versions), lastVersion);
+    // The upper bound is:
+    //  - None if the current branch is the last one of the release branches
+    //  - Otherwise, The upper bound is the lowest version that is present on the current branch but none of the previous ones
+    const bound =
+      release.length - 1 === idx
+        ? undefined
+        : getFirstVersion(tagsToVersions(release[idx + 1].tags), release.slice(0, idx + 1));
+
+    const diff = bound ? semverDiff(lastVersion, bound) : null;
+    return {
+      ...rest,
+      channel: idx === 0 ? channel : isNil(channel) ? name : channel,
+      tags,
+      type: 'release',
+      name,
+      range: getRange(lastVersion, bound),
+      accept: bound ? RELEASE_TYPE.slice(0, RELEASE_TYPE.indexOf(diff)) : RELEASE_TYPE,
+      main: idx === 0,
+    };
+  });
+}
+
+function prerelease({prerelease}) {
+  return prerelease.map(({name, prerelease, channel, tags, ...rest}) => {
+    const preid = prerelease === true ? name : prerelease;
+    return {
+      ...rest,
+      channel: isNil(channel) ? name : channel,
+      type: 'prerelease',
+      name,
+      prerelease: preid,
+      tags,
+    };
+  });
+}
+
+module.exports = {maintenance, release, prerelease};