fork-version 1.4.6

package/README.md

@@ -0,0 +1,13 @@
+# Fork-Version
+
+Fork-version is a re-write of [standard-version](https://github.com/conventional-changelog/standard-version) following on from its deprecation in May 15, 2022.
+
+## Installation
+
+To install the package locally to your project you can use one of the following commands:
+
+| Manager | Command                                            |
+| ------- | -------------------------------------------------- |
+| npm     | `npm install fork-version --save-exact --save-dev` |
+| yarn    | `yarn add fork-version --exact --dev`              |
+| pnpm    | `pnpm add fork-version --save-exact --save-dev`    |

package/dist/chunk-2I73SGKO.cjs

@@ -0,0 +1,624 @@
+'use strict';
+
+var path = require('path');
+var JoyCon = require('joycon');
+var bundleRequire = require('bundle-require');
+var zod = require('zod');
+var conventionalChangelogConfigSpec = require('conventional-changelog-config-spec');
+var fs = require('fs');
+var gitSemverTags = require('git-semver-tags');
+var semver = require('semver');
+var conventionalRecommendedBump = require('conventional-recommended-bump');
+var detectIndent = require('detect-indent');
+var detectNewLine = require('detect-newline');
+var conventionalChangelog = require('conventional-changelog');
+var child_process = require('child_process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var JoyCon__default = /*#__PURE__*/_interopDefault(JoyCon);
+var conventionalChangelogConfigSpec__default = /*#__PURE__*/_interopDefault(conventionalChangelogConfigSpec);
+var gitSemverTags__default = /*#__PURE__*/_interopDefault(gitSemverTags);
+var semver__default = /*#__PURE__*/_interopDefault(semver);
+var conventionalRecommendedBump__default = /*#__PURE__*/_interopDefault(conventionalRecommendedBump);
+var detectIndent__default = /*#__PURE__*/_interopDefault(detectIndent);
+var detectNewLine__default = /*#__PURE__*/_interopDefault(detectNewLine);
+var conventionalChangelog__default = /*#__PURE__*/_interopDefault(conventionalChangelog);
+
+// src/configuration.ts
+var ForkConfigSchema = zod.z.object({
+  /**
+   * The path where the changes should be calculated from.
+   * @default
+   * ```js
+   * process.cwd()
+   * ```
+   */
+  changePath: zod.z.string(),
+  /**
+   * The name of the changelog file.
+   * @default "CHANGELOG.md"
+   */
+  changelog: zod.z.string(),
+  /**
+   * Files to be updated.
+   * @default
+   * ```js
+   * ["bower.json", "manifest.json", "npm-shrinkwrap.json", "package-lock.json", "package.json"]
+   * ```
+   */
+  outFiles: zod.z.array(zod.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: zod.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: zod.z.string(),
+  /**
+   * Make a pre-release with optional label to specify a tag id.
+   * @example true, "alpha", "beta", "rc", etc.
+   * @default undefined
+   */
+  preReleaseTag: zod.z.string().or(zod.z.boolean()).optional(),
+  /**
+   * Commit all staged changes, not just files updated by fork-version.
+   * @default false
+   */
+  commitAll: zod.z.boolean(),
+  /**
+   * If true, no output will be written to disk or committed.
+   * @default false
+   */
+  dryRun: zod.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: zod.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: zod.z.boolean(),
+  /**
+   * If true, no output will be written to stdout.
+   * @default false
+   */
+  silent: zod.z.boolean(),
+  /**
+   * If true, allow git to run git commit hooks.
+   * @default false
+   */
+  verify: zod.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: zod.z.string().optional(),
+  /**
+   * If set, we'll attempt to update the version number to this version.
+   * @example "2.0.0"
+   * @default undefined
+   */
+  nextVersion: zod.z.string().optional(),
+  /**
+   * Override the default conventional-changelog preset configuration.
+   */
+  changelogPresetConfig: zod.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: zod.z.array(
+      zod.z.object({
+        type: zod.z.string(),
+        section: zod.z.string().optional(),
+        hidden: zod.z.boolean().optional()
+      })
+    ).optional(),
+    /**
+     * A URL representing a specific commit at a hash.
+     */
+    commitUrlFormat: zod.z.string().optional(),
+    /**
+     * A URL representing the comparison between two git SHAs.
+     */
+    compareUrlFormat: zod.z.string().optional(),
+    /**
+     * A URL representing the issue format (allowing a different URL format to be swapped in for Gitlab, Bitbucket, etc).
+     */
+    issueUrlFormat: zod.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: zod.z.string().optional(),
+    /**
+     * A string to be used to format the auto-generated release commit message.
+     */
+    releaseCommitMessageFormat: zod.z.string().optional(),
+    /**
+     * An array of prefixes used to detect references to issues
+     */
+    issuePrefixes: zod.z.array(zod.z.string()).optional()
+  })
+});
+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) {
+  const parsedConfig = ForkConfigSchema.partial().safeParse(config);
+  if (parsedConfig.success) {
+    return parsedConfig.data;
+  }
+  return DEFAULT_CONFIG;
+}
+function getPresetDefaults(usersChangelogPresetConfig) {
+  const preset = {
+    name: "conventionalcommits"
+  };
+  if (typeof conventionalChangelogConfigSpec__default.default.properties === "object") {
+    Object.entries(conventionalChangelogConfigSpec__default.default.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;
+}
+async function getForkConfig() {
+  const cwd = process.cwd();
+  const joycon = new JoyCon__default.default.default();
+  const configPath = await joycon.resolve({
+    files: ["fork.config.js"],
+    cwd,
+    stopDir: path__default.default.parse(cwd).root
+  });
+  if (configPath) {
+    const foundConfig = await bundleRequire.bundleRequire({ filepath: configPath });
+    const parsedConfig = ForkConfigSchema.partial().safeParse(
+      foundConfig.mod.default || foundConfig.mod
+    );
+    if (parsedConfig.success) {
+      const mergedOutFiles = DEFAULT_CONFIG.outFiles.concat(parsedConfig.data?.outFiles || []);
+      const usersConfig = Object.assign(DEFAULT_CONFIG, parsedConfig.data, {
+        outFiles: Array.from(new Set(mergedOutFiles))
+      });
+      if (usersConfig.silent) {
+        usersConfig.log = () => {
+        };
+        usersConfig.error = () => {
+        };
+      }
+      if ("debug" in parsedConfig && typeof parsedConfig.debug === "function") {
+        usersConfig.debug = parsedConfig.debug;
+      }
+      return Object.assign(usersConfig, {
+        changelogPresetConfig: getPresetDefaults(usersConfig?.changelogPresetConfig)
+      });
+    }
+  }
+  return Object.assign(DEFAULT_CONFIG, {
+    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 = path.extname(fileToGet);
+    if (fileExtension === ".json") {
+      const filePath = path.resolve(options.changePath, fileToGet);
+      if (fs.existsSync(filePath)) {
+        const fileContents = fs.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__default.default({ tagPrefix });
+  if (!gitTags.length) {
+    return "1.0.0";
+  }
+  const cleanedTags = [];
+  for (const tag of gitTags) {
+    const cleanedTag = semver__default.default.clean(tag.replace(new RegExp(`^${tagPrefix}`), ""));
+    if (cleanedTag) {
+      cleanedTags.push(cleanedTag);
+    }
+  }
+  return cleanedTags.sort(semver__default.default.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__default.default.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__default.default.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__default.default.valid(options.nextVersion)) {
+    return { nextVersion: options.nextVersion };
+  }
+  const preMajor = semver__default.default.lt(currentVersion, "1.0.0");
+  const recommendedBump = await conventionalRecommendedBump__default.default({
+    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__default.default.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 (!fs.lstatSync(fileToUpdate).isFile())
+        return;
+      const fileContents = fs.readFileSync(fileToUpdate, "utf8");
+      const indent = detectIndent__default.default(fileContents).indent;
+      const newline = detectNewLine__default.default(fileContents);
+      const parsedJson = JSON.parse(fileContents);
+      parsedJson.version = nextVersion;
+      if (parsedJson.packages && parsedJson.packages[""]) {
+        parsedJson.packages[""].version = nextVersion;
+      }
+      if (!options.dryRun) {
+        fs.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 = path.resolve(options.changelog);
+  try {
+    fs.accessSync(changelogPath, fs.constants.F_OK);
+  } catch (err) {
+    if (!options.dryRun && err.code === "ENOENT") {
+      options.log(`Creating Changelog file: ${changelogPath}`);
+      fs.writeFileSync(changelogPath, "\n", "utf8");
+    }
+  }
+  return {
+    path: changelogPath,
+    exists: fs.existsSync(changelogPath)
+  };
+}
+var RELEASE_PATTERN = /(^#+ \[?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m;
+function getOldReleaseContent(changelog) {
+  if (changelog.exists) {
+    const fileContents = fs.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__default.default(
+      {
+        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) {
+    fs.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) => {
+        child_process.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
+  };
+}
+
+exports.bumpVersion = bumpVersion;
+exports.commitChanges = commitChanges;
+exports.defineConfig = defineConfig;
+exports.getForkConfig = getForkConfig;
+exports.tagChanges = tagChanges;
+exports.updateChangelog = updateChangelog;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-2I73SGKO.cjs.map