fork-version 1.4.13 → 1.4.48

package/dist/chunk-S2VPLFG2.js

@@ -0,0 +1,798 @@
+import { z } from 'zod';
+import { resolve, parse } from 'path';
+import JoyCon from 'joycon';
+import { bundleRequire } from 'bundle-require';
+import meow from 'meow';
+import conventionalChangelogConfigSpec from 'conventional-changelog-config-spec';
+import semver3 from 'semver';
+import conventionalRecommendedBump from 'conventional-recommended-bump';
+import gitSemverTags from 'git-semver-tags';
+import { writeFileSync, lstatSync, readFileSync } from 'fs';
+import conventionalChangelog from 'conventional-changelog';
+import { execFile } from 'child_process';
+import detectIndent from 'detect-indent';
+import { detectNewline } from 'detect-newline';
+
+// src/config/schema.ts
+var ChangelogPresetConfigSchema = z.object({
+  /**
+   * An array of `type` objects representing the explicitly supported commit message types,
+   * and whether they should show up in generated `CHANGELOG`s.
+   */
+  types: z.array(
+    z.object({
+      type: z.string(),
+      section: z.string().optional(),
+      hidden: z.boolean().optional()
+    })
+  ),
+  /**
+   * A URL representing a specific commit at a hash.
+   * @default "{{host}}/{{owner}}/{{repository}}/commit/{{hash}}"
+   */
+  commitUrlFormat: z.string(),
+  /**
+   * A URL representing the comparison between two git SHAs.
+   * @default "{{host}}/{{owner}}/{{repository}}/compare/{{previousTag}}...{{currentTag}}"
+   */
+  compareUrlFormat: z.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: z.string(),
+  /**
+   * A URL representing the a user's profile URL on GitHub, Gitlab, etc. This URL is used
+   * for substituting @bcoe with https://github.com/bcoe in commit messages.
+   * @default "{{host}}/{{user}}"
+   */
+  userUrlFormat: z.string(),
+  /**
+   * A string to be used to format the auto-generated release commit message.
+   * @default "chore(release): {{currentTag}}"
+   */
+  releaseCommitMessageFormat: z.string(),
+  /**
+   * An array of prefixes used to detect references to issues
+   * @default ["#"]
+   */
+  issuePrefixes: z.array(z.string())
+});
+var ForkConfigSchema = z.object({
+  /**
+   * The path fork-version will run from.
+   * @default
+   * ```js
+   * process.cwd()
+   * ```
+   */
+  path: z.string(),
+  /**
+   * Name of the changelog file.
+   * @default "CHANGELOG.md"
+   */
+  changelog: z.string(),
+  /**
+   * The header to be used in 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: z.string(),
+  /**
+   * Files to be updated.
+   * @default
+   * ```js
+   * ["bower.json", "manifest.json", "npm-shrinkwrap.json", "package-lock.json", "package.json"]
+   * ```
+   */
+  files: z.array(z.string()),
+  /**
+   * Specify a prefix for the git tag fork-version will create.
+   *
+   * 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:
+   *
+   * | 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: z.string(),
+  /**
+   * Make a pre-release with optional label, if value is a string it will be used as the
+   * pre-release tag.
+   *
+   * | Value     | 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
+   */
+  preReleaseTag: z.string().or(z.boolean()).optional(),
+  /**
+   * Commit all staged changes, not just files updated by fork-version.
+   * @default false
+   */
+  commitAll: z.boolean(),
+  /**
+   * If set we'll log debug information.
+   * @default false
+   */
+  debug: z.boolean(),
+  /**
+   * If true, no output will be written to disk or committed.
+   * @default false
+   */
+  dryRun: z.boolean(),
+  /**
+   * If true and we cant find a version in the list of `files`, we'll fallback
+   * and attempt to use the latest git tag to get the current version.
+   * @default true
+   */
+  gitTagFallback: z.boolean(),
+  /**
+   * If set, we'll gather information about the current version and exit.
+   * @default false
+   */
+  inspectVersion: z.boolean(),
+  /**
+   * Should we sign the git commit using GPG?
+   * @see {@link https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--Sltkeyidgt GPG Sign Commits}
+   * @default false
+   */
+  sign: z.boolean(),
+  /**
+   * If true, no output will be written to stdout.
+   * @default false
+   */
+  silent: z.boolean(),
+  /**
+   * If true, allow git to run git commit hooks.
+   * @default false
+   */
+  verify: z.boolean(),
+  /**
+   * If set, we'll use this version number instead of trying to find a version from the list of `files`.
+   * @example "1.0.0"
+   * @default undefined
+   */
+  currentVersion: z.string().optional(),
+  /**
+   * If set, we'll attempt to update the version number to this version, instead of incrementing
+   * using "conventional-commit".
+   * @example "2.0.0"
+   * @default undefined
+   */
+  nextVersion: z.string().optional(),
+  /**
+   * Override the default conventional-changelog preset configuration.
+   */
+  changelogPresetConfig: ChangelogPresetConfigSchema.partial()
+});
+function defineConfig(config) {
+  return config;
+}
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  path: process.cwd(),
+  changelog: "CHANGELOG.md",
+  files: [
+    "package.json",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "manifest.json",
+    // Chrome extensions
+    "bower.json"
+  ],
+  header: `# 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.
+`,
+  tagPrefix: "v",
+  commitAll: false,
+  debug: false,
+  dryRun: false,
+  gitTagFallback: true,
+  inspectVersion: false,
+  sign: false,
+  silent: false,
+  verify: false,
+  changelogPresetConfig: {}
+};
+function getCliArguments() {
+  return meow(
+    `
+Usage:
+  $ fork-version [options]
+
+Options:
+  --path [Default: process.cwd()]
+    The path fork-version will run from.
+  --changelog [Default: "CHANGELOG.md"]
+    Name of the changelog file.
+  --header, -H
+    The header to be used in the changelog.
+  --files, --file, -F [Default: ["bower.json", "manifest.json", "npm-shrinkwrap.json", "package-lock.json", "package.json"]]
+    Files to be updated.
+  --tag-prefix [Default: "v"]
+    Specify a prefix for the git tag "fork-version" will create.
+  --pre-release-tag [Default: undefined]
+    Make a pre-release with optional label, If value is a string it
+    will be used as the pre-release tag.
+
+  --commit-all
+    Commit all staged changes, not just files updated by fork-version.
+  --debug
+    If true, we'll output debug information.
+  --dry-run
+    If true, no output will be written to disk or committed.
+  --git-tag-fallback [Default: true]
+    If true and we cant find a version in the given files, we'll fallback
+    and attempt to use the latest git tag for the current version.
+  --inspect-version
+    If set, we'll gather information about the current version and exit.
+  --sign
+    Should we sign the git commit using GPG?
+  --silent
+    If true, no output will be written to stdout.
+  --verify
+    If true, allow git to run git commit hooks.
+
+  --current-version
+    If set, we'll use this version number instead of trying to find a
+    version in a "file".
+  --next-version
+    If set, we'll attempt to update the version number to this version,
+    instead of incrementing using "conventional-commit".
+`,
+    {
+      importMeta: import.meta,
+      flags: {
+        path: { type: "string", default: process.cwd() },
+        changelog: { type: "string" },
+        header: { type: "string", shortFlag: "H" },
+        files: { type: "string", isMultiple: true, aliases: ["file"], shortFlag: "F" },
+        tagPrefix: { type: "string" },
+        preReleaseTag: { type: "string" },
+        commitAll: { type: "boolean" },
+        debug: { type: "boolean" },
+        dryRun: { type: "boolean" },
+        gitTagFallback: { type: "boolean" },
+        inspectVersion: { type: "boolean" },
+        sign: { type: "boolean" },
+        silent: { type: "boolean" },
+        verify: { type: "boolean" },
+        currentVersion: { type: "string" },
+        nextVersion: { type: "string" }
+      }
+    }
+  );
+}
+function getChangelogPresetConfig(usersChangelogPresetConfig) {
+  const preset = {
+    name: "conventionalcommits"
+  };
+  if (typeof conventionalChangelogConfigSpec.properties === "object") {
+    Object.entries(conventionalChangelogConfigSpec.properties).forEach(([key, value]) => {
+      if ("default" in value && value.default !== void 0) {
+        preset[key] = value.default;
+      }
+    });
+  }
+  if (usersChangelogPresetConfig && typeof usersChangelogPresetConfig === "object") {
+    Object.entries(usersChangelogPresetConfig).forEach(([key, value]) => {
+      if (value !== void 0) {
+        preset[key] = value;
+      }
+    });
+  }
+  return ChangelogPresetConfigSchema.passthrough().parse(preset);
+}
+
+// src/config/user-config.ts
+async function getUserConfig() {
+  const cliArguments = getCliArguments();
+  const cwd = cliArguments.flags.path ? resolve(cliArguments.flags.path) : process.cwd();
+  const joycon = new JoyCon();
+  const configFilePath = await joycon.resolve({
+    files: ["fork.config.ts", "fork.config.js", "fork.config.cjs", "fork.config.mjs"],
+    cwd,
+    stopDir: parse(cwd).root
+  });
+  if (!configFilePath) {
+    return {
+      ...DEFAULT_CONFIG,
+      ...cliArguments.flags,
+      path: cwd,
+      changelogPresetConfig: getChangelogPresetConfig()
+    };
+  }
+  const foundConfig = await bundleRequire({ filepath: configFilePath });
+  const parsedConfig = ForkConfigSchema.partial().safeParse(
+    foundConfig.mod.default || foundConfig.mod
+  );
+  if (!parsedConfig.success) {
+    throw parsedConfig.error;
+  }
+  const usersConfig = {
+    ...DEFAULT_CONFIG,
+    ...parsedConfig.data,
+    ...cliArguments.flags
+  };
+  const files = mergeFiles(parsedConfig.data?.files, cliArguments.flags?.files);
+  return {
+    ...usersConfig,
+    path: cwd,
+    files: files.length > 0 ? files : DEFAULT_CONFIG.files,
+    changelogPresetConfig: getChangelogPresetConfig(usersConfig?.changelogPresetConfig)
+  };
+}
+function mergeFiles(configFiles, cliFiles) {
+  return Array.from(
+    new Set(
+      [].concat(
+        Array.isArray(configFiles) ? configFiles : [],
+        Array.isArray(cliFiles) ? cliFiles : []
+      )
+    )
+  );
+}
+async function getLatestGitTagVersion(tagPrefix) {
+  const gitTags = await gitSemverTags({ tagPrefix });
+  if (!gitTags.length) {
+    return "1.0.0";
+  }
+  const cleanedTags = [];
+  for (const tag of gitTags) {
+    const cleanedTag = semver3.clean(tag.replace(new RegExp(`^${tagPrefix}`), ""));
+    if (cleanedTag) {
+      cleanedTags.push(cleanedTag);
+    }
+  }
+  return cleanedTags.sort(semver3.rcompare)[0];
+}
+function getPriority(type) {
+  return ["patch", "minor", "major"].indexOf(type ?? "");
+}
+function getVersionType(version) {
+  const parseVersion = semver3.parse(version);
+  if (parseVersion?.major) {
+    return "major";
+  } else if (parseVersion?.minor) {
+    return "minor";
+  } else if (parseVersion?.patch) {
+    return "patch";
+  }
+  return void 0;
+}
+function getReleaseType(releaseType, currentVersion, preReleaseTag) {
+  if (!preReleaseTag) {
+    return releaseType;
+  }
+  const currentVersionsIsPreRelease = Array.isArray(semver3.prerelease(currentVersion));
+  if (currentVersionsIsPreRelease) {
+    const currentReleaseType = getVersionType(currentVersion);
+    if (currentReleaseType === releaseType || getPriority(currentReleaseType) > getPriority(releaseType)) {
+      return "prerelease";
+    }
+  }
+  return `pre${releaseType}`;
+}
+
+// src/process/version.ts
+async function getCurrentVersion(config, logger, fileManager) {
+  const files = [];
+  const versions = /* @__PURE__ */ new Set();
+  for (const file of config.files) {
+    const fileState = fileManager.read(file);
+    if (fileState) {
+      files.push(fileState);
+      if (config.currentVersion) {
+        continue;
+      }
+      versions.add(fileState.version);
+    }
+  }
+  if (config.currentVersion) {
+    versions.add(config.currentVersion);
+  }
+  if (versions.size === 0) {
+    if (config.gitTagFallback) {
+      const version = await getLatestGitTagVersion(config.tagPrefix);
+      if (version) {
+        return {
+          files: [],
+          version
+        };
+      }
+    }
+    throw new Error("Unable to find current version");
+  } else if (versions.size > 1) {
+    throw new Error("Found multiple versions");
+  }
+  const currentVersion = versions.entries().next().value[0];
+  if (config.inspectVersion) {
+    console.log(currentVersion);
+    process.exit(0);
+  }
+  logger.log(`Current version: ${currentVersion}`);
+  return {
+    files,
+    version: currentVersion
+  };
+}
+async function getNextVersion(config, logger, currentVersion) {
+  if (config.nextVersion && semver3.valid(config.nextVersion)) {
+    logger.log(`Next version: ${config.nextVersion}`);
+    return { version: config.nextVersion };
+  }
+  const isPreMajor = semver3.lt(currentVersion, "1.0.0");
+  let recommendedBump;
+  try {
+    recommendedBump = await conventionalRecommendedBump({
+      preset: {
+        name: "conventionalcommits",
+        ...config.changelogPresetConfig,
+        preMajor: isPreMajor
+      },
+      path: config.path,
+      tagPrefix: config.tagPrefix,
+      cwd: config.path
+    });
+  } catch (error) {
+    throw new Error(`[conventional-recommended-bump] Unable to determine next version`);
+  }
+  if (recommendedBump.releaseType) {
+    const releaseType = getReleaseType(
+      recommendedBump.releaseType,
+      currentVersion,
+      config.preReleaseTag
+    );
+    const state = {
+      ...recommendedBump,
+      preMajor: isPreMajor,
+      releaseType,
+      version: semver3.inc(
+        currentVersion,
+        releaseType,
+        typeof config.preReleaseTag === "string" ? config.preReleaseTag : void 0
+      ) ?? ""
+    };
+    logger.log(`Next version: ${state.version} (${state.releaseType})`);
+    return state;
+  }
+  throw new Error("Unable to find next version");
+}
+function fileExists(filePath) {
+  try {
+    return lstatSync(filePath).isFile();
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/process/changelog.ts
+var RELEASE_PATTERN = /(^#+ \[?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m;
+function getOldReleaseContent(filePath, exists) {
+  if (exists) {
+    const fileContents = readFileSync(filePath, "utf-8");
+    const oldContentStart = fileContents.search(RELEASE_PATTERN);
+    if (oldContentStart !== -1) {
+      return fileContents.substring(oldContentStart);
+    }
+  }
+  return "";
+}
+function getNewReleaseContent(config, logger, nextVersion) {
+  return new Promise((onResolve) => {
+    let newContent = "";
+    conventionalChangelog(
+      {
+        preset: {
+          name: "conventionalcommits",
+          ...config.changelogPresetConfig
+        },
+        tagPrefix: config.tagPrefix,
+        warn: (...message) => logger.error("conventional-changelog: ", ...message),
+        cwd: config.path
+      },
+      {
+        version: nextVersion
+      },
+      {
+        merges: null,
+        path: config.path
+      }
+    ).on("error", (error) => {
+      logger.error("conventional-changelog: Unable to parse changes");
+      throw error;
+    }).on("data", (chunk) => {
+      newContent += chunk.toString();
+    }).on("end", () => {
+      onResolve(newContent);
+    });
+  });
+}
+async function updateChangelog(config, logger, nextVersion) {
+  if (config.header.search(RELEASE_PATTERN) !== -1) {
+    throw new Error("Header cannot contain release pattern");
+  }
+  const changelogPath = resolve(config.path, config.changelog);
+  if (!config.dryRun && !fileExists(changelogPath)) {
+    logger.log(`Creating Changelog file: ${changelogPath}`);
+    writeFileSync(changelogPath, "\n", "utf8");
+  }
+  const oldContent = getOldReleaseContent(changelogPath, fileExists(changelogPath));
+  const newContent = await getNewReleaseContent(config, logger, nextVersion);
+  logger.log(`Updating Changelog: ${changelogPath}`);
+  if (!config.dryRun && newContent) {
+    writeFileSync(
+      changelogPath,
+      `${config.header}
+${newContent}
+${oldContent}
+`,
+      "utf8"
+    );
+  }
+  return {
+    changelogPath,
+    oldContent,
+    newContent
+  };
+}
+var Git = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.add = this.add.bind(this);
+    this.commit = this.commit.bind(this);
+    this.tag = this.tag.bind(this);
+    this.revParse = this.revParse.bind(this);
+  }
+  add(...args) {
+    return this.execGit("add", args.filter(Boolean));
+  }
+  commit(...args) {
+    return this.execGit("commit", args.filter(Boolean));
+  }
+  tag(...args) {
+    return this.execGit("tag", args.filter(Boolean));
+  }
+  revParse(...args) {
+    return this.execGit("rev-parse", args.filter(Boolean));
+  }
+  execGit(command, args) {
+    if (this.config.dryRun) {
+      return Promise.resolve("");
+    }
+    this.logger.debug(`Executing: git ${command} ${args.join(" ")}`);
+    return new Promise((onResolve, onReject) => {
+      execFile(
+        "git",
+        [command, ...args],
+        {
+          cwd: this.config.path
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            this.logger.error(`git ${command}:`);
+            onReject(error);
+          }
+          onResolve(stdout ? stdout : stderr);
+        }
+      );
+    });
+  }
+};
+
+// src/utils/format-commit-message.ts
+function formatCommitMessage(message, version) {
+  if (!message) {
+    message = "chore(release): {{currentTag}}";
+  }
+  return message.replace(new RegExp("{{currentTag}}", "g"), version);
+}
+
+// src/process/commit.ts
+async function commitChanges(config, logger, files, nextVersion) {
+  const git = new Git(config, logger);
+  logger.log("Committing changes");
+  const filesToCommit = [];
+  if (fileExists(resolve(config.path, config.changelog))) {
+    filesToCommit.push(resolve(config.path, config.changelog));
+  }
+  for (const file of files) {
+    filesToCommit.push(file.path);
+  }
+  if (filesToCommit.length === 0) {
+    return {
+      filesToCommit
+    };
+  }
+  const shouldVerify = config.verify ? void 0 : "--no-verify";
+  const shouldSign = config.sign ? "--gpg-sign" : void 0;
+  if (config.commitAll) {
+    return {
+      filesToCommit,
+      gitAddOutput: await git.add("--all"),
+      gitCommitOutput: await git.commit(
+        shouldVerify,
+        shouldSign,
+        "--message",
+        formatCommitMessage(config.changelogPresetConfig?.releaseCommitMessageFormat, nextVersion)
+      )
+    };
+  }
+  return {
+    filesToCommit,
+    gitAddOutput: await git.add(...filesToCommit),
+    gitCommitOutput: await git.commit(
+      shouldVerify,
+      shouldSign,
+      ...filesToCommit,
+      "--message",
+      formatCommitMessage(config.changelogPresetConfig?.releaseCommitMessageFormat, nextVersion)
+    )
+  };
+}
+
+// src/process/tag.ts
+async function tagChanges(config, logger, nextVersion) {
+  const git = new Git(config, logger);
+  const tag = `${config.tagPrefix}${nextVersion}`;
+  logger.log(`Creating Tag: ${tag}`);
+  const gitTagOutput = await git.tag(
+    config.sign ? "--sign" : "--annotate",
+    tag,
+    "--message",
+    formatCommitMessage(config.changelogPresetConfig?.releaseCommitMessageFormat, nextVersion)
+  );
+  return {
+    gitTagOutput
+  };
+}
+
+// src/libs/stringify-package.ts
+var DEFAULT_INDENT = 2;
+var CRLF = "\r\n";
+var LF = "\n";
+function stringifyPackage(data, indent, newline) {
+  const stringified = JSON.stringify(data, null, indent ?? DEFAULT_INDENT);
+  if (newline === CRLF) {
+    return stringified.replace(new RegExp(LF, "g"), CRLF);
+  }
+  return stringified;
+}
+
+// src/strategies/json-package.ts
+var JSONPackage = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  read(fileName) {
+    const filePath = resolve(this.config.path, fileName);
+    if (fileExists(filePath)) {
+      const fileContents = readFileSync(filePath, "utf8");
+      const parsedJson = JSON.parse(fileContents);
+      if (parsedJson.version) {
+        return {
+          name: fileName,
+          path: filePath,
+          version: parsedJson.version,
+          isPrivate: typeof parsedJson?.private === "boolean" ? parsedJson.private : true
+        };
+      }
+      this.logger.warn(`Unable to determine json package file: ${fileName}`);
+    }
+  }
+  write(filePath, newVersion) {
+    const fileContents = readFileSync(filePath, "utf8");
+    const parsedJson = JSON.parse(fileContents);
+    parsedJson.version = newVersion;
+    if (parsedJson.packages?.[""]) {
+      parsedJson.packages[""].version = newVersion;
+    }
+    writeFileSync(
+      filePath,
+      stringifyPackage(parsedJson, detectIndent(fileContents).amount, detectNewline(fileContents)),
+      "utf8"
+    );
+  }
+};
+var PlainText = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  read(fileName) {
+    const filePath = resolve(this.config.path, fileName);
+    if (fileExists(filePath)) {
+      const fileContents = readFileSync(filePath, "utf8");
+      return {
+        name: fileName,
+        path: filePath,
+        version: fileContents || ""
+      };
+    }
+    this.logger.warn(`Unable to determine plain text file: ${fileName}`);
+  }
+  write(filePath, newVersion) {
+    writeFileSync(filePath, newVersion, "utf8");
+  }
+};
+
+// src/strategies/file-manager.ts
+var FileManager = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.JSONPackage = new JSONPackage(config, logger);
+    this.PlainText = new PlainText(config, logger);
+  }
+  JSONPackage;
+  PlainText;
+  /**
+   * 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(fileName) {
+    if (fileName.toLowerCase().endsWith(".json")) {
+      return this.JSONPackage.read(fileName);
+    } else if (fileName.toLowerCase().endsWith("version.txt")) {
+      return this.PlainText.read(fileName);
+    }
+    this.logger.error(`Unsupported file type: ${fileName}`);
+  }
+  /**
+   * Write the new version to the given file path.
+   *
+   * @example
+   * ```ts
+   * fileManager.write("/path/to/package.json", "1.2.3");
+   * ```
+   */
+  write(filePath, newVersion) {
+    if (this.config.dryRun) {
+      this.logger.log(`[Dry run]: Not updating ${filePath}`);
+      return;
+    }
+    if (filePath.toLowerCase().endsWith(".json")) {
+      return this.JSONPackage.write(filePath, newVersion);
+    } else if (filePath.toLowerCase().endsWith("version.txt")) {
+      return this.PlainText.write(filePath, newVersion);
+    }
+    this.logger.error(`Unsupported file type: ${filePath}`);
+  }
+};
+
+export { FileManager, ForkConfigSchema, Git, commitChanges, defineConfig, getCurrentVersion, getNextVersion, getUserConfig, tagChanges, updateChangelog };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-S2VPLFG2.js.map