obsidian-dev-utils 4.10.0 → 4.11.0

package/dist/lib/scripts/version.cjs

@@ -76,52 +76,32 @@ var VersionUpdateType = /* @__PURE__ */ ((VersionUpdateType2) => {
   VersionUpdateType2["Patch"] = "patch";
   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);
+async function addGitTag(newVersion) {
+  await (0, import_Root.execFromRoot)(`git tag -a ${newVersion} -m ${newVersion} --force`, { quiet: true });
 }
-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 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} --allow-empty`, { quiet: true });
 }
-async function checkGitInstalled() {
+async function checkGitHubCliInstalled() {
   try {
-    await (0, import_Root.execFromRoot)("git --version", { quiet: true });
+    await (0, import_Root.execFromRoot)("gh --version", { quiet: true });
   } catch {
-    throw new Error("Git is not installed. Please install it from https://git-scm.com/");
+    throw new Error("GitHub CLI is not installed. Please install it from https://cli.github.com/");
   }
 }
-async function checkGitHubCliInstalled() {
+async function checkGitInstalled() {
   try {
-    await (0, import_Root.execFromRoot)("gh --version", { quiet: true });
+    await (0, import_Root.execFromRoot)("git --version", { quiet: true });
   } catch {
-    throw new Error("GitHub CLI is not installed. Please install it from https://cli.github.com/");
+    throw new Error("Git is not installed. Please install it from https://git-scm.com/");
   }
 }
 async function checkGitRepoClean() {
@@ -134,42 +114,8 @@ async function checkGitRepoClean() {
     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 "beta" /* Beta */:
-    case "major" /* Major */:
-    case "minor" /* Minor */:
-    case "patch" /* Patch */:
-      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 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 getNewVersion(versionUpdateType) {
   const versionType = getVersionUpdateType(versionUpdateType);
@@ -211,65 +157,6 @@ async function getNewVersion(versionUpdateType) {
   }
   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} --allow-empty`, { quiet: true });
-}
-async function addGitTag(newVersion) {
-  await (0, import_Root.execFromRoot)(`git tag -a ${newVersion} -m ${newVersion} --force`, { quiet: true });
-}
-async function gitPush() {
-  await (0, import_Root.execFromRoot)("git push --follow-tags --force", { 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");
@@ -294,6 +181,24 @@ async function getReleaseNotes(newVersion) {
   releaseNotes += `**Full Changelog**: ${changesUrl}`;
   return releaseNotes;
 }
+function getVersionUpdateType(versionUpdateType) {
+  const versionUpdateTypeEnum = versionUpdateType;
+  switch (versionUpdateTypeEnum) {
+    case "beta" /* Beta */:
+    case "major" /* Major */:
+    case "minor" /* Minor */:
+    case "patch" /* Patch */:
+      return versionUpdateTypeEnum;
+    default:
+      if (/^\d+\.\d+\.\d+(-[\w\d.-]+)?$/.test(versionUpdateType)) {
+        return "manual" /* Manual */;
+      }
+      return "invalid" /* Invalid */;
+  }
+}
+async function gitPush() {
+  await (0, import_Root.execFromRoot)("git push --follow-tags --force", { quiet: true });
+}
 async function publishGitHubRelease(newVersion, isObsidianPlugin) {
   let filePaths;
   if (isObsidianPlugin) {
@@ -322,6 +227,101 @@ async function publishGitHubRelease(newVersion, isObsidianPlugin) {
     stdin: await getReleaseNotes(newVersion)
   });
 }
+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 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);
+}
+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;
+    });
+  }
+}
+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 getLatestObsidianVersion() {
+  const response = await fetch("https://api.github.com/repos/obsidianmd/obsidian-releases/releases/latest");
+  const obsidianReleasesJson = await response.json();
+  return obsidianReleasesJson.name;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   VersionUpdateType,
@@ -341,4 +341,4 @@ async function publishGitHubRelease(newVersion, isObsidianPlugin) {
   updateVersionInFiles,
   validate
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/scripts/version.ts"],
  "sourcesContent": ["var __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  Beta = 'beta',\n  Invalid = 'invalid',\n  Major = 'major',\n  Manual = 'manual',\n  Minor = 'minor',\n  Patch = 'patch'\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.Beta:\n    case VersionUpdateType.Major:\n    case VersionUpdateType.Minor:\n    case VersionUpdateType.Patch:\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.Beta:\n      if (beta === 0) {\n        patch++;\n      }\n      beta++;\n      break;\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  }\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} --allow-empty`, { 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} --force`, { 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 --force', { 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"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/scripts/version.ts"],
  "sourcesContent": ["var __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  Beta = 'beta',\n  Invalid = 'invalid',\n  Major = 'major',\n  Manual = 'manual',\n  Minor = 'minor',\n  Patch = 'patch'\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 * 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} --force`, { quiet: true });\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} --allow-empty`, { quiet: true });\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 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 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 * 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 * 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.Beta:\n      if (beta === 0) {\n        patch++;\n      }\n      beta++;\n      break;\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  }\n\n  return `${major.toString()}.${minor.toString()}.${patch.toString()}${beta > 0 ? `-beta.${beta.toString()}` : ''}`;\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 * 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.Beta:\n    case VersionUpdateType.Major:\n    case VersionUpdateType.Minor:\n    case VersionUpdateType.Patch:\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 * 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 --force', { quiet: true });\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\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 * 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 * 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 * 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 * 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"],
  "mappings": "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",
  "names": ["VersionUpdateType", "AdmZip"]
}


package/dist/lib/scripts/version.d.ts

@@ -44,30 +44,27 @@ export interface ObsidianReleasesJson {
     name: string;
 }
 /**
- * Updates the version of the project based on the specified update type.
+ * Creates a Git tag for the new version.
  *
- * This function performs a series of tasks to handle version updates:
- * 1. Validates the version update type.
- * 2. Checks if Git and GitHub CLI are installed.
- * 3. Verifies that the Git repository is clean.
- * 4. Runs spellcheck and linting.
- * 5. Builds the project.
- * 6. Updates version in files and changelog.
- * 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 newVersion - The new version number to use for the tag.
+ * @returns A promise that resolves when the tag has been created.
+ */
+export declare function addGitTag(newVersion: string): Promise<void>;
+/**
+ * Adds updated files to the Git staging area and commits them with the new version message.
  *
- * @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.
+ * @param newVersion - The new version number used as the commit message.
+ * @returns A promise that resolves when the files have been added and committed.
  */
-export declare function updateVersion(versionUpdateType: string): Promise<void>;
+export declare function addUpdatedFilesToGit(newVersion: string): Promise<void>;
 /**
- * Validates the version update type to ensure it is either a recognized type
- * or a valid manual version string.
+ * Checks if the GitHub CLI is installed on the system.
  *
- * @param versionUpdateType - The version update type to validate.
- * @throws Error if the version update type is invalid.
+ * Throws an error if the GitHub CLI is not installed.
+ *
+ * @throws Error if the GitHub CLI is not installed.
  */
-export declare function validate(versionUpdateType: string): void;
+export declare function checkGitHubCliInstalled(): Promise<void>;
 /**
  * Checks if Git is installed on the system.
  *
@@ -76,14 +73,6 @@ export declare function validate(versionUpdateType: string): void;
  * @throws Error if Git is not installed.
  */
 export declare function checkGitInstalled(): Promise<void>;
-/**
- * Checks if the GitHub CLI is installed on the system.
- *
- * Throws an error if the GitHub CLI is not installed.
- *
- * @throws Error if the GitHub CLI is not installed.
- */
-export declare function checkGitHubCliInstalled(): Promise<void>;
 /**
  * Checks if the Git repository is clean, meaning there are no uncommitted changes.
  *
@@ -93,21 +82,11 @@ export declare function checkGitHubCliInstalled(): Promise<void>;
  */
 export declare function checkGitRepoClean(): Promise<void>;
 /**
- * Determines the type of version update based on the input string.
- *
- * @param versionUpdateType - The input string representing the version update type.
- * @returns The corresponding `VersionUpdateType`.
- */
-export declare function getVersionUpdateType(versionUpdateType: string): VersionUpdateType;
-/**
- * Updates the version in various files, including `package.json`, `package-lock.json`,
- * and Obsidian plugin manifests if applicable.
+ * Copies the updated manifest file to the distribution build directory.
  *
- * @param newVersion - The new version string to update in the files.
- * @param isObsidianPlugin - Whether the project is an Obsidian plugin.
- * @returns A `Promise` that resolves when the update is complete.
+ * @returns A promise that resolves when the copy operation is complete.
  */
-export declare function updateVersionInFiles(newVersion: string, isObsidianPlugin: boolean): Promise<void>;
+export declare function copyUpdatedManifest(): Promise<void>;
 /**
  * Generates a new version string based on the current version and the specified update type.
  *
@@ -117,48 +96,25 @@ export declare function updateVersionInFiles(newVersion: string, isObsidianPlugi
  */
 export declare function getNewVersion(versionUpdateType: string): Promise<string>;
 /**
- * Updates the changelog file with new version information and commit messages.
- *
- * This function reads the current changelog, appends new entries for the latest version,
- * and prompts the user to review the changes.
- *
- * @param newVersion - The new version number to be added to the changelog.
- * @returns A promise that resolves when the changelog update is complete.
- */
-export declare function updateChangelog(newVersion: string): Promise<void>;
-/**
- * Adds updated files to the Git staging area and commits them with the new version message.
+ * Retrieves the release notes for a specific version from the changelog.
  *
- * @param newVersion - The new version number used as the commit message.
- * @returns A promise that resolves when the files have been added and committed.
+ * @param newVersion - The new version number for which to get the release notes.
+ * @returns A promise that resolves to the release notes for the specified version.
  */
-export declare function addUpdatedFilesToGit(newVersion: string): Promise<void>;
+export declare function getReleaseNotes(newVersion: string): Promise<string>;
 /**
- * Creates a Git tag for the new version.
+ * Determines the type of version update based on the input string.
  *
- * @param newVersion - The new version number to use for the tag.
- * @returns A promise that resolves when the tag has been created.
+ * @param versionUpdateType - The input string representing the version update type.
+ * @returns The corresponding `VersionUpdateType`.
  */
-export declare function addGitTag(newVersion: string): Promise<void>;
+export declare function getVersionUpdateType(versionUpdateType: string): VersionUpdateType;
 /**
  * Pushes commits and tags to the remote Git repository.
  *
  * @returns A promise that resolves when the push operation is complete.
  */
 export declare function gitPush(): Promise<void>;
-/**
- * Copies the updated manifest file to the distribution build directory.
- *
- * @returns A promise that resolves when the copy operation is complete.
- */
-export declare function copyUpdatedManifest(): Promise<void>;
-/**
- * Retrieves the release notes for a specific version from the changelog.
- *
- * @param newVersion - The new version number for which to get the release notes.
- * @returns A promise that resolves to the release notes for the specified version.
- */
-export declare function getReleaseNotes(newVersion: string): Promise<string>;
 /**
  * Publishes a GitHub release for the new version.
  *
@@ -169,3 +125,47 @@ export declare function getReleaseNotes(newVersion: string): Promise<string>;
  * @returns A promise that resolves when the release has been published.
  */
 export declare function publishGitHubRelease(newVersion: string, isObsidianPlugin: boolean): Promise<void>;
+/**
+ * Updates the changelog file with new version information and commit messages.
+ *
+ * This function reads the current changelog, appends new entries for the latest version,
+ * and prompts the user to review the changes.
+ *
+ * @param newVersion - The new version number to be added to the changelog.
+ * @returns A promise that resolves when the changelog update is complete.
+ */
+export declare function updateChangelog(newVersion: string): Promise<void>;
+/**
+ * Updates the version of the project based on the specified update type.
+ *
+ * This function performs a series of tasks to handle version updates:
+ * 1. Validates the version update type.
+ * 2. Checks if Git and GitHub CLI are installed.
+ * 3. Verifies that the Git repository is clean.
+ * 4. Runs spellcheck and linting.
+ * 5. Builds the project.
+ * 6. Updates version in files and changelog.
+ * 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 x.y.z[-beta:u]).
+ * @returns A promise that resolves when the version update is complete.
+ */
+export declare function updateVersion(versionUpdateType: string): Promise<void>;
+/**
+ * Updates the version in various files, including `package.json`, `package-lock.json`,
+ * and Obsidian plugin manifests if applicable.
+ *
+ * @param newVersion - The new version string to update in the files.
+ * @param isObsidianPlugin - Whether the project is an Obsidian plugin.
+ * @returns A `Promise` that resolves when the update is complete.
+ */
+export declare function updateVersionInFiles(newVersion: string, isObsidianPlugin: boolean): Promise<void>;
+/**
+ * Validates the version update type to ensure it is either a recognized type
+ * or a valid manual version string.
+ *
+ * @param versionUpdateType - The version update type to validate.
+ * @throws Error if the version update type is invalid.
+ */
+export declare function validate(versionUpdateType: string): void;