obsidian-dev-utils 18.4.0 → 19.0.0

package/dist/lib/ScriptUtils/version.mjs

@@ -0,0 +1,365 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm(){if(globalThis.process){return}const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};globalThis.process=browserProcess})();
+
+import { getLibDebugger } from "../Debug.mjs";
+import { throwExpression } from "../Error.mjs";
+import { ObsidianPluginRepoPaths } from "../obsidian/Plugin/ObsidianPluginRepoPaths.mjs";
+import { join } from "../Path.mjs";
+import { replaceAll } from "../String.mjs";
+import { readdirPosix } from "./Fs.mjs";
+import { editJson } from "./JSON.mjs";
+import {
+  cp,
+  createInterface,
+  existsSync,
+  readFile,
+  rm,
+  writeFile
+} from "./NodeModules.mjs";
+import {
+  editNpmShrinkWrapJson,
+  editPackageJson,
+  editPackageLockJson,
+  readPackageJson
+} from "./Npm.mjs";
+import { ObsidianDevUtilsRepoPaths } from "./ObsidianDevUtilsRepoPaths.mjs";
+import {
+  execFromRoot,
+  resolvePathFromRootSafe
+} from "./Root.mjs";
+var VersionUpdateType = /* @__PURE__ */ ((VersionUpdateType2) => {
+  VersionUpdateType2["Beta"] = "beta";
+  VersionUpdateType2["Invalid"] = "invalid";
+  VersionUpdateType2["Major"] = "major";
+  VersionUpdateType2["Manual"] = "manual";
+  VersionUpdateType2["Minor"] = "minor";
+  VersionUpdateType2["Patch"] = "patch";
+  return VersionUpdateType2;
+})(VersionUpdateType || {});
+async function addGitTag(newVersion) {
+  await execFromRoot(`git tag -a ${newVersion} -m ${newVersion} --force`, { isQuiet: true });
+}
+async function addUpdatedFilesToGit(newVersion) {
+  await execFromRoot(["git", "add", "--all"], { isQuiet: true });
+  await execFromRoot(`git commit -m ${newVersion} --allow-empty`, { isQuiet: true });
+}
+async function checkGitHubCliInstalled() {
+  try {
+    await execFromRoot("gh --version", { isQuiet: true });
+  } catch {
+    throw new Error("GitHub CLI is not installed. Please install it from https://cli.github.com/");
+  }
+}
+async function checkGitInstalled() {
+  try {
+    await execFromRoot("git --version", { isQuiet: true });
+  } catch {
+    throw new Error("Git is not installed. Please install it from https://git-scm.com/");
+  }
+}
+async function checkGitRepoClean() {
+  try {
+    const stdout = await execFromRoot("git status --porcelain --untracked-files=all", { isQuiet: 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.");
+  }
+}
+async function copyUpdatedManifest() {
+  await cp(
+    resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestJson),
+    resolvePathFromRootSafe(join(ObsidianPluginRepoPaths.DistBuild, ObsidianPluginRepoPaths.ManifestJson)),
+    { force: true }
+  );
+}
+async function getNewVersion(versionUpdateType) {
+  const versionType = getVersionUpdateType(versionUpdateType);
+  if (versionType === "manual" /* Manual */) {
+    return versionUpdateType;
+  }
+  const packageJson = await readPackageJson();
+  const currentVersion = packageJson.version ?? "";
+  const match = /^(?<Major>\d+)\.(?<Minor>\d+)\.(?<Patch>\d+)(?:-beta\.(?<Beta>\d+))?$/.exec(currentVersion);
+  if (!match) {
+    throw new Error(`Invalid current version format: ${currentVersion}`);
+  }
+  let major = Number(match.groups?.["Major"] ?? "");
+  let minor = Number(match.groups?.["Minor"] ?? "");
+  let patch = Number(match.groups?.["Patch"] ?? "");
+  let beta = Number(match.groups?.["Beta"] ?? "");
+  switch (versionType) {
+    case "beta" /* Beta */:
+      if (beta === 0) {
+        patch++;
+      }
+      beta++;
+      break;
+    case "major" /* Major */:
+      major++;
+      minor = 0;
+      patch = 0;
+      beta = 0;
+      break;
+    case "minor" /* Minor */:
+      minor++;
+      patch = 0;
+      beta = 0;
+      break;
+    case "patch" /* Patch */:
+      if (beta === 0) {
+        patch++;
+      } else {
+        beta = 0;
+      }
+      break;
+    default:
+      throw new Error(`Invalid version update type: ${versionType}`);
+  }
+  return `${major.toString()}.${minor.toString()}.${patch.toString()}${beta > 0 ? `-beta.${beta.toString()}` : ""}`;
+}
+async function getReleaseNotes(newVersion) {
+  const changelogPath = resolvePathFromRootSafe(ObsidianPluginRepoPaths.ChangelogMd);
+  const content = await readFile(changelogPath, "utf-8");
+  const newVersionEscaped = replaceAll(newVersion, ".", "\\.");
+  const match = new RegExp(`
+## ${newVersionEscaped}
+
+((.|
+)+?)
+
+##`).exec(content);
+  let releaseNotes = match?.[1] ? `${match[1]}
+
+` : "";
+  const tags = (await execFromRoot("git tag --sort=-creatordate", { isQuiet: true })).split(/\r?\n/);
+  const previousVersion = tags[1];
+  let changesUrl;
+  const repoUrl = await execFromRoot("gh repo view --json url -q .url", { isQuiet: true });
+  if (previousVersion) {
+    changesUrl = `${repoUrl}/compare/${previousVersion}...${newVersion}`;
+  } else {
+    changesUrl = `${repoUrl}/commits/${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 execFromRoot("git push --follow-tags --force", { isQuiet: true });
+}
+async function publishGitHubRelease(newVersion, isObsidianPlugin) {
+  let filePaths;
+  if (isObsidianPlugin) {
+    const buildDir = resolvePathFromRootSafe(ObsidianPluginRepoPaths.DistBuild);
+    const fileNames = await readdirPosix(buildDir);
+    filePaths = fileNames.map((fileName) => join(buildDir, fileName));
+  } else {
+    const resultJson = await execFromRoot(["npm", "pack", "--pack-destination", ObsidianDevUtilsRepoPaths.Dist, "--json"], { isQuiet: true });
+    const result = JSON.parse(resultJson);
+    filePaths = [
+      join(ObsidianDevUtilsRepoPaths.Dist, result[0].filename),
+      join(ObsidianDevUtilsRepoPaths.Dist, ObsidianDevUtilsRepoPaths.StylesCss)
+    ];
+  }
+  filePaths = filePaths.filter((filePath) => existsSync(resolvePathFromRootSafe(filePath)));
+  await execFromRoot([
+    "gh",
+    "release",
+    "create",
+    newVersion,
+    ...filePaths,
+    "--title",
+    `v${newVersion}`,
+    ...isBeta(newVersion) ? ["--prerelease"] : [],
+    "--notes-file",
+    "-"
+  ], {
+    isQuiet: true,
+    stdin: await getReleaseNotes(newVersion)
+  });
+}
+async function updateChangelog(newVersion) {
+  const HEADER_LINES_COUNT = 2;
+  const changelogPath = resolvePathFromRootSafe(ObsidianPluginRepoPaths.ChangelogMd);
+  let previousChangelogLines;
+  if (existsSync(changelogPath)) {
+    const content = await readFile(changelogPath, "utf-8");
+    previousChangelogLines = content.split("\n").slice(HEADER_LINES_COUNT);
+    if (previousChangelogLines.at(-1) === "") {
+      previousChangelogLines.pop();
+    }
+  } else {
+    previousChangelogLines = [];
+  }
+  const lastTag = replaceAll(previousChangelogLines[0] ?? "", "## ", "");
+  const commitRange = lastTag ? `${lastTag}..HEAD` : "HEAD";
+  const commitMessagesStr = await execFromRoot(`git log ${commitRange} --format=%B --first-parent -z`, { isQuiet: true });
+  const commitMessages = commitMessagesStr.split("\0").filter(Boolean).map(toSingleLine);
+  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 writeFile(changelogPath, newChangeLog, "utf-8");
+  const codeVersion = await execFromRoot("code --version", {
+    isQuiet: true,
+    shouldIgnoreExitCode: true
+  });
+  const _debugger = getLibDebugger("Version");
+  if (codeVersion) {
+    _debugger(`Please update the ${ObsidianPluginRepoPaths.ChangelogMd} file. Close Visual Studio Code when you are done...`);
+    await execFromRoot(["code", "-w", changelogPath], {
+      isQuiet: true,
+      shouldIgnoreExitCode: true
+    });
+  } else {
+    _debugger("Could not find Visual Studio Code in your PATH. Using console mode instead.");
+    await createInterface(process.stdin, process.stdout).question(
+      `Please update the ${ObsidianPluginRepoPaths.ChangelogMd} file. Press Enter when you are done...`
+    );
+  }
+}
+async function updateVersion(versionUpdateType, prepareGitHubRelease) {
+  if (!versionUpdateType) {
+    const npmOldVersion = process.env["npm_old_version"];
+    const npmNewVersion = process.env["npm_new_version"];
+    if (npmOldVersion && npmNewVersion) {
+      await updateVersionInFiles(npmOldVersion);
+      await updateVersion(npmNewVersion, prepareGitHubRelease);
+      return;
+    }
+    throw new Error("No version update type provided");
+  }
+  const isObsidianPlugin = existsSync(resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestJson));
+  validate(versionUpdateType);
+  await checkGitInstalled();
+  await checkGitRepoClean();
+  await checkGitHubCliInstalled();
+  await runCommand("format:check");
+  await runCommand("spellcheck");
+  await runCommand("build");
+  await runCommand("lint");
+  const newVersion = await getNewVersion(versionUpdateType);
+  await updateVersionInFiles(newVersion);
+  if (isObsidianPlugin) {
+    await updateVersionInFilesForPlugin(newVersion);
+  }
+  await updateChangelog(newVersion);
+  await addUpdatedFilesToGit(newVersion);
+  await addGitTag(newVersion);
+  await gitPush();
+  await prepareGitHubRelease?.(newVersion);
+  await publishGitHubRelease(newVersion, isObsidianPlugin);
+}
+async function updateVersionInFiles(newVersion) {
+  await editPackageJson((packageJson) => {
+    packageJson.version = newVersion;
+  });
+  await editPackageLockJson(update, { shouldSkipIfMissing: true });
+  await editNpmShrinkWrapJson(update, { shouldSkipIfMissing: true });
+  function update(packageLockJson) {
+    packageLockJson.version = newVersion;
+    const defaultPackage = packageLockJson.packages?.[""];
+    if (defaultPackage) {
+      defaultPackage.version = newVersion;
+    }
+  }
+}
+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 ?? throwExpression(new Error("Could not find the name of the latest Obsidian release"));
+}
+function isBeta(version) {
+  return version.includes("beta" /* Beta */);
+}
+async function runCommand(command) {
+  const packageJson = await readPackageJson();
+  const isKnownCommand = Object.keys(packageJson.scripts ?? {}).includes(command);
+  await execFromRoot(["npm", "run", ...isKnownCommand ? [] : ["obsidian-dev-utils"], command]);
+}
+function toSingleLine(str) {
+  const lines = str.split(/\r?\n/).filter(Boolean);
+  return lines.join(" ");
+}
+async function updateVersionInFilesForPlugin(newVersion) {
+  const manifestBetaJsonPath = resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestBetaJson);
+  if (isBeta(newVersion)) {
+    await cp(
+      resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestJson),
+      manifestBetaJsonPath,
+      { force: true }
+    );
+    await editJson(ObsidianPluginRepoPaths.ManifestBetaJson, (manifest) => {
+      manifest.version = newVersion;
+    });
+  } else {
+    const latestObsidianVersion = await getLatestObsidianVersion();
+    await editJson(ObsidianPluginRepoPaths.ManifestJson, (manifest) => {
+      manifest.minAppVersion = latestObsidianVersion;
+      manifest.version = newVersion;
+    });
+    await editJson(ObsidianPluginRepoPaths.VersionsJson, (versions) => {
+      versions[newVersion] = latestObsidianVersion;
+    });
+    if (existsSync(manifestBetaJsonPath)) {
+      await rm(manifestBetaJsonPath);
+    }
+  }
+  await copyUpdatedManifest();
+}
+export {
+  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/ScriptUtils/version.ts"],
  "sourcesContent": ["/**\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 type { PackageLockJson } from './Npm.ts';\n\nimport { getLibDebugger } from '../Debug.ts';\nimport { throwExpression } from '../Error.ts';\nimport { ObsidianPluginRepoPaths } from '../obsidian/Plugin/ObsidianPluginRepoPaths.ts';\nimport { join } from '../Path.ts';\nimport { replaceAll } from '../String.ts';\nimport { readdirPosix } from './Fs.ts';\nimport { editJson } from './JSON.ts';\nimport {\n  cp,\n  createInterface,\n  existsSync,\n  readFile,\n  rm,\n  writeFile\n} from './NodeModules.ts';\nimport {\n  editNpmShrinkWrapJson,\n  editPackageJson,\n  editPackageLockJson,\n  readPackageJson\n} from './Npm.ts';\nimport { ObsidianDevUtilsRepoPaths } from './ObsidianDevUtilsRepoPaths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\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`, { isQuiet: 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  await execFromRoot(['git', 'add', '--all'], { isQuiet: true });\n  await execFromRoot(`git commit -m ${newVersion} --allow-empty`, { isQuiet: 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', { isQuiet: 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', { isQuiet: 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', { isQuiet: 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(\n    resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestJson),\n    resolvePathFromRootSafe(join(ObsidianPluginRepoPaths.DistBuild, ObsidianPluginRepoPaths.ManifestJson)),\n    { force: true }\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 packageJson = await readPackageJson();\n  const currentVersion = packageJson.version ?? '';\n\n  const match = /^(?<Major>\\d+)\\.(?<Minor>\\d+)\\.(?<Patch>\\d+)(?:-beta\\.(?<Beta>\\d+))?$/.exec(currentVersion);\n  if (!match) {\n    throw new Error(`Invalid current version format: ${currentVersion}`);\n  }\n\n  let major = Number(match.groups?.['Major'] ?? '');\n  let minor = Number(match.groups?.['Minor'] ?? '');\n  let patch = Number(match.groups?.['Patch'] ?? '');\n  let beta = Number(match.groups?.['Beta'] ?? '');\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      if (beta === 0) {\n        patch++;\n      } else {\n        beta = 0;\n      }\n      break;\n    default:\n      throw new Error(`Invalid version update type: ${versionType}`);\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 = resolvePathFromRootSafe(ObsidianPluginRepoPaths.ChangelogMd);\n  const content = await readFile(changelogPath, 'utf-8');\n  const newVersionEscaped = replaceAll(newVersion, '.', '\\\\.');\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', { isQuiet: true })).split(/\\r?\\n/);\n  const previousVersion = tags[1];\n  let changesUrl: string;\n\n  const repoUrl = await execFromRoot('gh repo view --json url -q .url', { isQuiet: 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', { isQuiet: 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 = resolvePathFromRootSafe(ObsidianPluginRepoPaths.DistBuild);\n    const fileNames = await readdirPosix(buildDir);\n    filePaths = fileNames.map((fileName) => join(buildDir, fileName));\n  } else {\n    const resultJson = await execFromRoot(['npm', 'pack', '--pack-destination', ObsidianDevUtilsRepoPaths.Dist, '--json'], { isQuiet: true });\n    const result = JSON.parse(resultJson) as [{ filename: string }];\n    filePaths = [\n      join(ObsidianDevUtilsRepoPaths.Dist, result[0].filename),\n      join(ObsidianDevUtilsRepoPaths.Dist, ObsidianDevUtilsRepoPaths.StylesCss)\n    ];\n  }\n\n  filePaths = filePaths.filter((filePath) => existsSync(resolvePathFromRootSafe(filePath)));\n\n  await execFromRoot([\n    'gh',\n    'release',\n    'create',\n    newVersion,\n    ...filePaths,\n    '--title',\n    `v${newVersion}`,\n    ...(isBeta(newVersion) ? ['--prerelease'] : []),\n    '--notes-file',\n    '-'\n  ], {\n    isQuiet: 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 HEADER_LINES_COUNT = 2;\n  const changelogPath = resolvePathFromRootSafe(ObsidianPluginRepoPaths.ChangelogMd);\n  let previousChangelogLines: string[];\n  if (existsSync(changelogPath)) {\n    const content = await readFile(changelogPath, 'utf-8');\n    previousChangelogLines = content.split('\\n').slice(HEADER_LINES_COUNT);\n    if (previousChangelogLines.at(-1) === '') {\n      previousChangelogLines.pop();\n    }\n  } else {\n    previousChangelogLines = [];\n  }\n\n  const lastTag = replaceAll(previousChangelogLines[0] ?? '', '## ', '');\n  const commitRange = lastTag ? `${lastTag}..HEAD` : 'HEAD';\n  const commitMessagesStr = await execFromRoot(`git log ${commitRange} --format=%B --first-parent -z`, { isQuiet: true });\n  const commitMessages = commitMessagesStr.split('\\0').filter(Boolean).map(toSingleLine);\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  const codeVersion = await execFromRoot('code --version', {\n    isQuiet: true,\n    shouldIgnoreExitCode: true\n  });\n  const _debugger = getLibDebugger('Version');\n  if (codeVersion) {\n    _debugger(`Please update the ${ObsidianPluginRepoPaths.ChangelogMd} file. Close Visual Studio Code when you are done...`);\n    await execFromRoot(['code', '-w', changelogPath], {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n  } else {\n    _debugger('Could not find Visual Studio Code in your PATH. Using console mode instead.');\n    await createInterface(process.stdin, process.stdout).question(\n      `Please update the ${ObsidianPluginRepoPaths.ChangelogMd} file. Press Enter when you are done...`\n    );\n  }\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 * @param prepareGitHubRelease - A callback function to prepare the GitHub release.\n * @returns A promise that resolves when the version update is complete.\n */\nexport async function updateVersion(versionUpdateType?: string, prepareGitHubRelease?: (newVersion: string) => Promise<void>): 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);\n      await updateVersion(npmNewVersion, prepareGitHubRelease);\n      return;\n    }\n\n    throw new Error('No version update type provided');\n  }\n\n  const isObsidianPlugin = existsSync(resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestJson));\n\n  validate(versionUpdateType);\n  await checkGitInstalled();\n  await checkGitRepoClean();\n  await checkGitHubCliInstalled();\n  await runCommand('format:check');\n  await runCommand('spellcheck');\n  await runCommand('build');\n  await runCommand('lint');\n\n  const newVersion = await getNewVersion(versionUpdateType);\n  await updateVersionInFiles(newVersion);\n  if (isObsidianPlugin) {\n    await updateVersionInFilesForPlugin(newVersion);\n  }\n\n  await updateChangelog(newVersion);\n  await addUpdatedFilesToGit(newVersion);\n  await addGitTag(newVersion);\n  await gitPush();\n  await prepareGitHubRelease?.(newVersion);\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 * @returns A `Promise` that resolves when the update is complete.\n */\nexport async function updateVersionInFiles(newVersion: string): Promise<void> {\n  await editPackageJson((packageJson) => {\n    packageJson.version = newVersion;\n  });\n\n  await editPackageLockJson(update, { shouldSkipIfMissing: true });\n  await editNpmShrinkWrapJson(update, { shouldSkipIfMissing: true });\n\n  function update(packageLockJson: PackageLockJson): void {\n    packageLockJson.version = newVersion;\n    const defaultPackage = packageLockJson.packages?.[''];\n    if (defaultPackage) {\n      defaultPackage.version = newVersion;\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 Partial<ObsidianReleasesJson>;\n  return obsidianReleasesJson.name ?? throwExpression(new Error('Could not find the name of the latest Obsidian release'));\n}\n\nfunction isBeta(version: string): boolean {\n  return version.includes(VersionUpdateType.Beta);\n}\n\nasync function runCommand(command: string): Promise<void> {\n  const packageJson = await readPackageJson();\n  const isKnownCommand = Object.keys(packageJson.scripts ?? {}).includes(command);\n  await execFromRoot(['npm', 'run', ...(isKnownCommand ? [] : ['obsidian-dev-utils']), command]);\n}\n\nfunction toSingleLine(str: string): string {\n  const lines = str.split(/\\r?\\n/).filter(Boolean);\n  return lines.join(' ');\n}\n\nasync function updateVersionInFilesForPlugin(newVersion: string): Promise<void> {\n  const manifestBetaJsonPath = resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestBetaJson);\n  if (isBeta(newVersion)) {\n    await cp(\n      resolvePathFromRootSafe(ObsidianPluginRepoPaths.ManifestJson),\n      manifestBetaJsonPath,\n      { force: true }\n    );\n    await editJson<Manifest>(ObsidianPluginRepoPaths.ManifestBetaJson, (manifest) => {\n      manifest.version = newVersion;\n    });\n  } else {\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    if (existsSync(manifestBetaJsonPath)) {\n      await rm(manifestBetaJsonPath);\n    }\n  }\n\n  await copyUpdatedManifest();\n}\n"],
  "mappings": "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",
  "names": ["VersionUpdateType"]
}


package/dist/lib/{String.d.ts → String.d.cts}

@@ -2,7 +2,7 @@
  * @packageDocumentation String
  * Contains utility functions for string operations.
  */
-import type { ValueProvider } from './ValueProvider.ts';
+import type { ValueProvider } from './ValueProvider.cjs';
 /**
  * A synchronous/asynchronous function that generates replacement strings, or a string to replace with.
  */

package/dist/lib/String.d.mts

@@ -0,0 +1,138 @@
+/**
+ * @packageDocumentation String
+ * Contains utility functions for string operations.
+ */
+import type { ValueProvider } from './ValueProvider.mjs';
+/**
+ * A synchronous/asynchronous function that generates replacement strings, or a string to replace with.
+ */
+export type AsyncReplacer<ReplaceGroupArgs extends string[]> = ValueProvider<StringReplacement, [ReplaceCommonArgs, ...ReplaceGroupArgs]>;
+/**
+ * Common arguments for the `replaceAll`/`replaceAllAsync` functions.
+ */
+export interface ReplaceCommonArgs {
+    /**
+     * The groups of the match.
+     */
+    groups: Record<string, string | undefined> | undefined;
+    /**
+     * The offset of the match.
+     */
+    offset: number;
+    /**
+     * The source of the match.
+     */
+    source: string;
+    /**
+     * The substring of the match.
+     */
+    substring: string;
+}
+/**
+ * A synchronous function that generates replacement strings, or a string to replace with.
+ */
+export type Replacer<ReplaceGroupArgs extends string[]> = ((...args: [ReplaceCommonArgs, ...ReplaceGroupArgs]) => StringReplacement) | StringReplacement;
+type StringReplacement = string | void;
+/**
+ * Ensures that a string ends with the specified suffix, adding it if necessary.
+ *
+ * @param str - The string to check.
+ * @param suffix - The suffix to ensure.
+ * @returns The string that ends with the suffix.
+ */
+export declare function ensureEndsWith(str: string, suffix: string): string;
+/**
+ * Ensures that a string starts with the specified prefix, adding it if necessary.
+ *
+ * @param str - The string to check.
+ * @param prefix - The prefix to ensure.
+ * @returns The string that starts with the prefix.
+ */
+export declare function ensureStartsWith(str: string, prefix: string): string;
+/**
+ * Escapes special characters in a string.
+ *
+ * @param str - The string to escape.
+ * @returns The escaped string.
+ */
+export declare function escape(str: string): string;
+/**
+ * Inserts a substring at a specified position in a string.
+ *
+ * @param str - The string to insert the substring into.
+ * @param substring - The substring to insert.
+ * @param startIndex - The index to insert the substring at.
+ * @param endIndex - The index to end the substring at.
+ * @returns The modified string with the substring inserted.
+ */
+export declare function insertAt(str: string, substring: string, startIndex: number, endIndex?: number): string;
+/**
+ * Converts a string into a valid JavaScript variable name by replacing invalid characters with underscores.
+ *
+ * @param str - The string to convert.
+ * @returns The valid variable name.
+ */
+export declare function makeValidVariableName(str: string): string;
+/**
+ * Normalizes a string by converting it to the NFC form and replacing non-breaking spaces with regular spaces.
+ *
+ * @param str - The string to normalize.
+ * @returns The normalized string.
+ */
+export declare function normalize(str: string): string;
+/**
+ * Replaces occurrences of strings in a given string based on a replacements map.
+ *
+ * @param str - The string to perform replacements on.
+ * @param replacementsMap - An object mapping strings to their replacement values.
+ * @returns The modified string with replacements applied.
+ */
+export declare function replace(str: string, replacementsMap: Record<string, string>): string;
+/**
+ * Replaces all occurrences of a search string or pattern with the results of an replacer function.
+ *
+ * @typeParam ReplaceGroupArgs - The type of additional arguments passed to the replacer function.
+ * @param str - The string in which to perform replacements.
+ * @param searchValue - The string or regular expression to search for.
+ * @param replacer - A replacer function that generates replacement strings, or a string to replace with.
+ * @returns The string with all replacements made.
+ */
+export declare function replaceAll<ReplaceGroupArgs extends string[]>(str: string, searchValue: RegExp | string, replacer: Replacer<ReplaceGroupArgs>): string;
+/**
+ * Asynchronously replaces all occurrences of a search string or pattern with the results of an asynchronous replacer function.
+ *
+ * @typeParam ReplaceGroupArgs - The type of additional arguments passed to the replacer function.
+ * @param str - The string in which to perform replacements.
+ * @param searchValue - The string or regular expression to search for.
+ * @param replacer - A synchronous/asynchronous function that generates replacement strings, or a string to replace with.
+ * @returns A promise that resolves to the string with all replacements made.
+ */
+export declare function replaceAllAsync<ReplaceGroupArgs extends string[]>(str: string, searchValue: RegExp | string, replacer: AsyncReplacer<ReplaceGroupArgs>): Promise<string>;
+/**
+ * Trims the specified suffix from the end of a string.
+ *
+ * @param str - The string to trim.
+ * @param suffix - The suffix to remove from the end of the string.
+ * @param shouldValidate - If true, throws an error if the string does not end with the suffix.
+ * @returns The trimmed string.
+ * @throws If `validate` is true and the string does not end with the suffix.
+ */
+export declare function trimEnd(str: string, suffix: string, shouldValidate?: boolean): string;
+/**
+ * Trims the specified prefix from the start of a string.
+ *
+ * @param str - The string to trim.
+ * @param prefix - The prefix to remove from the start of the string.
+ * @param validate - If true, throws an error if the string does not start with the prefix.
+ * @returns The trimmed string.
+ * @throws If `validate` is true and the string does not start with the prefix.
+ */
+export declare function trimStart(str: string, prefix: string, validate?: boolean): string;
+/**
+ * Unescapes a string by replacing escape sequences with their corresponding characters.
+ *
+ * @param str - The string to unescape.
+ * @returns The unescaped string.
+ */
+export declare function unescape(str: string): string;
+export {};

package/dist/lib/Transformers/{DateTransformer.d.ts → DateTransformer.d.cts}

@@ -2,7 +2,7 @@
  * @packageDocumentation DateTransformer
  * A transformer that can transform Date to an ISO string and back.
  */
-import { TypedTransformer } from './TypedTransformer.ts';
+import { TypedTransformer } from './TypedTransformer.cjs';
 /**
  * A transformer that can transform Date to an ISO string and back.
  */

package/dist/lib/Transformers/DateTransformer.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @packageDocumentation DateTransformer
+ * A transformer that can transform Date to an ISO string and back.
+ */
+import { TypedTransformer } from './TypedTransformer.mjs';
+/**
+ * A transformer that can transform Date to an ISO string and back.
+ */
+export declare class DateTransformer extends TypedTransformer<Date, string> {
+    /**
+     * The id of the transformer.
+     */
+    get id(): string;
+    /**
+     * Determines if the value is a Date.
+     *
+     * @param value - The value to check.
+     * @returns A boolean indicating if the value is a Date.
+     */
+    canTransform(value: unknown): value is Date;
+    /**
+     * Restores the value from a string.
+     *
+     * @param transformedValue - The transformed value.
+     * @returns The restored value.
+     */
+    restoreValue(transformedValue: string): Date;
+    /**
+     * Transforms the value to a string.
+     *
+     * @param value - The value to transform.
+     * @returns The transformed value.
+     */
+    transformValue(value: Date): string;
+}

package/dist/lib/Transformers/{DurationTransformer.d.ts → DurationTransformer.d.cts}

@@ -3,7 +3,7 @@
  * A transformer that can transform Duration to an ISO string and back.
  */
 import type { Duration } from 'moment';
-import { TypedTransformer } from './TypedTransformer.ts';
+import { TypedTransformer } from './TypedTransformer.cjs';
 /**
  * A transformer that converts a Duration to an ISO string and back.
  */

package/dist/lib/Transformers/DurationTransformer.d.mts

@@ -0,0 +1,34 @@
+/**
+ * @packageDocumentation DurationTransformer
+ * A transformer that can transform Duration to an ISO string and back.
+ */
+import type { Duration } from 'moment';
+import { TypedTransformer } from './TypedTransformer.mjs';
+/**
+ * A transformer that converts a Duration to an ISO string and back.
+ */
+export declare class DurationTransformer extends TypedTransformer<Duration, string> {
+    /**
+     * The ID of the transformer.
+     * @returns The ID of the transformer.
+     */
+    get id(): string;
+    /**
+     * Checks if the value is a Duration.
+     * @param value - The value to check.
+     * @returns True if the value is a Duration, false otherwise.
+     */
+    canTransform(value: unknown): value is Duration;
+    /**
+     * Restores the value from a string.
+     * @param transformedValue - The string to restore the value from.
+     * @returns The restored value.
+     */
+    restoreValue(transformedValue: string): Duration;
+    /**
+     * Transforms the value to a string.
+     * @param value - The value to transform.
+     * @returns The transformed value.
+     */
+    transformValue(value: Duration): string;
+}