relion 0.1.1 → 0.3.0

package/dist/index.js

@@ -0,0 +1,652 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import Handlebars from "handlebars";
+import semver from "semver";
+import { execSync } from "node:child_process";
+
+//#region src/lifecycles/bump.ts
+const bump = (config) => {
+	if (!config.bump) return;
+	const bumpFiles = config.bump, newVersion = config.context.newVersion;
+	bumpFiles.forEach((versionedFile) => {
+		const fileContent = readFileSync(versionedFile.filePath, "utf8");
+		const updatedContent = fileContent.replace(versionedFile.versionPattern, `$1${newVersion}$3`);
+		if (!config.dryRun) writeFileSync(versionedFile.filePath, updatedContent, "utf8");
+		console.log(`Updated version in '${versionedFile.filePath}' to '${newVersion}'`);
+	});
+};
+
+//#endregion
+//#region src/defaults.ts
+const defaultConfig = {
+	bump: false,
+	changelog: false,
+	commit: false,
+	tag: false,
+	versionSourceFile: "./package.json",
+	newTagFormat: "v{{newVersion}}",
+	prevReleaseTagPattern: /^v(?<version>\d+\.\d+\.\d+)/,
+	zeroMajorBreakingIsMinor: true,
+	dryRun: false,
+	context: {
+		commitHyperlink: true,
+		refHyperlink: true
+	},
+	commitsParser: {
+		headerPattern: /^(?<type>\w+)(?:\((?<scope>.+)\))?(?<bang>!)?: (?<subject>.+)/s,
+		breakingChangesPattern: /BREAKING CHANGES?:\s*(?<content>.+)/s,
+		breakingChangeListPattern: /- (.+)/g,
+		tagPattern: /tag: (?<tag>.*?)[,)]/g,
+		coAuthorPattern: /Co-authored-by: (?<name>.+?) <(?<email>.+)>/g,
+		signerPattern: /Signed-off-by: (?<name>.+?) <(?<email>.+)>/g,
+		ghEmailPattern: /^(?:\d+\+)?(?<username>.+)@users\.noreply\.github\.com$/,
+		remoteUrlPattern: /^(https:\/\/|git@)(?<host>[^/:]+)[/:](?<owner>.+?)\/(?<name>.+?)(?:\..*)?$/,
+		refPattern: /^(?<action>.+?) (?<labels>.+)$/gm,
+		refLabelPattern: /(?:(?<owner>\S+?)\/(?<repo>\S+?))?#(?<number>\d+)/g,
+		refActionPattern: /Fixes|Closes|Refs/i,
+		dateSource: "authorDate",
+		dateFormat: "YYYY-MM-DD"
+	}
+};
+const defaultChangelogSections = {
+	breaking: {
+		title: "⚠️ BREAKING CHANGES",
+		commitType: "breaking"
+	},
+	feat: {
+		title: "✨ Features",
+		commitType: "feat"
+	},
+	fix: {
+		title: "🩹 Fixes",
+		commitType: "fix"
+	},
+	perf: {
+		title: "⚡ Performance",
+		commitType: "perf"
+	},
+	refactor: {
+		title: "🚜 Refactoring",
+		commitType: "refactor"
+	},
+	docs: {
+		title: "📚 Documentation",
+		commitType: "docs"
+	},
+	style: {
+		title: "🎨 Formatting",
+		commitType: "style"
+	},
+	build: {
+		title: "📦 Build",
+		commitType: "build"
+	},
+	ci: {
+		title: "🚀 CI",
+		commitType: "ci"
+	},
+	revert: {
+		title: "♻️ Reverts",
+		commitType: "revert"
+	},
+	deps: {
+		title: "🧩 Dependencies",
+		commitType: "chore",
+		filter: (commit$1) => !!commit$1.scope?.includes("deps")
+	},
+	chore: {
+		title: "🛠️ Chores",
+		commitType: "chore"
+	},
+	test: {
+		title: "🧪 Tests",
+		commitType: "test"
+	},
+	misc: {
+		title: "⚙️ Miscellaneous",
+		commitType: "*"
+	},
+	[Symbol.iterator]() {
+		return Object.values(this)[Symbol.iterator]();
+	}
+};
+const defaultChangelogOptions = {
+	stdout: false,
+	outputFile: "./CHANGELOG.md",
+	commitRange: "unreleased",
+	sections: [...defaultChangelogSections],
+	header: "# Changelog\n\n\n",
+	prevReleaseHeaderPattern: /^##.*?\d+\.\d+\.\d+/m,
+	helpers: { repeat: (string, n) => string.repeat(n) },
+	partials: {}
+};
+const defaultCommitOptions = {
+	message: "release({{repo.name}}): {{newTag}}",
+	signOff: false,
+	gpgSign: false,
+	stageAll: true,
+	extraArgs: ""
+};
+const defaultTagOptions = {
+	name: "{{newTag}}",
+	message: "release({{repo.name}}): {{newTag}}",
+	gpgSign: false,
+	force: false,
+	extraArgs: ""
+};
+const defaultVersionedFiles = [{
+	filePathRegex: /package\.json$/,
+	versionPattern: /(^.*?"version".*?")(.*?)(")/s
+}, {
+	filePathRegex: /package-lock\.json$/,
+	versionPattern: /(^.*?"version".*?"|"packages".*?"".*"version".*?")(.*?)(")/gs
+}];
+
+//#endregion
+//#region src/utils/config-resolver.ts
+const resolveConfig = async (userConfig) => {
+	const profileMergedConfig = mergeProfileConfig(userConfig);
+	const mergedConfig = mergeWithDefaults(profileMergedConfig);
+	const transformedConfig = transformVersionedFiles(mergedConfig);
+	const contextualConfig = await fillContext(transformedConfig);
+	const finalConfig = resolveTemplates(contextualConfig);
+	return finalConfig;
+};
+const mergeProfileConfig = (baseConfig) => {
+	const profileName = baseConfig.profile;
+	if (!profileName) return baseConfig;
+	const profileConfig = baseConfig[`_${profileName}`];
+	if (!profileConfig) throw new Error(`Profile "${profileName}" not found in configuration.`);
+	const mergeOption = (propKey, ...nestedPropKeys) => {
+		const isPlainObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+		const mergeObjects = (baseObj, overrideObject) => {
+			const isBasePlainObject = isPlainObject(baseObj);
+			const isOverridePlainObject = isPlainObject(overrideObject);
+			if (isBasePlainObject && isOverridePlainObject) return {
+				...baseObj,
+				...overrideObject
+			};
+			else if (!isBasePlainObject && isOverridePlainObject) return overrideObject;
+			else if (isBasePlainObject && !isOverridePlainObject) return baseObj;
+		};
+		const baseConfigProp = baseConfig[propKey];
+		const profileConfigProp = profileConfig[propKey];
+		const result = mergeObjects(baseConfigProp, profileConfigProp);
+		if (result === void 0) return void 0;
+		nestedPropKeys.forEach((key) => {
+			result[key] = mergeObjects(baseConfigProp?.[key], profileConfigProp?.[key]);
+		});
+		return result;
+	};
+	return {
+		...baseConfig,
+		...profileConfig,
+		commitsParser: mergeOption("commitsParser"),
+		changelog: mergeOption("changelog", "partials", "helpers"),
+		commit: mergeOption("commit"),
+		tag: mergeOption("tag"),
+		context: mergeOption("context")
+	};
+};
+const mergeWithDefaults = (userConfig) => {
+	const resolveOptions = (optionsName, options, defaults, ...subObjects) => {
+		if (options == void 0 || options === false) return false;
+		if (options === true) return defaults;
+		if (typeof options !== "object") throw new Error(`Invalid value for ${optionsName}. It should be a boolean or an object.`);
+		const result = {
+			...defaults,
+			...options
+		};
+		subObjects.forEach((subObjectKey) => result[subObjectKey] = {
+			...defaults[subObjectKey],
+			...options[subObjectKey]
+		});
+		return result;
+	};
+	return {
+		...defaultConfig,
+		...userConfig,
+		commitsParser: {
+			...defaultConfig.commitsParser,
+			...userConfig.commitsParser
+		},
+		changelog: resolveOptions("changelog", userConfig.changelog, defaultChangelogOptions, "partials", "helpers"),
+		commit: resolveOptions("commit", userConfig.commit, defaultCommitOptions),
+		tag: resolveOptions("tag", userConfig.tag, defaultTagOptions)
+	};
+};
+const transformVersionedFiles = (config) => {
+	const resolveVersionedFile = (filePath) => {
+		const matchingDefaultVersionFile = defaultVersionedFiles.find((defaultFile) => defaultFile.filePathRegex.test(filePath));
+		if (matchingDefaultVersionFile) return {
+			filePath,
+			versionPattern: matchingDefaultVersionFile.versionPattern
+		};
+		else throw new Error(`File ${filePath} doesn't match any default versioned files. Please provide a custom version pattern for this file.`);
+	};
+	const resolveBump = (bump$1) => {
+		if (bump$1 === false) return false;
+		if (bump$1 === true) return [versionSourceFile];
+		if (Array.isArray(bump$1)) return [versionSourceFile, ...bump$1.map((bumpFile) => typeof bumpFile === "string" ? resolveVersionedFile(bumpFile) : bumpFile)];
+		throw new Error("Invalid value for bump. It should be a boolean or an array.");
+	};
+	const versionSourceFile = typeof config.versionSourceFile === "string" ? resolveVersionedFile(config.versionSourceFile) : config.versionSourceFile;
+	return {
+		...config,
+		versionSourceFile,
+		bump: resolveBump(config.bump),
+		changelog: config.changelog === false ? false : {
+			...config.changelog,
+			compiledPartials: Object.fromEntries(Object.entries(config.changelog.partials).map(([key, template]) => [key, Handlebars.compile(template)]))
+		}
+	};
+};
+const fillContext = async (config) => {
+	const resolvedContext = config.context ?? {};
+	const repoInfo = getRepoInfo(config.commitsParser.remoteUrlPattern);
+	resolvedContext.repo = {
+		...repoInfo,
+		...resolvedContext.repo
+	};
+	const commitRange = config.changelog ? config.changelog.commitRange : "unreleased";
+	resolvedContext.commits = config.context?.commits ? await Promise.all(config.context.commits.map(async (commit$1) => {
+		return typeof commit$1 === "object" && "message" in commit$1 || typeof commit$1 === "string" ? (await parseCommits([commit$1], config.commitsParser, config.prevReleaseTagPattern))[0] : commit$1;
+	})) : await parseCommits(commitRange, config.commitsParser, config.prevReleaseTagPattern);
+	resolvedContext.currentVersion ??= parseVersion(config.versionSourceFile);
+	resolvedContext.currentTag ??= getVersionTags(config.prevReleaseTagPattern)[0];
+	resolvedContext.newVersion ??= await determineNextVersion(config, resolvedContext.currentVersion);
+	resolvedContext.newTag ??= compileTemplate(config.newTagFormat, resolvedContext);
+	const contextualConfig = {
+		...config,
+		context: resolvedContext
+	};
+	resolvedContext.releases = config.changelog ? groupCommitsByReleases(resolvedContext.commits, config.changelog.sections, contextualConfig) : null;
+	return contextualConfig;
+};
+const groupCommitsByReleases = (commits, sections, config) => {
+	const releases = {};
+	commits.forEach((commit$1) => {
+		const releaseTag = commit$1.tags?.find((tag$1) => config.prevReleaseTagPattern.test(tag$1));
+		if (releaseTag) releases[releaseTag] ??= {
+			tag: releaseTag,
+			version: config.prevReleaseTagPattern.exec(releaseTag)?.groups?.version,
+			date: commit$1.date,
+			commits: [commit$1]
+		};
+		else {
+			const latestReleaseTag = Object.keys(releases).at(-1);
+			if (latestReleaseTag) releases[latestReleaseTag].commits.push(commit$1);
+			else releases[config.context.newTag] = {
+				tag: config.context.newTag,
+				version: config.context.newVersion,
+				date: commit$1.date,
+				commits: [commit$1]
+			};
+		}
+	});
+	return Object.values(releases).map((release) => groupReleaseCommitsBySections(release, sections));
+};
+const groupReleaseCommitsBySections = (release, sections) => {
+	const { commits,...releaseWithoutCommits } = release;
+	return {
+		...releaseWithoutCommits,
+		commitGroups: groupCommitsBySections(commits, sections)
+	};
+};
+const groupCommitsBySections = (commits, sections) => {
+	const commitGroups = Object.fromEntries(sections.map((section) => [section.title, []]));
+	commits.forEach((commit$1) => {
+		const isBreaking = !!commit$1.breakingChanges;
+		let isGrouped = false;
+		let isBreakingGrouped = false;
+		for (const section of sections) {
+			if (section.filter && !section.filter(commit$1)) continue;
+			const sectionTypes = [section.commitType].flat();
+			if (isBreaking && !isBreakingGrouped && sectionTypes.includes("breaking")) {
+				commitGroups[section.title].push(commit$1);
+				isBreakingGrouped = true;
+				continue;
+			}
+			if (!isGrouped && (sectionTypes.includes(commit$1.type) || sectionTypes.includes("*"))) {
+				commitGroups[section.title].push(commit$1);
+				isGrouped = true;
+			}
+			if (isGrouped && (!isBreaking || isBreakingGrouped)) return;
+		}
+	});
+	Object.keys(commitGroups).forEach((key) => {
+		if (!commitGroups[key].length) delete commitGroups[key];
+	});
+	return Object.entries(commitGroups).map(([title, commits$1]) => ({
+		title,
+		commits: commits$1
+	}));
+};
+const resolveTemplates = (config) => {
+	return {
+		...config,
+		commit: config.commit ? {
+			...config.commit,
+			message: compileTemplate(config.commit.message, config.context)
+		} : config.commit,
+		tag: config.tag ? {
+			...config.tag,
+			name: compileTemplate(config.tag.name, config.context),
+			message: compileTemplate(config.tag.message, config.context)
+		} : config.tag
+	};
+};
+const compileTemplate = (value, context) => {
+	const compile = Handlebars.compile(value);
+	return compile(context);
+};
+
+//#endregion
+//#region src/utils/version-manager.ts
+const parseVersion = (versionedFile) => {
+	const fileContent = readFileSync(versionedFile.filePath, "utf8");
+	const version = versionedFile.versionPattern.exec(fileContent)?.[2];
+	if (!version) throw new Error(`Version not found in '${versionedFile.filePath}' with pattern '${versionedFile.versionPattern}'`);
+	if (!semver.valid(version)) throw new Error(`Invalid version format in '${versionedFile.filePath}': '${version}'`);
+	console.log(`Current version from '${versionedFile.filePath}': '${version}'`);
+	return version;
+};
+const determineNextVersion = async (config, currentVersion) => {
+	if (config.releaseVersion) {
+		if (!semver.valid(config.releaseVersion)) throw new Error(`Invalid release version format: '${config.releaseVersion}'`);
+		return config.releaseVersion;
+	}
+	let releaseType;
+	if (config.releaseType) releaseType = config.releaseType;
+	else {
+		const unreleasedCommits = await parseCommits("unreleased", config.commitsParser, config.prevReleaseTagPattern);
+		releaseType = calculateReleaseType(unreleasedCommits);
+		if (config.zeroMajorBreakingIsMinor && semver.major(currentVersion) === 0 && releaseType === "major") releaseType = "minor";
+	}
+	const newVersion = increaseVersion(currentVersion, releaseType);
+	console.log(`Determined new version: '${newVersion}' (release type: '${releaseType}')`);
+	return newVersion;
+};
+const calculateReleaseType = (commits) => {
+	const hasBreakingChange = commits.some((commit$1) => commit$1.breakingChanges);
+	if (hasBreakingChange) return "major";
+	const hasFeature = commits.some((commit$1) => commit$1.type === "feat");
+	if (hasFeature) return "minor";
+	return "patch";
+};
+const increaseVersion = (currentVersion, releaseType) => semver.inc(currentVersion, releaseType) ?? (() => {
+	throw new Error(`Failed to calculate new version from '${currentVersion}' with release type '${releaseType}'`);
+})();
+
+//#endregion
+//#region src/enums.ts
+let GpgSigLabel = /* @__PURE__ */ function(GpgSigLabel$1) {
+	GpgSigLabel$1["G"] = "valid";
+	GpgSigLabel$1["B"] = "bad";
+	GpgSigLabel$1["U"] = "valid, unknown validity";
+	GpgSigLabel$1["X"] = "valid, expired";
+	GpgSigLabel$1["Y"] = "valid, made by expired key";
+	GpgSigLabel$1["R"] = "valid, made by revoked key";
+	GpgSigLabel$1["E"] = "cannot check (missing key)";
+	GpgSigLabel$1["N"] = "no signature";
+	return GpgSigLabel$1;
+}({});
+
+//#endregion
+//#region src/utils/commits-parser.ts
+const parseCommits = async (arg1, commitsParser, prevReleaseTagPattern) => {
+	const rawCommits = Array.isArray(arg1) ? arg1 : getRawCommits(arg1, prevReleaseTagPattern);
+	const parser = commitsParser;
+	return (await Promise.all(rawCommits.map(async (commit$1) => {
+		if (typeof commit$1 === "string") commit$1 = { message: commit$1 };
+		const { hash, tagRefs } = commit$1;
+		const message = commit$1.message.trim();
+		if (!message) throw new Error(`Message is missing for commit: ${JSON.stringify(commit$1)}`);
+		let parsedMessage;
+		try {
+			parsedMessage = parseCommitMessage(message, parser);
+		} catch (error) {
+			console.warn(`Error parsing commit '${hash ?? "<no hash>"}':`, error.message);
+			return;
+		}
+		const { type, scope, subject, body, breakingChanges, footer } = parsedMessage;
+		const tags = tagRefs ? [...tagRefs.matchAll(parser.tagPattern)].map((m) => m.groups?.tag ?? "") : [];
+		const signers = footer ? [...footer.matchAll(parser.signerPattern)].map((m) => m.groups) : [];
+		const authors = [];
+		const addAuthor = (contributor) => {
+			if (!authors.some((a) => a.email === contributor.email)) authors.push(contributor);
+		};
+		const author = commit$1.authorName && commit$1.authorEmail ? getContributorDetails({
+			name: commit$1.authorName,
+			email: commit$1.authorEmail
+		}, signers) : void 0;
+		if (author) addAuthor(author);
+		const committer = commit$1.committerName && commit$1.committerEmail ? getContributorDetails({
+			name: commit$1.committerName,
+			email: commit$1.committerEmail
+		}, signers) : void 0;
+		if (committer) addAuthor(committer);
+		const coAuthors = footer ? [...footer.matchAll(parser.coAuthorPattern)].map((m) => m.groups).map((coAuthor) => getContributorDetails(coAuthor, signers)) : [];
+		coAuthors.forEach((coAuthor) => addAuthor(coAuthor));
+		const refs = await parseRefs(footer ?? "", parser);
+		const gpgSig = commit$1.gpgSigCode ? {
+			code: commit$1.gpgSigCode,
+			label: GpgSigLabel[commit$1.gpgSigCode],
+			keyId: commit$1.gpgSigKeyId
+		} : void 0;
+		let date = commit$1[parser.dateSource === "committerDate" ? "committerTs" : "authorTs"];
+		if (typeof date === "string") date = formatDate(/* @__PURE__ */ new Date(+date * 1e3), parser.dateFormat);
+		const parsedCommit = {
+			hash,
+			type,
+			scope,
+			subject,
+			body,
+			breakingChanges,
+			footer,
+			committer,
+			gpgSig,
+			date,
+			tags: tags.length ? tags : void 0,
+			authors: authors.length ? authors : void 0,
+			refs: refs.length ? refs : void 0
+		};
+		return parsedCommit;
+	}))).filter((commit$1) => commit$1 !== void 0);
+};
+const parseCommitMessage = (message, parser) => {
+	const [header, ...details] = message.split("\n\n");
+	const headerMatch = parser.headerPattern.exec(header);
+	if (!headerMatch?.groups) throw new Error(`Commit header '${header}' doesn't match expected format`);
+	const { type, scope, bang, subject } = headerMatch.groups;
+	let breakingChanges;
+	const breakingChangesPart = details.find((detail) => parser.breakingChangesPattern.test(detail));
+	if (breakingChangesPart) {
+		breakingChanges = parseBreakingChanges(breakingChangesPart, parser);
+		details.splice(details.indexOf(breakingChangesPart), 1);
+	} else if (bang) breakingChanges = subject;
+	const footerStart = details.findIndex((detail) => detail.match(parser.refActionPattern) ?? detail.match(parser.coAuthorPattern) ?? detail.match(parser.signerPattern));
+	const [body, footer] = footerStart === -1 ? [details.join("\n\n"), ""] : [details.slice(0, footerStart).join("\n\n"), details.slice(footerStart).join("\n\n")];
+	return {
+		type,
+		scope: scope || void 0,
+		subject,
+		body: body || void 0,
+		breakingChanges,
+		footer: footer || void 0
+	};
+};
+const parseBreakingChanges = (value, parser) => {
+	const breakingChanges = parser.breakingChangesPattern.exec(value)?.groups?.content;
+	if (!breakingChanges) throw new Error(`Failed to extract breaking changes content from '${value}' using pattern "${parser.breakingChangesPattern}"`);
+	const breakingChangeList = [...breakingChanges.matchAll(parser.breakingChangeListPattern)];
+	return breakingChangeList.length ? breakingChangeList.map((m) => m[1]) : breakingChanges;
+};
+const getContributorDetails = (contributor, signers) => {
+	const hasSignedOff = signers.some((signer) => signer.email === contributor.email && signer.name === contributor.name);
+	return {
+		...contributor,
+		hasSignedOff,
+		ghLogin: contributor.name,
+		ghUrl: `https://github.com/${contributor.name}`
+	};
+};
+const parseRefs = async (value, parser) => await Promise.all([...value.matchAll(parser.refPattern)].map((m) => m.groups).filter((rawRef) => parser.refActionPattern.test(rawRef.action)).flatMap((rawRef) => [...rawRef.labels.matchAll(parser.refLabelPattern)].map((m) => m.groups).filter((label) => !!label.number).map((label) => ({
+	action: rawRef.action,
+	owner: label.owner,
+	repo: label.repo,
+	number: label.number
+}))));
+const formatDate = (date, format) => {
+	const pad = (num) => num.toString().padStart(2, "0");
+	const dateParts = {
+		YYYY: date.getUTCFullYear().toString(),
+		MM: pad(date.getUTCMonth() + 1),
+		DD: pad(date.getUTCDate()),
+		HH: pad(date.getUTCHours()),
+		mm: pad(date.getUTCMinutes()),
+		ss: pad(date.getUTCSeconds())
+	};
+	return format.replace(/YYYY|MM|DD|HH|mm|ss/g, (k) => dateParts[k]);
+};
+
+//#endregion
+//#region src/utils/git-utils.ts
+const commitLogFormat = `##COMMIT##%n#HASH# %h%n#MSG# %B%n#REFS# %d%n#AUTHOR-NAME# %an%n#AUTHOR-EMAIL# %ae%n#AUTHOR-DATE# %at%n#COMMITTER-NAME# %cn%n#COMMITTER-EMAIL# %ce%n#COMMITTER-DATE# %ct%n#GPGSIG-CODE# %G?%n#GPGSIG-KEYID# %GK%n`;
+const rawCommitPattern = /##COMMIT##\n#HASH# (?<hash>.+)?\n#MSG# (?<message>[\s\S]*?)\n#REFS#\s+(?<tagRefs>.+)?\n#AUTHOR-NAME# (?<authorName>.+)?\n#AUTHOR-EMAIL# (?<authorEmail>.+)?\n#AUTHOR-DATE# (?<authorTs>.+)?\n#COMMITTER-NAME# (?<committerName>.+)?\n#COMMITTER-EMAIL# (?<committerEmail>.+)?\n#COMMITTER-DATE# (?<committerTs>.+)?\n#GPGSIG-CODE# (?<gpgSigCode>.+)?\n#GPGSIG-KEYID# (?<gpgSigKeyId>.+)?/g;
+const getRepoInfo = (remoteUrlPattern) => {
+	const remoteUrl = execSync("git remote get-url origin", { encoding: "utf8" }).trim();
+	const remoteUrlMatch = remoteUrlPattern.exec(remoteUrl);
+	if (!remoteUrlMatch?.groups) throw new Error(`Couldn't parse remote URL: ` + remoteUrl);
+	const { host, owner, name } = remoteUrlMatch.groups;
+	const homepage = `https://${host}/${owner}/${name}`;
+	return {
+		host,
+		owner,
+		name,
+		homepage
+	};
+};
+const getRawCommits = (commitRange, prevReleaseTagPattern) => {
+	const firstCommitHash = getFirstCommitHash();
+	const versionTags = getVersionTags(prevReleaseTagPattern);
+	let from, to;
+	if (typeof commitRange === "string") {
+		from = {
+			all: firstCommitHash,
+			unreleased: versionTags[0] ?? firstCommitHash
+		}[commitRange];
+		if (!from) throw new Error(`Invalid commit range: '${commitRange}'`);
+		to = "HEAD";
+	} else if ("from" in commitRange || "to" in commitRange) {
+		const fromValue = "from" in commitRange ? commitRange.from : "firstCommit";
+		from = fromValue === "firstCommit" ? firstCommitHash : fromValue;
+		to = "to" in commitRange ? commitRange.to : "HEAD";
+	} else if ("versionTag" in commitRange) {
+		const targetTagIndex = versionTags.indexOf(commitRange.versionTag);
+		if (targetTagIndex === -1) throw new Error(`Version tag '${commitRange.versionTag}' not found`);
+		from = versionTags[targetTagIndex];
+		to = versionTags[targetTagIndex + 1] ?? "HEAD";
+	} else throw new Error(`Invalid commit range provided`);
+	const gitLogCommits = execSync(`git log ${from}..${to} --pretty="${commitLogFormat}"`, { encoding: "utf8" });
+	return [...gitLogCommits.matchAll(rawCommitPattern)].map((m) => m.groups);
+};
+const getFirstCommitHash = () => execSync("git rev-list --max-parents=0 HEAD", { encoding: "utf8" }).trim();
+const getVersionTags = (tagPattern) => {
+	const rawTags = execSync("git tag --sort=-creatordate", { encoding: "utf8" });
+	return rawTags.split("\n").filter((tag$1) => tagPattern.test(tag$1));
+};
+
+//#endregion
+//#region src/templates/release.hbs
+var release_default = "{{#>header}}\n## &ensp; [` 📦 {{tag}}  `]({{repo.homepage}}/{{#if prevTag}}compare/{{prevTag}}...{{tag}}{{else}}commits/{{tag}}{{/if}})\n\n{{/header}}\n{{#each commitGroups}}\n### {{{repeat '&nbsp;' 5}}}{{title}}\n{{#each commits}}\n* {{#if scope}}`{{scope}}` {{/if}}{{{subject}}} {{#if ../../commitHyperlink}}[`{{hash}}`]({{../../repo.homepage}}/commit/{{hash}}){{else}}{{hash}}{{/if}}\n{{/each}}\n\n{{/each}}\n##### &emsp;&ensp;&nbsp; 🔗 [Full Commit History: {{#if prevTag}}`{{prevTag}}` → `{{tag}}`]({{repo.homepage}}/compare/{{prevTag}}...{{tag}}){{else}}`{{tag}}`]({{repo.homepage}}/commits/{{tag}}){{/if}} &ensp;/&ensp; _{{date}}_\n\n\n";
+
+//#endregion
+//#region src/lifecycles/changelog.ts
+const changelog = (config) => {
+	if (!config.changelog) return;
+	const options = config.changelog;
+	const releases = config.context.releases;
+	if (!releases) return;
+	const versionTags = getVersionTags(config.prevReleaseTagPattern);
+	Handlebars.registerPartial(options.compiledPartials);
+	Handlebars.registerHelper(options.helpers);
+	let result = options.header;
+	releases.forEach((release, index) => {
+		const prevRelease = releases[index + 1];
+		let prevTag, prevVersion;
+		if (prevRelease) {
+			prevTag = prevRelease.tag;
+			prevVersion = getVersionFromTag(prevTag, config.prevReleaseTagPattern);
+		} else {
+			const targetTagIndex = versionTags.indexOf(release.tag);
+			if (targetTagIndex === -1) {
+				prevTag = config.context.currentTag;
+				prevVersion = getVersionFromTag(prevTag, config.prevReleaseTagPattern);
+			} else {
+				prevTag = versionTags[targetTagIndex + 1];
+				prevVersion = prevTag && getVersionFromTag(prevTag, config.prevReleaseTagPattern);
+			}
+		}
+		const releaseContext = {
+			...release,
+			...config.context,
+			prevTag,
+			prevVersion
+		};
+		const rendered = renderTemplate(release_default, releaseContext);
+		result += rendered;
+	});
+	if (options.stdout) console.log(`Generated changelog:\n${result}`);
+	if (options.outputFile) {
+		console.log(`Writing changelog to file '${options.outputFile}'`);
+		if (!config.dryRun) writeToChangelogFile(options.outputFile, result, options.prevReleaseHeaderPattern);
+	}
+};
+const writeToChangelogFile = (outputFile, content, prevReleaseHeaderPattern) => {
+	const changelogContent = existsSync(outputFile) ? readFileSync(outputFile, { encoding: "utf8" }) : "";
+	const prevReleaseStart = changelogContent.search(prevReleaseHeaderPattern);
+	const headlessChangelog = changelogContent.slice(prevReleaseStart);
+	const newChangelog = content + headlessChangelog;
+	writeFileSync(outputFile, newChangelog, { encoding: "utf8" });
+};
+const renderTemplate = (template, releaseContext) => {
+	const compile = Handlebars.compile(template);
+	return compile(releaseContext);
+};
+const getVersionFromTag = (tag$1, tagPattern) => {
+	return tagPattern.exec(tag$1)?.groups?.version;
+};
+
+//#endregion
+//#region src/lifecycles/commit.ts
+const commit = (config) => {
+	if (!config.commit) return;
+	const options = config.commit;
+	console.log("Committing with options:", options);
+	if (options.stageAll && !config.dryRun) execSync("git add -A", { stdio: "inherit" });
+	if (!config.dryRun) execSync(`git commit -m "${options.message}" ${options.signOff ? "-s" : ""} ${options.gpgSign ? "-S" : ""} ${options.extraArgs}`, { stdio: "inherit" });
+};
+
+//#endregion
+//#region src/lifecycles/tag.ts
+const tag = (config) => {
+	if (!config.tag) return;
+	const options = config.tag;
+	console.log("Tagging with options:", options);
+	if (!config.dryRun) execSync(`git tag -a ${options.name} -m "${options.message}" ${options.gpgSign ? "-s" : ""} ${options.force ? "-f" : ""} ${options.extraArgs}`, { stdio: "inherit" });
+};
+
+//#endregion
+//#region src/relion.ts
+async function relion(userConfig) {
+	const config = await resolveConfig(userConfig);
+	bump(config);
+	changelog(config);
+	commit(config);
+	tag(config);
+}
+const defineConfig = (config) => config;
+
+//#endregion
+export { relion as default, defineConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":["defaultConfig: MergedConfig","defaultChangelogSections: DefaultChangelogSections","commit","defaultChangelogOptions: CompleteChangelogOptions","defaultCommitOptions: CompleteCommitOptions","defaultTagOptions: CompleteTagOptions","defaultVersionedFiles: DefaultVersionedFile[]","result: Required<T>","bump","commit","releases: Record<string, ReleaseWithFlatCommits>","tag","commitGroups: Record<string, Commit[]>","commits","releaseType: ReleaseType","commit","commit","authors: Contributor[]","dateParts: Record<string, string>","from: string","to: string","tag","prevTag: string | undefined","prevVersion: string | undefined","releaseContext: ReleaseContext","releaseTemplate","tag"],"sources":["../src/lifecycles/bump.ts","../src/defaults.ts","../src/utils/config-resolver.ts","../src/utils/version-manager.ts","../src/enums.ts","../src/utils/commits-parser.ts","../src/utils/git-utils.ts","../src/templates/release.hbs","../src/lifecycles/changelog.ts","../src/lifecycles/commit.ts","../src/lifecycles/tag.ts","../src/relion.ts"],"sourcesContent":["import { readFileSync, writeFileSync } from 'node:fs'\nimport type { ResolvedConfig } from '@/types'\n\nexport const bump = (config: ResolvedConfig): void => {\n\tif (!config.bump) return\n\tconst bumpFiles = config.bump, newVersion = config.context.newVersion\n\tbumpFiles.forEach((versionedFile) => {\n\t\tconst fileContent = readFileSync(versionedFile.filePath, 'utf8')\n\t\tconst updatedContent = fileContent.replace(versionedFile.versionPattern, `$1${newVersion}$3`)\n\t\tif (!config.dryRun) writeFileSync(versionedFile.filePath, updatedContent, 'utf8')\n\t\tconsole.log(`Updated version in '${versionedFile.filePath}' to '${newVersion}'`)\n\t})\n}","import type { MergedConfig, DefaultVersionedFile, CompleteChangelogOptions, CompleteCommitOptions, CompleteTagOptions, DefaultChangelogSections } from '@/types'\n\nexport const defaultConfig: MergedConfig = {\n\tbump: false,\n\tchangelog: false,\n\tcommit: false,\n\ttag: false,\n\tversionSourceFile: './package.json',\n\tnewTagFormat: 'v{{newVersion}}',\n\tprevReleaseTagPattern: /^v(?<version>\\d+\\.\\d+\\.\\d+)/,\n\tzeroMajorBreakingIsMinor: true,\n\tdryRun: false,\n\tcontext: {\n\t\tcommitHyperlink: true,\n\t\trefHyperlink: true,\n\t},\n\tcommitsParser: {\n\t\theaderPattern: /^(?<type>\\w+)(?:\\((?<scope>.+)\\))?(?<bang>!)?: (?<subject>.+)/s,\n\t\tbreakingChangesPattern: /BREAKING CHANGES?:\\s*(?<content>.+)/s,\n\t\tbreakingChangeListPattern: /- (.+)/g,\n\t\ttagPattern: /tag: (?<tag>.*?)[,)]/g,\n\t\tcoAuthorPattern: /Co-authored-by: (?<name>.+?) <(?<email>.+)>/g,\n\t\tsignerPattern: /Signed-off-by: (?<name>.+?) <(?<email>.+)>/g,\n\t\tghEmailPattern: /^(?:\\d+\\+)?(?<username>.+)@users\\.noreply\\.github\\.com$/,\n\t\tremoteUrlPattern: /^(https:\\/\\/|git@)(?<host>[^/:]+)[/:](?<owner>.+?)\\/(?<name>.+?)(?:\\..*)?$/,\n\t\trefPattern: /^(?<action>.+?) (?<labels>.+)$/gm,\n\t\trefLabelPattern: /(?:(?<owner>\\S+?)\\/(?<repo>\\S+?))?#(?<number>\\d+)/g,\n\t\trefActionPattern: /Fixes|Closes|Refs/i,\n\t\tdateSource: 'authorDate',\n\t\tdateFormat: 'YYYY-MM-DD',\n\t},\n}\n\nexport const defaultChangelogSections: DefaultChangelogSections = {\n\tbreaking: { title: '⚠️ BREAKING CHANGES', commitType: 'breaking' },\n\tfeat: { title: '✨ Features', commitType: 'feat' },\n\tfix: { title: '🩹 Fixes', commitType: 'fix' },\n\tperf: { title: '⚡ Performance', commitType: 'perf' },\n\trefactor: { title: '🚜 Refactoring', commitType: 'refactor' },\n\tdocs: { title: '📚 Documentation', commitType: 'docs' },\n\tstyle: { title: '🎨 Formatting', commitType: 'style' },\n\tbuild: { title: '📦 Build', commitType: 'build' },\n\tci: { title: '🚀 CI', commitType: 'ci' },\n\trevert: { title: '♻️ Reverts', commitType: 'revert' },\n\tdeps: { title: '🧩 Dependencies', commitType: 'chore',\n\t\tfilter: commit => !!commit.scope?.includes('deps') },\n\tchore: { title: '🛠️ Chores', commitType: 'chore' },\n\ttest: { title: '🧪 Tests', commitType: 'test' },\n\tmisc: { title: '⚙️ Miscellaneous', commitType: '*' },\n\t[Symbol.iterator]() {\n\t\treturn Object.values(this)[Symbol.iterator]()\n\t},\n}\n\nexport const defaultChangelogOptions: CompleteChangelogOptions = {\n\tstdout: false,\n\toutputFile: './CHANGELOG.md',\n\tcommitRange: 'unreleased',\n\tsections: [...defaultChangelogSections],\n\theader: '# Changelog\\n\\n\\n',\n\tprevReleaseHeaderPattern: /^##.*?\\d+\\.\\d+\\.\\d+/m,\n\thelpers: {\n\t\trepeat: (string: string, n: number) => string.repeat(n),\n\t},\n\tpartials: {},\n}\n\nexport const defaultCommitOptions: CompleteCommitOptions = {\n\tmessage: 'release({{repo.name}}): {{newTag}}',\n\tsignOff: false,\n\tgpgSign: false,\n\tstageAll: true,\n\textraArgs: '',\n}\n\nexport const defaultTagOptions: CompleteTagOptions = {\n\tname: '{{newTag}}',\n\tmessage: 'release({{repo.name}}): {{newTag}}',\n\tgpgSign: false,\n\tforce: false,\n\textraArgs: '',\n}\n\nexport const defaultVersionedFiles: DefaultVersionedFile[] = [\n\t{\n\t\tfilePathRegex: /package\\.json$/,\n\t\tversionPattern: /(^.*?\"version\".*?\")(.*?)(\")/s,\n\t},\n\t{\n\t\tfilePathRegex: /package-lock\\.json$/,\n\t\tversionPattern: /(^.*?\"version\".*?\"|\"packages\".*?\"\".*\"version\".*?\")(.*?)(\")/gs,\n\t},\n]","import { parseVersion, determineNextVersion, getVersionTags, getRepoInfo, parseCommits } from '@/utils'\nimport type { UserConfig, ResolvedConfig, TransformedConfig, VersionedFile, MergedConfig, ResolvedContext, FalseOrComplete, ContextualConfig, ResolvedChangelogSection, ChangelogSectionDefinition, Commit, ReleaseWithFlatCommits, ReleaseWithGroupedCommits } from '@/types'\nimport { defaultConfig, defaultVersionedFiles, defaultChangelogOptions, defaultCommitOptions, defaultTagOptions } from '@/defaults'\nimport Handlebars from 'handlebars'\n\nexport const resolveConfig = async (userConfig: UserConfig): Promise<ResolvedConfig> => {\n\tconst profileMergedConfig = mergeProfileConfig(userConfig)\n\tconst mergedConfig = mergeWithDefaults(profileMergedConfig)\n\tconst transformedConfig = transformVersionedFiles(mergedConfig)\n\tconst contextualConfig = await fillContext(transformedConfig)\n\tconst finalConfig = resolveTemplates(contextualConfig)\n\treturn finalConfig\n}\n\nconst mergeProfileConfig = (baseConfig: UserConfig): UserConfig => {\n\tconst profileName = baseConfig.profile\n\tif (!profileName) return baseConfig\n\n\tconst profileConfig = baseConfig[`_${profileName}`]\n\tif (!profileConfig) throw new Error(`Profile \"${profileName}\" not found in configuration.`)\n\n\tconst mergeOption = <T extends keyof UserConfig>(propKey: T, ...nestedPropKeys: string[]): UserConfig[T] => {\n\t\ttype PlainObject = Record<string, unknown>\n\n\t\tconst isPlainObject = (value: unknown): value is PlainObject =>\n\t\t\tObject.prototype.toString.call(value) === '[object Object]'\n\n\t\tconst mergeObjects = (baseObj: unknown, overrideObject: unknown): unknown => {\n\t\t\tconst isBasePlainObject = isPlainObject(baseObj)\n\t\t\tconst isOverridePlainObject = isPlainObject(overrideObject)\n\t\t\tif (isBasePlainObject && isOverridePlainObject) {\n\t\t\t\treturn { ...baseObj, ...overrideObject }\n\t\t\t} else if (!isBasePlainObject && isOverridePlainObject) {\n\t\t\t\treturn overrideObject\n\t\t\t} else if (isBasePlainObject && !isOverridePlainObject) {\n\t\t\t\treturn baseObj\n\t\t\t}\n\t\t}\n\n\t\tconst baseConfigProp = baseConfig[propKey] as PlainObject | undefined\n\t\tconst profileConfigProp = profileConfig[propKey] as PlainObject | undefined\n\t\tconst result = mergeObjects(baseConfigProp, profileConfigProp) as PlainObject | undefined\n\t\tif (result === undefined) return undefined\n\n\t\tnestedPropKeys.forEach((key) => {\n\t\t\tresult[key] = mergeObjects(baseConfigProp?.[key], profileConfigProp?.[key])\n\t\t})\n\n\t\treturn result as UserConfig[T]\n\t}\n\n\treturn {\n\t\t...baseConfig, ...profileConfig,\n\t\tcommitsParser: mergeOption('commitsParser'),\n\t\tchangelog: mergeOption('changelog', 'partials', 'helpers'),\n\t\tcommit: mergeOption('commit'),\n\t\ttag: mergeOption('tag'),\n\t\tcontext: mergeOption('context'),\n\t}\n}\n\nconst mergeWithDefaults = (userConfig: UserConfig): MergedConfig => {\n\tconst resolveOptions = <T>(optionsName: string, options: boolean | T | undefined, defaults: Required<T>, ...subObjects: (keyof T)[]): FalseOrComplete<T> => {\n\t\tif (options == undefined || options === false) return false\n\t\tif (options === true) return defaults\n\t\tif (typeof options !== 'object') throw new Error(`Invalid value for ${optionsName}. It should be a boolean or an object.`)\n\t\tconst result: Required<T> = { ...defaults, ...options }\n\t\tsubObjects.forEach(subObjectKey => result[subObjectKey] = { ...defaults[subObjectKey], ...options[subObjectKey] })\n\t\treturn result\n\t}\n\n\treturn {\n\t\t...defaultConfig, ...userConfig,\n\t\tcommitsParser: { ...defaultConfig.commitsParser, ...userConfig.commitsParser },\n\t\tchangelog: resolveOptions('changelog', userConfig.changelog, defaultChangelogOptions, 'partials', 'helpers'),\n\t\tcommit: resolveOptions('commit', userConfig.commit, defaultCommitOptions),\n\t\ttag: resolveOptions('tag', userConfig.tag, defaultTagOptions),\n\t}\n}\n\nconst transformVersionedFiles = (config: MergedConfig): TransformedConfig => {\n\tconst resolveVersionedFile = (filePath: string): VersionedFile => {\n\t\tconst matchingDefaultVersionFile = defaultVersionedFiles.find(defaultFile =>\n\t\t\tdefaultFile.filePathRegex.test(filePath))\n\t\tif (matchingDefaultVersionFile) {\n\t\t\treturn { filePath, versionPattern: matchingDefaultVersionFile.versionPattern }\n\t\t} else {\n\t\t\tthrow new Error(\n\t\t\t\t`File ${filePath} doesn't match any default versioned files. `\n\t\t\t\t+ 'Please provide a custom version pattern for this file.',\n\t\t\t)\n\t\t}\n\t}\n\n\tconst resolveBump = (bump: MergedConfig['bump']): false | VersionedFile[] => {\n\t\tif (bump === false) return false\n\t\tif (bump === true) return [versionSourceFile]\n\t\tif (Array.isArray(bump)) return [\n\t\t\tversionSourceFile,\n\t\t\t...(bump.map(bumpFile =>\n\t\t\t\ttypeof bumpFile === 'string' ? resolveVersionedFile(bumpFile) : bumpFile,\n\t\t\t)),\n\t\t]\n\t\tthrow new Error('Invalid value for bump. It should be a boolean or an array.')\n\t}\n\n\tconst versionSourceFile = typeof config.versionSourceFile === 'string'\n\t\t? resolveVersionedFile(config.versionSourceFile)\n\t\t: config.versionSourceFile\n\n\treturn {\n\t\t...config,\n\t\tversionSourceFile,\n\t\tbump: resolveBump(config.bump),\n\t\tchangelog: config.changelog === false\n\t\t\t? false\n\t\t\t: { ...config.changelog,\n\t\t\t\tcompiledPartials: Object.fromEntries(Object.entries(config.changelog.partials).map(([key, template]) => [key, Handlebars.compile(template)])),\n\t\t\t},\n\t}\n}\n\nconst fillContext = async (config: TransformedConfig): Promise<ContextualConfig> => {\n\tconst resolvedContext = (config.context ?? {}) as Partial<ResolvedContext>\n\n\tconst repoInfo = getRepoInfo(config.commitsParser.remoteUrlPattern)\n\tresolvedContext.repo = { ...repoInfo, ...resolvedContext.repo }\n\n\tconst commitRange = config.changelog ? config.changelog.commitRange : 'unreleased'\n\n\tresolvedContext.commits = config.context?.commits\n\t\t? await Promise.all(config.context.commits.map(async (commit) => {\n\t\t\treturn ((typeof commit === 'object' && 'message' in commit) || typeof commit === 'string')\n\t\t\t\t? (await parseCommits([commit], config.commitsParser, config.prevReleaseTagPattern))[0]\n\t\t\t\t: commit\n\t\t}))\n\t\t: await parseCommits(commitRange, config.commitsParser, config.prevReleaseTagPattern)\n\n\tresolvedContext.currentVersion ??= parseVersion(config.versionSourceFile)\n\tresolvedContext.currentTag ??= getVersionTags(config.prevReleaseTagPattern)[0]\n\tresolvedContext.newVersion ??= await determineNextVersion(config, resolvedContext.currentVersion)\n\tresolvedContext.newTag ??= compileTemplate(config.newTagFormat, resolvedContext as ResolvedContext)\n\n\tconst contextualConfig = { ...config, context: resolvedContext as ResolvedContext }\n\n\tresolvedContext.releases = config.changelog\n\t\t? groupCommitsByReleases(resolvedContext.commits, config.changelog.sections, contextualConfig)\n\t\t: null\n\n\treturn contextualConfig\n}\n\nconst groupCommitsByReleases = (commits: Commit[], sections: ChangelogSectionDefinition[], config: ContextualConfig): ReleaseWithGroupedCommits[] => {\n\tconst releases: Record<string, ReleaseWithFlatCommits> = {}\n\n\tcommits.forEach((commit) => {\n\t\tconst releaseTag = commit.tags?.find(tag => config.prevReleaseTagPattern.test(tag))\n\t\tif (releaseTag) {\n\t\t\treleases[releaseTag] ??= {\n\t\t\t\ttag: releaseTag,\n\t\t\t\tversion: config.prevReleaseTagPattern.exec(releaseTag)?.groups?.version,\n\t\t\t\tdate: commit.date,\n\t\t\t\tcommits: [commit],\n\t\t\t}\n\t\t} else {\n\t\t\tconst latestReleaseTag = Object.keys(releases).at(-1)\n\t\t\tif (latestReleaseTag) {\n\t\t\t\treleases[latestReleaseTag].commits.push(commit)\n\t\t\t} else {\n\t\t\t\treleases[config.context.newTag] = {\n\t\t\t\t\ttag: config.context.newTag,\n\t\t\t\t\tversion: config.context.newVersion,\n\t\t\t\t\tdate: commit.date,\n\t\t\t\t\tcommits: [commit],\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t})\n\n\treturn Object.values(releases).map(release => groupReleaseCommitsBySections(release, sections))\n}\n\nconst groupReleaseCommitsBySections = (release: ReleaseWithFlatCommits, sections: ChangelogSectionDefinition[]): ReleaseWithGroupedCommits => {\n\tconst { commits, ...releaseWithoutCommits } = release\n\treturn {\n\t\t...releaseWithoutCommits,\n\t\tcommitGroups: groupCommitsBySections(commits, sections),\n\t}\n}\n\nconst groupCommitsBySections = (commits: Commit[], sections: ChangelogSectionDefinition[]): ResolvedChangelogSection[] => {\n\tconst commitGroups: Record<string, Commit[]> = Object.fromEntries(sections.map(section => [section.title, []]))\n\n\tcommits.forEach((commit) => {\n\t\tconst isBreaking = !!commit.breakingChanges\n\t\tlet isGrouped = false\n\t\tlet isBreakingGrouped = false\n\n\t\tfor (const section of sections) {\n\t\t\tif (section.filter && !section.filter(commit)) continue\n\n\t\t\tconst sectionTypes = [section.commitType].flat()\n\n\t\t\tif (isBreaking && !isBreakingGrouped && sectionTypes.includes('breaking')) {\n\t\t\t\tcommitGroups[section.title].push(commit)\n\t\t\t\tisBreakingGrouped = true\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tif (!isGrouped && (sectionTypes.includes(commit.type) || sectionTypes.includes('*'))) {\n\t\t\t\tcommitGroups[section.title].push(commit)\n\t\t\t\tisGrouped = true\n\t\t\t}\n\n\t\t\tif (isGrouped && (!isBreaking || isBreakingGrouped)) return\n\t\t}\n\t})\n\n\tObject.keys(commitGroups).forEach((key) => {\n\t\tif (!commitGroups[key].length) delete commitGroups[key]\n\t})\n\n\treturn Object.entries(commitGroups).map(([title, commits]) => ({ title, commits }))\n}\n\nconst resolveTemplates = (config: ContextualConfig): ResolvedConfig => {\n\treturn {\n\t\t...config,\n\t\tcommit: config.commit\n\t\t\t? { ...config.commit, message: compileTemplate(config.commit.message, config.context) }\n\t\t\t: config.commit,\n\t\ttag: config.tag\n\t\t\t? {\n\t\t\t\t...config.tag,\n\t\t\t\tname: compileTemplate(config.tag.name, config.context),\n\t\t\t\tmessage: compileTemplate(config.tag.message, config.context),\n\t\t\t}\n\t\t\t: config.tag,\n\t}\n}\n\nconst compileTemplate = (value: string, context: ResolvedContext): string => {\n\tconst compile = Handlebars.compile(value)\n\treturn compile(context)\n}","import { readFileSync } from 'node:fs'\nimport semver from 'semver'\nimport type { ReleaseType, Commit, VersionedFile, TransformedConfig } from '@/types'\nimport { parseCommits } from '@/utils'\n\nexport const parseVersion = (versionedFile: VersionedFile): string => {\n\tconst fileContent = readFileSync(versionedFile.filePath, 'utf8')\n\tconst version = versionedFile.versionPattern.exec(fileContent)?.[2]\n\tif (!version) throw new Error(`Version not found in '${versionedFile.filePath}' with pattern '${versionedFile.versionPattern}'`)\n\tif (!semver.valid(version)) throw new Error(`Invalid version format in '${versionedFile.filePath}': '${version}'`)\n\tconsole.log(`Current version from '${versionedFile.filePath}': '${version}'`)\n\treturn version\n}\n\nexport const determineNextVersion = async (config: TransformedConfig, currentVersion: string): Promise<string> => {\n\tif (config.releaseVersion) {\n\t\tif (!semver.valid(config.releaseVersion)) {\n\t\t\tthrow new Error(`Invalid release version format: '${config.releaseVersion}'`)\n\t\t}\n\t\treturn config.releaseVersion\n\t}\n\tlet releaseType: ReleaseType\n\tif (config.releaseType) {\n\t\treleaseType = config.releaseType\n\t} else {\n\t\tconst unreleasedCommits = await parseCommits('unreleased', config.commitsParser, config.prevReleaseTagPattern)\n\t\treleaseType = calculateReleaseType(unreleasedCommits)\n\t\tif (config.zeroMajorBreakingIsMinor && semver.major(currentVersion) === 0 && releaseType === 'major') releaseType = 'minor'\n\t}\n\tconst newVersion = increaseVersion(currentVersion, releaseType)\n\tconsole.log(`Determined new version: '${newVersion}' (release type: '${releaseType}')`)\n\treturn newVersion\n}\n\nconst calculateReleaseType = (commits: Commit[]): ReleaseType => {\n\tconst hasBreakingChange = commits.some(commit => commit.breakingChanges)\n\tif (hasBreakingChange) return 'major'\n\n\tconst hasFeature = commits.some(commit => commit.type === 'feat')\n\tif (hasFeature) return 'minor'\n\n\treturn 'patch'\n}\n\nconst increaseVersion = (currentVersion: string, releaseType: ReleaseType): string =>\n\tsemver.inc(currentVersion, releaseType) ?? (() => {\n\t\tthrow new Error(`Failed to calculate new version from '${currentVersion}' with release type '${releaseType}'`)\n\t})()","export enum GpgSigLabel {\n\tG = 'valid',\n\tB = 'bad',\n\tU = 'valid, unknown validity',\n\tX = 'valid, expired',\n\tY = 'valid, made by expired key',\n\tR = 'valid, made by revoked key',\n\tE = 'cannot check (missing key)',\n\tN = 'no signature',\n}\n\nexport enum RefType {\n\tissue = 'issue',\n\tpr = 'PR',\n}","import type { CompleteCommitsParser, Commit, RawCommit, RawReference, RefLabel, Reference, Contributor, CommitMessage, CommitRange } from '@/types'\nimport { GpgSigLabel } from '@/enums'\nimport { getRawCommits } from '@/utils'\n\n// const commitStore: Record<string, Commit> = {}\n\nexport const parseCommits = async (arg1: CommitRange | RawCommit[], commitsParser: CompleteCommitsParser, prevReleaseTagPattern: RegExp): Promise<Commit[]> => {\n\tconst rawCommits = Array.isArray(arg1) ? arg1 : getRawCommits(arg1, prevReleaseTagPattern)\n\tconst parser = commitsParser\n\n\treturn (await Promise.all(rawCommits.map(async (commit) => {\n\t\tif (typeof commit === 'string') commit = { message: commit }\n\n\t\tconst { hash, tagRefs } = commit\n\n\t\tconst message = commit.message.trim()\n\t\tif (!message) throw new Error(`Message is missing for commit: ${JSON.stringify(commit)}`)\n\n\t\tlet parsedMessage\n\t\ttry {\n\t\t\tparsedMessage = parseCommitMessage(message, parser)\n\t\t} catch (error) {\n\t\t\tconsole.warn(`Error parsing commit '${hash ?? '<no hash>'}':`, (error as Error).message)\n\t\t\treturn\n\t\t}\n\t\tconst { type, scope, subject, body, breakingChanges, footer } = parsedMessage\n\t\tconst tags = tagRefs ? [...tagRefs.matchAll(parser.tagPattern)].map(m => m.groups?.tag ?? '') : []\n\n\t\tconst signers = footer\n\t\t\t? [...footer.matchAll(parser.signerPattern)].map(m => m.groups as unknown as Contributor)\n\t\t\t: []\n\n\t\tconst authors: Contributor[] = []\n\t\tconst addAuthor = (contributor: Contributor): void => {\n\t\t\tif (!authors.some(a => a.email === contributor.email)) authors.push(contributor)\n\t\t}\n\n\t\tconst author = commit.authorName && commit.authorEmail\n\t\t\t? getContributorDetails({ name: commit.authorName, email: commit.authorEmail }, signers)\n\t\t\t: undefined\n\t\tif (author) addAuthor(author)\n\n\t\tconst committer = commit.committerName && commit.committerEmail\n\t\t\t? getContributorDetails({ name: commit.committerName, email: commit.committerEmail }, signers)\n\t\t\t: undefined\n\t\tif (committer) addAuthor(committer)\n\n\t\tconst coAuthors = footer\n\t\t\t? [...footer.matchAll(parser.coAuthorPattern)].map(m => m.groups as unknown as Contributor)\n\t\t\t\t.map(coAuthor => getContributorDetails(coAuthor, signers))\n\t\t\t: []\n\t\tcoAuthors.forEach(coAuthor => addAuthor(coAuthor))\n\n\t\tconst refs = await parseRefs((footer ?? ''), parser)\n\n\t\tconst gpgSig = commit.gpgSigCode\n\t\t\t? {\n\t\t\t\tcode: commit.gpgSigCode,\n\t\t\t\tlabel: GpgSigLabel[commit.gpgSigCode],\n\t\t\t\tkeyId: commit.gpgSigKeyId,\n\t\t\t}\n\t\t\t: undefined\n\n\t\tlet date = commit[parser.dateSource === 'committerDate' ? 'committerTs' : 'authorTs']\n\t\tif (typeof date === 'string') date = formatDate(new Date(+date * 1000), parser.dateFormat)\n\n\t\tconst parsedCommit = { hash, type, scope, subject, body, breakingChanges, footer, committer, gpgSig, date,\n\t\t\ttags: tags.length ? tags : undefined,\n\t\t\tauthors: authors.length ? authors : undefined,\n\t\t\trefs: refs.length ? refs : undefined,\n\t\t}\n\t\t// if (hash && !(hash in commitStore)) commitStore[hash] = parsedCommit\n\t\t// console.log(Object.keys(commitStore).length, 'commits in store')\n\t\treturn parsedCommit\n\t}))).filter(commit => commit !== undefined)\n}\n\nconst parseCommitMessage = (message: string, parser: CompleteCommitsParser): CommitMessage => {\n\tconst [header, ...details] = message.split('\\n\\n')\n\n\tconst headerMatch = parser.headerPattern.exec(header)\n\tif (!headerMatch?.groups) throw new Error(`Commit header '${header}' doesn't match expected format`)\n\tconst { type, scope, bang, subject } = headerMatch.groups\n\n\tlet breakingChanges\n\tconst breakingChangesPart = details.find(detail => parser.breakingChangesPattern.test(detail))\n\tif (breakingChangesPart) {\n\t\tbreakingChanges = parseBreakingChanges(breakingChangesPart, parser)\n\t\tdetails.splice(details.indexOf(breakingChangesPart), 1)\n\t} else if (bang) {\n\t\tbreakingChanges = subject\n\t}\n\n\tconst footerStart = details.findIndex(detail =>\n\t\tdetail.match(parser.refActionPattern)\n\t\t?? detail.match(parser.coAuthorPattern)\n\t\t?? detail.match(parser.signerPattern))\n\tconst [body, footer] = footerStart === -1\n\t\t? [details.join('\\n\\n'), '']\n\t\t: [details.slice(0, footerStart).join('\\n\\n'), details.slice(footerStart).join('\\n\\n')]\n\n\treturn {\n\t\ttype,\n\t\tscope: scope || undefined,\n\t\tsubject,\n\t\tbody: body || undefined,\n\t\tbreakingChanges,\n\t\tfooter: footer || undefined,\n\t}\n}\n\nconst parseBreakingChanges = (value: string, parser: CompleteCommitsParser): Commit['breakingChanges'] => {\n\tconst breakingChanges = parser.breakingChangesPattern.exec(value)?.groups?.content\n\tif (!breakingChanges) throw new Error(`Failed to extract breaking changes content from '${value}' using pattern \"${parser.breakingChangesPattern}\"`)\n\n\tconst breakingChangeList = [...breakingChanges.matchAll(parser.breakingChangeListPattern)]\n\n\treturn breakingChangeList.length\n\t\t? breakingChangeList.map(m => m[1])\n\t\t: breakingChanges\n}\n\nconst getContributorDetails = (contributor: Contributor, signers: Contributor[]): Contributor => {\n\tconst hasSignedOff = signers.some(signer => signer.email === contributor.email && signer.name === contributor.name)\n\treturn {\n\t\t...contributor,\n\t\thasSignedOff,\n\t\tghLogin: contributor.name,\n\t\tghUrl: `https://github.com/${contributor.name}`,\n\t}\n}\n\nconst parseRefs = async (value: string, parser: CompleteCommitsParser): Promise<Reference[]> =>\n\tawait Promise.all([...value.matchAll(parser.refPattern)].map(m => m.groups as unknown as RawReference)\n\t\t.filter(rawRef => parser.refActionPattern.test(rawRef.action))\n\t\t.flatMap(rawRef =>\n\t\t\t[...rawRef.labels.matchAll(parser.refLabelPattern)].map(m => m.groups as unknown as RefLabel)\n\t\t\t\t.filter(label => !!label.number)\n\t\t\t\t.map(label => ({\n\t\t\t\t\taction: rawRef.action,\n\t\t\t\t\towner: label.owner,\n\t\t\t\t\trepo: label.repo,\n\t\t\t\t\tnumber: label.number,\n\t\t\t\t})),\n\t\t),\n\t)\n\nconst formatDate = (date: Date, format: string): string => {\n\tconst pad = (num: number) => num.toString().padStart(2, '0')\n\n\tconst dateParts: Record<string, string> = {\n\t\tYYYY: date.getUTCFullYear().toString(),\n\t\tMM: pad(date.getUTCMonth() + 1),\n\t\tDD: pad(date.getUTCDate()),\n\t\tHH: pad(date.getUTCHours()),\n\t\tmm: pad(date.getUTCMinutes()),\n\t\tss: pad(date.getUTCSeconds()),\n\t}\n\n\treturn format.replace(/YYYY|MM|DD|HH|mm|ss/g, k => dateParts[k])\n}","import { execSync } from 'node:child_process'\nimport type { CommitRange, RawCommit, RepoInfo } from '@/types'\n\nconst commitLogFormat = `##COMMIT##%n#HASH# %h%n#MSG# %B%n#REFS# %d%n#AUTHOR-NAME# %an%n#AUTHOR-EMAIL# %ae%n#AUTHOR-DATE# %at%n#COMMITTER-NAME# %cn%n#COMMITTER-EMAIL# %ce%n#COMMITTER-DATE# %ct%n#GPGSIG-CODE# %G?%n#GPGSIG-KEYID# %GK%n`\nconst rawCommitPattern = /##COMMIT##\\n#HASH# (?<hash>.+)?\\n#MSG# (?<message>[\\s\\S]*?)\\n#REFS#\\s+(?<tagRefs>.+)?\\n#AUTHOR-NAME# (?<authorName>.+)?\\n#AUTHOR-EMAIL# (?<authorEmail>.+)?\\n#AUTHOR-DATE# (?<authorTs>.+)?\\n#COMMITTER-NAME# (?<committerName>.+)?\\n#COMMITTER-EMAIL# (?<committerEmail>.+)?\\n#COMMITTER-DATE# (?<committerTs>.+)?\\n#GPGSIG-CODE# (?<gpgSigCode>.+)?\\n#GPGSIG-KEYID# (?<gpgSigKeyId>.+)?/g\n\nexport const getRepoInfo = (remoteUrlPattern: RegExp): RepoInfo => {\n\tconst remoteUrl = execSync('git remote get-url origin', { encoding: 'utf8' }).trim()\n\tconst remoteUrlMatch = remoteUrlPattern.exec(remoteUrl)\n\tif (!remoteUrlMatch?.groups) throw new Error(`Couldn't parse remote URL: ` + remoteUrl)\n\n\tconst { host, owner, name } = remoteUrlMatch.groups\n\tconst homepage = `https://${host}/${owner}/${name}`\n\n\treturn { host, owner, name, homepage }\n}\n\nexport const getRawCommits = (commitRange: CommitRange, prevReleaseTagPattern: RegExp): RawCommit[] => {\n\tconst firstCommitHash = getFirstCommitHash()\n\tconst versionTags = getVersionTags(prevReleaseTagPattern)\n\n\tlet from: string, to: string\n\tif (typeof commitRange === 'string') {\n\t\tfrom = {\n\t\t\tall: firstCommitHash,\n\t\t\tunreleased: versionTags[0] ?? firstCommitHash,\n\t\t}[commitRange]\n\t\tif (!from) throw new Error(`Invalid commit range: '${commitRange}'`)\n\t\tto = 'HEAD'\n\t} else if ('from' in commitRange || 'to' in commitRange) {\n\t\tconst fromValue = 'from' in commitRange ? commitRange.from : 'firstCommit'\n\t\tfrom = fromValue === 'firstCommit' ? firstCommitHash : fromValue\n\t\tto = 'to' in commitRange ? commitRange.to : 'HEAD'\n\t} else if ('versionTag' in commitRange) {\n\t\tconst targetTagIndex = versionTags.indexOf(commitRange.versionTag)\n\t\tif (targetTagIndex === -1) throw new Error(`Version tag '${commitRange.versionTag}' not found`)\n\t\tfrom = versionTags[targetTagIndex]\n\t\tto = versionTags[targetTagIndex + 1] ?? 'HEAD'\n\t} else {\n\t\tthrow new Error(`Invalid commit range provided`)\n\t}\n\n\tconst gitLogCommits = execSync(`git log ${from}..${to} --pretty=\"${commitLogFormat}\"`, { encoding: 'utf8' })\n\treturn [...gitLogCommits.matchAll(rawCommitPattern)].map(m => m.groups as RawCommit)\n}\n\nconst getFirstCommitHash = (): string => execSync('git rev-list --max-parents=0 HEAD', { encoding: 'utf8' }).trim()\n\nexport const getVersionTags = (tagPattern: RegExp): string[] => {\n\tconst rawTags = execSync('git tag --sort=-creatordate', { encoding: 'utf8' })\n\treturn rawTags.split('\\n').filter(tag => tagPattern.test(tag))\n}","\"{{#>header}}\\n## &ensp; [` 📦 {{tag}}  `]({{repo.homepage}}/{{#if prevTag}}compare/{{prevTag}}...{{tag}}{{else}}commits/{{tag}}{{/if}})\\n\\n{{/header}}\\n{{#each commitGroups}}\\n### {{{repeat '&nbsp;' 5}}}{{title}}\\n{{#each commits}}\\n* {{#if scope}}`{{scope}}` {{/if}}{{{subject}}} {{#if ../../commitHyperlink}}[`{{hash}}`]({{../../repo.homepage}}/commit/{{hash}}){{else}}{{hash}}{{/if}}\\n{{/each}}\\n\\n{{/each}}\\n##### &emsp;&ensp;&nbsp; 🔗 [Full Commit History: {{#if prevTag}}`{{prevTag}}` → `{{tag}}`]({{repo.homepage}}/compare/{{prevTag}}...{{tag}}){{else}}`{{tag}}`]({{repo.homepage}}/commits/{{tag}}){{/if}} &ensp;/&ensp; _{{date}}_\\n\\n\\n\"","import { getVersionTags } from '@/utils'\nimport type { ReleaseContext, ReleaseWithGroupedCommits, ResolvedConfig } from '@/types'\nimport { existsSync, readFileSync, writeFileSync } from 'node:fs'\nimport Handlebars from 'handlebars'\nimport releaseTemplate from '@/templates/release.hbs'\n\nexport const changelog = (config: ResolvedConfig): void => {\n\tif (!config.changelog) return\n\n\tconst options = config.changelog\n\tconst releases = config.context.releases\n\tif (!releases) return\n\n\tconst versionTags = getVersionTags(config.prevReleaseTagPattern)\n\n\tHandlebars.registerPartial(options.compiledPartials)\n\tHandlebars.registerHelper(options.helpers)\n\n\tlet result = options.header\n\treleases.forEach((release: ReleaseWithGroupedCommits, index: number) => {\n\t\tconst prevRelease = releases[index + 1] as ReleaseWithGroupedCommits | undefined\n\t\tlet prevTag: string | undefined, prevVersion: string | undefined\n\t\tif (prevRelease) {\n\t\t\tprevTag = prevRelease.tag\n\t\t\tprevVersion = getVersionFromTag(prevTag, config.prevReleaseTagPattern)\n\t\t} else {\n\t\t\tconst targetTagIndex = versionTags.indexOf(release.tag)\n\t\t\tif (targetTagIndex === -1) {\n\t\t\t\tprevTag = config.context.currentTag\n\t\t\t\tprevVersion = getVersionFromTag(prevTag, config.prevReleaseTagPattern)\n\t\t\t} else {\n\t\t\t\tprevTag = versionTags[targetTagIndex + 1]\n\t\t\t\tprevVersion = prevTag && getVersionFromTag(prevTag, config.prevReleaseTagPattern)\n\t\t\t}\n\t\t}\n\t\tconst releaseContext: ReleaseContext = {\n\t\t\t...release,\n\t\t\t...config.context,\n\t\t\tprevTag,\n\t\t\tprevVersion,\n\t\t}\n\t\tconst rendered = renderTemplate(releaseTemplate, releaseContext)\n\t\tresult += rendered\n\t})\n\n\tif (options.stdout) {\n\t\tconsole.log(`Generated changelog:\\n${result}`)\n\t}\n\tif (options.outputFile) {\n\t\tconsole.log(`Writing changelog to file '${options.outputFile}'`)\n\t\tif (!config.dryRun) writeToChangelogFile(options.outputFile, result, options.prevReleaseHeaderPattern)\n\t}\n}\n\nconst writeToChangelogFile = (outputFile: string, content: string, prevReleaseHeaderPattern: RegExp): void => {\n\tconst changelogContent = existsSync(outputFile) ? readFileSync(outputFile, { encoding: 'utf8' }) : ''\n\tconst prevReleaseStart = changelogContent.search(prevReleaseHeaderPattern)\n\tconst headlessChangelog = changelogContent.slice(prevReleaseStart)\n\tconst newChangelog = content + headlessChangelog\n\twriteFileSync(outputFile, newChangelog, { encoding: 'utf8' })\n}\n\nconst renderTemplate = (template: string, releaseContext: ReleaseContext): string => {\n\tconst compile = Handlebars.compile(template)\n\treturn compile(releaseContext)\n}\n\nconst getVersionFromTag = (tag: string, tagPattern: RegExp): string | undefined => {\n\treturn tagPattern.exec(tag)?.groups?.version\n}","import { execSync } from 'node:child_process'\nimport type { ResolvedConfig } from '@/types'\n\nexport const commit = (config: ResolvedConfig): void => {\n\tif (!config.commit) return\n\tconst options = config.commit\n\tconsole.log('Committing with options:', options)\n\tif (options.stageAll && !config.dryRun) execSync('git add -A', { stdio: 'inherit' })\n\tif (!config.dryRun) execSync(`git commit -m \"${options.message}\" ${options.signOff ? '-s' : ''} ${options.gpgSign ? '-S' : ''} ${options.extraArgs}`, { stdio: 'inherit' })\n}","import { execSync } from 'node:child_process'\nimport type { ResolvedConfig } from '@/types'\n\nexport const tag = (config: ResolvedConfig): void => {\n\tif (!config.tag) return\n\tconst options = config.tag\n\tconsole.log('Tagging with options:', options)\n\tif (!config.dryRun) execSync(`git tag -a ${options.name} -m \"${options.message}\" ${options.gpgSign ? '-s' : ''} ${options.force ? '-f' : ''} ${options.extraArgs}`, { stdio: 'inherit' })\n}","import { bump, commit, tag, changelog } from '@/lifecycles'\nimport { resolveConfig } from '@/utils'\nimport type { UserConfig } from '@/types'\n\nexport default async function relion(userConfig: UserConfig) {\n\tconst config = await resolveConfig(userConfig)\n\tbump(config)\n\tchangelog(config)\n\tcommit(config)\n\ttag(config)\n}\n\nexport const defineConfig = (config: UserConfig): UserConfig => config"],"mappings":"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"}