fork-version 4.1.10 → 5.0.1

package/dist/process/changelog.d.ts

@@ -0,0 +1,7 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+
+//#region src/process/changelog.d.ts
+declare function updateChangelog(config: ForkConfig, logger: Logger, nextVersion: string): Promise<void>;
+//#endregion
+export { updateChangelog };

package/dist/process/changelog.js

@@ -0,0 +1,69 @@
+import { fileExists } from "../utils/file-state.js";
+import { resolve } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+import conventionalChangelog from "conventional-changelog";
+//#region src/process/changelog.ts
+/**
+* Matches the following changelog header formats:
+* - `## [1.2.3]`
+* - `<a name="1.2.3"></a>`
+*/
+const RELEASE_PATTERN = /(^#+ \[?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m;
+/**
+* Get the existing changelog content from the latest release onwards.
+* @see {@link RELEASE_PATTERN}
+*/
+function getOldReleaseContent(filePath, exists) {
+	if (exists) {
+		const fileContents = readFileSync(filePath, "utf-8");
+		const oldContentStart = fileContents.search(RELEASE_PATTERN);
+		if (oldContentStart !== -1) return fileContents.substring(oldContentStart);
+	}
+	return "";
+}
+/**
+* Generate the new changelog content for this release.
+*/
+function getNewReleaseContent(config, logger, nextVersion) {
+	return new Promise((onResolve) => {
+		let newContent = "";
+		conventionalChangelog({
+			preset: {
+				name: "conventionalcommits",
+				...config.changelogPresetConfig
+			},
+			tagPrefix: config.tagPrefix,
+			warn: (...message) => logger.debug("[conventional-changelog] ", ...message),
+			cwd: config.path
+		}, { version: nextVersion }, {
+			merges: null,
+			path: config.path
+		}).on("error", (cause) => {
+			throw new Error("[conventional-changelog] Unable to parse changes", { cause });
+		}).on("data", (chunk) => {
+			newContent += chunk.toString();
+		}).on("end", () => {
+			onResolve(newContent);
+		});
+	});
+}
+async function updateChangelog(config, logger, nextVersion) {
+	if (config.skipChangelog) {
+		logger.skipping("Skipping changelog update");
+		return;
+	}
+	if (config.header.search(RELEASE_PATTERN) !== -1) throw new Error("Header cannot contain release pattern");
+	const changelogPath = resolve(config.path, config.changelog);
+	if (!config.dryRun && !fileExists(changelogPath)) {
+		logger.log(`Creating changelog: ${changelogPath}`);
+		writeFileSync(changelogPath, "\n", "utf8");
+	} else logger.log(`Updating changelog: ${changelogPath}`);
+	const oldContent = getOldReleaseContent(changelogPath, fileExists(changelogPath));
+	const newContent = await getNewReleaseContent(config, logger, nextVersion);
+	if (!config.dryRun && newContent) writeFileSync(changelogPath, `${config.header}
+${newContent}
+${oldContent}
+`.trim(), "utf8");
+}
+//#endregion
+export { updateChangelog };

package/dist/process/commit.d.ts

@@ -0,0 +1,9 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+import { FileState } from "../files/file-manager.js";
+import { Git } from "../services/git.js";
+
+//#region src/process/commit.d.ts
+declare function commitChanges(config: ForkConfig, logger: Logger, git: Git, files: FileState[], nextVersion: string): Promise<void>;
+//#endregion
+export { commitChanges };

package/dist/process/commit.js

@@ -0,0 +1,22 @@
+import { fileExists } from "../utils/file-state.js";
+import { formatCommitMessage } from "../utils/format-commit-message.js";
+import { resolve } from "node:path";
+//#region src/process/commit.ts
+async function commitChanges(config, logger, git, files, nextVersion) {
+	if (config.skipCommit) {
+		logger.skipping("Skipping commit");
+		return;
+	}
+	logger.log("Committing changes");
+	const filesToCommit = [];
+	if (fileExists(resolve(config.path, config.changelog))) filesToCommit.push(resolve(config.path, config.changelog));
+	for (const file of files) filesToCommit.push(file.path);
+	if (filesToCommit.length === 0) return;
+	if (config.commitAll) await git.add("--all");
+	else await git.add(...filesToCommit);
+	const shouldVerify = config.verify ? void 0 : "--no-verify";
+	const shouldSign = config.sign ? "--gpg-sign" : "--no-gpg-sign";
+	await git.commit(shouldVerify, shouldSign, "--message", formatCommitMessage(config.changelogPresetConfig?.releaseCommitMessageFormat, nextVersion));
+}
+//#endregion
+export { commitChanges };

package/dist/process/get-commits.d.ts

@@ -0,0 +1,14 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+import { Git } from "../services/git.js";
+import { Commit } from "../commit-parser/types.js";
+
+//#region src/process/get-commits.d.ts
+interface CommitsSinceTag {
+  latestTag: string | undefined;
+  latestTagVersion: string | undefined;
+  commits: Commit[];
+}
+declare function getCommitsSinceTag(config: ForkConfig, logger: Logger, git: Git): Promise<CommitsSinceTag>;
+//#endregion
+export { CommitsSinceTag, getCommitsSinceTag };

package/dist/process/get-commits.js

@@ -0,0 +1,25 @@
+import { CommitParser } from "../commit-parser/commit-parser.js";
+import { filterRevertedCommits } from "../commit-parser/filter-reverted-commits.js";
+import { cleanTag } from "../utils/clean-tag.js";
+//#region src/process/get-commits.ts
+async function getCommitsSinceTag(config, logger, git) {
+	const commitParser = new CommitParser(config.commitParserOptions);
+	if (config.debug) commitParser.setLogger(logger);
+	const latestTag = await git.getMostRecentTag(config.tagPrefix);
+	if (!latestTag) logger.warn("No previous tag found, using all commits");
+	const foundCommits = await git.getCommits(latestTag, "HEAD");
+	const commits = foundCommits.reduce((acc, commit) => {
+		const parsed = commitParser.parse(commit);
+		if (parsed) acc.push(parsed);
+		return acc;
+	}, []);
+	const filteredCommits = filterRevertedCommits(commits);
+	logger.debug(`Found ${foundCommits.length} commits since tag: ${latestTag ?? "none"} (${commits.length} parsed, ${filteredCommits.length} after filtering reverts)`);
+	return {
+		latestTag,
+		latestTagVersion: cleanTag(latestTag, config.tagPrefix),
+		commits: filteredCommits
+	};
+}
+//#endregion
+export { getCommitsSinceTag };

package/dist/process/get-current-version.d.ts

@@ -0,0 +1,13 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+import { FileManager, FileState } from "../files/file-manager.js";
+import { Git } from "../services/git.js";
+
+//#region src/process/get-current-version.d.ts
+interface CurrentVersion {
+  version: string;
+  files: FileState[];
+}
+declare function getCurrentVersion(config: ForkConfig, logger: Logger, git: Git, fileManager: FileManager, filesToUpdate: string[], latestTagVersion: string | undefined): Promise<CurrentVersion>;
+//#endregion
+export { CurrentVersion, getCurrentVersion };

package/dist/process/get-current-version.js

@@ -0,0 +1,35 @@
+import semver from "semver";
+//#region src/process/get-current-version.ts
+async function getCurrentVersion(config, logger, git, fileManager, filesToUpdate, latestTagVersion) {
+	const files = [];
+	const versions = /* @__PURE__ */ new Set();
+	for (const file of filesToUpdate) {
+		if (await git.isIgnored(file)) {
+			logger.debug(`[Git Ignored] ${file}`);
+			continue;
+		}
+		const fileState = fileManager.read(file);
+		if (fileState) {
+			files.push(fileState);
+			if (!config.currentVersion) versions.add(fileState.version);
+		}
+	}
+	if (config.currentVersion) versions.add(config.currentVersion);
+	if (versions.size === 0 && config.gitTagFallback && latestTagVersion) {
+		logger.warn(`Using latest git tag as fallback`);
+		versions.add(latestTagVersion);
+	}
+	if (versions.size === 0) throw new Error("Unable to find current version");
+	else if (versions.size > 1) {
+		if (!config.allowMultipleVersions) throw new Error("Found multiple versions");
+		logger.warn(`Found multiple versions (${Array.from(versions).join(", ")}), using the higher semver version`);
+	}
+	const currentVersion = semver.rsort(Array.from(versions))[0];
+	logger.log(`Current version: ${currentVersion}`);
+	return {
+		files,
+		version: currentVersion
+	};
+}
+//#endregion
+export { getCurrentVersion };

package/dist/process/get-next-version.d.ts

@@ -0,0 +1,21 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+import { Commit } from "../commit-parser/types.js";
+import { ReleaseType } from "semver";
+
+//#region src/process/get-next-version.d.ts
+interface NextVersion {
+  version: string;
+  releaseType?: ReleaseType;
+  preMajor?: boolean;
+  changes?: {
+    major: number;
+    minor: number;
+    patch: number;
+    merges: number;
+    reverts: number;
+  };
+}
+declare function getNextVersion(config: ForkConfig, logger: Logger, commits: Commit[], currentVersion: string): Promise<NextVersion>;
+//#endregion
+export { NextVersion, getNextVersion };

package/dist/process/get-next-version.js

@@ -0,0 +1,72 @@
+import { getReleaseType } from "../utils/release-type.js";
+import semver from "semver";
+//#region src/process/get-next-version.ts
+async function getNextVersion(config, logger, commits, currentVersion) {
+	if (config.skipBump) {
+		logger.skipping(`Skipping bump, using ${currentVersion} as the next version`);
+		return { version: currentVersion };
+	}
+	if (config.nextVersion) {
+		if (!semver.valid(config.nextVersion)) throw new Error(`Invalid Version: ${config.nextVersion}`);
+		logger.log(`Next version: ${config.nextVersion}`);
+		return { version: config.nextVersion };
+	}
+	const isPreMajor = semver.lt(currentVersion, "1.0.0");
+	let releaseType = "patch";
+	const changes = {
+		major: 0,
+		minor: 0,
+		patch: 0,
+		merges: 0,
+		reverts: 0
+	};
+	if (config.releaseAs) releaseType = config.releaseAs;
+	else {
+		/**
+		* - 0 = major
+		* - 1 = minor
+		* - 2 = patch
+		*/
+		let level = 2;
+		const MINOR_TYPES = ["feat", "feature"];
+		for (const commit of commits) {
+			if (commit.merge) {
+				changes.merges += 1;
+				continue;
+			}
+			if (commit.revert) {
+				changes.reverts += 1;
+				continue;
+			}
+			if (commit.notes.length > 0 || commit.breakingChange) {
+				changes.major += commit.notes.length + (commit.breakingChange ? 1 : 0);
+				level = 0;
+			} else if (MINOR_TYPES.includes(commit.type.toLowerCase())) {
+				changes.minor += 1;
+				if (level === 2) level = 1;
+			} else changes.patch += 1;
+		}
+		if (isPreMajor && level < 2) {
+			level++;
+			changes.patch += changes.minor;
+			changes.minor = changes.major;
+			changes.major = 0;
+		}
+		if (level === 0) releaseType = "major";
+		else if (level === 1) releaseType = "minor";
+		else releaseType = "patch";
+	}
+	const releaseTypeOrPreRelease = getReleaseType(releaseType, currentVersion, config.preRelease);
+	const nextVersion = semver.inc(currentVersion, releaseTypeOrPreRelease, typeof config.preRelease === "string" ? config.preRelease : "") ?? "";
+	logger.log(`Next version: ${nextVersion} (${releaseTypeOrPreRelease})`);
+	if (commits.length > 0) logger.log(`  - Commits: ${commits.length}` + (changes.major > 0 ? `, Majors: ${changes.major}` : "") + (changes.minor > 0 ? `, Minors: ${changes.minor}` : "") + (changes.patch > 0 ? `, Patches: ${changes.patch}` : "") + (changes.reverts > 0 ? `, Reverts: ${changes.reverts}` : "") + (changes.merges > 0 ? `, Merges: ${changes.merges}` : ""));
+	else logger.log("  - No commits found.");
+	return {
+		version: nextVersion,
+		releaseType: releaseTypeOrPreRelease,
+		preMajor: isPreMajor,
+		changes
+	};
+}
+//#endregion
+export { getNextVersion };

package/dist/process/tag.d.ts

@@ -0,0 +1,8 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+import { Git } from "../services/git.js";
+
+//#region src/process/tag.d.ts
+declare function tagChanges(config: ForkConfig, logger: Logger, git: Git, nextVersion: string): Promise<void>;
+//#endregion
+export { tagChanges };

package/dist/process/tag.js

@@ -0,0 +1,15 @@
+import { formatCommitMessage } from "../utils/format-commit-message.js";
+//#region src/process/tag.ts
+async function tagChanges(config, logger, git, nextVersion) {
+	if (config.skipTag) {
+		logger.skipping("Skipping tag creation");
+		return;
+	}
+	/** @example "v1.2.3" or "version/1.2.3" */
+	const tag = `${config.tagPrefix}${nextVersion}`;
+	logger.log(`Creating tag: ${tag}`);
+	const shouldSign = config.sign ? "--sign" : "--no-sign";
+	await git.tag(shouldSign, "--annotate", tag, "--message", formatCommitMessage(config.changelogPresetConfig?.releaseCommitMessageFormat, nextVersion));
+}
+//#endregion
+export { tagChanges };

package/dist/services/git.d.ts

@@ -0,0 +1,141 @@
+import { ForkConfig } from "../config/types.js";
+
+//#region src/services/git.d.ts
+interface GitConfig {
+  path: ForkConfig["path"];
+  dryRun?: ForkConfig["dryRun"];
+}
+declare class Git {
+  #private;
+  constructor(config: GitConfig);
+  /**
+   * Add file contents to the index
+   *
+   * [git-add Documentation](https://git-scm.com/docs/git-add)
+   *
+   * @example
+   * ```ts
+   * await git.add("CHANGELOG.md");
+   * ```
+   */
+  add(...args: (string | undefined)[]): Promise<string>;
+  /**
+   * Record changes to the repository
+   *
+   * [git-commit Documentation](https://git-scm.com/docs/git-commit)
+   *
+   * @example
+   * ```ts
+   * await git.commit("--message", "chore(release): 1.2.3");
+   * ```
+   */
+  commit(...args: (string | undefined)[]): Promise<string>;
+  /**
+   * Create, list, delete or verify a tag object
+   *
+   * [git-tag Documentation](https://git-scm.com/docs/git-tag)
+   *
+   * @example
+   * ```ts
+   * await git.tag("--annotate", "v1.2.3", "--message", "chore(release): 1.2.3");
+   * ```
+   */
+  tag(...args: (string | undefined)[]): Promise<string>;
+  /**
+   * Show commit logs
+   *
+   * - [git-log Documentation](https://git-scm.com/docs/git-log)
+   * - [pretty-formats Documentation](https://git-scm.com/docs/pretty-formats)
+   *
+   * @example
+   * ```ts
+   * await git.log("--oneline");
+   * ```
+   */
+  log(...args: (string | undefined)[]): Promise<string>;
+  /**
+   * Check if a file is ignored by git
+   *
+   * [git-check-ignore Documentation](https://git-scm.com/docs/git-check-ignore)
+   *
+   * @example
+   * ```ts
+   * await git.isIgnored("src/my-file.txt");
+   * ```
+   */
+  isIgnored(file: string): Promise<boolean>;
+  /**
+   * Get the name of the current branch
+   *
+   * [git-rev-parse Documentation](https://git-scm.com/docs/git-rev-parse)
+   *
+   * @example
+   * ```ts
+   * await git.getBranchName(); // "main"
+   * ```
+   */
+  getBranchName(): Promise<string>;
+  /**
+   * Get the URL of the remote repository
+   *
+   * [git-config Documentation](https://git-scm.com/docs/git-config)
+   *
+   * @example
+   * ```ts
+   * await git.getRemoteUrl(); // "https://github.com/eglavin/fork-version"
+   * ```
+   */
+  getRemoteUrl(): Promise<string>;
+  /**
+   * `getTags` returns valid semver version tags in order of the commit history
+   *
+   * Using `git log` to get the commit history, we then parse the tags from the
+   * commit details which is expected to be in the following format:
+   * ```txt
+   * commit 3841b1d05750d42197fe958e3d8e06df378a842d (HEAD -> main, tag: v1.0.2, tag: v1.0.1, tag: v1.0.0)
+   * Author: Username <username@example.com>
+   * Date:   Sat Nov 9 15:00:00 2024 +0000
+   *
+   *     chore(release): v1.0.0
+   * ```
+   *
+   * - [Functionality extracted from the conventional-changelog - git-semver-tags project](https://github.com/conventional-changelog/conventional-changelog/blob/fac8045242099c016f5f3905e54e02b7d466bd7b/packages/git-semver-tags/index.js)
+   * - [conventional-changelog git-semver-tags MIT Licence](https://github.com/conventional-changelog/conventional-changelog/blob/fac8045242099c016f5f3905e54e02b7d466bd7b/packages/git-semver-tags/LICENSE.md)
+   *
+   * @example
+   * ```ts
+   * await git.getTags("v"); // ["v1.0.2", "v1.0.1", "v1.0.0"]
+   * ```
+   */
+  getTags(tagPrefix: string | undefined): Promise<string[]>;
+  /**
+   * Returns the most recent tag from the commit history, or `undefined` if no valid semver tags are found
+   *
+   * @example
+   * ```ts
+   * await git.getMostRecentTag("v"); // "1.2.3"
+   * ```
+   */
+  getMostRecentTag(tagPrefix: string | undefined): Promise<string | undefined>;
+  /**
+   * Get commit history in a parsable format
+   *
+   * An array of strings with commit details is returned in the following format:
+   * ```txt
+   * subject
+   * body
+   * hash
+   * committer date
+   * committer name
+   * committer email
+   * ```
+   *
+   * @example
+   * ```ts
+   * await git.getCommits("v1.0.0", "HEAD", "src/utils");
+   * ```
+   */
+  getCommits(from?: string, to?: string, ...paths: string[]): Promise<string[]>;
+}
+//#endregion
+export { Git };