obsidian-dev-utils 2.27.0 → 3.0.1

package/dist/lib/scripts/version.cjs

@@ -0,0 +1,349 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var version_exports = {};
+__export(version_exports, {
+  VersionUpdateType: () => VersionUpdateType,
+  addGitTag: () => addGitTag,
+  addUpdatedFilesToGit: () => addUpdatedFilesToGit,
+  checkGitHubCliInstalled: () => checkGitHubCliInstalled,
+  checkGitInstalled: () => checkGitInstalled,
+  checkGitRepoClean: () => checkGitRepoClean,
+  copyUpdatedManifest: () => copyUpdatedManifest,
+  getNewVersion: () => getNewVersion,
+  getReleaseNotes: () => getReleaseNotes,
+  getVersionUpdateType: () => getVersionUpdateType,
+  gitPush: () => gitPush,
+  publishGitHubRelease: () => publishGitHubRelease,
+  updateChangelog: () => updateChangelog,
+  updateVersion: () => updateVersion,
+  updateVersionInFiles: () => updateVersionInFiles,
+  validate: () => validate
+});
+module.exports = __toCommonJS(version_exports);
+var import_adm_zip = __toESM(require("adm-zip"), 1);
+var import_ObsidianPluginRepoPaths = require("../obsidian/Plugin/ObsidianPluginRepoPaths.cjs");
+var import_Path = require("../Path.cjs");
+var import_Fs = require("./Fs.cjs");
+var import_JSON = require("./JSON.cjs");
+var import_NodeModules = require("./NodeModules.cjs");
+var import_Npm = require("./Npm.cjs");
+var import_ObsidianDevUtilsRepoPaths = require("./ObsidianDevUtilsRepoPaths.cjs");
+var import_Root = require("./Root.cjs");
+var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
+  const normalizedPath = __filename.replace(/\\/g, "/");
+  const windowsDriveLetterMatch = /^([a-zA-Z]):/.exec(normalizedPath);
+  let path = normalizedPath;
+  if (windowsDriveLetterMatch) {
+    path = `/${windowsDriveLetterMatch[1].toUpperCase()}:${normalizedPath.slice(2)}`;
+  }
+  const encodedPath = encodeURIComponent(path).replace(/%2F/g, "/").replace(/%3A/g, ":");
+  return new URL(`file://${encodedPath}`);
+})();
+var __process = globalThis["process"] ?? {
+  "cwd": () => "/",
+  "env": {},
+  "platform": "android"
+};
+var VersionUpdateType = /* @__PURE__ */ ((VersionUpdateType2) => {
+  VersionUpdateType2["Major"] = "major";
+  VersionUpdateType2["Minor"] = "minor";
+  VersionUpdateType2["Patch"] = "patch";
+  VersionUpdateType2["Beta"] = "beta";
+  VersionUpdateType2["Manual"] = "manual";
+  VersionUpdateType2["Invalid"] = "invalid";
+  return VersionUpdateType2;
+})(VersionUpdateType || {});
+async function updateVersion(versionUpdateType) {
+  if (!versionUpdateType) {
+    const npmOldVersion = __process.env["npm_old_version"];
+    const npmNewVersion = __process.env["npm_new_version"];
+    if (npmOldVersion && npmNewVersion) {
+      await updateVersionInFiles(npmOldVersion, false);
+      await updateVersion(npmNewVersion);
+      return;
+    }
+  }
+  const isObsidianPlugin = (0, import_NodeModules.existsSync)((0, import_Root.resolvePathFromRoot)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ManifestJson));
+  validate(versionUpdateType);
+  await checkGitInstalled();
+  await checkGitRepoClean();
+  await checkGitHubCliInstalled();
+  await (0, import_Root.execFromRoot)("npm run spellcheck");
+  await (0, import_Root.execFromRoot)("npm run build");
+  await (0, import_Root.execFromRoot)("npm run lint");
+  const newVersion = await getNewVersion(versionUpdateType);
+  await updateVersionInFiles(newVersion, isObsidianPlugin);
+  await updateChangelog(newVersion);
+  await addUpdatedFilesToGit(newVersion);
+  await addGitTag(newVersion);
+  await gitPush();
+  if (isObsidianPlugin) {
+    await copyUpdatedManifest();
+  }
+  await publishGitHubRelease(newVersion, isObsidianPlugin);
+}
+function validate(versionUpdateType) {
+  if (getVersionUpdateType(versionUpdateType) === "invalid" /* Invalid */) {
+    throw new Error("Invalid version update type. Please use 'major', 'minor', 'patch', or 'x.y.z[-suffix]' format.");
+  }
+}
+async function checkGitInstalled() {
+  try {
+    await (0, import_Root.execFromRoot)("git --version", { quiet: true });
+  } catch {
+    throw new Error("Git is not installed. Please install it from https://git-scm.com/");
+  }
+}
+async function checkGitHubCliInstalled() {
+  try {
+    await (0, import_Root.execFromRoot)("gh --version", { quiet: true });
+  } catch {
+    throw new Error("GitHub CLI is not installed. Please install it from https://cli.github.com/");
+  }
+}
+async function checkGitRepoClean() {
+  try {
+    const stdout = await (0, import_Root.execFromRoot)("git status --porcelain --untracked-files=all", { quiet: true });
+    if (stdout) {
+      throw new Error();
+    }
+  } catch {
+    throw new Error("Git repository is not clean. Please commit or stash your changes before releasing a new version.");
+  }
+}
+function getVersionUpdateType(versionUpdateType) {
+  const versionUpdateTypeEnum = versionUpdateType;
+  switch (versionUpdateTypeEnum) {
+    case "major" /* Major */:
+    case "minor" /* Minor */:
+    case "patch" /* Patch */:
+    case "beta" /* Beta */:
+      return versionUpdateTypeEnum;
+    default:
+      if (/^\d+\.\d+\.\d+(-[\w\d.-]+)?$/.test(versionUpdateType)) {
+        return "manual" /* Manual */;
+      }
+      return "invalid" /* Invalid */;
+  }
+}
+async function updateVersionInFiles(newVersion, isObsidianPlugin) {
+  await (0, import_Npm.editNpmPackage)((npmPackage) => {
+    npmPackage.version = newVersion;
+  });
+  await (0, import_Npm.editNpmPackageLock)((npmPackageLock) => {
+    npmPackageLock.version = newVersion;
+    const defaultPackage = npmPackageLock.packages?.[""];
+    if (defaultPackage) {
+      defaultPackage.version = newVersion;
+    }
+  }, { skipIfMissing: true });
+  if (isObsidianPlugin) {
+    const latestObsidianVersion = await getLatestObsidianVersion();
+    await (0, import_JSON.editJson)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ManifestJson, (manifest) => {
+      manifest.minAppVersion = latestObsidianVersion;
+      manifest.version = newVersion;
+    });
+    await (0, import_JSON.editJson)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.VersionsJson, (versions) => {
+      versions[newVersion] = latestObsidianVersion;
+    });
+  }
+}
+async function getNewVersion(versionUpdateType) {
+  const versionType = getVersionUpdateType(versionUpdateType);
+  if (versionType === "manual" /* Manual */) {
+    return versionUpdateType;
+  }
+  const npmPackage = await (0, import_Npm.readNpmPackage)();
+  const currentVersion = npmPackage.version;
+  const match = /^(\d+)\.(\d+)\.(\d+)(-beta.(\d+))?/.exec(currentVersion);
+  if (!match) {
+    throw new Error(`Invalid current version format: ${currentVersion}`);
+  }
+  let major = Number(match[1]);
+  let minor = Number(match[2]);
+  let patch = Number(match[3]);
+  let beta = match[5] ? Number(match[5]) : 0;
+  switch (versionType) {
+    case "major" /* Major */:
+      major++;
+      minor = 0;
+      patch = 0;
+      beta = 0;
+      break;
+    case "minor" /* Minor */:
+      minor++;
+      patch = 0;
+      beta = 0;
+      break;
+    case "patch" /* Patch */:
+      patch++;
+      beta = 0;
+      break;
+    case "beta" /* Beta */:
+      beta++;
+      break;
+  }
+  return `${major.toString()}.${minor.toString()}.${patch.toString()}${beta > 0 ? `-beta.${beta.toString()}` : ""}`;
+}
+async function getLatestObsidianVersion() {
+  const response = await fetch("https://api.github.com/repos/obsidianmd/obsidian-releases/releases/latest");
+  const obsidianReleasesJson = await response.json();
+  return obsidianReleasesJson.name;
+}
+async function updateChangelog(newVersion) {
+  const changelogPath = (0, import_Root.resolvePathFromRoot)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ChangelogMd);
+  let previousChangelogLines;
+  if (!(0, import_NodeModules.existsSync)(changelogPath)) {
+    previousChangelogLines = [];
+  } else {
+    const content = await (0, import_NodeModules.readFile)(changelogPath, "utf-8");
+    previousChangelogLines = content.split("\n").slice(2);
+    if (previousChangelogLines.at(-1) === "") {
+      previousChangelogLines.pop();
+    }
+  }
+  const lastTag = previousChangelogLines[0]?.replace("## ", "");
+  const commitRange = lastTag ? `${lastTag}..HEAD` : "HEAD";
+  const commitMessages = (await (0, import_Root.execFromRoot)(`git log ${commitRange} --format=%s --first-parent`, { quiet: true })).split(/\r?\n/);
+  let newChangeLog = `# CHANGELOG
+
+## ${newVersion}
+
+`;
+  for (const message of commitMessages) {
+    newChangeLog += `- ${message}
+`;
+  }
+  if (previousChangelogLines.length > 0) {
+    newChangeLog += "\n";
+    for (const line of previousChangelogLines) {
+      newChangeLog += `${line}
+`;
+    }
+  }
+  await (0, import_NodeModules.writeFile)(changelogPath, newChangeLog, "utf-8");
+  await (0, import_NodeModules.createInterface)(__process.stdin, __process.stdout).question(`Please update the ${import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ChangelogMd} file. Press Enter when you are done...`);
+}
+async function addUpdatedFilesToGit(newVersion) {
+  const files = [
+    import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ManifestJson,
+    import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.PackageJson,
+    import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.PackageLockJson,
+    import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.VersionsJson,
+    import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ChangelogMd
+  ].filter((file) => (0, import_NodeModules.existsSync)((0, import_Root.resolvePathFromRoot)(file)));
+  await (0, import_Root.execFromRoot)(["git", "add", ...files], { quiet: true });
+  await (0, import_Root.execFromRoot)(`git commit -m ${newVersion}`, { quiet: true });
+}
+async function addGitTag(newVersion) {
+  await (0, import_Root.execFromRoot)(`git tag -a ${newVersion} -m ${newVersion}`, { quiet: true });
+}
+async function gitPush() {
+  await (0, import_Root.execFromRoot)("git push --follow-tags", { quiet: true });
+}
+async function copyUpdatedManifest() {
+  await (0, import_NodeModules.cp)((0, import_Root.resolvePathFromRoot)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ManifestJson), (0, import_Root.resolvePathFromRoot)((0, import_Path.join)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.DistBuild, import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ManifestJson)), { force: true });
+}
+async function getReleaseNotes(newVersion) {
+  const changelogPath = (0, import_Root.resolvePathFromRoot)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.ChangelogMd);
+  const content = await (0, import_NodeModules.readFile)(changelogPath, "utf-8");
+  const newVersionEscaped = newVersion.replaceAll(".", "\\.");
+  const match = new RegExp(`
+## ${newVersionEscaped}
+
+((.|
+)+?)
+
+##`).exec(content);
+  let releaseNotes = match?.[1] ? match[1] + "\n\n" : "";
+  const tags = (await (0, import_Root.execFromRoot)("git tag --sort=-creatordate", { quiet: true })).split(/\r?\n/);
+  const previousVersion = tags[1];
+  let changesUrl = "";
+  const repoUrl = await (0, import_Root.execFromRoot)("gh repo view --json url -q .url", { quiet: true });
+  if (previousVersion) {
+    changesUrl = `${repoUrl}/compare/${previousVersion}...${newVersion}`;
+  } else {
+    changesUrl = `${repoUrl}/commits/${newVersion}`;
+  }
+  releaseNotes += `**Full Changelog**: ${changesUrl}`;
+  return releaseNotes;
+}
+async function publishGitHubRelease(newVersion, isObsidianPlugin) {
+  let filePaths;
+  if (isObsidianPlugin) {
+    const buildDir = (0, import_Root.resolvePathFromRoot)(import_ObsidianPluginRepoPaths.ObsidianPluginRepoPaths.DistBuild);
+    const fileNames = await (0, import_Fs.readdirPosix)(buildDir);
+    filePaths = fileNames.map((fileName) => (0, import_Path.join)(buildDir, fileName));
+  } else {
+    const zip = new import_adm_zip.default();
+    zip.addLocalFolder((0, import_Root.resolvePathFromRoot)(import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.Dist), import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.Dist, (filename) => !filename.endsWith(".zip"));
+    const files = [
+      import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.ChangelogMd,
+      import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.License,
+      import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.ReadmeMd,
+      import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.PackageJson
+    ];
+    for (const file of files) {
+      zip.addLocalFile((0, import_Root.resolvePathFromRoot)(file));
+    }
+    const npmPackage = await (0, import_Npm.readNpmPackage)();
+    const distZipPath = (0, import_Root.resolvePathFromRoot)((0, import_Path.join)(import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.Dist, `${npmPackage.name}-${newVersion}.zip`));
+    zip.writeZip(distZipPath);
+    filePaths = [distZipPath];
+  }
+  await (0, import_Root.execFromRoot)(["gh", "release", "create", newVersion, ...filePaths, "--title", `v${newVersion}`, "--notes-file", "-"], {
+    quiet: true,
+    stdin: await getReleaseNotes(newVersion)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VersionUpdateType,
+  addGitTag,
+  addUpdatedFilesToGit,
+  checkGitHubCliInstalled,
+  checkGitInstalled,
+  checkGitRepoClean,
+  copyUpdatedManifest,
+  getNewVersion,
+  getReleaseNotes,
+  getVersionUpdateType,
+  gitPush,
+  publishGitHubRelease,
+  updateChangelog,
+  updateVersion,
+  updateVersionInFiles,
+  validate
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/scripts/version.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis[\"import.meta.url\"] ?? (()=>{const normalizedPath=__filename.replace(/\\\\/g,\"/\");const windowsDriveLetterMatch=/^([a-zA-Z]):/.exec(normalizedPath);let path=normalizedPath;if(windowsDriveLetterMatch){path=`/${windowsDriveLetterMatch[1].toUpperCase()}:${normalizedPath.slice(2)}`}const encodedPath=encodeURIComponent(path).replace(/%2F/g,\"/\").replace(/%3A/g,\":\");return new URL(`file://${encodedPath}`)})();\nvar __process = globalThis[\"process\"] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation version\n * This module provides functions for managing version updates in a project.\n * It includes tasks such as validating version update types, checking the state\n * of Git and GitHub CLI, updating version numbers in files, and performing\n * Git operations such as tagging and pushing.\n *\n * The main function, `updateVersion`, coordinates these tasks to ensure that\n * version updates are handled consistently and correctly. It also integrates\n * with Obsidian plugins, if applicable, by updating relevant files and releasing\n * new versions on GitHub.\n */\n\nimport AdmZip from 'adm-zip';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian/Plugin/ObsidianPluginRepoPaths.ts';\nimport { join } from '../Path.ts';\nimport { readdirPosix } from './Fs.ts';\nimport { editJson } from './JSON.ts';\nimport {\n  cp,\n  createInterface,\n  existsSync,\n  readFile,\n  writeFile\n} from './NodeModules.ts';\nimport {\n  editNpmPackage,\n  editNpmPackageLock,\n  readNpmPackage\n} from './Npm.ts';\nimport { ObsidianDevUtilsRepoPaths } from './ObsidianDevUtilsRepoPaths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRoot\n} from './Root.ts';\n\n/**\n * Enum representing different types of version updates.\n */\nexport enum VersionUpdateType {\n  Major = 'major',\n  Minor = 'minor',\n  Patch = 'patch',\n  Beta = 'beta',\n  Manual = 'manual',\n  Invalid = 'invalid'\n}\n\n/**\n * Type representing the manifest file format for Obsidian plugins.\n */\nexport interface Manifest {\n  /**\n   * The minimum Obsidian version required for the plugin.\n   */\n  minAppVersion: string;\n\n  /**\n   * The version of the plugin.\n   */\n  version: string;\n}\n\n/**\n * Type representing the structure of Obsidian releases JSON.\n */\nexport interface ObsidianReleasesJson {\n  /**\n   * The name of the Obsidian release.\n   */\n  name: string;\n}\n\n/**\n * Updates the version of the project based on the specified update type.\n *\n * This function performs a series of tasks to handle version updates:\n * 1. Validates the version update type.\n * 2. Checks if Git and GitHub CLI are installed.\n * 3. Verifies that the Git repository is clean.\n * 4. Runs spellcheck and linting.\n * 5. Builds the project.\n * 6. Updates version in files and changelog.\n * 7. Adds updated files to Git, tags the commit, and pushes to the repository.\n * 8. If an Obsidian plugin, copies the updated manifest and publishes a GitHub release.\n *\n * @param versionUpdateType - The type of version update to perform (major, minor, patch, beta, or x.y.z[-beta:u]).\n * @returns A promise that resolves when the version update is complete.\n */\nexport async function updateVersion(versionUpdateType: string): Promise<void> {\n  if (!versionUpdateType) {\n    const npmOldVersion = process.env['npm_old_version'];\n    const npmNewVersion = process.env['npm_new_version'];\n\n    if (npmOldVersion && npmNewVersion) {\n      await updateVersionInFiles(npmOldVersion, false);\n      await updateVersion(npmNewVersion);\n      return;\n    }\n  }\n\n  const isObsidianPlugin = existsSync(resolvePathFromRoot(ObsidianPluginRepoPaths.ManifestJson));\n  validate(versionUpdateType);\n  await checkGitInstalled();\n  await checkGitRepoClean();\n  await checkGitHubCliInstalled();\n  await execFromRoot('npm run spellcheck');\n  await execFromRoot('npm run build');\n  await execFromRoot('npm run lint');\n\n  const newVersion = await getNewVersion(versionUpdateType);\n  await updateVersionInFiles(newVersion, isObsidianPlugin);\n  await updateChangelog(newVersion);\n  await addUpdatedFilesToGit(newVersion);\n  await addGitTag(newVersion);\n  await gitPush();\n  if (isObsidianPlugin) {\n    await copyUpdatedManifest();\n  }\n  await publishGitHubRelease(newVersion, isObsidianPlugin);\n}\n\n/**\n * Validates the version update type to ensure it is either a recognized type\n * or a valid manual version string.\n *\n * @param versionUpdateType - The version update type to validate.\n * @throws Error if the version update type is invalid.\n */\nexport function validate(versionUpdateType: string): void {\n  if (getVersionUpdateType(versionUpdateType) === VersionUpdateType.Invalid) {\n    throw new Error('Invalid version update type. Please use \\'major\\', \\'minor\\', \\'patch\\', or \\'x.y.z[-suffix]\\' format.');\n  }\n}\n\n/**\n * Checks if Git is installed on the system.\n *\n * Throws an error if Git is not installed.\n *\n * @throws Error if Git is not installed.\n */\nexport async function checkGitInstalled(): Promise<void> {\n  try {\n    await execFromRoot('git --version', { quiet: true });\n  } catch {\n    throw new Error('Git is not installed. Please install it from https://git-scm.com/');\n  }\n}\n\n/**\n * Checks if the GitHub CLI is installed on the system.\n *\n * Throws an error if the GitHub CLI is not installed.\n *\n * @throws Error if the GitHub CLI is not installed.\n */\nexport async function checkGitHubCliInstalled(): Promise<void> {\n  try {\n    await execFromRoot('gh --version', { quiet: true });\n  } catch {\n    throw new Error('GitHub CLI is not installed. Please install it from https://cli.github.com/');\n  }\n}\n\n/**\n * Checks if the Git repository is clean, meaning there are no uncommitted changes.\n *\n * Throws an error if the Git repository is not clean.\n *\n * @throws Error if the Git repository is not clean.\n */\nexport async function checkGitRepoClean(): Promise<void> {\n  try {\n    const stdout = await execFromRoot('git status --porcelain --untracked-files=all', { quiet: true });\n    if (stdout) {\n      throw new Error();\n    }\n  } catch {\n    throw new Error('Git repository is not clean. Please commit or stash your changes before releasing a new version.');\n  }\n}\n\n/**\n * Determines the type of version update based on the input string.\n *\n * @param versionUpdateType - The input string representing the version update type.\n * @returns The corresponding `VersionUpdateType`.\n */\nexport function getVersionUpdateType(versionUpdateType: string): VersionUpdateType {\n  const versionUpdateTypeEnum = versionUpdateType as VersionUpdateType;\n  switch (versionUpdateTypeEnum) {\n    case VersionUpdateType.Major:\n    case VersionUpdateType.Minor:\n    case VersionUpdateType.Patch:\n    case VersionUpdateType.Beta:\n      return versionUpdateTypeEnum;\n\n    default:\n      if (/^\\d+\\.\\d+\\.\\d+(-[\\w\\d.-]+)?$/.test(versionUpdateType)) {\n        return VersionUpdateType.Manual;\n      }\n\n      return VersionUpdateType.Invalid;\n  }\n}\n\n/**\n * Updates the version in various files, including `package.json`, `package-lock.json`,\n * and Obsidian plugin manifests if applicable.\n *\n * @param newVersion - The new version string to update in the files.\n * @param isObsidianPlugin - Whether the project is an Obsidian plugin.\n * @returns A `Promise` that resolves when the update is complete.\n */\nexport async function updateVersionInFiles(newVersion: string, isObsidianPlugin: boolean): Promise<void> {\n  await editNpmPackage((npmPackage) => {\n    npmPackage.version = newVersion;\n  });\n\n  await editNpmPackageLock((npmPackageLock) => {\n    npmPackageLock.version = newVersion;\n    const defaultPackage = npmPackageLock.packages?.[''];\n    if (defaultPackage) {\n      defaultPackage.version = newVersion;\n    }\n  }, { skipIfMissing: true });\n\n  if (isObsidianPlugin) {\n    const latestObsidianVersion = await getLatestObsidianVersion();\n\n    await editJson<Manifest>(ObsidianPluginRepoPaths.ManifestJson, (manifest) => {\n      manifest.minAppVersion = latestObsidianVersion;\n      manifest.version = newVersion;\n    });\n\n    await editJson<Record<string, string>>(ObsidianPluginRepoPaths.VersionsJson, (versions) => {\n      versions[newVersion] = latestObsidianVersion;\n    });\n  }\n}\n\n/**\n * Generates a new version string based on the current version and the specified update type.\n *\n * @param versionUpdateType - The type of version update (major, minor, patch, beta, or manual).\n * @returns A `Promise` that resolves to the new version string.\n * @throws Error if the current version format is invalid.\n */\nexport async function getNewVersion(versionUpdateType: string): Promise<string> {\n  const versionType = getVersionUpdateType(versionUpdateType);\n  if (versionType === VersionUpdateType.Manual) {\n    return versionUpdateType;\n  }\n\n  const npmPackage = await readNpmPackage();\n  const currentVersion = npmPackage.version;\n\n  const match = /^(\\d+)\\.(\\d+)\\.(\\d+)(-beta.(\\d+))?/.exec(currentVersion);\n  if (!match) {\n    throw new Error(`Invalid current version format: ${currentVersion}`);\n  }\n\n  let major = Number(match[1]);\n  let minor = Number(match[2]);\n  let patch = Number(match[3]);\n  let beta = match[5] ? Number(match[5]) : 0;\n\n  switch (versionType) {\n    case VersionUpdateType.Major:\n      major++;\n      minor = 0;\n      patch = 0;\n      beta = 0;\n      break;\n    case VersionUpdateType.Minor:\n      minor++;\n      patch = 0;\n      beta = 0;\n      break;\n    case VersionUpdateType.Patch:\n      patch++;\n      beta = 0;\n      break;\n    case VersionUpdateType.Beta:\n      beta++;\n      break;\n  }\n\n  return `${major.toString()}.${minor.toString()}.${patch.toString()}${beta > 0 ? `-beta.${beta.toString()}` : ''}`;\n}\n\n/**\n * Fetches the latest version of Obsidian from the GitHub releases API.\n *\n * @returns A promise that resolves to the latest version of Obsidian.\n */\nasync function getLatestObsidianVersion(): Promise<string> {\n  const response = await fetch('https://api.github.com/repos/obsidianmd/obsidian-releases/releases/latest');\n  const obsidianReleasesJson = await response.json() as ObsidianReleasesJson;\n  return obsidianReleasesJson.name;\n}\n\n/**\n * Updates the changelog file with new version information and commit messages.\n *\n * This function reads the current changelog, appends new entries for the latest version,\n * and prompts the user to review the changes.\n *\n * @param newVersion - The new version number to be added to the changelog.\n * @returns A promise that resolves when the changelog update is complete.\n */\nexport async function updateChangelog(newVersion: string): Promise<void> {\n  const changelogPath = resolvePathFromRoot(ObsidianPluginRepoPaths.ChangelogMd);\n  let previousChangelogLines: string[];\n  if (!existsSync(changelogPath)) {\n    previousChangelogLines = [];\n  } else {\n    const content = await readFile(changelogPath, 'utf-8');\n    previousChangelogLines = content.split('\\n').slice(2);\n    if (previousChangelogLines.at(-1) === '') {\n      previousChangelogLines.pop();\n    }\n  }\n\n  const lastTag = previousChangelogLines[0]?.replace('## ', '');\n  const commitRange = lastTag ? `${lastTag}..HEAD` : 'HEAD';\n  const commitMessages = (await execFromRoot(`git log ${commitRange} --format=%s --first-parent`, { quiet: true })).split(/\\r?\\n/);\n\n  let newChangeLog = `# CHANGELOG\\n\\n## ${newVersion}\\n\\n`;\n\n  for (const message of commitMessages) {\n    newChangeLog += `- ${message}\\n`;\n  }\n\n  if (previousChangelogLines.length > 0) {\n    newChangeLog += '\\n';\n    for (const line of previousChangelogLines) {\n      newChangeLog += `${line}\\n`;\n    }\n  }\n\n  await writeFile(changelogPath, newChangeLog, 'utf-8');\n\n  await createInterface(process.stdin, process.stdout).question(`Please update the ${ObsidianPluginRepoPaths.ChangelogMd} file. Press Enter when you are done...`);\n}\n\n/**\n * Adds updated files to the Git staging area and commits them with the new version message.\n *\n * @param newVersion - The new version number used as the commit message.\n * @returns A promise that resolves when the files have been added and committed.\n */\nexport async function addUpdatedFilesToGit(newVersion: string): Promise<void> {\n  const files = [\n    ObsidianPluginRepoPaths.ManifestJson,\n    ObsidianPluginRepoPaths.PackageJson,\n    ObsidianPluginRepoPaths.PackageLockJson,\n    ObsidianPluginRepoPaths.VersionsJson,\n    ObsidianPluginRepoPaths.ChangelogMd\n  ].filter((file) => existsSync(resolvePathFromRoot(file)));\n  await execFromRoot(['git', 'add', ...files], { quiet: true });\n  await execFromRoot(`git commit -m ${newVersion}`, { quiet: true });\n}\n\n/**\n * Creates a Git tag for the new version.\n *\n * @param newVersion - The new version number to use for the tag.\n * @returns A promise that resolves when the tag has been created.\n */\nexport async function addGitTag(newVersion: string): Promise<void> {\n  await execFromRoot(`git tag -a ${newVersion} -m ${newVersion}`, { quiet: true });\n}\n\n/**\n * Pushes commits and tags to the remote Git repository.\n *\n * @returns A promise that resolves when the push operation is complete.\n */\nexport async function gitPush(): Promise<void> {\n  await execFromRoot('git push --follow-tags', { quiet: true });\n}\n\n/**\n * Copies the updated manifest file to the distribution build directory.\n *\n * @returns A promise that resolves when the copy operation is complete.\n */\nexport async function copyUpdatedManifest(): Promise<void> {\n  await cp(resolvePathFromRoot(ObsidianPluginRepoPaths.ManifestJson), resolvePathFromRoot(join(ObsidianPluginRepoPaths.DistBuild, ObsidianPluginRepoPaths.ManifestJson)), { force: true });\n}\n\n/**\n * Retrieves the release notes for a specific version from the changelog.\n *\n * @param newVersion - The new version number for which to get the release notes.\n * @returns A promise that resolves to the release notes for the specified version.\n */\nexport async function getReleaseNotes(newVersion: string): Promise<string> {\n  const changelogPath = resolvePathFromRoot(ObsidianPluginRepoPaths.ChangelogMd);\n  const content = await readFile(changelogPath, 'utf-8');\n  const newVersionEscaped = newVersion.replaceAll('.', '\\\\.');\n  const match = new RegExp(`\\n## ${newVersionEscaped}\\n\\n((.|\\n)+?)\\n\\n##`).exec(content);\n  let releaseNotes = match?.[1] ? match[1] + '\\n\\n' : '';\n\n  const tags = (await execFromRoot('git tag --sort=-creatordate', { quiet: true })).split(/\\r?\\n/);\n  const previousVersion = tags[1];\n  let changesUrl = '';\n\n  const repoUrl = await execFromRoot('gh repo view --json url -q .url', { quiet: true });\n\n  if (previousVersion) {\n    changesUrl = `${repoUrl}/compare/${previousVersion}...${newVersion}`;\n  } else {\n    changesUrl = `${repoUrl}/commits/${newVersion}`;\n  }\n\n  releaseNotes += `**Full Changelog**: ${changesUrl}`;\n  return releaseNotes;\n}\n\n/**\n * Publishes a GitHub release for the new version.\n *\n * Handles the creation of a release and uploading files for either an Obsidian plugin or another project.\n *\n * @param newVersion - The new version number for the release.\n * @param isObsidianPlugin - A boolean indicating if the project is an Obsidian plugin.\n * @returns A promise that resolves when the release has been published.\n */\nexport async function publishGitHubRelease(newVersion: string, isObsidianPlugin: boolean): Promise<void> {\n  let filePaths: string[];\n\n  if (isObsidianPlugin) {\n    const buildDir = resolvePathFromRoot(ObsidianPluginRepoPaths.DistBuild);\n    const fileNames = await readdirPosix(buildDir);\n    filePaths = fileNames.map((fileName) => join(buildDir, fileName));\n  } else {\n    const zip = new AdmZip();\n    zip.addLocalFolder(resolvePathFromRoot(ObsidianDevUtilsRepoPaths.Dist), ObsidianDevUtilsRepoPaths.Dist, (filename) => !filename.endsWith('.zip'));\n\n    const files = [\n      ObsidianDevUtilsRepoPaths.ChangelogMd,\n      ObsidianDevUtilsRepoPaths.License,\n      ObsidianDevUtilsRepoPaths.ReadmeMd,\n      ObsidianDevUtilsRepoPaths.PackageJson\n    ];\n\n    for (const file of files) {\n      zip.addLocalFile(resolvePathFromRoot(file));\n    }\n\n    const npmPackage = await readNpmPackage();\n    const distZipPath = resolvePathFromRoot(join(ObsidianDevUtilsRepoPaths.Dist, `${npmPackage.name}-${newVersion}.zip`));\n    zip.writeZip(distZipPath);\n    filePaths = [distZipPath];\n  }\n\n  await execFromRoot(['gh', 'release', 'create', newVersion, ...filePaths, '--title', `v${newVersion}`, '--notes-file', '-'], {\n    quiet: true,\n    stdin: await getReleaseNotes(newVersion)\n  });\n}\n"],
  "mappings": "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",
  "names": ["VersionUpdateType", "AdmZip"]
}


package/dist/lib/{bin → scripts}/version.d.ts

@@ -10,7 +10,6 @@
  * with Obsidian plugins, if applicable, by updating relevant files and releasing
  * new versions on GitHub.
  */
-import { CliTaskResult } from "../cli.ts";
 /**
  * Enum representing different types of version updates.
  */
@@ -25,7 +24,7 @@ export declare enum VersionUpdateType {
 /**
  * Type representing the manifest file format for Obsidian plugins.
  */
-export type Manifest = {
+export interface Manifest {
     /**
      * The minimum Obsidian version required for the plugin.
      */
@@ -34,16 +33,16 @@ export type Manifest = {
      * The version of the plugin.
      */
     version: string;
-};
+}
 /**
  * Type representing the structure of Obsidian releases JSON.
  */
-export type ObsidianReleasesJson = {
+export interface ObsidianReleasesJson {
     /**
      * The name of the Obsidian release.
      */
     name: string;
-};
+}
 /**
  * Updates the version of the project based on the specified update type.
  *
@@ -57,10 +56,10 @@ export type ObsidianReleasesJson = {
  * 7. Adds updated files to Git, tags the commit, and pushes to the repository.
  * 8. If an Obsidian plugin, copies the updated manifest and publishes a GitHub release.
  *
- * @param versionUpdateType - The type of version update to perform (major, minor, patch, beta, or manual).
- * @returns A `Promise` that resolves to a `TaskResult` indicating the success or failure of the version update.
+ * @param versionUpdateType - The type of version update to perform (major, minor, patch, beta, or x.y.z[-beta:u]).
+ * @returns A promise that resolves when the version update is complete.
  */
-export declare function updateVersion(versionUpdateType: string): Promise<CliTaskResult | void>;
+export declare function updateVersion(versionUpdateType: string): Promise<void>;
 /**
  * Validates the version update type to ensure it is either a recognized type
  * or a valid manual version string.

package/dist/lib/url.cjs

@@ -26,7 +26,16 @@ __export(url_exports, {
   isUrl: () => isUrl
 });
 module.exports = __toCommonJS(url_exports);
-var __import_meta_url = globalThis["import.meta.url"] ?? (() => require("node:url").pathToFileURL(__filename))();
+var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
+  const normalizedPath = __filename.replace(/\\/g, "/");
+  const windowsDriveLetterMatch = /^([a-zA-Z]):/.exec(normalizedPath);
+  let path = normalizedPath;
+  if (windowsDriveLetterMatch) {
+    path = `/${windowsDriveLetterMatch[1].toUpperCase()}:${normalizedPath.slice(2)}`;
+  }
+  const encodedPath = encodeURIComponent(path).replace(/%2F/g, "/").replace(/%3A/g, ":");
+  return new URL(`file://${encodedPath}`);
+})();
 var __process = globalThis["process"] ?? {
   "cwd": () => "/",
   "env": {},
@@ -44,4 +53,4 @@ function isUrl(str) {
 0 && (module.exports = {
   isUrl
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL3VybC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsidmFyIF9faW1wb3J0X21ldGFfdXJsID0gZ2xvYmFsVGhpc1tcImltcG9ydC5tZXRhLnVybFwiXSA/PyAoKCk9PnJlcXVpcmUoXCJub2RlOnVybFwiKS5wYXRoVG9GaWxlVVJMKF9fZmlsZW5hbWUpKSgpO1xudmFyIF9fcHJvY2VzcyA9IGdsb2JhbFRoaXNbXCJwcm9jZXNzXCJdID8/IHtcbiAgXCJjd2RcIjogKCk9PlwiL1wiLFxuICBcImVudlwiOiB7fSxcbiAgXCJwbGF0Zm9ybVwiOiBcImFuZHJvaWRcIlxufTtcbi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uIHVybFxuICogQ29udGFpbnMgYSB1dGlsaXR5IGZ1bmN0aW9uIGZvciB2YWxpZGF0aW5nIFVSTHMuXG4gKi9cblxuLyoqXG4gKiBEZXRlcm1pbmVzIHdoZXRoZXIgYSBnaXZlbiBzdHJpbmcgaXMgYSB2YWxpZCBVUkwsIGV4Y2x1ZGluZyBmaWxlIFVSTHMuXG4gKlxuICogQHBhcmFtIHN0ciAtIFRoZSBzdHJpbmcgdG8gdmFsaWRhdGUgYXMgYSBVUkwuXG4gKiBAcmV0dXJucyBgdHJ1ZWAgaWYgdGhlIHN0cmluZyBpcyBhIHZhbGlkIFVSTCBhbmQgbm90IGEgZmlsZSBVUkwsIG90aGVyd2lzZSBgZmFsc2VgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNVcmwoc3RyOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgdHJ5IHtcbiAgICBjb25zdCB1cmwgPSBuZXcgVVJMKHN0cik7XG4gICAgcmV0dXJuIHVybC5wcm90b2NvbCAhPT0gXCJmaWxlOlwiO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLElBQUksb0JBQW9CLFdBQVcsaUJBQWlCLE1BQU0sTUFBSSxRQUFRLFVBQVUsRUFBRSxjQUFjLFVBQVUsR0FBRztBQUM3RyxJQUFJLFlBQVksV0FBVyxTQUFTLEtBQUs7QUFBQSxFQUN2QyxPQUFPLE1BQUk7QUFBQSxFQUNYLE9BQU8sQ0FBQztBQUFBLEVBQ1IsWUFBWTtBQUNkO0FBWU8sU0FBUyxNQUFNLEtBQXNCO0FBQzFDLE1BQUk7QUFDRixVQUFNLE1BQU0sSUFBSSxJQUFJLEdBQUc7QUFDdkIsV0FBTyxJQUFJLGFBQWE7QUFBQSxFQUMxQixRQUFRO0FBQ04sV0FBTztBQUFBLEVBQ1Q7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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