fork-version 4.1.9 → 5.0.0

package/dist/commit-parser/commit-parser.js

@@ -0,0 +1,327 @@
+import { createParserOptions } from "./options.js";
+import { ParserError } from "./parser-error.js";
+//#region src/commit-parser/commit-parser.ts
+var CommitParser = class {
+	#options;
+	#logger;
+	constructor(userOptions) {
+		this.#options = createParserOptions(userOptions);
+		this.setLogger = this.setLogger.bind(this);
+		this.createCommit = this.createCommit.bind(this);
+		this.parseRawCommit = this.parseRawCommit.bind(this);
+		this.parseSubject = this.parseSubject.bind(this);
+		this.parseMerge = this.parseMerge.bind(this);
+		this.parseRevert = this.parseRevert.bind(this);
+		this.parseMentions = this.parseMentions.bind(this);
+		this.parseReferenceParts = this.parseReferenceParts.bind(this);
+		this.parseReferences = this.parseReferences.bind(this);
+		this.parseNotes = this.parseNotes.bind(this);
+		this.parseRawLines = this.parseRawLines.bind(this);
+		this.parse = this.parse.bind(this);
+	}
+	setLogger(logger) {
+		this.#logger = logger;
+		return this;
+	}
+	createCommit() {
+		return {
+			raw: "",
+			subject: "",
+			body: "",
+			hash: "",
+			refNames: "",
+			date: "",
+			name: "",
+			email: "",
+			type: "",
+			scope: "",
+			breakingChange: "",
+			title: "",
+			merge: null,
+			revert: null,
+			notes: [],
+			mentions: [],
+			references: [],
+			tags: []
+		};
+	}
+	/**
+	* Parse the raw commit message into its expected parts
+	* - subject
+	* - body
+	* - hash
+	* - date
+	* - name
+	* - email
+	*
+	* @throws {ParserError}
+	*/
+	parseRawCommit(rawCommit) {
+		const parsedCommit = this.createCommit();
+		const parts = rawCommit.split(/\r?\n/);
+		if (parts.length < 6) throw new ParserError("Commit doesn't contain enough parts", rawCommit);
+		const email = parts.pop();
+		const name = parts.pop();
+		const date = parts.pop();
+		const refNames = parts.pop();
+		const hash = parts.pop();
+		if (email) parsedCommit.email = email.trim();
+		if (name) parsedCommit.name = name.trim();
+		if (date) {
+			parsedCommit.date = date.trim();
+			if (Number.isNaN(Date.parse(parsedCommit.date))) throw new ParserError("Unable to parse commit date", rawCommit);
+		}
+		if (refNames) {
+			parsedCommit.refNames = refNames.trim();
+			const TAG_REGEX = /tag:\s*(?<tag>.+?)[,)]/gi;
+			let tagMatch = null;
+			while (tagMatch = TAG_REGEX.exec(refNames)) {
+				const { tag = "" } = tagMatch.groups ?? {};
+				if (tag) parsedCommit.tags.push(tag);
+			}
+		}
+		if (hash) parsedCommit.hash = hash.trim();
+		const subject = parts.shift()?.trimStart();
+		if (subject) {
+			parsedCommit.subject = subject;
+			parsedCommit.raw = subject;
+		}
+		parsedCommit.body = parts.filter((line) => {
+			if (this.#options.commentPattern) return !this.#options.commentPattern.test(line.trim());
+			return true;
+		}).join("\n").trim();
+		const raw = parts.join("\n").trim();
+		if (raw) parsedCommit.raw += "\n" + raw;
+		return parsedCommit;
+	}
+	/**
+	* Parse the commit subject into its expected parts
+	* - type
+	* - scope (optional)
+	* - breaking change (optional)
+	* - title
+	*
+	* @throws {ParserError}
+	*/
+	parseSubject(commit) {
+		if (!this.#options.subjectPattern) return false;
+		const subjectMatch = this.#options.subjectPattern.exec(commit.subject);
+		if (subjectMatch?.groups) {
+			const { type = "", scope = "", breakingChange = "", title = "" } = subjectMatch.groups;
+			if (!type || !title) throw new ParserError("Unable to parse commit subject", commit);
+			commit.type = type;
+			commit.scope = scope;
+			if (breakingChange) commit.breakingChange = breakingChange;
+			commit.title = title;
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Parse merge information from the commit subject
+	* @example
+	* ```txt
+	* "Merge pull request #123 from fork-version/feature"
+	* ```
+	*/
+	parseMerge(commit) {
+		if (!this.#options.mergePattern) return false;
+		const mergeMatch = this.#options.mergePattern.exec(commit.subject);
+		if (mergeMatch?.groups) {
+			const { id = "", source = "" } = mergeMatch.groups;
+			commit.merge = {
+				id,
+				source
+			};
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Parse revert information from the commit body
+	* @example
+	* ```txt
+	* "Revert "feat: initial commit"
+	*
+	* This reverts commit 4a79e9e546b4020d2882b7810dc549fa71960f4f."
+	* ```
+	*/
+	parseRevert(commit) {
+		if (!this.#options.revertPattern) return false;
+		const revertMatch = this.#options.revertPattern.exec(commit.raw);
+		if (revertMatch?.groups) {
+			const { hash = "", subject = "" } = revertMatch.groups;
+			commit.revert = {
+				hash,
+				subject
+			};
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Search for mentions from the commit line
+	* @example
+	* ```txt
+	* "@fork-version"
+	* ```
+	*/
+	parseMentions(line, outMentions) {
+		if (!this.#options.mentionPattern) return false;
+		const mentionRegex = new RegExp(this.#options.mentionPattern, "g");
+		let foundMention = false;
+		let mentionMatch;
+		while (mentionMatch = mentionRegex.exec(line)) {
+			if (!mentionMatch) break;
+			const { username = "" } = mentionMatch.groups ?? {};
+			outMentions.add(username);
+			foundMention = true;
+		}
+		return foundMention;
+	}
+	/**
+	* Search for references from the commit line
+	* @example
+	* ```txt
+	* "#1234"
+	* "owner/repo#1234"
+	* ```
+	*/
+	parseReferenceParts(referenceText, action) {
+		if (!this.#options.issuePattern) return void 0;
+		const references = [];
+		const issueRegex = new RegExp(this.#options.issuePattern, "gi");
+		let issueMatch;
+		while (issueMatch = issueRegex.exec(referenceText)) {
+			if (!issueMatch) break;
+			const { repository = "", prefix = "", issue = "" } = issueMatch.groups ?? {};
+			const reference = {
+				prefix,
+				issue,
+				action,
+				owner: null,
+				repository: null
+			};
+			if (repository) {
+				const slashIndex = repository.indexOf("/");
+				if (slashIndex !== -1) {
+					reference.owner = repository.slice(0, slashIndex);
+					reference.repository = repository.slice(slashIndex + 1);
+				} else reference.repository = repository;
+			}
+			references.push(reference);
+		}
+		if (references.length > 0) return references;
+	}
+	/**
+	* Search for actions and references from the commit line
+	* @example
+	* ```txt
+	* "Closes #1234"
+	* "fixes owner/repo#1234"
+	* ```
+	*/
+	parseReferences(line, outReferences) {
+		if (!this.#options.referenceActionPattern || !this.#options.issuePattern) return false;
+		const referenceActionRegex = new RegExp(this.#options.referenceActionPattern, "gi").test(line) ? new RegExp(this.#options.referenceActionPattern, "gi") : /(?<reference>.*)/g;
+		let foundReference = false;
+		let referenceActionMatch;
+		while (referenceActionMatch = referenceActionRegex.exec(line)) {
+			if (!referenceActionMatch) break;
+			const { action = "", reference = "" } = referenceActionMatch.groups ?? {};
+			const parsedReferences = this.parseReferenceParts(reference, action || null);
+			if (!parsedReferences) break;
+			for (const ref of parsedReferences) if (!outReferences.some((r) => r.prefix === ref.prefix && r.issue === ref.issue)) outReferences.push(ref);
+			foundReference = true;
+		}
+		return foundReference;
+	}
+	/**
+	* Search for notes from the commit line
+	* @example
+	* ```txt
+	* "BREAKING CHANGE: this is a breaking change"
+	* ```
+	*/
+	parseNotes(line, outNotes) {
+		if (!this.#options.notePattern) return false;
+		const noteMatch = new RegExp(this.#options.notePattern, "ig").exec(line);
+		if (noteMatch?.groups) {
+			const { title = "", text = "" } = noteMatch.groups;
+			outNotes.push({
+				title,
+				text
+			});
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Parse the raw commit for mentions, references and notes
+	*/
+	parseRawLines(commit) {
+		const mentions = /* @__PURE__ */ new Set();
+		const references = [];
+		const notes = [];
+		let lastNoteLine = -1;
+		const splitMessage = commit.raw.split("\n");
+		for (let index = 0; index < splitMessage.length; index++) {
+			const line = splitMessage[index];
+			const trimmedLine = line.trim();
+			if (this.#options.commentPattern?.test(trimmedLine)) continue;
+			this.parseMentions(trimmedLine, mentions);
+			if (this.parseReferences(trimmedLine, references)) {
+				lastNoteLine = -1;
+				continue;
+			}
+			if (this.parseNotes(trimmedLine, notes)) lastNoteLine = index;
+			else if (lastNoteLine !== -1) {
+				notes[notes.length - 1].text += `\n${line}`;
+				lastNoteLine = index;
+			}
+		}
+		if (mentions.size > 0) commit.mentions = Array.from(mentions);
+		if (references.length > 0) commit.references = references;
+		if (notes.length > 0) commit.notes = notes.map((note) => ({
+			...note,
+			text: note.text.trim()
+		}));
+	}
+	/**
+	* Parse a commit log with the following format separated by new line characters:
+	* ```txt
+	* refactor: add test file
+	* Add a test file to the project
+	* 4ef2c86d393a9660aa9f753144256b1f200c16bd
+	* 2024-12-22T17:36:50Z
+	* Fork Version
+	* fork-version@example.com
+	* ```
+	*
+	* @example
+	* ```ts
+	* parse("refactor: add test file\nAdd a test file to the project\n4ef2c86d393a9660aa9f753144256b1f200c16bd\n2024-12-22T17:36:50Z\nFork Version\nfork-version@example.com");
+	* ```
+	*
+	* The expected input value can be generated by running the following command:
+	* ```sh
+	* git log --format="%s%n%b%n%H%n%cI%n%cN%n%cE%n"
+	* ```
+	* @see {@link https://git-scm.com/docs/pretty-formats|Git Pretty Format Documentation}
+	*/
+	parse(rawCommit) {
+		try {
+			const commit = this.parseRawCommit(rawCommit);
+			this.parseSubject(commit);
+			this.parseMerge(commit);
+			this.parseRevert(commit);
+			this.parseRawLines(commit);
+			return commit;
+		} catch (error) {
+			if (this.#logger) this.#logger.debug("[Commit Parser] Failed to parse commit", { error });
+			return;
+		}
+	}
+};
+//#endregion
+export { CommitParser };

package/dist/commit-parser/filter-reverted-commits.d.ts

@@ -0,0 +1,17 @@
+import { Commit } from "./types.js";
+
+//#region src/commit-parser/filter-reverted-commits.d.ts
+/**
+ * Filter out revert commits and their corresponding reverted commits,
+ * this function expects the input to be sorted by date in descending order
+ * from the most recent to the oldest commit.
+ *
+ * @example
+ * ```ts
+ * const commits: Commit[] = [...];
+ * const filteredCommits = filterRevertedCommits(commits);
+ * ```
+ */
+declare function filterRevertedCommits(parsedCommits: Commit[]): Commit[];
+//#endregion
+export { filterRevertedCommits };

package/dist/commit-parser/filter-reverted-commits.js

@@ -0,0 +1,34 @@
+//#region src/commit-parser/filter-reverted-commits.ts
+/**
+* Filter out revert commits and their corresponding reverted commits,
+* this function expects the input to be sorted by date in descending order
+* from the most recent to the oldest commit.
+*
+* @example
+* ```ts
+* const commits: Commit[] = [...];
+* const filteredCommits = filterRevertedCommits(commits);
+* ```
+*/
+function filterRevertedCommits(parsedCommits) {
+	const revertedCommits = [];
+	for (const commit of parsedCommits) {
+		if (!commit.revert) continue;
+		if (revertedCommits.some((r) => r.revert?.hash === commit.hash || r.revert?.subject === commit.subject)) continue;
+		revertedCommits.push(commit);
+	}
+	if (revertedCommits.length === 0) return parsedCommits;
+	const commitsWithoutReverts = [];
+	for (const commit of parsedCommits) {
+		if (commit.revert) continue;
+		const revertedIndex = revertedCommits.findIndex((r) => r.revert?.hash === commit.hash || r.revert?.subject === commit.subject);
+		if (revertedIndex !== -1) {
+			revertedCommits.splice(revertedIndex, 1);
+			continue;
+		}
+		commitsWithoutReverts.push(commit);
+	}
+	return commitsWithoutReverts;
+}
+//#endregion
+export { filterRevertedCommits };

package/dist/commit-parser/options.d.ts

@@ -0,0 +1,74 @@
+//#region src/commit-parser/options.d.ts
+interface ParserOptions {
+  /**
+   * Pattern to match commit subjects
+   * - Expected capture groups: `type` `title`
+   * - Optional capture groups: `scope`, `breakingChange`
+   */
+  subjectPattern: RegExp | undefined;
+  /**
+   * Pattern to match merge commits
+   * - Expected capture groups: `id`, `source`
+   */
+  mergePattern: RegExp | undefined;
+  /**
+   * Pattern to match revert commits
+   * - Expected capture groups: `subject`, `hash`
+   */
+  revertPattern: RegExp | undefined;
+  /**
+   * Pattern to match commented out lines which will be trimmed
+   */
+  commentPattern: RegExp | undefined;
+  /**
+   * Pattern to match mentions
+   * - Expected capture groups: `username`
+   */
+  mentionPattern: RegExp | undefined;
+  /**
+   * List of action labels to match reference sections
+   * @default
+   * ["close", "closes", "closed", "fix", "fixes", "fixed", "resolve", "resolves", "resolved"]
+   */
+  referenceActions?: string[];
+  /**
+   * Pattern to match reference sections
+   * - Expected capture groups: `action`, `reference`
+   */
+  referenceActionPattern: RegExp | undefined;
+  /**
+   * List of issue prefixes to match issue ids
+   * @default
+   * ["#"]
+   */
+  issuePrefixes?: string[];
+  /**
+   * Pattern to match issue references
+   * - Expected capture groups: `repository`, `prefix`, `issue`
+   */
+  issuePattern: RegExp | undefined;
+  /**
+   * List of keywords to match note titles
+   * @default
+   * ["BREAKING CHANGE", "BREAKING-CHANGE"]
+   */
+  noteKeywords?: string[];
+  /**
+   * Pattern to match note sections
+   * - Expected capture groups: `title`
+   * - Optional capture groups: `text`
+   */
+  notePattern: RegExp | undefined;
+}
+/**
+ * Creates parser options by merging user-provided options with default values.
+ *
+ * Additionally, if a user provides a string for a property that expects a RegExp value,
+ * the function will attempt to parse it into a RegExp object.
+ *
+ * @param userOptions Optional user-provided options to override the defaults.
+ * @return A complete set of parser options with defaults applied and user overrides where specified.
+ */
+declare function createParserOptions(userOptions?: Partial<ParserOptions>): ParserOptions;
+//#endregion
+export { ParserOptions, createParserOptions };

package/dist/commit-parser/options.js

@@ -0,0 +1,70 @@
+import { escapeRegex } from "../utils/escape-regex.js";
+import { parseRegExpString } from "../utils/parse-regexp-string.js";
+import { trimStringArray } from "../utils/trim-string-array.js";
+//#region src/commit-parser/options.ts
+/**
+* Creates default parser options with predefined patterns and lists.
+*
+* The default expects the user is using Github as their hosting service.
+*
+* @param userOptions Optional user-provided options to override the defaults.
+* @returns A complete set of parser options with defaults applied and user overrides where specified.
+*/
+function createDefaultParserOptions(userOptions) {
+	const referenceActions = trimStringArray(userOptions?.referenceActions, escapeRegex) ?? [
+		"close",
+		"closes",
+		"closed",
+		"fix",
+		"fixes",
+		"fixed",
+		"resolve",
+		"resolves",
+		"resolved"
+	];
+	const joinedReferenceActions = referenceActions.join("|");
+	const issuePrefixes = trimStringArray(userOptions?.issuePrefixes, escapeRegex) ?? ["#"];
+	const joinedIssuePrefixes = issuePrefixes.join("|");
+	const noteKeywords = trimStringArray(userOptions?.noteKeywords, escapeRegex) ?? ["BREAKING CHANGE", "BREAKING-CHANGE"];
+	const joinedNoteKeywords = noteKeywords.join("|");
+	return {
+		subjectPattern: /^(?<type>\w+)(?:\((?<scope>.*)\))?(?<breakingChange>!)?:\s+(?<title>.*)/i,
+		mergePattern: /^Merge pull request #(?<id>\d*) from (?<source>.*)/i,
+		revertPattern: /^[Rr]evert "(?<subject>.*)"(\s*This reverts commit (?<hash>[a-zA-Z0-9]*)\.)?/,
+		commentPattern: /^#(?!\d+\s)/,
+		mentionPattern: /(?<!\w)@(?<username>[\w-]+)/,
+		referenceActions,
+		referenceActionPattern: joinedReferenceActions ? new RegExp(`(?<action>${joinedReferenceActions})(?:\\s+(?<reference>.*?))(?=(?:${joinedReferenceActions})|$)`) : void 0,
+		issuePrefixes,
+		issuePattern: joinedIssuePrefixes ? new RegExp(`(?:.*?)??\\s*(?<repository>[\\w-\\.\\/]*?)??(?<prefix>${joinedIssuePrefixes})(?<issue>[\\w-]*\\d+)`) : void 0,
+		noteKeywords,
+		notePattern: joinedNoteKeywords ? new RegExp(`^(?<title>${joinedNoteKeywords}):(\\s*(?<text>.*))`) : void 0
+	};
+}
+/**
+* Creates parser options by merging user-provided options with default values.
+*
+* Additionally, if a user provides a string for a property that expects a RegExp value,
+* the function will attempt to parse it into a RegExp object.
+*
+* @param userOptions Optional user-provided options to override the defaults.
+* @return A complete set of parser options with defaults applied and user overrides where specified.
+*/
+function createParserOptions(userOptions) {
+	const initialOptions = createDefaultParserOptions(userOptions);
+	if (userOptions) for (const key of Object.keys(userOptions)) {
+		const userValue = userOptions[key];
+		if (!(key in initialOptions)) continue;
+		if (Array.isArray(initialOptions[key])) continue;
+		if (initialOptions[key] instanceof RegExp) {
+			if (userValue instanceof RegExp) initialOptions[key] = userValue;
+			else if (typeof userValue === "string") {
+				const parsed = parseRegExpString(userValue);
+				if (parsed) initialOptions[key] = parsed;
+			} else if (userValue == void 0) initialOptions[key] = void 0;
+		}
+	}
+	return initialOptions;
+}
+//#endregion
+export { createParserOptions };

package/dist/commit-parser/parser-error.js

@@ -0,0 +1,14 @@
+//#region src/commit-parser/parser-error.ts
+/**
+* Error thrown when commit parser encounters an error.
+*/
+var ParserError = class extends Error {
+	detail;
+	constructor(message, detail) {
+		super(message);
+		this.name = "ParserError";
+		this.detail = detail;
+	}
+};
+//#endregion
+export { ParserError };

package/dist/commit-parser/types.d.ts

@@ -0,0 +1,53 @@
+//#region src/commit-parser/types.d.ts
+interface CommitMerge {
+  id: string;
+  source: string;
+}
+interface CommitRevert {
+  hash: string;
+  subject: string;
+}
+interface CommitReference {
+  prefix: string;
+  issue: string;
+  action: string | null;
+  owner: string | null;
+  repository: string | null;
+}
+interface CommitNote {
+  title: string;
+  text: string;
+}
+interface Commit {
+  raw: string;
+  subject: string;
+  body: string;
+  hash: string;
+  refNames: string;
+  /**
+   * Committer date in ISO 8601 format
+   * @example
+   * "2024-12-22T17:36:50Z"
+   */
+  date: string;
+  /**
+   * Committer name (respects .mailmap)
+   */
+  name: string;
+  /**
+   * Committer email (respects .mailmap)
+   */
+  email: string;
+  type: string;
+  scope: string;
+  breakingChange: string;
+  title: string;
+  merge: CommitMerge | null;
+  revert: CommitRevert | null;
+  mentions: string[];
+  references: CommitReference[];
+  notes: CommitNote[];
+  tags: string[];
+}
+//#endregion
+export { Commit, CommitMerge, CommitNote, CommitReference, CommitRevert };

package/dist/config/changelog-preset-config.js

@@ -0,0 +1,41 @@
+import { ChangelogPresetConfigSchema, ChangelogPresetConfigTypeSchema } from "./schema.js";
+import { z } from "zod";
+import conventionalChangelogConfigSpec from "conventional-changelog-config-spec";
+//#region src/config/changelog-preset-config.ts
+function getChangelogPresetConfig(mergedConfig, cliArguments, detectedChangelogOptions) {
+	const preset = { name: "conventionalcommits" };
+	if (typeof conventionalChangelogConfigSpec.properties === "object") Object.entries(conventionalChangelogConfigSpec.properties).forEach(([key, value]) => {
+		if ("default" in value && value.default !== void 0) {
+			if (mergedConfig?.changelogAll && key === "types") {
+				const parsedTypes = z.array(ChangelogPresetConfigTypeSchema).safeParse(value.default);
+				if (parsedTypes.success) {
+					parsedTypes.data.forEach((type) => {
+						if (!type.section) {
+							delete type.hidden;
+							type.section = "Other Changes";
+						}
+					});
+					preset[key] = parsedTypes.data;
+					return;
+				}
+			}
+			preset[key] = value.default;
+		}
+	});
+	if (detectedChangelogOptions) Object.entries(detectedChangelogOptions).forEach(([key, value]) => {
+		if (value !== void 0) preset[key] = value;
+	});
+	if (mergedConfig?.changelogPresetConfig && typeof mergedConfig.changelogPresetConfig === "object") Object.entries(mergedConfig.changelogPresetConfig).forEach(([key, value]) => {
+		if (value !== void 0) preset[key] = value;
+	});
+	if (mergedConfig?.releaseMessageSuffix && !cliArguments?.releaseMessageSuffix) preset.releaseCommitMessageFormat = `${preset.releaseCommitMessageFormat} ${mergedConfig.releaseMessageSuffix}`;
+	if (cliArguments?.commitUrlFormat) preset.commitUrlFormat = cliArguments.commitUrlFormat;
+	if (cliArguments?.compareUrlFormat) preset.compareUrlFormat = cliArguments.compareUrlFormat;
+	if (cliArguments?.issueUrlFormat) preset.issueUrlFormat = cliArguments.issueUrlFormat;
+	if (cliArguments?.userUrlFormat) preset.userUrlFormat = cliArguments.userUrlFormat;
+	if (cliArguments?.releaseCommitMessageFormat) preset.releaseCommitMessageFormat = cliArguments.releaseCommitMessageFormat;
+	if (cliArguments?.releaseMessageSuffix) preset.releaseCommitMessageFormat = `${preset.releaseCommitMessageFormat} ${cliArguments.releaseMessageSuffix}`;
+	return ChangelogPresetConfigSchema.passthrough().parse(preset);
+}
+//#endregion
+export { getChangelogPresetConfig };