fork-version 4.1.10 → 5.0.0

package/dist/services/git.js

@@ -0,0 +1,236 @@
+import { escapeRegex } from "../utils/escape-regex.js";
+import semver from "semver";
+import { execFile } from "node:child_process";
+//#region src/services/git.ts
+var Git = class {
+	#path;
+	#dryRun;
+	constructor(config) {
+		this.#path = config.path;
+		this.#dryRun = config.dryRun ?? false;
+		this.add = this.add.bind(this);
+		this.commit = this.commit.bind(this);
+		this.tag = this.tag.bind(this);
+		this.log = this.log.bind(this);
+		this.isIgnored = this.isIgnored.bind(this);
+		this.getBranchName = this.getBranchName.bind(this);
+		this.getRemoteUrl = this.getRemoteUrl.bind(this);
+		this.getTags = this.getTags.bind(this);
+		this.getMostRecentTag = this.getMostRecentTag.bind(this);
+		this.getCommits = this.getCommits.bind(this);
+	}
+	async #execGit(command, args) {
+		return new Promise((onResolve, onReject) => {
+			execFile("git", [command, ...args], {
+				cwd: this.#path,
+				maxBuffer: Infinity
+			}, (error, stdout, stderr) => {
+				if (error) onReject(error);
+				else onResolve(stdout ? stdout : stderr);
+			});
+		});
+	}
+	/**
+	* Add file contents to the index
+	*
+	* [git-add Documentation](https://git-scm.com/docs/git-add)
+	*
+	* @example
+	* ```ts
+	* await git.add("CHANGELOG.md");
+	* ```
+	*/
+	async add(...args) {
+		if (this.#dryRun) return "";
+		return this.#execGit("add", args.filter(Boolean));
+	}
+	/**
+	* 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");
+	* ```
+	*/
+	async commit(...args) {
+		if (this.#dryRun) return "";
+		return this.#execGit("commit", args.filter(Boolean));
+	}
+	/**
+	* 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");
+	* ```
+	*/
+	async tag(...args) {
+		if (this.#dryRun) return "";
+		return this.#execGit("tag", args.filter(Boolean));
+	}
+	/**
+	* 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");
+	* ```
+	*/
+	async log(...args) {
+		try {
+			return await this.#execGit("log", args.filter(Boolean));
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* 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");
+	* ```
+	*/
+	async isIgnored(file) {
+		try {
+			await this.#execGit("check-ignore", ["--no-index", file]);
+			return true;
+		} catch (_error) {
+			return false;
+		}
+	}
+	/**
+	* 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"
+	* ```
+	*/
+	async getBranchName() {
+		try {
+			return (await this.#execGit("rev-parse", ["--abbrev-ref", "HEAD"])).trim();
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* 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"
+	* ```
+	*/
+	async getRemoteUrl() {
+		try {
+			return (await this.#execGit("config", ["--get", "remote.origin.url"])).trim();
+		} catch (_error) {
+			return "";
+		}
+	}
+	/**
+	* `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"]
+	* ```
+	*/
+	async getTags(tagPrefix) {
+		const logOutput = await this.log("--decorate", "--no-color", "--date-order");
+		/**
+		* Search for tags in the following formats:
+		* @example "tag: 1.2.3," or "tag: 1.2.3)"
+		*/
+		const TAG_REGEX = /tag:\s*(?<tag>.+?)[,)]/gi;
+		const tags = [];
+		const escapedTagPrefix = tagPrefix ? escapeRegex(tagPrefix) : void 0;
+		let tagMatch = null;
+		while (tagMatch = TAG_REGEX.exec(logOutput)) {
+			const { tag = "" } = tagMatch.groups ?? {};
+			if (tagPrefix) {
+				if (tag.startsWith(tagPrefix)) {
+					const tagWithoutPrefix = tag.replace(new RegExp(`^${escapedTagPrefix}`), "");
+					if (semver.valid(tagWithoutPrefix)) tags.push(tag);
+				}
+			} else if (/^\d/.test(tag) && semver.valid(tag)) tags.push(tag);
+		}
+		return tags;
+	}
+	/**
+	* 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"
+	* ```
+	*/
+	async getMostRecentTag(tagPrefix) {
+		return (await this.getTags(tagPrefix))[0] || void 0;
+	}
+	/**
+	* 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");
+	* ```
+	*/
+	async getCommits(from = "", to = "HEAD", ...paths) {
+		const SCISSOR = "^----------- FORK VERSION -----------^";
+		const LOG_FORMAT = [
+			"%s",
+			"%b",
+			"%H",
+			"%d",
+			"%cI",
+			"%cN",
+			"%cE",
+			SCISSOR
+		].join("%n");
+		const splitCommits = (await this.log(`--format=${LOG_FORMAT}`, [from, to].filter(Boolean).join(".."), paths.length ? "--" : "", ...paths)).split(`\n${SCISSOR}\n`);
+		if (splitCommits.length === 0) return splitCommits;
+		if (splitCommits[0] === SCISSOR) splitCommits.shift();
+		if (splitCommits[splitCommits.length - 1] === "") splitCommits.pop();
+		return splitCommits;
+	}
+};
+//#endregion
+export { Git };

package/dist/services/logger.d.ts

@@ -0,0 +1,18 @@
+import { ForkConfig } from "../config/types.js";
+
+//#region src/services/logger.d.ts
+interface LoggerConfig {
+  silent?: ForkConfig["silent"];
+  debug?: ForkConfig["debug"];
+}
+declare class Logger {
+  #private;
+  constructor(config: LoggerConfig);
+  log(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+  debug(message: string, ...optionalParams: any[]): void;
+  skipping(message: string): void;
+}
+//#endregion
+export { Logger };

package/dist/services/logger.js

@@ -0,0 +1,35 @@
+import { styleText } from "node:util";
+//#region src/services/logger.ts
+var Logger = class {
+	#silent;
+	#debug;
+	constructor(config) {
+		this.#silent = config.silent ?? false;
+		this.#debug = config.debug ?? false;
+		this.log = this.log.bind(this);
+		this.warn = this.warn.bind(this);
+		this.error = this.error.bind(this);
+		this.debug = this.debug.bind(this);
+		this.skipping = this.skipping.bind(this);
+	}
+	log(message) {
+		if (!this.#silent) console.log(message);
+	}
+	warn(message) {
+		if (!this.#silent) console.warn(styleText("yellowBright", message));
+	}
+	error(message) {
+		if (!this.#silent) console.error(styleText("redBright", message));
+	}
+	debug(message, ...optionalParams) {
+		if (!this.#silent && this.#debug) {
+			console.debug(styleText("cyanBright", message));
+			if (optionalParams.length > 0) console.debug(...optionalParams);
+		}
+	}
+	skipping(message) {
+		if (!this.#silent) console.log(styleText("magenta", message));
+	}
+};
+//#endregion
+export { Logger };

package/dist/utils/clean-tag.js

@@ -0,0 +1,21 @@
+import { escapeRegex } from "./escape-regex.js";
+import semver from "semver";
+//#region src/utils/clean-tag.ts
+/**
+* Cleans a git tag by removing the specified prefix and ensuring it's a valid semver version.
+*
+* @example
+* ```ts
+* cleanTag("v1.2.3", "v"); // "1.2.3"
+* cleanTag("release-2.0.0", "release-"); // "2.0.0"
+* cleanTag("1.0.0"); // "1.0.0"
+* ```
+*/
+function cleanTag(tag, tagPrefix) {
+	if (!tag) return void 0;
+	const escapedTagPrefix = tagPrefix ? escapeRegex(tagPrefix) : void 0;
+	const tagWithoutPrefix = escapedTagPrefix ? tag.replace(new RegExp(`^${escapedTagPrefix}`), "") : tag;
+	return semver.clean(tagWithoutPrefix) ?? void 0;
+}
+//#endregion
+export { cleanTag };

package/dist/utils/escape-regex.js

@@ -0,0 +1,17 @@
+//#region src/utils/escape-regex.ts
+/**
+* Escapes special characters in a string for use in a regular expression.
+*
+* @example
+* ```ts
+* escapeRegex("Hello. How are you?"); // "Hello\. How are you\?"
+* ```
+*
+* @param input The string to be escaped for use in a regular expression.
+* @returns The escaped string, safe for use in a regular expression.
+*/
+function escapeRegex(input) {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+export { escapeRegex };

package/dist/utils/file-state.js

@@ -0,0 +1,19 @@
+import { lstatSync } from "node:fs";
+//#region src/utils/file-state.ts
+/**
+* Determine if a file exists.
+* @example
+* ```ts
+* fileExists("~/.bashrc"); // true
+* fileExists("~/missing-file.txt"); // false
+* ```
+*/
+function fileExists(filePath) {
+	try {
+		return lstatSync(filePath).isFile();
+	} catch (_error) {
+		return false;
+	}
+}
+//#endregion
+export { fileExists };

package/dist/utils/format-commit-message.js

@@ -0,0 +1,13 @@
+//#region src/utils/format-commit-message.ts
+/**
+* Formats the commit message by replacing the `{{currentTag}}` placeholder
+* globally with the new version.
+*
+* Falls back to `chore(release): {{currentTag}}` if message is argument is falsy.
+*/
+function formatCommitMessage(message, version) {
+	if (!message) message = "chore(release): {{currentTag}}";
+	return message.replace(/* @__PURE__ */ new RegExp("{{currentTag}}", "g"), version);
+}
+//#endregion
+export { formatCommitMessage };

package/dist/utils/parse-regexp-string.js

@@ -0,0 +1,31 @@
+//#region src/utils/parse-regexp-string.ts
+/**
+* Parses a string into a RegExp object. If the string is in the form of a regular expression literal
+* (e.g., "/pattern/flags"), it will be parsed accordingly. Otherwise, it will be treated as a
+* plain string pattern.
+*
+* @example
+* ```ts
+* parseRegExpString("/abc/i"); // returns a valid RegExp object with pattern "abc" and flag "i"
+* parseRegExpString("abc"); // returns a RegExp object with pattern "abc" and no flags
+* parseRegExpString("[unclosed"); // returns null due to invalid regex
+* ```
+*
+* @param input The string to parse into a RegExp object.
+* @returns A RegExp object if parsing is successful, or null if the input is invalid.
+*/
+function parseRegExpString(input) {
+	const literal = /^\/(.+)\/([a-z]*)$/i.exec(input);
+	if (literal) try {
+		return new RegExp(literal[1], literal[2]);
+	} catch {
+		return null;
+	}
+	try {
+		return new RegExp(input);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { parseRegExpString };

package/dist/utils/release-type.js

@@ -0,0 +1,47 @@
+import semver from "semver";
+//#region src/utils/release-type.ts
+/**
+* Get the priority of given type.
+* @example
+* - "patch" => 0
+* - "minor" => 1
+* - "major" => 2
+*/
+function getPriority(type) {
+	return [
+		"patch",
+		"minor",
+		"major"
+	].indexOf(type ?? "");
+}
+/**
+* Get the given versions highest state.
+* @example
+* - "patch"
+* - "minor"
+* - "major"
+*/
+function getVersionType(version) {
+	const parseVersion = semver.parse(version);
+	if (parseVersion?.major) return "major";
+	else if (parseVersion?.minor) return "minor";
+	else if (parseVersion?.patch) return "patch";
+}
+/**
+* Get the recommended release type for the given version depending on if
+* the user asks for a prerelease with or without a tag.
+* ```js
+* getReleaseType("patch", "1.0.0", false) => "patch"
+* getReleaseType("major", "0.0.0-beta", "beta") => "premajor"
+* ```
+*/
+function getReleaseType(releaseType, currentVersion, preReleaseTag) {
+	if (!preReleaseTag) return releaseType;
+	if (Array.isArray(semver.prerelease(currentVersion))) {
+		const currentReleaseType = getVersionType(currentVersion);
+		if (currentReleaseType === releaseType || getPriority(currentReleaseType) > getPriority(releaseType)) return "prerelease";
+	}
+	return `pre${releaseType}`;
+}
+//#endregion
+export { getReleaseType };

package/dist/utils/trim-string-array.js

@@ -0,0 +1,20 @@
+//#region src/utils/trim-string-array.ts
+/**
+* Trims whitespace from each string in the provided array and optionally applies a transformation function to each item.
+* If the resulting array is empty after trimming, it returns undefined.
+*
+* @param array The array of strings to be trimmed and transformed.
+* @param transformFn Optional function to apply to each trimmed item (e.g., for escaping regex characters).
+* @returns A new array of trimmed (and optionally transformed) strings, or undefined if the resulting array is empty.
+*/
+function trimStringArray(array, transformFn) {
+	const items = [];
+	if (Array.isArray(array)) for (const item of array) {
+		const _item = item.trim();
+		if (_item) items.push(transformFn ? transformFn(_item) : _item);
+	}
+	if (items.length === 0) return;
+	return items;
+}
+//#endregion
+export { trimStringArray };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fork-version",
-  "version": "4.1.10",
+  "version": "5.0.0",
   "license": "MIT",
   "description": "Fork-Version automates version control tasks such as determining, updating, and committing versions, files, and changelogs, simplifying the process when adhering to the conventional commit standard.",
   "keywords": [
@@ -35,30 +35,10 @@
   },
   "private": false,
   "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    },
-    "./cli": {
-      "import": {
-        "types": "./dist/cli.d.ts",
-        "default": "./dist/cli.js"
-      },
-      "require": {
-        "types": "./dist/cli.d.cts",
-        "default": "./dist/cli.cjs"
-      }
-    },
+    ".": "./dist/index.js",
+    "./cli": "./dist/cli.js",
     "./package.json": "./package.json"
   },
   "bin": {
@@ -71,10 +51,10 @@
   ],
   "scripts": {
     "fork-version": "node dist/cli.js",
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "update-json-schema": "node scripts/update-json-schema.js",
-    "update-readme-cli-options": "node scripts/update-readme-cli-options.js",
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "update-json-schema": "node scripts/update-json-schema.ts",
+    "update-readme-cli-options": "node scripts/update-readme-cli-options.ts",
     "lint": "eslint --fix \"src/**/*.{js,ts}\"",
     "lint:check": "eslint \"src/**/*.{js,ts}\"",
     "lint:format": "prettier --write \"src/**/*.{js,ts}\"",
@@ -100,6 +80,7 @@
     "zod": "4.3.6"
   },
   "devDependencies": {
+    "@arethetypeswrong/core": "0.18.2",
     "@eslint/js": "10.0.1",
     "@types/json-schema": "7.0.15",
     "@types/node": "24.11.0",
@@ -111,9 +92,10 @@
     "eslint-plugin-prettier": "5.5.5",
     "globals": "17.4.0",
     "prettier": "3.8.1",
+    "publint": "0.3.18",
     "rimraf": "6.1.3",
-    "tsup": "8.5.1",
-    "typescript": "5.9.3",
+    "tsdown": "0.21.7",
+    "typescript": "6.0.2",
     "typescript-eslint": "8.58.0",
     "vitest": "4.1.2"
   }