fork-version 4.1.9 → 5.0.0

package/dist/config/types.d.ts

@@ -0,0 +1,279 @@
+import { getCliArguments } from "./cli-arguments.js";
+import { ParserOptions } from "../commit-parser/options.js";
+
+//#region src/config/types.d.ts
+interface ChangelogPresetConfigType {
+  /**
+   * The type of commit message.
+   * @example "feat", "fix", "chore", etc..
+   */
+  type: string;
+  /**
+   * The scope of the commit message.
+   */
+  scope?: string;
+  /**
+   * The section of the `CHANGELOG` the commit should show up in.
+   */
+  section?: string;
+  /**
+   * Should show in the generated changelog message?
+   */
+  hidden?: boolean;
+}
+interface ChangelogPresetConfig {
+  /**
+   * List of explicitly supported commit message types.
+   */
+  types: ChangelogPresetConfigType[];
+  /**
+   * A URL representing a specific commit at a hash.
+   * @default "{{host}}/{{owner}}/{{repository}}/commit/{{hash}}"
+   */
+  commitUrlFormat: string;
+  /**
+   * A URL representing the comparison between two git SHAs.
+   * @default "{{host}}/{{owner}}/{{repository}}/compare/{{previousTag}}...{{currentTag}}"
+   */
+  compareUrlFormat: string;
+  /**
+   * A URL representing the issue format (allowing a different URL format to be swapped in
+   * for Gitlab, Bitbucket, etc).
+   * @default "{{host}}/{{owner}}/{{repository}}/issues/{{id}}"
+   */
+  issueUrlFormat: string;
+  /**
+   * A URL representing a user's profile on GitHub, Gitlab, etc. This URL is used
+   * for substituting @eglavin with https://github.com/eglavin in commit messages.
+   * @default "{{host}}/{{user}}"
+   */
+  userUrlFormat: string;
+  /**
+   * A string to be used to format the auto-generated release commit message.
+   * @default "chore(release): {{currentTag}}"
+   */
+  releaseCommitMessageFormat: string;
+  /**
+   * List of prefixes used to detect references to issues.
+   * @default ["#"]
+   */
+  issuePrefixes: string[];
+}
+interface ForkConfig {
+  /**
+   * The command to run, can be one of the following:
+   *
+   * - `main` - Bumps the version, update files, generate changelog, commit, and tag.
+   * - `inspect-version` - Prints the current version and exits.
+   * - `inspect-tag` - Prints the current git tag and exits.
+   * - `inspect` - Prints the current version and git tag and exits.
+   * - `validate-config` - Validates the configuration and exits.
+   *
+   * @default "main"
+   */
+  command: "main" | "inspect" | "inspect-version" | "inspect-tag" | "validate-config";
+  /**
+   * If set, Fork-Version will print the current version and exit.
+   * @default false
+   *
+   * @deprecated Set the `inspect-version` command instead.
+   */
+  inspectVersion?: boolean;
+  /**
+   * List of the files to be updated.
+   * @default
+   * ```js
+   * ["bower.json", "deno.json", "deno.jsonc", "jsr.json", "jsr.jsonc", "manifest.json", "npm-shrinkwrap.json", "package-lock.json", "package.json"]
+   * ```
+   */
+  files: string[];
+  /**
+   * Glob pattern to match files to be updated.
+   *
+   * Internally we're using [glob](https://github.com/isaacs/node-glob) to match files.
+   *
+   * Read more about the pattern syntax [here](https://github.com/isaacs/node-glob/tree/v10.3.12?tab=readme-ov-file#glob-primer).
+   *
+   * @default undefined
+   * @example "*.json"
+   */
+  glob?: string;
+  /**
+   * The path Fork-Version will run from.
+   * @default
+   * ```js
+   * process.cwd()
+   * ```
+   */
+  path: string;
+  /**
+   * Name of the changelog file.
+   * @default "CHANGELOG.md"
+   */
+  changelog: string;
+  /**
+   * The header text for the changelog.
+   * @default
+   * ```markdown
+   * # Changelog
+   *
+   * All notable changes to this project will be documented in this file. See [fork-version](https://github.com/eglavin/fork-version) for commit guidelines.
+   * ```
+   */
+  header: string;
+  /**
+   * Specify a prefix for the created tag.
+   *
+   * For instance if your version tag is prefixed by "version/" instead of "v" you have to specify
+   * `tagPrefix: "version/"`.
+   *
+   * `tagPrefix` can also be used for a monorepo environment where you might want to deploy
+   * multiple package from the same repository. In this case you can specify a prefix for
+   * each package:
+   *
+   * | Example Value            | Tag Created                   |
+   * |:-------------------------|:------------------------------|
+   * | ""                       | `1.2.3`                       |
+   * | "version/"               | `version/1.2.3`               |
+   * | "@eglavin/fork-version-" | `@eglavin/fork-version-1.2.3` |
+   *
+   * @example "", "version/", "@eglavin/fork-version-"
+   * @default "v"
+   */
+  tagPrefix: string;
+  /**
+   * Make a pre-release with optional label if given value is a string.
+   *
+   * | Example Value | Produced Version |
+   * |:--------------|:-----------------|
+   * | true          | `1.2.3-0`        |
+   * | "alpha"       | `1.2.3-alpha-0`  |
+   * | "beta"        | `1.2.3-beta-0`   |
+   *
+   * @example true, "alpha", "beta", "rc"
+   * @default undefined
+   */
+  preRelease?: string | boolean;
+  /**
+   * If set, Fork-Version will use this version instead of trying to determine one.
+   * @example "1.0.0"
+   * @default undefined
+   */
+  currentVersion?: string;
+  /**
+   * If set, Fork-Version will attempt to update to this version, instead of incrementing using "conventional-commit".
+   * @example "2.0.0"
+   * @default undefined
+   */
+  nextVersion?: string;
+  /**
+   * Release as increments the version by the specified level. Overrides the default behaviour of "conventional-commit".
+   * @example "major", "minor", "patch"
+   * @default undefined
+   */
+  releaseAs?: "major" | "minor" | "patch";
+  /**
+   * Don't throw an error if multiple versions are found in the given files.
+   * @default true
+   */
+  allowMultipleVersions: boolean;
+  /**
+   * Commit all changes, not just files updated by Fork-Version.
+   * @default false
+   */
+  commitAll: boolean;
+  /**
+   * By default the conventional-changelog spec will only add commit types of `feat` and `fix` to the generated changelog.
+   * If this flag is set, all [default commit types](https://github.com/conventional-changelog/conventional-changelog-config-spec/blob/238093090c14bd7d5151eb5316e635623ce633f9/versions/2.2.0/schema.json#L18)
+   * will be added to the changelog.
+   * @default false
+   */
+  changelogAll: boolean;
+  /**
+   * Output debug information.
+   * @default false
+   */
+  debug: boolean;
+  /**
+   * No output will be written to disk or committed.
+   * @default false
+   */
+  dryRun: boolean;
+  /**
+   * Run without logging to the terminal.
+   * @default false
+   */
+  silent: boolean;
+  /**
+   * If unable to find a version in the given files, fallback and attempt to use the latest git tag.
+   * @default true
+   */
+  gitTagFallback: boolean;
+  /**
+   * If true, git will sign the commit with the systems GPG key.
+   * @see {@link https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--Sltkeyidgt Git - GPG Sign Commits}
+   * @default false
+   */
+  sign: boolean;
+  /**
+   * If true, git will run user defined git hooks before committing.
+   * @see {@link https://git-scm.com/docs/githooks Git - Git Hooks}
+   * @default false
+   */
+  verify: boolean;
+  /**
+   * Print inspected output as a parsable json string.
+   * @default false
+   */
+  asJson: boolean;
+  /**
+   * Skip the bump step.
+   * @default false
+   */
+  skipBump: boolean;
+  /**
+   * Skip the changelog step.
+   * @default false
+   */
+  skipChangelog: boolean;
+  /**
+   * Skip the commit step.
+   * @default false
+   */
+  skipCommit: boolean;
+  /**
+   * Skip the tag step.
+   * @default false
+   */
+  skipTag: boolean;
+  /**
+   * The detected git host:
+   * - `GitHub`
+   * - `GitLab`
+   * - `Bitbucket`
+   * - `Azure Devops`
+   * - Or undefined if unknown or not detected.
+   */
+  detectedGitHost?: string;
+  /**
+   * Override the default "conventional-changelog-conventionalcommits" preset configuration.
+   */
+  changelogPresetConfig?: Partial<ChangelogPresetConfig>;
+  /**
+   * Add a suffix to the release commit message.
+   * @example "[skip ci]"
+   */
+  releaseMessageSuffix?: string;
+  /**
+   * Options to pass to commits parser.
+   */
+  commitParserOptions?: Partial<ParserOptions>;
+}
+type Config = Partial<ForkConfig>;
+type CLIArguments = ReturnType<typeof getCliArguments>;
+interface ForkVersionCLIArgs {
+  input: CLIArguments["input"];
+  flags: Partial<CLIArguments["flags"]>;
+}
+//#endregion
+export { ChangelogPresetConfig, ChangelogPresetConfigType, Config, ForkConfig, ForkVersionCLIArgs };

package/dist/config/user-config.d.ts

@@ -0,0 +1,6 @@
+import { ForkConfig, ForkVersionCLIArgs } from "./types.js";
+
+//#region src/config/user-config.d.ts
+declare function getUserConfig(cliArguments: ForkVersionCLIArgs): Promise<ForkConfig>;
+//#endregion
+export { getUserConfig };

package/dist/config/user-config.js

@@ -0,0 +1,50 @@
+import { getChangelogPresetConfig } from "./changelog-preset-config.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+import { detectGitHost } from "../detect-git-host/detect-git-host.js";
+import { loadConfigFile } from "./load-config.js";
+import { mergeFiles } from "./merge-files.js";
+import { join, resolve } from "node:path";
+import { glob } from "node:fs/promises";
+//#region src/config/user-config.ts
+async function getUserConfig(cliArguments) {
+	const cwd = cliArguments.flags.path ? resolve(cliArguments.flags.path) : process.cwd();
+	const configFile = await loadConfigFile(cwd);
+	const mergedConfig = {
+		...DEFAULT_CONFIG,
+		...configFile,
+		...cliArguments.flags
+	};
+	const globResults = [];
+	if (mergedConfig.glob) {
+		const IGNORE_LIST = new Set(["node_modules", ".git"]);
+		const entries = glob(mergedConfig.glob, {
+			cwd,
+			withFileTypes: true,
+			exclude: (entry) => IGNORE_LIST.has(entry.name)
+		});
+		for await (const entry of entries) if (entry.isFile()) globResults.push(join(entry.parentPath, entry.name));
+	}
+	const files = mergeFiles(configFile?.files, cliArguments.flags.files, globResults);
+	const detectedGitHost = await detectGitHost(cwd);
+	let command = DEFAULT_CONFIG.command;
+	if (cliArguments.input.length > 0 && cliArguments.input[0].trim()) command = cliArguments.input[0].trim().toLowerCase();
+	else if (mergedConfig.command.trim()) command = mergedConfig.command.trim().toLowerCase();
+	if (mergedConfig.inspectVersion) command = "inspect-version";
+	const shouldBeSilent = ![DEFAULT_CONFIG.command].includes(command);
+	return {
+		...mergedConfig,
+		command,
+		files,
+		path: cwd,
+		preRelease: cliArguments.flags.preReleaseTag ?? cliArguments.flags.preRelease ?? configFile.preRelease,
+		silent: shouldBeSilent || mergedConfig.silent,
+		detectedGitHost: detectedGitHost?.hostName,
+		changelogPresetConfig: getChangelogPresetConfig(mergedConfig, cliArguments.flags, detectedGitHost?.changelogOptions),
+		commitParserOptions: {
+			...detectedGitHost?.commitParserOptions,
+			...mergedConfig.commitParserOptions
+		}
+	};
+}
+//#endregion
+export { getUserConfig };

package/dist/detect-git-host/detect-git-host.js

@@ -0,0 +1,35 @@
+import { Git } from "../services/git.js";
+import { detectGitHubOptions } from "./host-github.js";
+import { detectGitlabOptions } from "./host-gitlab.js";
+import { detectBitbucketOptions } from "./host-bitbucket.js";
+import { detectAzureDevopsOptions } from "./host-azure-devops.js";
+//#region src/detect-git-host/detect-git-host.ts
+/**
+* Detects the Git hosting service based on the remote URL of the Git repository at the given path.
+*
+* Supports `GitHub`, `GitLab`, `Bitbucket`, and `Azure DevOps`.
+*
+* @param path - The file system path to the Git repository.
+* @returns A promise that resolves to a DetectedGitHost object if a supported host is detected, or undefined if no supported host is found.
+*/
+async function detectGitHost(path) {
+	const remoteUrl = await new Git({ path }).getRemoteUrl();
+	if (remoteUrl.includes("github.com")) {
+		const githubOptions = detectGitHubOptions(remoteUrl);
+		if (githubOptions) return githubOptions;
+	}
+	if (remoteUrl.includes("gitlab.com")) {
+		const gitlabOptions = detectGitlabOptions(remoteUrl);
+		if (gitlabOptions) return gitlabOptions;
+	}
+	if (/bitbucket\.(org|com)/.test(remoteUrl)) {
+		const bitbucketOptions = detectBitbucketOptions(remoteUrl);
+		if (bitbucketOptions) return bitbucketOptions;
+	}
+	if (remoteUrl.includes("dev.azure.com")) {
+		const azureDevopsOptions = detectAzureDevopsOptions(remoteUrl);
+		if (azureDevopsOptions) return azureDevopsOptions;
+	}
+}
+//#endregion
+export { detectGitHost };

package/dist/detect-git-host/host-azure-devops.js

@@ -0,0 +1,28 @@
+//#region src/detect-git-host/host-azure-devops.ts
+/**
+* A checked out Azure Devops remote URL looks like one of these:
+*
+* | Checkout Type | Remote URL                                                                                |
+* |:------------- |:----------------------------------------------------------------------------------------- |
+* | HTTPS         | `https://{{ORGANISATION}}@dev.azure.com/{{ORGANISATION}}/{{PROJECT}}/_git/{{REPOSITORY}}` |
+* | SSH           | `git@ssh.dev.azure.com:v3/{{ORGANISATION}}/{{PROJECT}}/{{REPOSITORY}}`                    |
+*/
+function detectAzureDevopsOptions(remoteUrl) {
+	let matches = null;
+	if (/^https:\/\/(.*)?dev\.azure\.com/.test(remoteUrl)) matches = /^https:\/\/(.*)?dev\.azure\.com\/(?<organisation>.*?)\/(?<project>.*?)\/_git\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	else if (remoteUrl.startsWith("git@ssh.dev.azure.com:")) matches = /^git@ssh\.dev\.azure\.com:v\d\/(?<organisation>.*?)\/(?<project>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	if (matches?.groups) {
+		const { organisation = "", project = "", repository = "" } = matches.groups;
+		return {
+			hostName: "Azure Devops",
+			changelogOptions: {
+				commitUrlFormat: `https://dev.azure.com/${organisation}/${project}/_git/${repository}/commit/{{hash}}`,
+				compareUrlFormat: `https://dev.azure.com/${organisation}/${project}/_git/${repository}/branchCompare?baseVersion=GT{{previousTag}}&targetVersion=GT{{currentTag}}`,
+				issueUrlFormat: `https://dev.azure.com/${organisation}/${project}/_workitems/edit/{{id}}`
+			},
+			commitParserOptions: { mergePattern: /^Merged PR (?<id>\d*): (?<source>.*)/i }
+		};
+	}
+}
+//#endregion
+export { detectAzureDevopsOptions };

package/dist/detect-git-host/host-bitbucket.js

@@ -0,0 +1,28 @@
+//#region src/detect-git-host/host-bitbucket.ts
+/**
+* A checked out Bitbucket remote URL looks like one of these:
+*
+* | Checkout Type | Remote URL                                                                |
+* |:------------- |:------------------------------------------------------------------------- |
+* | HTTPS         | `https://{{WORKSPACE}}@bitbucket.org/{{ORGANISATION}}/{{REPOSITORY}}.git` |
+* | SSH           | `git@bitbucket.org:{{ORGANISATION}}/{{REPOSITORY}}.git`                   |
+*/
+function detectBitbucketOptions(remoteUrl) {
+	let matches = null;
+	if (/^https:\/\/(.*)?bitbucket\.(org|com)/.test(remoteUrl)) matches = /^https:\/\/(.*)?bitbucket\.(?<domain>org|com)\/(?<organisation>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	else if (remoteUrl.startsWith("git@bitbucket.org:")) matches = /^git@bitbucket\.(?<domain>org|com):(?<organisation>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	if (matches?.groups) {
+		const { domain = "", organisation = "", repository = "" } = matches.groups;
+		return {
+			hostName: "Bitbucket",
+			changelogOptions: {
+				commitUrlFormat: `https://bitbucket.${domain}/${organisation}/${repository}/commits/{{hash}}`,
+				compareUrlFormat: `https://bitbucket.${domain}/${organisation}/${repository}/branches/compare/{{currentTag}}..{{previousTag}}`,
+				issueUrlFormat: `https://bitbucket.${domain}/${organisation}/${repository}/issues/{{id}}`
+			},
+			commitParserOptions: { mergePattern: /^Merged in (?<source>.*) \(pull request #(?<id>\d*)\)/i }
+		};
+	}
+}
+//#endregion
+export { detectBitbucketOptions };

package/dist/detect-git-host/host-github.js

@@ -0,0 +1,32 @@
+//#region src/detect-git-host/host-github.ts
+/**
+* A checked out GitHub remote URL looks like one of these:
+*
+* | Checkout Type | Remote URL                                               |
+* |:------------- |:-------------------------------------------------------- |
+* | HTTPS         | `https://github.com/{{ORGANISATION}}/{{REPOSITORY}}.git` |
+* | SSH           | `git@github.com:{{ORGANISATION}}/{{REPOSITORY}}.git`		  |
+*/
+function detectGitHubOptions(remoteUrl) {
+	let matches = null;
+	if (/^https:\/\/(.*)?github\.com/.test(remoteUrl)) matches = /^https:\/\/(.*)?github\.com\/(?<organisation>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	else if (remoteUrl.startsWith("git@github.com:")) matches = /^git@github\.com:(?<organisation>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	if (matches?.groups) {
+		const { organisation = "", repository = "" } = matches.groups;
+		return {
+			hostName: "GitHub",
+			changelogOptions: {
+				commitUrlFormat: `https://github.com/${organisation}/${repository}/commit/{{hash}}`,
+				compareUrlFormat: `https://github.com/${organisation}/${repository}/compare/{{previousTag}}...{{currentTag}}`,
+				issueUrlFormat: `https://github.com/${organisation}/${repository}/issues/{{id}}`,
+				issuePrefixes: ["#", "gh-"]
+			},
+			commitParserOptions: {
+				mergePattern: /^Merge pull request #(?<id>\d*) from (?<source>.*)/i,
+				issuePrefixes: ["#", "gh-"]
+			}
+		};
+	}
+}
+//#endregion
+export { detectGitHubOptions };

package/dist/detect-git-host/host-gitlab.js

@@ -0,0 +1,48 @@
+//#region src/detect-git-host/host-gitlab.ts
+/**
+* A checked out GitLab remote URL looks like one of these:
+*
+* | Checkout Type | Remote URL                                               |
+* |:------------- |:-------------------------------------------------------- |
+* | HTTPS         | `https://gitlab.com/{{ORGANISATION}}/{{REPOSITORY}}.git` |
+* | SSH           | `git@gitlab.com:{{ORGANISATION}}/{{REPOSITORY}}.git`     |
+*/
+function detectGitlabOptions(remoteUrl) {
+	let matches = null;
+	if (/^https:\/\/(.*)?gitlab\.com/.test(remoteUrl)) matches = /^https:\/\/(.*)?gitlab\.com\/(?<organisation>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	else if (remoteUrl.startsWith("git@gitlab.com:")) matches = /^git@gitlab\.com:(?<organisation>.*?)\/(?<repository>.*?)(?:\.git)?$/.exec(remoteUrl);
+	if (matches?.groups) {
+		const { organisation = "", repository = "" } = matches.groups;
+		return {
+			hostName: "GitLab",
+			changelogOptions: {
+				commitUrlFormat: `https://gitlab.com/${organisation}/${repository}/-/commit/{{hash}}`,
+				compareUrlFormat: `https://gitlab.com/${organisation}/${repository}/-/compare/{{previousTag}}...{{currentTag}}`,
+				issueUrlFormat: `https://gitlab.com/${organisation}/${repository}/-/issues/{{id}}`
+			},
+			commitParserOptions: {
+				mergePattern: /^Merge branch '(?<source>.*)' into '(.*)'/i,
+				referenceActions: [
+					"close",
+					"closes",
+					"closed",
+					"closing",
+					"fix",
+					"fixes",
+					"fixed",
+					"fixing",
+					"resolve",
+					"resolves",
+					"resolved",
+					"resolving",
+					"implement",
+					"implements",
+					"implemented",
+					"implementing"
+				]
+			}
+		};
+	}
+}
+//#endregion
+export { detectGitlabOptions };

package/dist/files/arm-bicep.js

@@ -0,0 +1,44 @@
+import { basename } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+//#region src/files/arm-bicep.ts
+/**
+* An ARM bicep file with metadata and variable called contentVersion.
+*
+* @example
+* ```bicep
+* metadata contentVersion = '1.2.3.4'
+* var contentVersion string = '1.2.3.4'
+* ```
+*/
+var ARMBicep = class {
+	#logger;
+	constructor(logger) {
+		this.#logger = logger;
+	}
+	/** https://regex101.com/r/Lriphb/2 */
+	#metadataRegex = /(metadata contentVersion *= *['"])(?<version>[^'"]+)(['"])/;
+	/** https://regex101.com/r/iKCTF9/1 */
+	#varRegex = /(var contentVersion(?: string)? *= *['"])(?<version>[^'"]+)(['"])/;
+	read(filePath) {
+		const fileName = basename(filePath);
+		const fileContents = readFileSync(filePath, "utf8");
+		const metadataMatch = this.#metadataRegex.exec(fileContents);
+		const varMatch = this.#varRegex.exec(fileContents);
+		if (metadataMatch?.groups?.version && varMatch?.groups?.version) return {
+			name: fileName,
+			path: filePath,
+			version: metadataMatch.groups.version
+		};
+		if (!metadataMatch) this.#logger.warn(`[File Manager] Missing 'metadata contentVersion' in bicep file: ${fileName}`);
+		if (!varMatch) this.#logger.warn(`[File Manager] Missing 'var contentVersion' in bicep file: ${fileName}`);
+	}
+	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");
+	}
+	isSupportedFile(fileName) {
+		return fileName.endsWith(".bicep");
+	}
+};
+//#endregion
+export { ARMBicep };

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

@@ -0,0 +1,47 @@
+import { ForkConfig } from "../config/types.js";
+import { Logger } from "../services/logger.js";
+
+//#region src/files/file-manager.d.ts
+interface FileState {
+  name: string;
+  path: string;
+  version: string;
+  [other: string]: unknown;
+}
+interface IFileManager {
+  read(fileName: string): FileState | undefined;
+  write(fileState: FileState, newVersion: string): void;
+  isSupportedFile(fileName: string): boolean;
+}
+declare class FileManager {
+  #private;
+  constructor(config: ForkConfig, logger: Logger);
+  /**
+   * Get the state from the given file name.
+   *
+   * @example
+   * ```ts
+   * fileManager.read("package.json");
+   * ```
+   *
+   * @returns
+   * ```json
+   * { "name": "package.json", "path": "/path/to/package.json", "version": "1.2.3", "isPrivate": true }
+   * ```
+   */
+  read(pathOrName: string): FileState | undefined;
+  /**
+   * Write the new version to the given file.
+   *
+   * @example
+   * ```ts
+   * fileManager.write(
+   *   { name: "package.json", path: "/path/to/package.json", version: "1.2.2" },
+   *   "1.2.3"
+   * );
+   * ```
+   */
+  write(fileState: FileState, newVersion: string): void;
+}
+//#endregion
+export { FileManager, FileState, IFileManager };

package/dist/files/file-manager.js

@@ -0,0 +1,65 @@
+import { fileExists } from "../utils/file-state.js";
+import { JSONPackage } from "./json-package.js";
+import { YAMLPackage } from "./yaml-package.js";
+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 { isAbsolute, resolve } from "node:path";
+//#region src/files/file-manager.ts
+var FileManager = class {
+	#config;
+	#logger;
+	#fileManagers = [];
+	constructor(config, logger) {
+		this.#config = config;
+		this.#logger = logger;
+		this.#fileManagers = [
+			new JSONPackage(logger),
+			new YAMLPackage(logger),
+			new PlainText(logger),
+			new MSBuildProject(logger),
+			new ARMBicep(logger),
+			new InstallShieldISM(logger)
+		];
+	}
+	/**
+	* Get the state from the given file name.
+	*
+	* @example
+	* ```ts
+	* fileManager.read("package.json");
+	* ```
+	*
+	* @returns
+	* ```json
+	* { "name": "package.json", "path": "/path/to/package.json", "version": "1.2.3", "isPrivate": true }
+	* ```
+	*/
+	read(pathOrName) {
+		const _fileName = pathOrName.toLowerCase();
+		const filePath = isAbsolute(pathOrName) ? pathOrName : resolve(this.#config.path, pathOrName);
+		if (!fileExists(filePath)) return;
+		for (const fileManager of this.#fileManagers) if (fileManager.isSupportedFile(_fileName)) return fileManager.read(filePath);
+		this.#logger.error(`[File Manager] Unsupported file: ${pathOrName}`);
+	}
+	/**
+	* Write the new version to the given file.
+	*
+	* @example
+	* ```ts
+	* fileManager.write(
+	*   { name: "package.json", path: "/path/to/package.json", version: "1.2.2" },
+	*   "1.2.3"
+	* );
+	* ```
+	*/
+	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}`);
+	}
+};
+//#endregion
+export { FileManager };