fork-version 5.0.2 → 5.1.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Fork Version
 
+## [5.1.1](https://github.com/eglavin/fork-version/compare/v5.1.0...v5.1.1) (2026-04-12)
+
+
+### Docs
+
+* add all files and custom file manager examples ([43c85a4](https://github.com/eglavin/fork-version/commit/43c85a482906f73c7b45a28a522bec150b3f2cff))
+* update build metadata info in readme ([e03c362](https://github.com/eglavin/fork-version/commit/e03c362094b7f0685fd386c7754f705a4d727472))
+
+
+### Refactor
+
+* move build metadata out of yaml class ([59627fc](https://github.com/eglavin/fork-version/commit/59627fc903bcd5aae1b44954fd6183417025a2f3))
+
+
+## [5.1.0](https://github.com/eglavin/fork-version/compare/v5.0.2...v5.1.0) (2026-04-11)
+
+
+### Features
+
+* implement custom user provided file managers ([9c6ed7c](https://github.com/eglavin/fork-version/commit/9c6ed7ccf39c736dfdb53b959f989c4139892523))
+
+
+### Docs
+
+* update readme with details on using custom file managers ([57a6f17](https://github.com/eglavin/fork-version/commit/57a6f174473992b113c47acee53f24a82db4e56d))
+
+
+### Refactor
+
+* remove name property from file managers ([202fc21](https://github.com/eglavin/fork-version/commit/202fc21c49f13081d352f2e5c549a8ea3c68de7f))
+* use loose object when validating custom file managers ([3b3f8a9](https://github.com/eglavin/fork-version/commit/3b3f8a92d082d9374f6fba8acd39655cc7405e39))
+
+
+### Test
+
+* add custom file manager object test ([6b58f40](https://github.com/eglavin/fork-version/commit/6b58f404ce6c4059ab43dfe2ccc3a189ae098f65))
+
+
 ## [5.0.2](https://github.com/eglavin/fork-version/compare/v5.0.1...v5.0.2) (2026-04-10)
 
 

package/README.md

@@ -292,36 +292,37 @@ Alternatively you can define your config using a key in your `package.json` file
 
 #### Config Properties
 
-| Property                                              | Type             | Default                 | Description                                                                                                         |
-| :---------------------------------------------------- | :--------------- | :---------------------- | :------------------------------------------------------------------------------------------------------------------ |
-| command                                               | string           | `main`                  | The command to run. Can be one of: main, inspect-version, inspect-tag, validate-config. Defaults to main.           |
-| [files](#configfiles)                                 | Array\<string>   | `["package.json", ...]` | List of the files to be updated                                                                                     |
-| [glob](#configglob)                                   | string           | -                       | Glob pattern to match files to be updated                                                                           |
-| path                                                  | string           | `process.cwd()`         | The path Fork-Version will run from                                                                                 |
-| changelog                                             | string           | `CHANGELOG.md`          | Name of the changelog file                                                                                          |
-| header                                                | string           | `# Changelog...`        | The header text for the changelog                                                                                   |
-| [tagPrefix](#configtagprefix)                         | string           | `v`                     | Prefix for the created tag                                                                                          |
-| [preRelease](#configprerelease)                       | string / boolean | -                       | Make a pre-release with optional label if given value is a string                                                   |
-| currentVersion                                        | string           | -                       | Use this version instead of trying to determine one                                                                 |
-| nextVersion                                           | string           | -                       | Attempt to update to this version, instead of incrementing using "conventional-commit"                              |
-| [releaseAs](#configreleaseas)                         | string           | -                       | Release as increments the version by the specified level. Overrides the default behaviour of "conventional-commit". |
-| allowMultipleVersions                                 | boolean          | true                    | Don't throw an error if multiple versions are found in the given files.                                             |
-| commitAll                                             | boolean          | false                   | Commit all changes, not just files updated by Fork-Version                                                          |
-| changelogAll                                          | boolean          | false                   | If this flag is set, all default commit types will be added to the changelog, not just `feat` and `fix`.            |
-| debug                                                 | boolean          | false                   | Output debug information                                                                                            |
-| dryRun                                                | boolean          | false                   | No output will be written to disk or committed                                                                      |
-| silent                                                | boolean          | false                   | Run without logging to the terminal                                                                                 |
-| gitTagFallback                                        | boolean          | true                    | If unable to find a version in the given files, fallback and attempt to use the latest git tag                      |
-| sign                                                  | boolean          | false                   | Sign the commit with the systems GPG key                                                                            |
-| verify                                                | boolean          | false                   | Run user defined git hooks before committing                                                                        |
-| asJson                                                | boolean          | false                   | Print inspected output as a parsable json string                                                                    |
-| skipBump                                              | boolean          | false                   | Skip the bump step                                                                                                  |
-| skipChangelog                                         | boolean          | false                   | Skip the changelog step                                                                                             |
-| skipCommit                                            | boolean          | false                   | Skip the commit step                                                                                                |
-| skipTag                                               | boolean          | false                   | Skip the tag step                                                                                                   |
-| [changelogPresetConfig](#configchangelogpresetconfig) | object           | {}                      | Override defaults from the "conventional-changelog-conventionalcommits" preset configuration                        |
-| releaseMessageSuffix                                  | string           | -                       | Add a suffix to the end of the release message                                                                      |
-| [commitParserOptions](#configcommitparseroptions)     | object           | {}                      | Options to pass to commits parser                                                                                   |
+| Property                                              | Type                 | Default                 | Description                                                                                                         |
+| :---------------------------------------------------- | :------------------- | :---------------------- | :------------------------------------------------------------------------------------------------------------------ |
+| command                                               | string               | `main`                  | The command to run. Can be one of: main, inspect-version, inspect-tag, validate-config. Defaults to main.           |
+| [files](#configfiles)                                 | Array\<string>       | `["package.json", ...]` | List of the files to be updated                                                                                     |
+| [customFileManagers](#custom-file-updaters)           | Array\<IFileManager> | -                       | Support for user provided custom file managers                                                                      |
+| [glob](#configglob)                                   | string               | -                       | Glob pattern to match files to be updated                                                                           |
+| path                                                  | string               | `process.cwd()`         | The path Fork-Version will run from                                                                                 |
+| changelog                                             | string               | `CHANGELOG.md`          | Name of the changelog file                                                                                          |
+| header                                                | string               | `# Changelog...`        | The header text for the changelog                                                                                   |
+| [tagPrefix](#configtagprefix)                         | string               | `v`                     | Prefix for the created tag                                                                                          |
+| [preRelease](#configprerelease)                       | string / boolean     | -                       | Make a pre-release with optional label if given value is a string                                                   |
+| currentVersion                                        | string               | -                       | Use this version instead of trying to determine one                                                                 |
+| nextVersion                                           | string               | -                       | Attempt to update to this version, instead of incrementing using "conventional-commit"                              |
+| [releaseAs](#configreleaseas)                         | string               | -                       | Release as increments the version by the specified level. Overrides the default behaviour of "conventional-commit". |
+| allowMultipleVersions                                 | boolean              | true                    | Don't throw an error if multiple versions are found in the given files.                                             |
+| commitAll                                             | boolean              | false                   | Commit all changes, not just files updated by Fork-Version                                                          |
+| changelogAll                                          | boolean              | false                   | If this flag is set, all default commit types will be added to the changelog, not just `feat` and `fix`.            |
+| debug                                                 | boolean              | false                   | Output debug information                                                                                            |
+| dryRun                                                | boolean              | false                   | No output will be written to disk or committed                                                                      |
+| silent                                                | boolean              | false                   | Run without logging to the terminal                                                                                 |
+| gitTagFallback                                        | boolean              | true                    | If unable to find a version in the given files, fallback and attempt to use the latest git tag                      |
+| sign                                                  | boolean              | false                   | Sign the commit with the systems GPG key                                                                            |
+| verify                                                | boolean              | false                   | Run user defined git hooks before committing                                                                        |
+| asJson                                                | boolean              | false                   | Print inspected output as a parsable json string                                                                    |
+| skipBump                                              | boolean              | false                   | Skip the bump step                                                                                                  |
+| skipChangelog                                         | boolean              | false                   | Skip the changelog step                                                                                             |
+| skipCommit                                            | boolean              | false                   | Skip the commit step                                                                                                |
+| skipTag                                               | boolean              | false                   | Skip the tag step                                                                                                   |
+| [changelogPresetConfig](#configchangelogpresetconfig) | object               | {}                      | Override defaults from the "conventional-changelog-conventionalcommits" preset configuration                        |
+| releaseMessageSuffix                                  | string               | -                       | Add a suffix to the end of the release message                                                                      |
+| [commitParserOptions](#configcommitparseroptions)     | object               | {}                      | Options to pass to commits parser                                                                                   |
 
 ##### config.files
 
@@ -337,7 +338,7 @@ By default Fork-Version will attempt to read versions from and update these file
 - "manifest.json"
 - "bower.json"
 
-See the [Supported File Types](#supported-file-types) section below to see the currently supported file types.
+See the [Supported File Types](#supported-file-types) section below to see the currently supported file types and the [Custom File Updater's](#custom-file-updaters) section below to see how to support other file types.
 
 ##### config.glob
 
@@ -469,6 +470,16 @@ If you are using one of the following Git hosts, Fork-Version will automatically
 - [MS Build](#ms-build)
 - [ARM Bicep](#arm-bicep)
 - [Install Shield ISM](#install-shield-ism)
+- [Custom File Updater's](#custom-file-updaters)
+
+> [!Note]
+> If your version strings include build metadata like one of the following examples:
+>
+> - 1.2.3+49a3f2b
+> - 1.2.3-0+49a3f2b
+> - 1.2.3-alpha.0+49a3f2b
+>
+> this metadata will be retained without modification.
 
 #### Json Package
 
@@ -493,9 +504,6 @@ publish_to: 'none'
 version: 1.2.3
 ```
 
-> [!NOTE]
-> If you're using Fork-Version for a flutter project, Fork-Version will split the version and the builder number on the "+" character, the version will be updated and the builder number will be left as is.
-
 #### Plain Text
 
 A plain text file is a file which contains just the version as the content. Files that end with `version.txt` will be treated as a plain text version file.
@@ -546,7 +554,69 @@ An Install Shield `*.ism` file can be either binary or an xml file. Fork-Version
 
 #### Custom File Updater's
 
-`TODO` [add support for custom file readers and writers through config #5](https://github.com/eglavin/fork-version/issues/5)
+***Released in version 5.1.0***
+
+If you have a file type that isn't supported by default, you can create a custom file manager to read and write the updated version to that file.
+
+To do this you will need to create a class or an object that implements the `IFileManager` interface and add an instance of that class or object to the `customFileManagers` array in your config.
+
+The following example show a custom file manager for a json file with the name of `test.json` with the following structure:
+
+Example `test.json` file:
+
+```json
+{
+  "package": {
+    "version": "1.2.3"
+  }
+}
+```
+
+Example Custom File Manager implementation:
+
+```ts
+// fork.config.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { defineConfig, MissingPropertyException, type FileState, type IFileManager } from "fork-version";
+
+class CustomFileManager implements IFileManager {
+  async read(filePath: string): Promise<FileState | undefined> {
+    const fileContent = await readFile(filePath, "utf-8");
+    if (fileContent) {
+      const parsedContent = JSON.parse(fileContent);
+      if ("package" in parsedContent && "version" in parsedContent.package) {
+        return {
+          path: filePath,
+          version: parsedContent.package.version,
+        };
+      }
+    }
+    throw new MissingPropertyException("My Custom File", "package.version");
+  }
+
+  async write(fileState: FileState, newVersion: string): Promise<void> {
+    const fileContent = await readFile(fileState.path, "utf-8");
+    if (fileContent) {
+      const parsedContent = JSON.parse(fileContent);
+      if ("package" in parsedContent && "version" in parsedContent.package) {
+        parsedContent.package.version = newVersion;
+        const updatedContent = JSON.stringify(parsedContent, null, 2);
+        await writeFile(fileState.path, updatedContent, "utf-8");
+      }
+    }
+  }
+
+  isSupportedFile(fileName: string) {
+    return fileName === "test.json";
+  }
+}
+
+export default defineConfig({
+  customFileManagers: [new CustomFileManager()],
+});
+```
+
+> [See `IFileManager` interface to see the required methods and properties for a custom file manager.](./src/files/file-manager.ts)
 
 ### Code Usage
 

package/dist/cli.js

@@ -30,7 +30,7 @@ async function runFork() {
 			const result = await main(config, logger, fileManager, git);
 			const branchName = await git.getBranchName();
 			logger.log(`\nRun \`git push --follow-tags origin ${branchName}\` to push the changes and the tag.`);
-			if (result.current.files.some((file) => file.name === "package.json" && !file.isPrivate)) {
+			if (result.current.files.some((file) => file.path.endsWith("package.json") && !file.isPrivate)) {
 				const npmTag = typeof config.preRelease === "string" ? config.preRelease : "prerelease";
 				logger.log(`${result.next.releaseType}`.startsWith("pre") ? `Run \`npm publish --tag ${npmTag}\` to publish the package.` : "Run `npm publish` to publish the package.");
 			}

package/dist/commands/inspect.d.ts

@@ -1,6 +1,6 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
 import { FileManager } from "../files/file-manager.js";
+import { ForkConfig } from "../config/types.js";
 import { Git } from "../services/git.js";
 
 //#region src/commands/inspect.d.ts

package/dist/commands/main.d.ts

@@ -1,6 +1,6 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
 import { FileManager } from "../files/file-manager.js";
+import { ForkConfig } from "../config/types.js";
 import { Git } from "../services/git.js";
 import { CommitsSinceTag } from "../process/get-commits.js";
 import { CurrentVersion } from "../process/get-current-version.js";

package/dist/commands/main.js

@@ -14,7 +14,7 @@ async function main(config, logger, fileManager, git) {
 	logger.log("Updating files: ");
 	for (const outFile of current.files) {
 		logger.log(`  - ${outFile.path}`);
-		fileManager.write(outFile, next.version);
+		await fileManager.write(outFile, next.version);
 	}
 	await updateChangelog(config, logger, next.version);
 	await commitChanges(config, logger, git, current.files, next.version);

package/dist/config/load-config.js

@@ -1,6 +1,6 @@
-import { ForkConfigSchema } from "./schema.js";
+import { ForkConfigJSONSchema, ForkConfigJSSchema } from "./schema.js";
 import { parse } from "node:path";
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import JoyCon from "joycon";
 import { bundleRequire } from "bundle-require";
 //#region src/config/load-config.ts
@@ -23,21 +23,21 @@ async function loadConfigFile(cwd) {
 	]);
 	if (!configFilePath) return {};
 	if (configFilePath.endsWith("json")) {
-		const fileContent = JSON.parse(readFileSync(configFilePath).toString());
+		const fileContent = JSON.parse(await readFile(configFilePath, "utf8"));
 		if (configFilePath.endsWith("package.json")) {
 			if (fileContent[PACKAGE_JSON_CONFIG_KEY] && typeof fileContent[PACKAGE_JSON_CONFIG_KEY] === "object") {
-				const parsed = ForkConfigSchema.partial().safeParse(fileContent[PACKAGE_JSON_CONFIG_KEY]);
+				const parsed = ForkConfigJSONSchema.partial().safeParse(fileContent[PACKAGE_JSON_CONFIG_KEY]);
 				if (!parsed.success) throw new Error(`Validation error in: ${configFilePath}`, { cause: parsed.error });
 				return parsed.data;
 			}
 			return {};
 		}
-		const parsed = ForkConfigSchema.partial().safeParse(fileContent);
+		const parsed = ForkConfigJSONSchema.partial().safeParse(fileContent);
 		if (!parsed.success) throw new Error(`Validation error in: ${configFilePath}`, { cause: parsed.error });
 		return parsed.data;
 	}
 	const fileContent = await bundleRequire({ filepath: configFilePath });
-	const parsed = ForkConfigSchema.partial().safeParse(fileContent.mod.default || fileContent.mod);
+	const parsed = ForkConfigJSSchema.partial().safeParse(fileContent.mod.default || fileContent.mod);
 	if (!parsed.success) throw new Error(`Validation error in: ${configFilePath}`, { cause: parsed.error });
 	return parsed.data;
 }

package/dist/config/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 //#region src/config/schema.d.ts
-declare const ForkConfigSchema: z.ZodObject<{
+declare const ForkConfigJSONSchema: z.ZodObject<{
   command: z.ZodLiteral<"main" | "inspect" | "inspect-version" | "inspect-tag" | "validate-config">;
   inspectVersion: z.ZodOptional<z.ZodBoolean>;
   files: z.ZodArray<z.ZodString>;
@@ -46,5 +46,55 @@ declare const ForkConfigSchema: z.ZodObject<{
   releaseMessageSuffix: z.ZodOptional<z.ZodString>;
   commitParserOptions: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
 }, z.core.$strip>;
+declare const ForkConfigJSSchema: z.ZodObject<{
+  command: z.ZodOptional<z.ZodLiteral<"main" | "inspect" | "inspect-version" | "inspect-tag" | "validate-config">>;
+  inspectVersion: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+  files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  glob: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  path: z.ZodOptional<z.ZodString>;
+  changelog: z.ZodOptional<z.ZodString>;
+  header: z.ZodOptional<z.ZodString>;
+  tagPrefix: z.ZodOptional<z.ZodString>;
+  preRelease: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>>;
+  currentVersion: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  nextVersion: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  releaseAs: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"major">, z.ZodLiteral<"minor">, z.ZodLiteral<"patch">]>>>;
+  allowMultipleVersions: z.ZodOptional<z.ZodBoolean>;
+  commitAll: z.ZodOptional<z.ZodBoolean>;
+  changelogAll: z.ZodOptional<z.ZodBoolean>;
+  debug: z.ZodOptional<z.ZodBoolean>;
+  dryRun: z.ZodOptional<z.ZodBoolean>;
+  silent: z.ZodOptional<z.ZodBoolean>;
+  gitTagFallback: z.ZodOptional<z.ZodBoolean>;
+  sign: z.ZodOptional<z.ZodBoolean>;
+  verify: z.ZodOptional<z.ZodBoolean>;
+  asJson: z.ZodOptional<z.ZodBoolean>;
+  skipBump: z.ZodOptional<z.ZodBoolean>;
+  skipChangelog: z.ZodOptional<z.ZodBoolean>;
+  skipCommit: z.ZodOptional<z.ZodBoolean>;
+  skipTag: z.ZodOptional<z.ZodBoolean>;
+  detectedGitHost: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  changelogPresetConfig: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+    types: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      scope: z.ZodOptional<z.ZodString>;
+      section: z.ZodOptional<z.ZodString>;
+      hidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    commitUrlFormat: z.ZodOptional<z.ZodString>;
+    compareUrlFormat: z.ZodOptional<z.ZodString>;
+    issueUrlFormat: z.ZodOptional<z.ZodString>;
+    userUrlFormat: z.ZodOptional<z.ZodString>;
+    releaseCommitMessageFormat: z.ZodOptional<z.ZodString>;
+    issuePrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  releaseMessageSuffix: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  commitParserOptions: z.ZodOptional<z.ZodOptional<z.ZodObject<{}, z.core.$loose>>>;
+  customFileManagers: z.ZodArray<z.ZodObject<{
+    read: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    write: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    isSupportedFile: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  }, z.core.$loose>>;
+}, z.core.$strip>;
 //#endregion
-export { ForkConfigSchema };
+export { ForkConfigJSONSchema, ForkConfigJSSchema };

package/dist/config/schema.js

@@ -15,7 +15,7 @@ const ChangelogPresetConfigSchema = z.object({
 	releaseCommitMessageFormat: z.string().describe("A string to be used to format the auto-generated release commit message."),
 	issuePrefixes: z.array(z.string()).describe("List of prefixes used to detect references to issues.")
 });
-const ForkConfigSchema = z.object({
+const ForkConfigJSONSchema = z.object({
 	command: z.literal([
 		"main",
 		"inspect",
@@ -57,5 +57,11 @@ const ForkConfigSchema = z.object({
 	releaseMessageSuffix: z.string().optional().describe("Add a suffix to the release commit message."),
 	commitParserOptions: z.looseObject({}).optional().describe("Options to pass to commits parser.")
 });
+const CustomFileManagerSchema = z.looseObject({
+	read: z.function(),
+	write: z.function(),
+	isSupportedFile: z.function()
+});
+const ForkConfigJSSchema = ForkConfigJSONSchema.partial().extend({ customFileManagers: z.array(CustomFileManagerSchema).describe("List of custom file managers to use. See documentation for details.") });
 //#endregion
-export { ChangelogPresetConfigSchema, ChangelogPresetConfigTypeSchema, ForkConfigSchema };
+export { ChangelogPresetConfigSchema, ChangelogPresetConfigTypeSchema, ForkConfigJSONSchema, ForkConfigJSSchema };

package/dist/config/types.d.ts

@@ -1,5 +1,6 @@
 import { getCliArguments } from "./cli-arguments.js";
 import { ParserOptions } from "../commit-parser/options.js";
+import { IFileManager } from "../files/file-manager.js";
 
 //#region src/config/types.d.ts
 interface ChangelogPresetConfigType {
@@ -87,6 +88,11 @@ interface ForkConfig {
    * ```
    */
   files: string[];
+  /**
+   * List of custom file managers to use. See documentation for details.
+   * @default undefined
+   */
+  customFileManagers?: IFileManager[];
   /**
    * Glob pattern to match files to be updated.
    *

package/dist/files/arm-bicep.js

@@ -1,6 +1,5 @@
 import { MissingPropertyException } from "./file-manager.js";
-import { basename } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 //#region src/files/arm-bicep.ts
 /**
 * An ARM bicep file with metadata and variable called contentVersion.
@@ -16,19 +15,18 @@ var ARMBicep = class {
 	#metadataRegex = /(metadata contentVersion *= *['"])(?<version>[^'"]+)(['"])/;
 	/** https://regex101.com/r/iKCTF9/1 */
 	#varRegex = /(var contentVersion(?: string)? *= *['"])(?<version>[^'"]+)(['"])/;
-	read(filePath) {
-		const fileContents = readFileSync(filePath, "utf8");
+	async read(filePath) {
+		const fileContents = await readFile(filePath, "utf8");
 		const metadataMatch = this.#metadataRegex.exec(fileContents);
 		if (metadataMatch?.groups?.version) return {
-			name: basename(filePath),
 			path: filePath,
 			version: metadataMatch.groups.version
 		};
 		throw new MissingPropertyException("ARM Bicep", "metadata contentVersion");
 	}
-	write(fileState, newVersion) {
-		const updatedContent = readFileSync(fileState.path, "utf8").replace(this.#metadataRegex, `$1${newVersion}$3`).replace(this.#varRegex, `$1${newVersion}$3`);
-		writeFileSync(fileState.path, updatedContent, "utf8");
+	async write(fileState, newVersion) {
+		const updatedContent = (await readFile(fileState.path, "utf8")).replace(this.#metadataRegex, `$1${newVersion}$3`).replace(this.#varRegex, `$1${newVersion}$3`);
+		await writeFile(fileState.path, updatedContent, "utf8");
 	}
 	isSupportedFile(fileName) {
 		return fileName.endsWith(".bicep");

package/dist/files/file-manager.d.ts

@@ -1,5 +1,5 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
+import { ForkConfig } from "../config/types.js";
 
 //#region src/files/file-manager.d.ts
 /**
@@ -12,45 +12,82 @@ declare class MissingPropertyException extends Error {
   constructor(fileType: string, propertyName: string);
 }
 interface FileState {
-  name: string;
   path: string;
   version: string;
+  buildMetadata?: string;
   [other: string]: unknown;
 }
 interface IFileManager {
-  read(fileName: string): FileState | undefined;
-  write(fileState: FileState, newVersion: string): void;
-  isSupportedFile(fileName: string): boolean;
+  /**
+   * Function to read the file and return its current state.
+   * @param filePath The path of the file to read, can be either an absolute path or a file name relative to the config path.
+   * @returns The state of the file, including its current version and any other relevant information.
+   * @throws {MissingPropertyException} If the file is missing a required property.
+   * @throws {Error} If an unexpected error occurs while reading the file.
+   *
+   * @example
+   * ```ts
+   * const fileState = await fileManager.read("package.json");
+   *
+   * // Returns
+   * { path: "package.json", version: "1.2.3" }
+   * ```
+   */
+  read(filePath: string): Promise<FileState | undefined>;
+  /**
+   * Function to write the new version to the file.
+   * @param fileState The current state of the file, including its path and current version.
+   * @param newVersion The new version string to write to the file.
+   *
+   * @example
+   * ```ts
+   * await fileManager.write(
+   *   { path: "package.json", version: "1.2.2" },
+   *   "1.2.3"
+   * );
+   * ```
+   */
+  write(fileState: FileState, newVersion: string): Promise<void>;
+  /**
+   * Determine if the file manager supports the given file based on its name or path.
+   * File name will be transformed to lower case before checking for support to allow for case-insensitive file matching.
+   * @param filePath The name or path of the file to check.
+   * @returns `true` if the file is supported by this file manager, `false` otherwise.
+   *
+   * @example
+   * ```ts
+   * fileManager.isSupportedFile("package.json");
+   * ```
+   */
+  isSupportedFile(filePath: string): boolean;
 }
 declare class FileManager {
   #private;
   constructor(config: ForkConfig, logger: Logger);
   /**
-   * Get the state from the given file name.
+   * Get the state from the given file.
    *
    * @example
    * ```ts
    * fileManager.read("package.json");
-   * ```
    *
-   * @returns
-   * ```json
-   * { "name": "package.json", "path": "/path/to/package.json", "version": "1.2.3", "isPrivate": true }
+   * // Returns
+   * { path: "package.json", version: "1.2.3" }
    * ```
    */
-  read(pathOrName: string): FileState | undefined;
+  read(pathOrName: string): Promise<FileState | undefined>;
   /**
-   * Write the new version to the given file.
+   * Write new version to the given file.
    *
    * @example
    * ```ts
    * fileManager.write(
-   *   { name: "package.json", path: "/path/to/package.json", version: "1.2.2" },
+   *   { path: "package.json", version: "1.2.2" },
    *   "1.2.3"
    * );
    * ```
    */
-  write(fileState: FileState, newVersion: string): void;
+  write(fileState: FileState, newVersion: string): Promise<void>;
 }
 //#endregion
 export { FileManager, FileState, IFileManager, MissingPropertyException };

package/dist/files/file-manager.js

@@ -5,7 +5,8 @@ import { PlainText } from "./plain-text.js";
 import { MSBuildProject } from "./ms-build-project.js";
 import { ARMBicep } from "./arm-bicep.js";
 import { InstallShieldISM } from "./install-shield-ism.js";
-import { basename, isAbsolute, resolve } from "node:path";
+import { extractBuildMetadata } from "../utils/extract-build-metadata.js";
+import { isAbsolute, relative, resolve } from "node:path";
 //#region src/files/file-manager.ts
 /**
 * Exception thrown if a file manager encounters a file missing a required property,
@@ -28,7 +29,7 @@ var FileManager = class {
 	constructor(config, logger) {
 		this.#config = config;
 		this.#logger = logger;
-		this.#fileManagers = [
+		const builtinFileManagers = [
 			new JSONPackage(),
 			new YAMLPackage(),
 			new PlainText(),
@@ -36,51 +37,63 @@ var FileManager = class {
 			new ARMBicep(),
 			new InstallShieldISM()
 		];
+		if (config.customFileManagers) this.#fileManagers = [...config.customFileManagers, ...builtinFileManagers];
+		else this.#fileManagers = builtinFileManagers;
 	}
 	/**
-	* Get the state from the given file name.
+	* Get the state from the given file.
 	*
 	* @example
 	* ```ts
 	* fileManager.read("package.json");
-	* ```
 	*
-	* @returns
-	* ```json
-	* { "name": "package.json", "path": "/path/to/package.json", "version": "1.2.3", "isPrivate": true }
+	* // Returns
+	* { path: "package.json", version: "1.2.3" }
 	* ```
 	*/
-	read(pathOrName) {
-		const _fileName = pathOrName.toLowerCase();
+	async read(pathOrName) {
 		const filePath = isAbsolute(pathOrName) ? pathOrName : resolve(this.#config.path, pathOrName);
+		const relativePath = relative(this.#config.path, filePath);
+		const fileNameLower = relativePath.toLocaleLowerCase();
 		if (!fileExists(filePath)) return;
-		for (const fileManager of this.#fileManagers) if (fileManager.isSupportedFile(_fileName)) {
+		for (const fileManager of this.#fileManagers) if (fileManager.isSupportedFile(fileNameLower)) {
 			try {
-				return fileManager.read(filePath);
+				const fileState = await fileManager.read(filePath);
+				if (fileState) {
+					const { version, buildMetadata } = extractBuildMetadata(fileState.version);
+					if (buildMetadata) {
+						fileState.version = version;
+						fileState.buildMetadata = buildMetadata;
+					}
+				}
+				return fileState;
 			} catch (error) {
-				if (error instanceof MissingPropertyException) this.#logger.warn(`[File Manager] Missing '${error.propertyName}' property in ${error.fileType} file: ${basename(_fileName)}`);
+				if (error instanceof MissingPropertyException) this.#logger.warn(`[File Manager] Missing '${error.propertyName}' property in ${error.fileType} file: ${relativePath}`);
 				else throw new Error(`An unexpected error occurred while reading file: ${filePath}`, { cause: error });
 			}
 			return;
 		}
-		this.#logger.error(`[File Manager] Unsupported file: ${pathOrName}`);
+		this.#logger.error(`[File Manager] Unsupported file: ${relativePath}`);
 	}
 	/**
-	* Write the new version to the given file.
+	* Write new version to the given file.
 	*
 	* @example
 	* ```ts
 	* fileManager.write(
-	*   { name: "package.json", path: "/path/to/package.json", version: "1.2.2" },
+	*   { path: "package.json", version: "1.2.2" },
 	*   "1.2.3"
 	* );
 	* ```
 	*/
-	write(fileState, newVersion) {
+	async write(fileState, newVersion) {
 		if (this.#config.dryRun) return;
-		const _fileName = fileState.name.toLowerCase();
-		for (const fileManager of this.#fileManagers) if (fileManager.isSupportedFile(_fileName)) return fileManager.write(fileState, newVersion);
-		this.#logger.error(`[File Manager] Unsupported file: ${fileState.path}`);
+		const relativePath = relative(this.#config.path, fileState.path);
+		const fileNameLower = relativePath.toLocaleLowerCase();
+		let updatedVersion = newVersion;
+		if (fileState?.buildMetadata) updatedVersion += `+${fileState.buildMetadata}`;
+		for (const fileManager of this.#fileManagers) if (fileManager.isSupportedFile(fileNameLower)) return await fileManager.write(fileState, updatedVersion);
+		this.#logger.error(`[File Manager] Unsupported file: ${relativePath}`);
 	}
 };
 //#endregion

package/dist/files/install-shield-ism.js

@@ -1,6 +1,5 @@
 import { MissingPropertyException } from "./file-manager.js";
-import { basename } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import * as cheerio from "cheerio/slim";
 //#region src/files/install-shield-ism.ts
 /**
@@ -29,23 +28,22 @@ var InstallShieldISM = class {
 		xmlMode: true,
 		xml: { decodeEntities: false }
 	};
-	read(filePath) {
-		const fileContents = readFileSync(filePath, "utf8");
+	async read(filePath) {
+		const fileContents = await readFile(filePath, "utf8");
 		const version = cheerio.load(fileContents, this.#cheerioOptions)("msi > table[name=\"Property\"] > row > td:contains(\"ProductVersion\")").next().text().trim();
 		if (version) return {
-			name: basename(filePath),
 			path: filePath,
 			version
 		};
 		throw new MissingPropertyException("InstallShield ISM", "ProductVersion");
 	}
-	write(fileState, newVersion) {
-		const fileContents = readFileSync(fileState.path, "utf8");
+	async write(fileState, newVersion) {
+		const fileContents = await readFile(fileState.path, "utf8");
 		const $ = cheerio.load(fileContents, this.#cheerioOptions);
 		const versionCell = $("msi > table[name=\"Property\"] > row > td:contains(\"ProductVersion\")").next();
 		if (versionCell.length > 0) versionCell.text(newVersion);
 		const updatedContent = $.xml().replaceAll("\"/>", "\" />");
-		writeFileSync(fileState.path, updatedContent, "utf8");
+		await writeFile(fileState.path, updatedContent, "utf8");
 	}
 	isSupportedFile(fileName) {
 		return fileName.endsWith(".ism");

package/dist/files/json-package.js

@@ -1,7 +1,6 @@
 import { MissingPropertyException } from "./file-manager.js";
-import { basename } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
-import { applyEdits, modify, parse as parse$1 } from "jsonc-parser";
+import { readFile, writeFile } from "node:fs/promises";
+import { applyEdits, modify, parse } from "jsonc-parser";
 //#region src/files/json-package.ts
 /**
 * A json package file should have a version property, like what can be seen
@@ -33,28 +32,27 @@ var JSONPackage = class {
 	#setStringInJsonc(jsonc, jsonPath, newString) {
 		return applyEdits(jsonc, modify(jsonc, jsonPath, newString, {}));
 	}
-	read(filePath) {
-		const fileContents = readFileSync(filePath, "utf8");
+	async read(filePath) {
+		const fileContents = await readFile(filePath, "utf8");
 		const parseErrors = [];
-		const parsedJson = parse$1(fileContents, parseErrors, this.#jsoncOptions);
+		const parsedJson = parse(fileContents, parseErrors, this.#jsoncOptions);
 		if (parsedJson?.version && parseErrors.length === 0) return {
-			name: basename(filePath),
 			path: filePath,
 			version: parsedJson.version,
 			isPrivate: typeof parsedJson?.private === "boolean" ? parsedJson.private : true
 		};
 		throw new MissingPropertyException("JSON", "version");
 	}
-	write(fileState, newVersion) {
-		let fileContents = readFileSync(fileState.path, "utf8");
-		const parsedJson = parse$1(fileContents, [], this.#jsoncOptions);
+	async write(fileState, newVersion) {
+		let fileContents = await readFile(fileState.path, "utf8");
+		const parsedJson = parse(fileContents, [], this.#jsoncOptions);
 		fileContents = this.#setStringInJsonc(fileContents, ["version"], newVersion);
 		if (parsedJson?.packages?.[""]) fileContents = this.#setStringInJsonc(fileContents, [
 			"packages",
 			"",
 			"version"
 		], newVersion);
-		writeFileSync(fileState.path, fileContents, "utf8");
+		await writeFile(fileState.path, fileContents, "utf8");
 	}
 	isSupportedFile(fileName) {
 		return fileName.endsWith(".json") || fileName.endsWith(".jsonc");

package/dist/files/ms-build-project.js

@@ -1,6 +1,5 @@
 import { MissingPropertyException } from "./file-manager.js";
-import { basename } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import * as cheerio from "cheerio/slim";
 //#region src/files/ms-build-project.ts
 /**
@@ -22,22 +21,21 @@ var MSBuildProject = class {
 		xmlMode: true,
 		xml: { decodeEntities: false }
 	};
-	read(filePath) {
-		const fileContents = readFileSync(filePath, "utf8");
+	async read(filePath) {
+		const fileContents = await readFile(filePath, "utf8");
 		const version = cheerio.load(fileContents, this.#cheerioOptions)("Project > PropertyGroup > Version").text();
 		if (version) return {
-			name: basename(filePath),
 			path: filePath,
 			version
 		};
 		throw new MissingPropertyException("MSBuild", "Version");
 	}
-	write(fileState, newVersion) {
-		const fileContents = readFileSync(fileState.path, "utf8");
+	async write(fileState, newVersion) {
+		const fileContents = await readFile(fileState.path, "utf8");
 		const $ = cheerio.load(fileContents, this.#cheerioOptions);
 		$("Project > PropertyGroup > Version").text(newVersion);
 		const updatedContent = $.xml().replaceAll("\"/>", "\" />");
-		writeFileSync(fileState.path, updatedContent, "utf8");
+		await writeFile(fileState.path, updatedContent, "utf8");
 	}
 	isSupportedFile(fileName) {
 		return [

package/dist/files/plain-text.js

@@ -1,6 +1,5 @@
 import { MissingPropertyException } from "./file-manager.js";
-import { basename } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 //#region src/files/plain-text.ts
 /**
 * A plain text file will have just the version as the content.
@@ -11,17 +10,16 @@ import { readFileSync, writeFileSync } from "node:fs";
 * ```
 */
 var PlainText = class {
-	read(filePath) {
-		const fileContents = readFileSync(filePath, "utf8").trim();
+	async read(filePath) {
+		const fileContents = (await readFile(filePath, "utf8")).trim();
 		if (fileContents) return {
-			name: basename(filePath),
 			path: filePath,
 			version: fileContents
 		};
 		throw new MissingPropertyException("Plain Text", "version");
 	}
-	write(fileState, newVersion) {
-		writeFileSync(fileState.path, newVersion, "utf8");
+	async write(fileState, newVersion) {
+		await writeFile(fileState.path, newVersion, "utf8");
 	}
 	isSupportedFile(fileName) {
 		return fileName.endsWith("version.txt");

package/dist/files/yaml-package.js

@@ -1,7 +1,6 @@
 import { MissingPropertyException } from "./file-manager.js";
-import { basename } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
-import { parse as parse$1, parseDocument } from "yaml";
+import { readFile, writeFile } from "node:fs/promises";
+import { parse, parseDocument } from "yaml";
 //#region src/files/yaml-package.ts
 /**
 * A yaml package file should have a version property on the top level, like what can be seen
@@ -16,38 +15,18 @@ import { parse as parse$1, parseDocument } from "yaml";
 * ```
 */
 var YAMLPackage = class {
-	/**
-	* If the version is returned with a "+" symbol in the value then the version might be from a
-	* flutter `pubspec.yaml` file, if so we want to retain the input builderNumber by splitting it
-	* and joining it again later.
-	*/
-	#handleBuildNumber(fileVersion) {
-		const [version, builderNumber] = fileVersion.split("+");
-		if (/^\d+$/.test(builderNumber)) return {
-			version,
-			builderNumber
+	async read(filePath) {
+		const fileVersion = parse(await readFile(filePath, "utf8"))?.version;
+		if (fileVersion) return {
+			path: filePath,
+			version: fileVersion
 		};
-		return { version: fileVersion };
-	}
-	read(filePath) {
-		const fileVersion = parse$1(readFileSync(filePath, "utf-8"))?.version;
-		if (fileVersion) {
-			const parsedVersion = this.#handleBuildNumber(fileVersion);
-			return {
-				name: basename(filePath),
-				path: filePath,
-				version: parsedVersion.version || "",
-				builderNumber: parsedVersion.builderNumber ?? void 0
-			};
-		}
 		throw new MissingPropertyException("YAML", "version");
 	}
-	write(fileState, newVersion) {
-		const yamlDocument = parseDocument(readFileSync(fileState.path, "utf8"));
-		let newFileVersion = newVersion;
-		if (fileState.builderNumber !== void 0) newFileVersion += `+${fileState.builderNumber}`;
-		yamlDocument.set("version", newFileVersion);
-		writeFileSync(fileState.path, yamlDocument.toString(), "utf8");
+	async write(fileState, newVersion) {
+		const yamlDocument = parseDocument(await readFile(fileState.path, "utf8"));
+		yamlDocument.set("version", newVersion);
+		await writeFile(fileState.path, yamlDocument.toString(), "utf8");
 	}
 	isSupportedFile(fileName) {
 		return fileName.endsWith(".yaml") || fileName.endsWith(".yml");

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ParserOptions, createParserOptions } from "./commit-parser/options.js";
-import { ChangelogPresetConfig, ChangelogPresetConfigType, Config, ForkConfig } from "./config/types.js";
 import { Logger } from "./services/logger.js";
 import { FileManager, FileState, IFileManager, MissingPropertyException } from "./files/file-manager.js";
+import { ChangelogPresetConfig, ChangelogPresetConfigType, Config, ForkConfig } from "./config/types.js";
 import { Git } from "./services/git.js";
 import { inspect } from "./commands/inspect.js";
 import { main } from "./commands/main.js";
@@ -9,7 +9,7 @@ import { validateConfig } from "./commands/validate-config.js";
 import { Commit, CommitMerge, CommitNote, CommitReference, CommitRevert } from "./commit-parser/types.js";
 import { CommitParser } from "./commit-parser/commit-parser.js";
 import { filterRevertedCommits } from "./commit-parser/filter-reverted-commits.js";
-import { ForkConfigSchema } from "./config/schema.js";
+import { ForkConfigJSONSchema, ForkConfigJSSchema } from "./config/schema.js";
 import { defineConfig } from "./config/define-config.js";
 import { getUserConfig } from "./config/user-config.js";
 import { CommitsSinceTag, getCommitsSinceTag } from "./process/get-commits.js";
@@ -18,4 +18,4 @@ import { NextVersion, getNextVersion } from "./process/get-next-version.js";
 import { updateChangelog } from "./process/changelog.js";
 import { commitChanges } from "./process/commit.js";
 import { tagChanges } from "./process/tag.js";
-export { type ChangelogPresetConfig, type ChangelogPresetConfigType, type Commit, type CommitMerge, type CommitNote, CommitParser, type CommitReference, type CommitRevert, type CommitsSinceTag, type Config, type CurrentVersion, FileManager, type FileState, type ForkConfig, ForkConfigSchema, Git, type IFileManager, Logger, MissingPropertyException, type NextVersion, type ParserOptions, commitChanges, createParserOptions, defineConfig, filterRevertedCommits, getCommitsSinceTag, getCurrentVersion, getNextVersion, getUserConfig, inspect, main, tagChanges, updateChangelog, validateConfig };
+export { type ChangelogPresetConfig, type ChangelogPresetConfigType, type Commit, type CommitMerge, type CommitNote, CommitParser, type CommitReference, type CommitRevert, type CommitsSinceTag, type Config, type CurrentVersion, FileManager, type FileState, type ForkConfig, ForkConfigJSONSchema, ForkConfigJSSchema, Git, type IFileManager, Logger, MissingPropertyException, type NextVersion, type ParserOptions, commitChanges, createParserOptions, defineConfig, filterRevertedCommits, getCommitsSinceTag, getCurrentVersion, getNextVersion, getUserConfig, inspect, main, tagChanges, updateChangelog, validateConfig };

package/dist/index.js

@@ -10,10 +10,10 @@ import { commitChanges } from "./process/commit.js";
 import { tagChanges } from "./process/tag.js";
 import { main } from "./commands/main.js";
 import { validateConfig } from "./commands/validate-config.js";
-import { ForkConfigSchema } from "./config/schema.js";
+import { ForkConfigJSONSchema, ForkConfigJSSchema } from "./config/schema.js";
 import { defineConfig } from "./config/define-config.js";
 import { Git } from "./services/git.js";
 import { getUserConfig } from "./config/user-config.js";
 import { FileManager, MissingPropertyException } from "./files/file-manager.js";
 import { Logger } from "./services/logger.js";
-export { CommitParser, FileManager, ForkConfigSchema, Git, Logger, MissingPropertyException, commitChanges, createParserOptions, defineConfig, filterRevertedCommits, getCommitsSinceTag, getCurrentVersion, getNextVersion, getUserConfig, inspect, main, tagChanges, updateChangelog, validateConfig };
+export { CommitParser, FileManager, ForkConfigJSONSchema, ForkConfigJSSchema, Git, Logger, MissingPropertyException, commitChanges, createParserOptions, defineConfig, filterRevertedCommits, getCommitsSinceTag, getCurrentVersion, getNextVersion, getUserConfig, inspect, main, tagChanges, updateChangelog, validateConfig };

package/dist/process/changelog.d.ts

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

package/dist/process/changelog.js

@@ -1,6 +1,6 @@
 import { fileExists } from "../utils/file-state.js";
 import { resolve } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import conventionalChangelog from "conventional-changelog";
 //#region src/process/changelog.ts
 /**
@@ -13,9 +13,9 @@ 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) {
+async function getOldReleaseContent(filePath, exists) {
 	if (exists) {
-		const fileContents = readFileSync(filePath, "utf-8");
+		const fileContents = await readFile(filePath, "utf8");
 		const oldContentStart = fileContents.search(RELEASE_PATTERN);
 		if (oldContentStart !== -1) return fileContents.substring(oldContentStart);
 	}
@@ -56,11 +56,11 @@ async function updateChangelog(config, logger, nextVersion) {
 	const changelogPath = resolve(config.path, config.changelog);
 	if (!config.dryRun && !fileExists(changelogPath)) {
 		logger.log(`Creating changelog: ${changelogPath}`);
-		writeFileSync(changelogPath, "\n", "utf8");
+		await writeFile(changelogPath, "\n", "utf8");
 	} else logger.log(`Updating changelog: ${changelogPath}`);
-	const oldContent = getOldReleaseContent(changelogPath, fileExists(changelogPath));
+	const oldContent = await getOldReleaseContent(changelogPath, fileExists(changelogPath));
 	const newContent = await getNewReleaseContent(config, logger, nextVersion);
-	if (!config.dryRun && newContent) writeFileSync(changelogPath, `${config.header}
+	if (!config.dryRun && newContent) await writeFile(changelogPath, `${config.header}
 ${newContent}
 ${oldContent}
 `.trim(), "utf8");

package/dist/process/commit.d.ts

@@ -1,6 +1,6 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
 import { FileState } from "../files/file-manager.js";
+import { ForkConfig } from "../config/types.js";
 import { Git } from "../services/git.js";
 
 //#region src/process/commit.d.ts

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

@@ -1,5 +1,5 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
+import { ForkConfig } from "../config/types.js";
 import { Git } from "../services/git.js";
 import { Commit } from "../commit-parser/types.js";
 

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

@@ -1,6 +1,6 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
 import { FileManager, FileState } from "../files/file-manager.js";
+import { ForkConfig } from "../config/types.js";
 import { Git } from "../services/git.js";
 
 //#region src/process/get-current-version.d.ts

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

@@ -8,7 +8,7 @@ async function getCurrentVersion(config, logger, git, fileManager, filesToUpdate
 			logger.debug(`[Git Ignored] ${file}`);
 			continue;
 		}
-		const fileState = fileManager.read(file);
+		const fileState = await fileManager.read(file);
 		if (fileState) {
 			files.push(fileState);
 			if (!config.currentVersion) versions.add(fileState.version);

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

@@ -1,5 +1,5 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
+import { ForkConfig } from "../config/types.js";
 import { Commit } from "../commit-parser/types.js";
 import { ReleaseType } from "semver";
 

package/dist/process/tag.d.ts

@@ -1,5 +1,5 @@
-import { ForkConfig } from "../config/types.js";
 import { Logger } from "../services/logger.js";
+import { ForkConfig } from "../config/types.js";
 import { Git } from "../services/git.js";
 
 //#region src/process/tag.d.ts

package/dist/utils/extract-build-metadata.js

@@ -0,0 +1,37 @@
+//#region src/utils/extract-build-metadata.ts
+/**
+* This function is used to separate build metadata from the version string.
+* Build metadata is denoted by a plus sign (`+`) followed by a string of characters.
+*
+* Example version strings including build metadata:
+* - `1.2.3+49a3f2b`
+* - `1.2.3-0+49a3f2b`
+* - `1.2.3-alpha.0+49a3f2b`
+*
+* In the above examples, the build metadata is `+49a3f2b`, which should be
+* ignored when determining the next version.
+*
+* @param version The version string to extract build metadata from.
+* @return Both the version string without build metadata and the extracted build metadata (if any).
+*
+* @example
+* ```ts
+* const versionWithMetadata = "1.2.3+49a3f2b";
+* const { version, buildMetadata } = extractBuildMetadata(versionWithMetadata);
+* console.log(version); // Output: "1.2.3"
+* console.log(buildMetadata); // Output: "49a3f2b"
+* ```
+*/
+function extractBuildMetadata(version) {
+	const plusIndex = version.indexOf("+");
+	if (plusIndex === -1) return {
+		version,
+		buildMetadata: void 0
+	};
+	return {
+		version: version.substring(0, plusIndex),
+		buildMetadata: version.substring(plusIndex + 1) || void 0
+	};
+}
+//#endregion
+export { extractBuildMetadata };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fork-version",
-  "version": "5.0.2",
+  "version": "5.1.1",
   "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": [