fork-version 1.4.14 → 1.4.48

package/dist/chunk-X4ZM273H.js

@@ -1,712 +0,0 @@
-import path, { resolve, extname } from 'node:path';
-import JoyCon from 'joycon';
-import { bundleRequire } from 'bundle-require';
-import { z } from 'zod';
-import conventionalChangelogConfigSpec from 'conventional-changelog-config-spec';
-import meow from 'meow';
-import { writeFileSync, lstatSync, readFileSync, accessSync, constants, existsSync } from 'node:fs';
-import gitSemverTags from 'git-semver-tags';
-import semver from 'semver';
-import conventionalRecommendedBump from 'conventional-recommended-bump';
-import detectIndent from 'detect-indent';
-import detectNewLine from 'detect-newline';
-import conventionalChangelog from 'conventional-changelog';
-import { execFile } from 'node:child_process';
-
-// src/configuration.ts
-var ForkConfigSchema = z.object({
-  /**
-   * The path where the changes should be calculated from.
-   * @default
-   * ```js
-   * process.cwd()
-   * ```
-   */
-  changePath: z.string(),
-  /**
-   * The name of the changelog file.
-   * @default "CHANGELOG.md"
-   */
-  changelog: z.string(),
-  /**
-   * Files to be updated.
-   * @default
-   * ```js
-   * ["bower.json", "manifest.json", "npm-shrinkwrap.json", "package-lock.json", "package.json"]
-   * ```
-   */
-  outFiles: z.array(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(),
-  /**
-   * Specify a prefix for the git tag that will be taken into account during the comparison.
-   *
-   * For instance if your version tag is prefixed by `version/` instead of `v` you would
-   * have to specify `tagPrefix: "version/"`.
-   * @default `v`
-   */
-  tagPrefix: z.string(),
-  /**
-   * Make a pre-release with optional label to specify a tag id.
-   * @example true, "alpha", "beta", "rc", etc.
-   * @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 true, no output will be written to disk or committed.
-   * @default false
-   */
-  dryRun: z.boolean(),
-  /**
-   * If true and we cant find a version in an `outFiles`, we'll fallback and attempt
-   * to use the latest git tag for the current version.
-   * @default true
-   */
-  gitTagFallback: 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 it in an `outFiles`.
-   * @example "1.0.0"
-   * @default undefined
-   */
-  currentVersion: z.string().optional(),
-  /**
-   * If set, we'll attempt to update the version number to this version.
-   * @example "2.0.0"
-   * @default undefined
-   */
-  nextVersion: z.string().optional(),
-  /**
-   * Override the default conventional-changelog preset configuration.
-   */
-  changelogPresetConfig: 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()
-      })
-    ).optional(),
-    /**
-     * A URL representing a specific commit at a hash.
-     */
-    commitUrlFormat: z.string().optional(),
-    /**
-     * A URL representing the comparison between two git SHAs.
-     */
-    compareUrlFormat: z.string().optional(),
-    /**
-     * A URL representing the issue format (allowing a different URL format to be swapped in for Gitlab, Bitbucket, etc).
-     */
-    issueUrlFormat: z.string().optional(),
-    /**
-     * 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.
-     */
-    userUrlFormat: z.string().optional(),
-    /**
-     * A string to be used to format the auto-generated release commit message.
-     */
-    releaseCommitMessageFormat: z.string().optional(),
-    /**
-     * An array of prefixes used to detect references to issues
-     */
-    issuePrefixes: z.array(z.string()).optional()
-  }),
-  /**
-   * Log function, can be used to override the default `console.log` function
-   * to log to a file or another service.
-   * @default console.log
-   */
-  log: z.function().args(z.string()).returns(z.void()),
-  /**
-   * Error logger function, can be used to override the default `console.error`
-   * function to log to a file or another service.
-   * @default console.error
-   */
-  error: z.function().args(z.string()).returns(z.void()),
-  /**
-   * Debug logger function, by default this is a noop function, but can be replaced
-   * with a custom logger function or `console.info` to print output.
-   * @default  () => {}
-   */
-  debug: z.function().args(z.string()).returns(z.void())
-});
-var DEFAULT_CONFIG = {
-  changePath: process.cwd(),
-  changelog: "CHANGELOG.md",
-  outFiles: [
-    "bower.json",
-    "manifest.json",
-    // Chrome extensions
-    "npm-shrinkwrap.json",
-    "package-lock.json",
-    "package.json"
-  ],
-  header: "# Changelog\n\nAll notable changes to this project will be documented in this file. See [fork-version](https://github.com/eglavin/fork-version) for commit guidelines.\n",
-  tagPrefix: "v",
-  commitAll: false,
-  dryRun: false,
-  gitTagFallback: true,
-  sign: false,
-  silent: false,
-  verify: false,
-  changelogPresetConfig: {},
-  log: console.log,
-  // eslint-disable-line no-console
-  error: console.error,
-  // eslint-disable-line no-console
-  debug: () => {
-  }
-};
-function defineConfig(config) {
-  return config;
-}
-function getPresetDefaults(usersChangelogPresetConfig) {
-  const preset = {
-    name: "conventionalcommits"
-  };
-  if (typeof conventionalChangelogConfigSpec.properties === "object") {
-    Object.entries(conventionalChangelogConfigSpec.properties).forEach(([key, value]) => {
-      const _value = 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 preset;
-}
-function getCliArguments() {
-  return meow(
-    `
-Usage:
-	$ fork-version
-
-Options:
-	--changelog
-		Name of the changelog file. [Default: "CHANGELOG.md"]
-	--outFiles
-		Files to be updated. [Default: ["bower.json", "manifest.json", "npm-shrinkwrap.json", "package-lock.json", "package.json"]]
-	--header, -H
-		The header to be used in the changelog.
-
-	--tagPrefix
-		Specify a prefix for the git tag that will be taken into account during the comparison. [Default: "v"]
-	--preReleaseTag
-		Make a pre-release with optional label to specify a tag id. [Default: undefined]
-
-	--commitAll
-		Commit all staged changes, not just files updated by fork-version.
-	--dryRun
-		If true, no output will be written to disk or committed.
-	--gitTagFallback
-		If true and we cant find a version in an outFiles, we'll fallback and attempt to use the latest git tag for the current version. [Default: true]
-	--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.
-
-	--currentVersion
-		If set, we'll use this current version number instead of trying to find it in an outFiles.
-	--nextVersion
-		If set, we'll attempt to update to this version.
-`,
-    {
-      importMeta: import.meta,
-      flags: {
-        changelog: {
-          type: "string"
-        },
-        outFiles: {
-          type: "string",
-          isMultiple: true
-        },
-        header: {
-          type: "string",
-          shortFlag: "H"
-        },
-        tagPrefix: {
-          type: "string"
-        },
-        preReleaseTag: {
-          type: "string"
-        },
-        commitAll: {
-          type: "boolean"
-        },
-        dryRun: {
-          type: "boolean"
-        },
-        gitTagFallback: {
-          type: "boolean"
-        },
-        sign: {
-          type: "boolean"
-        },
-        silent: {
-          type: "boolean"
-        },
-        verify: {
-          type: "boolean"
-        },
-        currentVersion: {
-          type: "string"
-        },
-        nextVersion: {
-          type: "string"
-        }
-      }
-    }
-  );
-}
-async function getForkConfig() {
-  const cwd = process.cwd();
-  const joycon = new JoyCon.default();
-  const configPath = await joycon.resolve({
-    files: ["fork.config.js"],
-    cwd,
-    stopDir: path.parse(cwd).root
-  });
-  const cliArguments = getCliArguments();
-  if (configPath) {
-    const foundConfig = await bundleRequire({ filepath: configPath });
-    const parsedConfig = ForkConfigSchema.partial().safeParse(
-      foundConfig.mod.default || foundConfig.mod
-    );
-    if (parsedConfig.success) {
-      const usersConfig = Object.assign({}, DEFAULT_CONFIG, parsedConfig.data, cliArguments.flags);
-      if ("debug" in parsedConfig && typeof parsedConfig.debug === "function") {
-        usersConfig.debug = parsedConfig.debug;
-      }
-      if (usersConfig.silent) {
-        usersConfig.log = () => {
-        };
-        usersConfig.error = () => {
-        };
-        usersConfig.debug = () => {
-        };
-      }
-      const mergedOutFiles = DEFAULT_CONFIG.outFiles.concat(
-        parsedConfig.data?.outFiles || [],
-        cliArguments.flags?.outFiles || []
-      );
-      return Object.assign(usersConfig, {
-        changelogPresetConfig: getPresetDefaults(usersConfig?.changelogPresetConfig),
-        outFiles: Array.from(new Set(mergedOutFiles))
-      });
-    } else {
-      throw parsedConfig.error;
-    }
-  }
-  return Object.assign(DEFAULT_CONFIG, cliArguments.flags, {
-    changelogPresetConfig: getPresetDefaults()
-  });
-}
-
-// 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 || (indent === 0 ? 0 : DEFAULT_INDENT));
-  if (newline === CRLF) {
-    return stringified.replace(new RegExp(LF, "g"), CRLF);
-  }
-  return stringified;
-}
-
-// src/process/version.ts
-function getFile(options, fileToGet) {
-  try {
-    const fileExtension = extname(fileToGet);
-    if (fileExtension === ".json") {
-      const filePath = resolve(options.changePath, fileToGet);
-      if (existsSync(filePath)) {
-        const fileContents = readFileSync(filePath, "utf8");
-        const parsedJson = JSON.parse(fileContents);
-        if (parsedJson.version) {
-          return {
-            name: fileToGet,
-            path: filePath,
-            type: "package-file",
-            version: parsedJson.version,
-            isPrivate: "private" in parsedJson && (typeof parsedJson.private === "boolean" ? parsedJson.private : false)
-          };
-        } else {
-          options.log(`Unable to find version in file: ${fileToGet}`);
-        }
-      }
-    }
-  } catch (error) {
-    options.error(`Error reading file: ${fileToGet}`, error);
-  }
-}
-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 = semver.clean(tag.replace(new RegExp(`^${tagPrefix}`), ""));
-    if (cleanedTag) {
-      cleanedTags.push(cleanedTag);
-    }
-  }
-  return cleanedTags.sort(semver.rcompare)[0];
-}
-async function getCurrentVersion(options) {
-  const files = [];
-  const versions = [];
-  for (const file of options.outFiles) {
-    const fileState = getFile(options, file);
-    if (fileState) {
-      files.push(fileState);
-      if (options.currentVersion) {
-        continue;
-      }
-      if (!versions.includes(fileState.version)) {
-        versions.push(fileState.version);
-      }
-    }
-  }
-  if (options.currentVersion) {
-    versions.push(options.currentVersion);
-  }
-  if (versions.length === 0) {
-    if (options.gitTagFallback) {
-      const version = await getLatestGitTagVersion(options.tagPrefix);
-      if (version) {
-        return {
-          files: [],
-          currentVersion: version
-        };
-      }
-    }
-    throw new Error("Unable to find current version");
-  } else if (versions.length > 1) {
-    throw new Error("Found multiple versions");
-  }
-  return {
-    files,
-    currentVersion: versions[0]
-  };
-}
-function getPriority(type) {
-  return ["patch", "minor", "major"].indexOf(type || "");
-}
-function getVersionType(version) {
-  const parseVersion = semver.parse(version);
-  if (parseVersion?.major) {
-    return "major";
-  } else if (parseVersion?.minor) {
-    return "minor";
-  } else if (parseVersion?.patch) {
-    return "patch";
-  }
-  return void 0;
-}
-function getReleaseType(releaseType, currentVersion, preReleaseTag) {
-  if (!preReleaseTag) {
-    return releaseType;
-  }
-  if (Array.isArray(semver.prerelease(currentVersion))) {
-    const currentReleaseType = getVersionType(currentVersion);
-    if (currentReleaseType === releaseType || getPriority(currentReleaseType) > getPriority(releaseType)) {
-      return "prerelease";
-    }
-  }
-  return `pre${releaseType}`;
-}
-async function getNextVersion(options, currentVersion) {
-  if (options.nextVersion && semver.valid(options.nextVersion)) {
-    return { nextVersion: options.nextVersion };
-  }
-  const preMajor = semver.lt(currentVersion, "1.0.0");
-  const recommendedBump = await conventionalRecommendedBump({
-    preset: {
-      name: "conventionalcommits",
-      ...options.changelogPresetConfig || {},
-      preMajor
-    },
-    path: options.changePath,
-    tagPrefix: options.tagPrefix,
-    cwd: options.changePath
-  });
-  if (recommendedBump.releaseType) {
-    const releaseType = getReleaseType(
-      recommendedBump.releaseType,
-      currentVersion,
-      options.preReleaseTag
-    );
-    return Object.assign(recommendedBump, {
-      preMajor,
-      releaseType,
-      nextVersion: semver.inc(
-        currentVersion,
-        releaseType,
-        typeof options.preReleaseTag === "string" ? options.preReleaseTag : void 0
-      ) || ""
-    });
-  }
-  throw new Error("Unable to find next version");
-}
-function updateFile(options, fileToUpdate, type, nextVersion) {
-  try {
-    if (type === "package-file") {
-      if (!lstatSync(fileToUpdate).isFile())
-        return;
-      const fileContents = readFileSync(fileToUpdate, "utf8");
-      const indent = detectIndent(fileContents).indent;
-      const newline = detectNewLine(fileContents);
-      const parsedJson = JSON.parse(fileContents);
-      parsedJson.version = nextVersion;
-      if (parsedJson.packages && parsedJson.packages[""]) {
-        parsedJson.packages[""].version = nextVersion;
-      }
-      if (!options.dryRun) {
-        writeFileSync(fileToUpdate, stringifyPackage(parsedJson, indent, newline), "utf8");
-      }
-    }
-  } catch (error) {
-    options.error("Error writing: ", error);
-  }
-}
-async function bumpVersion(options) {
-  const current = await getCurrentVersion(options);
-  const next = await getNextVersion(options, current.currentVersion);
-  options.log(`Current version: ${current.currentVersion}
-Next version: ${next.nextVersion} (${next.releaseType})
-Updating Files: `);
-  for (const outFile of current.files) {
-    options.log(`	${outFile.path}`);
-    updateFile(options, outFile.path, outFile.type, next.nextVersion);
-  }
-  return {
-    currentVersion: current.currentVersion,
-    files: current.files,
-    nextVersion: next.nextVersion,
-    level: next.level,
-    preMajor: next.preMajor,
-    reason: next.reason,
-    releaseType: next.releaseType
-  };
-}
-function createChangelog(options) {
-  const changelogPath = resolve(options.changelog);
-  try {
-    accessSync(changelogPath, constants.F_OK);
-  } catch (err) {
-    if (!options.dryRun && err.code === "ENOENT") {
-      options.log(`Creating Changelog file: ${changelogPath}`);
-      writeFileSync(changelogPath, "\n", "utf8");
-    }
-  }
-  return {
-    path: changelogPath,
-    exists: existsSync(changelogPath)
-  };
-}
-var RELEASE_PATTERN = /(^#+ \[?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m;
-function getOldReleaseContent(changelog) {
-  if (changelog.exists) {
-    const fileContents = readFileSync(changelog.path, "utf-8");
-    const oldContentStart = fileContents.search(RELEASE_PATTERN);
-    if (oldContentStart !== -1) {
-      return fileContents.substring(oldContentStart);
-    }
-  }
-  return "";
-}
-function getNewReleaseContent(options, bumpResult) {
-  return new Promise((resolve3) => {
-    let newContent = "";
-    conventionalChangelog(
-      {
-        preset: {
-          name: "conventionalcommits",
-          ...options.changelogPresetConfig || {}
-        },
-        tagPrefix: options.tagPrefix,
-        warn: (...message) => options.error("conventional-changelog: ", ...message),
-        cwd: options.changePath
-      },
-      {
-        version: bumpResult.nextVersion
-      },
-      {
-        merges: null,
-        path: options.changePath
-      }
-    ).on("error", (error) => {
-      options.error("conventional-changelog: Unable to parse changes");
-      throw error;
-    }).on("data", (chunk) => {
-      newContent += chunk.toString();
-    }).on("end", () => {
-      resolve3(newContent);
-    });
-  });
-}
-async function updateChangelog(options, bumpResult) {
-  if (options.header.search(RELEASE_PATTERN) !== -1) {
-    throw new Error("Header cannot contain release pattern");
-  }
-  const changelog = createChangelog(options);
-  const oldContent = getOldReleaseContent(changelog);
-  const newContent = await getNewReleaseContent(options, bumpResult);
-  options.log(`Updating Changelog:
-	${changelog.path}`);
-  if (!options.dryRun && newContent) {
-    writeFileSync(changelog.path, `${options.header}
-${newContent}
-${oldContent}`, "utf8");
-  }
-  return {
-    changelog,
-    oldContent,
-    newContent
-  };
-}
-function createExecute(options) {
-  async function executeGit(...execArgs) {
-    const args = execArgs.filter(Boolean);
-    options.debug(`Executing: git ${args.join(" ")}`);
-    if (!options.dryRun) {
-      return new Promise((resolve3) => {
-        execFile("git", args, (error, stdout, stderr) => {
-          if (error) {
-            options.error(`git ${args[0]}:`);
-            throw error;
-          }
-          resolve3(stdout ? stdout : stderr);
-        });
-      });
-    }
-    return "";
-  }
-  return {
-    executeGit
-  };
-}
-
-// src/utils/format-commit-message.ts
-function formatCommitMessage(message, newVersion) {
-  if (!message) {
-    message = "chore(release): {{currentTag}}";
-  }
-  return message.replace(new RegExp("{{currentTag}}", "g"), newVersion);
-}
-
-// src/process/commit.ts
-async function commitChanges(options, bumpResult) {
-  const { executeGit } = createExecute(options);
-  options.log("Committing changes");
-  const filesToCommit = [options.changelog];
-  for (const file of bumpResult.files) {
-    filesToCommit.push(file.name);
-  }
-  if (filesToCommit.length === 0) {
-    return {
-      filesToCommit
-    };
-  }
-  const gitAddOutput = await executeGit("add", ...filesToCommit);
-  const shouldVerify = options.verify ? void 0 : "--no-verify";
-  const shouldSign = options.sign ? "-S" : void 0;
-  const shouldCommitAll = options.commitAll ? [] : filesToCommit;
-  const gitCommitOutput = await executeGit(
-    "commit",
-    shouldVerify,
-    shouldSign,
-    ...shouldCommitAll,
-    "-m",
-    formatCommitMessage(
-      options.changelogPresetConfig?.releaseCommitMessageFormat,
-      bumpResult.nextVersion
-    )
-  );
-  return {
-    filesToCommit,
-    gitAddOutput,
-    gitCommitOutput
-  };
-}
-
-// src/process/tag.ts
-async function tagChanges(options, bumpResult) {
-  const { executeGit } = createExecute(options);
-  const shouldSign = options.sign ? "-s" : "-a";
-  const tag = `${options.tagPrefix}${bumpResult.nextVersion}`;
-  options.log(`Creating Tag: ${tag}`);
-  const gitTagOutput = await executeGit(
-    "tag",
-    shouldSign,
-    tag,
-    "-m",
-    formatCommitMessage(
-      options.changelogPresetConfig?.releaseCommitMessageFormat,
-      bumpResult.nextVersion
-    )
-  );
-  const currentBranchName = await executeGit("rev-parse", "--abbrev-ref", "HEAD");
-  const hasPublicPackageFile = bumpResult.files.some(
-    (file) => file.name === "package.json" && file.isPrivate === false
-  );
-  const isPreRelease = `${bumpResult.releaseType}`.startsWith("pre");
-  const pushMessage = `Run \`git push --follow-tags origin ${currentBranchName.trim()}\` to push the changes and the tag.`;
-  const publishMessage = isPreRelease ? `Run \`npm publish --tag ${typeof options.preReleaseTag === "string" ? options.preReleaseTag : "prerelease"}\` to publish the package.` : "Run `npm publish` to publish the package.";
-  options.log(`
-${pushMessage}
-${hasPublicPackageFile ? publishMessage : ""}`);
-  return {
-    gitTagOutput,
-    currentBranchName,
-    hasPublicPackageFile,
-    pushMessage,
-    publishMessage
-  };
-}
-
-export { bumpVersion, commitChanges, defineConfig, getForkConfig, tagChanges, updateChangelog };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-X4ZM273H.js.map