105 lines
3.8 KiB
JavaScript
105 lines
3.8 KiB
JavaScript
import { isNil, sortBy } from "lodash-es";
|
|
import semverDiff from "semver-diff";
|
|
import { FIRST_RELEASE, RELEASE_TYPE } from "../definitions/constants.js";
|
|
import {
|
|
getFirstVersion,
|
|
getLatestVersion,
|
|
getLowerBound,
|
|
getRange,
|
|
getUpperBound,
|
|
highest,
|
|
isMajorRange,
|
|
lowest,
|
|
tagsToVersions,
|
|
} from "../utils.js";
|
|
|
|
export 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)),
|
|
};
|
|
});
|
|
}
|
|
|
|
export function release({ release }) {
|
|
if (release.length === 0) {
|
|
return release;
|
|
}
|
|
|
|
// The initial 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,
|
|
};
|
|
});
|
|
}
|
|
|
|
export 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,
|
|
};
|
|
});
|
|
}
|