@mnaoumov/obsidian-lib 10.6.0 → 10.8.0

package/dist/lib/esm/broken-link-candidates.mjs

@@ -0,0 +1,275 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+var BrokenLinkEvidenceKind = /* @__PURE__ */ ((BrokenLinkEvidenceKind2) => {
+  BrokenLinkEvidenceKind2["Alias"] = "Alias";
+  BrokenLinkEvidenceKind2["CaseChange"] = "CaseChange";
+  BrokenLinkEvidenceKind2["GitRename"] = "GitRename";
+  BrokenLinkEvidenceKind2["RenamedFolder"] = "RenamedFolder";
+  BrokenLinkEvidenceKind2["SameName"] = "SameName";
+  BrokenLinkEvidenceKind2["Title"] = "Title";
+  return BrokenLinkEvidenceKind2;
+})(BrokenLinkEvidenceKind || {});
+const FOLDER_NOTE_MIN_SUFFIX_LENGTH = 2;
+const EVIDENCE_KIND_ORDER = [
+  "GitRename" /* GitRename */,
+  "CaseChange" /* CaseChange */,
+  "Alias" /* Alias */,
+  "Title" /* Title */,
+  "RenamedFolder" /* RenamedFolder */,
+  "SameName" /* SameName */
+];
+class BrokenLinkCandidateFinder {
+  aliasesByPath;
+  childFoldersByFolder = /* @__PURE__ */ new Map();
+  filePathSet;
+  filesByLowerCasePath = /* @__PURE__ */ new Map();
+  filesByName = /* @__PURE__ */ new Map();
+  folderNoteFileNames;
+  folderPaths = /* @__PURE__ */ new Set([""]);
+  gitRenames;
+  titlesByPath;
+  /**
+   * Indexes the vault snapshot.
+   *
+   * @param params - The snapshot.
+   */
+  constructor(params) {
+    this.aliasesByPath = params.aliasesByPath;
+    this.filePathSet = new Set(params.filePaths);
+    this.folderNoteFileNames = new Set(params.folderNoteFileNames);
+    this.gitRenames = params.gitRenames;
+    this.titlesByPath = params.titlesByPath;
+    for (const filePath of params.filePaths) {
+      addToMultiMap(this.filesByName, getName(filePath), filePath);
+      addToMultiMap(this.filesByLowerCasePath, filePath.toLowerCase(), filePath);
+      let folder = getParentPath(filePath);
+      while (!this.folderPaths.has(folder)) {
+        this.folderPaths.add(folder);
+        addToMultiMap(this.childFoldersByFolder, getParentPath(folder), folder);
+        folder = getParentPath(folder);
+      }
+    }
+  }
+  /**
+   * Finds the candidates for every missing path at once.
+   *
+   * All at once because one kind of evidence is collective: a renamed folder is recognized by every missing
+   * target that was under it turning up together under one sibling folder.
+   *
+   * @param missingPaths - The vault paths that links lead to and no file holds.
+   * @returns The candidates for each missing path, strongest first; an empty list when nothing is known.
+   */
+  findAll(missingPaths) {
+    const uniqueMissingPaths = new Set(missingPaths);
+    const missingSubtrees = this.getMissingSubtrees(uniqueMissingPaths);
+    const result = /* @__PURE__ */ new Map();
+    for (const missingPath of uniqueMissingPaths) {
+      let add2 = function(path, kind, description) {
+        addToMultiMap(evidenceByPath, path, { description, kind });
+      };
+      var add = add2;
+      const evidenceByPath = /* @__PURE__ */ new Map();
+      this.addGitRenameCandidate(missingPath, add2);
+      this.addCaseChangeCandidates(missingPath, add2);
+      this.addAliasAndTitleCandidates(missingPath, add2);
+      this.addRenamedFolderCandidates(missingPath, missingSubtrees, add2);
+      this.addSameNameCandidates(missingPath, add2);
+      result.set(missingPath, sortCandidates(evidenceByPath));
+    }
+    return result;
+  }
+  addAliasAndTitleCandidates(missingPath, add) {
+    const name = getName(missingPath);
+    const isFolderNote = this.folderNoteFileNames.has(name);
+    let oldName;
+    if (isFolderNote) {
+      oldName = getName(getParentPath(missingPath));
+      if (!oldName) {
+        return;
+      }
+    } else if (name.toLowerCase().endsWith(".md")) {
+      oldName = name.slice(0, -".md".length);
+    } else {
+      return;
+    }
+    const lowerCaseOldName = oldName.toLowerCase();
+    const isEligible = (path) => this.filePathSet.has(path) && (!isFolderNote || getName(path) === name);
+    for (const [path, aliases] of this.aliasesByPath) {
+      if (isEligible(path) && aliases.some((alias) => alias.toLowerCase() === lowerCaseOldName)) {
+        add(path, "Alias" /* Alias */, `Its aliases hold the old name "${oldName}".`);
+      }
+    }
+    for (const [path, title] of this.titlesByPath) {
+      if (isEligible(path) && title.toLowerCase() === lowerCaseOldName) {
+        add(path, "Title" /* Title */, `Its title is the old name "${oldName}".`);
+      }
+    }
+  }
+  addCaseChangeCandidates(missingPath, add) {
+    for (const path of this.filesByLowerCasePath.get(missingPath.toLowerCase()) ?? []) {
+      add(path, "CaseChange" /* CaseChange */, "Only the letter case of its path differs.");
+    }
+  }
+  addGitRenameCandidate(missingPath, add) {
+    const gitRename = this.gitRenames.get(missingPath);
+    if (gitRename && this.filePathSet.has(gitRename.newPath)) {
+      add(gitRename.newPath, "GitRename" /* GitRename */, `Git history records the rename, in commit ${gitRename.commit}.`);
+    }
+  }
+  addRenamedFolderCandidates(missingPath, missingSubtrees, add) {
+    const missingSubtree = missingSubtrees.get(missingPath);
+    if (!missingSubtree) {
+      return;
+    }
+    const parentPath = getParentPath(missingSubtree.root);
+    const remainder = getRelativePath(missingSubtree.root, missingPath);
+    for (const siblingFolder of this.childFoldersByFolder.get(parentPath) ?? []) {
+      const isSubtreeIntact = [...missingSubtree.remainders].every((path) => this.filePathSet.has(joinPath(siblingFolder, path)));
+      if (!isSubtreeIntact) {
+        continue;
+      }
+      const fileCount = missingSubtree.remainders.size;
+      add(
+        joinPath(siblingFolder, remainder),
+        "RenamedFolder" /* RenamedFolder */,
+        `The folder "${missingSubtree.root}" is gone, and its sibling "${siblingFolder}" holds ${fileCount === 1 ? "the missing file that was" : `all ${String(fileCount)} missing files that were`} under it.`
+      );
+    }
+  }
+  addSameNameCandidates(missingPath, add) {
+    const name = getName(missingPath);
+    const minSuffixLength = this.folderNoteFileNames.has(name) ? FOLDER_NOTE_MIN_SUFFIX_LENGTH : 1;
+    const missingSegments = missingPath.split("/");
+    let bestSuffixLength = minSuffixLength;
+    let bestPaths = [];
+    for (const path of this.filesByName.get(name) ?? []) {
+      const suffixLength = getCommonSuffixLength(missingSegments, path.split("/"));
+      if (suffixLength > bestSuffixLength) {
+        bestSuffixLength = suffixLength;
+        bestPaths = [path];
+      } else if (suffixLength === bestSuffixLength) {
+        bestPaths.push(path);
+      }
+    }
+    const suffix = missingSegments.slice(-bestSuffixLength).join("/");
+    for (const path of bestPaths) {
+      add(path, "SameName" /* SameName */, `It has the same name, "${suffix}", in another folder.`);
+    }
+  }
+  /**
+   * Groups the missing paths by the highest missing folder above each, the root of a subtree that may have been
+   * renamed as a whole.
+   *
+   * @param missingPaths - The missing paths.
+   * @returns Each missing path's subtree; a path whose own folder exists has none.
+   */
+  getMissingSubtrees(missingPaths) {
+    const subtreesByRoot = /* @__PURE__ */ new Map();
+    const result = /* @__PURE__ */ new Map();
+    for (const missingPath of missingPaths) {
+      let root = getParentPath(missingPath);
+      if (this.folderPaths.has(root)) {
+        continue;
+      }
+      while (!this.folderPaths.has(getParentPath(root))) {
+        root = getParentPath(root);
+      }
+      let missingSubtree = subtreesByRoot.get(root);
+      if (!missingSubtree) {
+        missingSubtree = { remainders: /* @__PURE__ */ new Set(), root };
+        subtreesByRoot.set(root, missingSubtree);
+      }
+      missingSubtree.remainders.add(getRelativePath(root, missingPath));
+      result.set(missingPath, missingSubtree);
+    }
+    return result;
+  }
+}
+function getParentPath(path) {
+  const index = path.lastIndexOf("/");
+  return index === -1 ? "" : path.slice(0, index);
+}
+function getPathMapping(oldPath, newPath) {
+  const oldSegments = oldPath.split("/");
+  const newSegments = newPath.split("/");
+  const suffixLength = getCommonSuffixLength(oldSegments, newSegments);
+  return {
+    newPrefix: newSegments.slice(0, newSegments.length - suffixLength).join("/"),
+    oldPrefix: oldSegments.slice(0, oldSegments.length - suffixLength).join("/")
+  };
+}
+function addToMultiMap(map, key, value) {
+  let values = map.get(key);
+  if (!values) {
+    values = [];
+    map.set(key, values);
+  }
+  values.push(value);
+}
+function getCommonSuffixLength(segments1, segments2) {
+  let length = 0;
+  while (length < segments1.length && length < segments2.length && segments1.at(-length - 1) === segments2.at(-length - 1)) {
+    length++;
+  }
+  return length;
+}
+function getEvidenceRank(evidence) {
+  return EVIDENCE_KIND_ORDER.indexOf(evidence.kind);
+}
+function getName(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function getRelativePath(folder, path) {
+  return path.slice(folder.length + 1);
+}
+function joinPath(folder, path) {
+  return `${folder}/${path}`;
+}
+function sortCandidates(evidenceByPath) {
+  const candidates = [...evidenceByPath].map(([path, evidence]) => ({
+    evidence: evidence.sort((evidence1, evidence2) => getEvidenceRank(evidence1) - getEvidenceRank(evidence2)),
+    path
+  }));
+  return candidates.sort((candidate1, candidate2) => {
+    const rankDifference = getEvidenceRank(ensureNonNullable(candidate1.evidence[0])) - getEvidenceRank(ensureNonNullable(candidate2.evidence[0]));
+    return rankDifference || candidate1.path.localeCompare(candidate2.path);
+  });
+}
+export {
+  BrokenLinkCandidateFinder,
+  BrokenLinkEvidenceKind,
+  getParentPath,
+  getPathMapping
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/broken-link-candidates.ts"],"sourcesContent":["/**\n * @file\n *\n * Where did a missing link target go? Pure, no `App`: every question about which file a broken link most likely\n * meant is answerable from a list of paths, the notes' aliases and titles, and the vault's git renames.\n *\n * A rename is not recoverable from the link alone: a link to `alpha/bravo/charlie/!.md` says nothing about\n * `charlie` having become `delta`. So every candidate carries the evidence that produced it, from outside the\n * link, and the finder never picks one of several: a caller offers a one-click fix only when exactly one\n * candidate exists.\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\n/**\n * The kind of evidence that makes a file a candidate for a missing link target.\n *\n * Candidates list evidence strongest first, in EVIDENCE_KIND_ORDER below.\n */\nexport enum BrokenLinkEvidenceKind {\n  /**\n   * The candidate's `aliases` hold the missing target's old name.\n   */\n  Alias = 'Alias',\n\n  /**\n   * The candidate's path differs from the missing one only in letter case.\n   */\n  CaseChange = 'CaseChange',\n\n  /**\n   * The vault's git history records the missing path being renamed to the candidate.\n   */\n  GitRename = 'GitRename',\n\n  /**\n   * The missing target's folder is gone, and a sibling folder holds every missing target that was under it.\n   */\n  RenamedFolder = 'RenamedFolder',\n\n  /**\n   * A file with the same name, and the longest run of the same parent folders, sits elsewhere.\n   */\n  SameName = 'SameName',\n\n  /**\n   * The candidate's `title` is the missing target's old name.\n   */\n  Title = 'Title'\n}\n\n/**\n * A folder note's own name identifies nothing, so a same-name candidate must share its folder's name too.\n */\nconst FOLDER_NOTE_MIN_SUFFIX_LENGTH = 2;\n\nconst EVIDENCE_KIND_ORDER: readonly BrokenLinkEvidenceKind[] = [\n  BrokenLinkEvidenceKind.GitRename,\n  BrokenLinkEvidenceKind.CaseChange,\n  BrokenLinkEvidenceKind.Alias,\n  BrokenLinkEvidenceKind.Title,\n  BrokenLinkEvidenceKind.RenamedFolder,\n  BrokenLinkEvidenceKind.SameName\n];\n\n/**\n * One file that a missing link target may have become, and why.\n */\nexport interface BrokenLinkCandidate {\n  /**\n   * Every reason this file is a candidate, strongest first.\n   */\n  readonly evidence: readonly BrokenLinkEvidence[];\n\n  /**\n   * The candidate's vault path.\n   */\n  readonly path: string;\n}\n\n/**\n * The parameters for {@link BrokenLinkCandidateFinder}.\n */\nexport interface BrokenLinkCandidateFinderConstructorParams {\n  /**\n   * Each note's `aliases`, by note path.\n   */\n  readonly aliasesByPath: ReadonlyMap<string, readonly string[]>;\n\n  /**\n   * Every file in the vault.\n   */\n  readonly filePaths: readonly string[];\n\n  /**\n   * The file names a folder note is stored under, such as `index.md`. Such a name says nothing about which\n   * note it is, so a same-name candidate must share its folder's name too, and the old name an alias is\n   * matched against is the folder's.\n   */\n  readonly folderNoteFileNames: readonly string[];\n\n  /**\n   * The vault's git renames: each old vault path to the path it was renamed to, chains already followed.\n   */\n  readonly gitRenames: ReadonlyMap<string, GitRename>;\n\n  /**\n   * Each note's `title`, by note path.\n   */\n  readonly titlesByPath: ReadonlyMap<string, string>;\n}\n\n/**\n * One reason a file is a candidate for a missing link target.\n */\nexport interface BrokenLinkEvidence {\n  /**\n   * A sentence naming the evidence, for the user to judge it by.\n   */\n  readonly description: string;\n\n  /**\n   * The kind of evidence.\n   */\n  readonly kind: BrokenLinkEvidenceKind;\n}\n\n/**\n * A rename recorded in the vault's git history.\n */\nexport interface GitRename {\n  /**\n   * The abbreviated hash of the commit that made the last rename of the chain.\n   */\n  readonly commit: string;\n\n  /**\n   * The vault path the file was last renamed to.\n   */\n  readonly newPath: string;\n}\n\n/**\n * The part of a missing path that a candidate replaced: what a \"fix all like this\" applies to every other link.\n */\nexport interface PathMapping {\n  /**\n   * The part of the candidate path that replaced {@link oldPrefix}; `''` for the vault root.\n   */\n  readonly newPrefix: string;\n\n  /**\n   * The leading part of the missing path that no longer exists; `''` for the vault root.\n   */\n  readonly oldPrefix: string;\n}\n\ntype EvidenceAdder = (path: string, kind: BrokenLinkEvidenceKind, description: string) => void;\n\ninterface MissingSubtree {\n  /**\n   * Each missing path under the subtree's root, relative to it.\n   */\n  readonly remainders: Set<string>;\n\n  readonly root: string;\n}\n\n/**\n * Finds the candidates for missing link targets, from one snapshot of the vault.\n */\nexport class BrokenLinkCandidateFinder {\n  private readonly aliasesByPath: ReadonlyMap<string, readonly string[]>;\n  private readonly childFoldersByFolder = new Map<string, string[]>();\n  private readonly filePathSet: ReadonlySet<string>;\n  private readonly filesByLowerCasePath = new Map<string, string[]>();\n  private readonly filesByName = new Map<string, string[]>();\n  private readonly folderNoteFileNames: ReadonlySet<string>;\n  private readonly folderPaths = new Set<string>(['']);\n  private readonly gitRenames: ReadonlyMap<string, GitRename>;\n  private readonly titlesByPath: ReadonlyMap<string, string>;\n\n  /**\n   * Indexes the vault snapshot.\n   *\n   * @param params - The snapshot.\n   */\n  public constructor(params: BrokenLinkCandidateFinderConstructorParams) {\n    this.aliasesByPath = params.aliasesByPath;\n    this.filePathSet = new Set(params.filePaths);\n    this.folderNoteFileNames = new Set(params.folderNoteFileNames);\n    this.gitRenames = params.gitRenames;\n    this.titlesByPath = params.titlesByPath;\n\n    for (const filePath of params.filePaths) {\n      addToMultiMap(this.filesByName, getName(filePath), filePath);\n      addToMultiMap(this.filesByLowerCasePath, filePath.toLowerCase(), filePath);\n\n      let folder = getParentPath(filePath);\n      while (!this.folderPaths.has(folder)) {\n        this.folderPaths.add(folder);\n        addToMultiMap(this.childFoldersByFolder, getParentPath(folder), folder);\n        folder = getParentPath(folder);\n      }\n    }\n  }\n\n  /**\n   * Finds the candidates for every missing path at once.\n   *\n   * All at once because one kind of evidence is collective: a renamed folder is recognized by every missing\n   * target that was under it turning up together under one sibling folder.\n   *\n   * @param missingPaths - The vault paths that links lead to and no file holds.\n   * @returns The candidates for each missing path, strongest first; an empty list when nothing is known.\n   */\n  public findAll(missingPaths: Iterable<string>): Map<string, BrokenLinkCandidate[]> {\n    const uniqueMissingPaths = new Set(missingPaths);\n    const missingSubtrees = this.getMissingSubtrees(uniqueMissingPaths);\n    const result = new Map<string, BrokenLinkCandidate[]>();\n\n    for (const missingPath of uniqueMissingPaths) {\n      const evidenceByPath = new Map<string, BrokenLinkEvidence[]>();\n      function add(path: string, kind: BrokenLinkEvidenceKind, description: string): void {\n        addToMultiMap(evidenceByPath, path, { description, kind });\n      }\n\n      this.addGitRenameCandidate(missingPath, add);\n      this.addCaseChangeCandidates(missingPath, add);\n      this.addAliasAndTitleCandidates(missingPath, add);\n      this.addRenamedFolderCandidates(missingPath, missingSubtrees, add);\n      this.addSameNameCandidates(missingPath, add);\n\n      result.set(missingPath, sortCandidates(evidenceByPath));\n    }\n\n    return result;\n  }\n\n  private addAliasAndTitleCandidates(missingPath: string, add: EvidenceAdder): void {\n    const name = getName(missingPath);\n    const isFolderNote = this.folderNoteFileNames.has(name);\n    let oldName: string;\n\n    if (isFolderNote) {\n      oldName = getName(getParentPath(missingPath));\n      if (!oldName) {\n        return;\n      }\n    } else if (name.toLowerCase().endsWith('.md')) {\n      oldName = name.slice(0, -'.md'.length);\n    } else {\n      return;\n    }\n\n    const lowerCaseOldName = oldName.toLowerCase();\n    const isEligible = (path: string): boolean => this.filePathSet.has(path) && (!isFolderNote || getName(path) === name);\n\n    for (const [path, aliases] of this.aliasesByPath) {\n      if (isEligible(path) && aliases.some((alias) => alias.toLowerCase() === lowerCaseOldName)) {\n        add(path, BrokenLinkEvidenceKind.Alias, `Its aliases hold the old name \"${oldName}\".`);\n      }\n    }\n\n    for (const [path, title] of this.titlesByPath) {\n      if (isEligible(path) && title.toLowerCase() === lowerCaseOldName) {\n        add(path, BrokenLinkEvidenceKind.Title, `Its title is the old name \"${oldName}\".`);\n      }\n    }\n  }\n\n  private addCaseChangeCandidates(missingPath: string, add: EvidenceAdder): void {\n    for (const path of this.filesByLowerCasePath.get(missingPath.toLowerCase()) ?? []) {\n      add(path, BrokenLinkEvidenceKind.CaseChange, 'Only the letter case of its path differs.');\n    }\n  }\n\n  private addGitRenameCandidate(missingPath: string, add: EvidenceAdder): void {\n    const gitRename = this.gitRenames.get(missingPath);\n    if (gitRename && this.filePathSet.has(gitRename.newPath)) {\n      add(gitRename.newPath, BrokenLinkEvidenceKind.GitRename, `Git history records the rename, in commit ${gitRename.commit}.`);\n    }\n  }\n\n  private addRenamedFolderCandidates(missingPath: string, missingSubtrees: ReadonlyMap<string, MissingSubtree>, add: EvidenceAdder): void {\n    const missingSubtree = missingSubtrees.get(missingPath);\n    if (!missingSubtree) {\n      return;\n    }\n\n    const parentPath = getParentPath(missingSubtree.root);\n    const remainder = getRelativePath(missingSubtree.root, missingPath);\n\n    for (const siblingFolder of this.childFoldersByFolder.get(parentPath) ?? []) {\n      const isSubtreeIntact = [...missingSubtree.remainders].every((path) => this.filePathSet.has(joinPath(siblingFolder, path)));\n      if (!isSubtreeIntact) {\n        continue;\n      }\n\n      const fileCount = missingSubtree.remainders.size;\n      add(\n        joinPath(siblingFolder, remainder),\n        BrokenLinkEvidenceKind.RenamedFolder,\n        `The folder \"${missingSubtree.root}\" is gone, and its sibling \"${siblingFolder}\" holds ${fileCount === 1 ? 'the missing file that was' : `all ${String(fileCount)} missing files that were`} under it.`\n      );\n    }\n  }\n\n  private addSameNameCandidates(missingPath: string, add: EvidenceAdder): void {\n    const name = getName(missingPath);\n    const minSuffixLength = this.folderNoteFileNames.has(name) ? FOLDER_NOTE_MIN_SUFFIX_LENGTH : 1;\n    const missingSegments = missingPath.split('/');\n    let bestSuffixLength = minSuffixLength;\n    let bestPaths: string[] = [];\n\n    for (const path of this.filesByName.get(name) ?? []) {\n      const suffixLength = getCommonSuffixLength(missingSegments, path.split('/'));\n      if (suffixLength > bestSuffixLength) {\n        bestSuffixLength = suffixLength;\n        bestPaths = [path];\n      } else if (suffixLength === bestSuffixLength) {\n        bestPaths.push(path);\n      }\n    }\n\n    const suffix = missingSegments.slice(-bestSuffixLength).join('/');\n    for (const path of bestPaths) {\n      add(path, BrokenLinkEvidenceKind.SameName, `It has the same name, \"${suffix}\", in another folder.`);\n    }\n  }\n\n  /**\n   * Groups the missing paths by the highest missing folder above each, the root of a subtree that may have been\n   * renamed as a whole.\n   *\n   * @param missingPaths - The missing paths.\n   * @returns Each missing path's subtree; a path whose own folder exists has none.\n   */\n  private getMissingSubtrees(missingPaths: ReadonlySet<string>): Map<string, MissingSubtree> {\n    const subtreesByRoot = new Map<string, MissingSubtree>();\n    const result = new Map<string, MissingSubtree>();\n\n    for (const missingPath of missingPaths) {\n      let root = getParentPath(missingPath);\n      if (this.folderPaths.has(root)) {\n        continue;\n      }\n\n      while (!this.folderPaths.has(getParentPath(root))) {\n        root = getParentPath(root);\n      }\n\n      let missingSubtree = subtreesByRoot.get(root);\n      if (!missingSubtree) {\n        missingSubtree = { remainders: new Set(), root };\n        subtreesByRoot.set(root, missingSubtree);\n      }\n\n      missingSubtree.remainders.add(getRelativePath(root, missingPath));\n      result.set(missingPath, missingSubtree);\n    }\n\n    return result;\n  }\n}\n\n/**\n * The parent folder of a vault path.\n *\n * @param path - The path.\n * @returns The parent folder; `''` for the vault root.\n */\nexport function getParentPath(path: string): string {\n  const index = path.lastIndexOf('/');\n  return index === -1 ? '' : path.slice(0, index);\n}\n\n/**\n * The part of a missing path that a candidate path replaced, found by dropping the path segments they end with\n * in common.\n *\n * @param oldPath - The missing path.\n * @param newPath - The candidate path.\n * @returns The prefixes that differ.\n */\nexport function getPathMapping(oldPath: string, newPath: string): PathMapping {\n  const oldSegments = oldPath.split('/');\n  const newSegments = newPath.split('/');\n  const suffixLength = getCommonSuffixLength(oldSegments, newSegments);\n  return {\n    newPrefix: newSegments.slice(0, newSegments.length - suffixLength).join('/'),\n    oldPrefix: oldSegments.slice(0, oldSegments.length - suffixLength).join('/')\n  };\n}\n\nfunction addToMultiMap<Key, Value>(map: Map<Key, Value[]>, key: Key, value: Value): void {\n  let values = map.get(key);\n  if (!values) {\n    values = [];\n    map.set(key, values);\n  }\n  values.push(value);\n}\n\nfunction getCommonSuffixLength(segments1: readonly string[], segments2: readonly string[]): number {\n  let length = 0;\n  while (length < segments1.length && length < segments2.length && segments1.at(-length - 1) === segments2.at(-length - 1)) {\n    length++;\n  }\n  return length;\n}\n\nfunction getEvidenceRank(evidence: BrokenLinkEvidence): number {\n  return EVIDENCE_KIND_ORDER.indexOf(evidence.kind);\n}\n\nfunction getName(path: string): string {\n  return path.slice(path.lastIndexOf('/') + 1);\n}\n\n// The folder is never the vault root here: a missing subtree's root is a missing folder, and its siblings are\n// folders too.\nfunction getRelativePath(folder: string, path: string): string {\n  return path.slice(folder.length + 1);\n}\n\nfunction joinPath(folder: string, path: string): string {\n  return `${folder}/${path}`;\n}\n\nfunction sortCandidates(evidenceByPath: ReadonlyMap<string, BrokenLinkEvidence[]>): BrokenLinkCandidate[] {\n  const candidates = [...evidenceByPath].map(([path, evidence]) => ({\n    evidence: evidence.sort((evidence1, evidence2) => getEvidenceRank(evidence1) - getEvidenceRank(evidence2)),\n    path\n  }));\n\n  return candidates.sort((candidate1, candidate2) => {\n    const rankDifference = getEvidenceRank(ensureNonNullable(candidate1.evidence[0])) - getEvidenceRank(ensureNonNullable(candidate2.evidence[0]));\n    return rankDifference || candidate1.path.localeCompare(candidate2.path);\n  });\n}\n"],"mappings":"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","names":["BrokenLinkEvidenceKind","add"]}

package/dist/lib/esm/command-handlers/index.d.mts

@@ -8,6 +8,9 @@ export * as 'folder-command-handler' from './folder-command-handler.mjs';
 export * as 'global-command-handler' from './global-command-handler.mjs';
 export * as 'open-bug-report-command-handler' from './open-bug-report-command-handler.mjs';
 export * as 'open-demo-vault-command-handler' from './open-demo-vault-command-handler.mjs';
+export * as 'open-discussion-command-handler' from './open-discussion-command-handler.mjs';
+export * as 'open-feature-request-command-handler' from './open-feature-request-command-handler.mjs';
+export * as 'open-git-hub-command-handler' from './open-git-hub-command-handler.mjs';
 export * as 'open-settings-command-handler' from './open-settings-command-handler.mjs';
 export * as 'undo-bulk-operation-command-handler' from './undo-bulk-operation-command-handler.mjs';
 export * as 'unlock-active-note-command-handler' from './unlock-active-note-command-handler.mjs';

package/dist/lib/esm/command-handlers/index.mjs

@@ -12,6 +12,9 @@ import * as folder_command_handler from "./folder-command-handler.mjs";
 import * as global_command_handler from "./global-command-handler.mjs";
 import * as open_bug_report_command_handler from "./open-bug-report-command-handler.mjs";
 import * as open_demo_vault_command_handler from "./open-demo-vault-command-handler.mjs";
+import * as open_discussion_command_handler from "./open-discussion-command-handler.mjs";
+import * as open_feature_request_command_handler from "./open-feature-request-command-handler.mjs";
+import * as open_git_hub_command_handler from "./open-git-hub-command-handler.mjs";
 import * as open_settings_command_handler from "./open-settings-command-handler.mjs";
 import * as undo_bulk_operation_command_handler from "./undo-bulk-operation-command-handler.mjs";
 import * as unlock_active_note_command_handler from "./unlock-active-note-command-handler.mjs";
@@ -25,8 +28,11 @@ export {
   global_command_handler as "global-command-handler",
   open_bug_report_command_handler as "open-bug-report-command-handler",
   open_demo_vault_command_handler as "open-demo-vault-command-handler",
+  open_discussion_command_handler as "open-discussion-command-handler",
+  open_feature_request_command_handler as "open-feature-request-command-handler",
+  open_git_hub_command_handler as "open-git-hub-command-handler",
   open_settings_command_handler as "open-settings-command-handler",
   undo_bulk_operation_command_handler as "undo-bulk-operation-command-handler",
   unlock_active_note_command_handler as "unlock-active-note-command-handler"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvbW1hbmQtaGFuZGxlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ2NvbW1hbmQtaGFuZGxlci1jb21wb25lbnQnIGZyb20gJy4vY29tbWFuZC1oYW5kbGVyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL2NvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnZWRpdG9yLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9lZGl0b3ItY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdmaWxlLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9maWxlLWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnZm9sZGVyLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9mb2xkZXItY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdnbG9iYWwtY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL2dsb2JhbC1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ29wZW4tYnVnLXJlcG9ydC1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1idWctcmVwb3J0LWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnb3Blbi1kZW1vLXZhdWx0LWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9vcGVuLWRlbW8tdmF1bHQtY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdvcGVuLWRpc2N1c3Npb24tY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL29wZW4tZGlzY3Vzc2lvbi1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ29wZW4tZmVhdHVyZS1yZXF1ZXN0LWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9vcGVuLWZlYXR1cmUtcmVxdWVzdC1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ29wZW4tZ2l0LWh1Yi1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1naXQtaHViLWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnb3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ3VuZG8tYnVsay1vcGVyYXRpb24tY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL3VuZG8tYnVsay1vcGVyYXRpb24tY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICd1bmxvY2stYWN0aXZlLW5vdGUtY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL3VubG9jay1hY3RpdmUtbm90ZS1jb21tYW5kLWhhbmRsZXIudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZQSxtQ0FBcUM7QUFDakQsWUFBWUMsK0JBQWlDO0FBQzdDLFlBQVlDLHFCQUF1QjtBQUNuQyxZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMsMEJBQTRCO0FBQ3hDLFlBQVlDLDRCQUE4QjtBQUMxQyxZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMscUNBQXVDO0FBQ25ELFlBQVlDLHFDQUF1QztBQUNuRCxZQUFZQyxxQ0FBdUM7QUFDbkQsWUFBWUMsMENBQTRDO0FBQ3hELFlBQVlDLGtDQUFvQztBQUNoRCxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMseUNBQTJDO0FBQ3ZELFlBQVlDLHdDQUEwQzsiLAogICJuYW1lcyI6IFsiYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXIiLCAiY29tbWFuZC1oYW5kbGVyLWNvbXBvbmVudCIsICJjb21tYW5kLWhhbmRsZXIiLCAiZWRpdG9yLWNvbW1hbmQtaGFuZGxlciIsICJmaWxlLWNvbW1hbmQtaGFuZGxlciIsICJmb2xkZXItY29tbWFuZC1oYW5kbGVyIiwgImdsb2JhbC1jb21tYW5kLWhhbmRsZXIiLCAib3Blbi1idWctcmVwb3J0LWNvbW1hbmQtaGFuZGxlciIsICJvcGVuLWRlbW8tdmF1bHQtY29tbWFuZC1oYW5kbGVyIiwgIm9wZW4tZGlzY3Vzc2lvbi1jb21tYW5kLWhhbmRsZXIiLCAib3Blbi1mZWF0dXJlLXJlcXVlc3QtY29tbWFuZC1oYW5kbGVyIiwgIm9wZW4tZ2l0LWh1Yi1jb21tYW5kLWhhbmRsZXIiLCAib3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXIiLCAidW5kby1idWxrLW9wZXJhdGlvbi1jb21tYW5kLWhhbmRsZXIiLCAidW5sb2NrLWFjdGl2ZS1ub3RlLWNvbW1hbmQtaGFuZGxlciJdCn0K

package/dist/lib/esm/command-handlers/open-bug-report-command-handler.d.mts

@@ -5,7 +5,7 @@
  * Handles the "Report a bug" command.
  */
 import type { App } from 'obsidian';
-import { GlobalCommandHandler } from './global-command-handler.mjs';
+import { OpenGitHubCommandHandler } from './open-git-hub-command-handler.mjs';
 /**
  * Constructor parameters for {@link OpenBugReportCommandHandler}.
  */
@@ -27,15 +27,11 @@ export interface OpenBugReportCommandHandlerConstructorParams {
  * A command handler that opens the plugin's bug-report issue form on GitHub, prefilled with the
  * environment. See {@link getBugReportIssueFormUrl} for the field ids the form must use.
  */
-export declare class OpenBugReportCommandHandler extends GlobalCommandHandler {
+export declare class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {
     /**
      * The Obsidian app instance.
      */
     protected readonly app: App;
-    /**
-     * The plugin's GitHub repository, as `owner/name`.
-     */
-    protected readonly gitHubRepo: string;
     /**
      * The id of the reporting plugin.
      */
@@ -47,7 +43,9 @@ export declare class OpenBugReportCommandHandler extends GlobalCommandHandler {
      */
     constructor(params: OpenBugReportCommandHandlerConstructorParams);
     /**
-     * Executes the command, opening the prefilled issue form in the browser.
+     * Builds the prefilled bug-report URL.
+     *
+     * @returns The link.
      */
-    execute(): Promise<void>;
+    protected getUrl(): Promise<string>;
 }

package/dist/lib/esm/command-handlers/open-bug-report-command-handler.mjs

@@ -4,16 +4,12 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 import { getBugReportIssueFormUrl } from "../bug-report.mjs";
-import { GlobalCommandHandler } from "./global-command-handler.mjs";
-class OpenBugReportCommandHandler extends GlobalCommandHandler {
+import { OpenGitHubCommandHandler } from "./open-git-hub-command-handler.mjs";
+class OpenBugReportCommandHandler extends OpenGitHubCommandHandler {
   /**
    * The Obsidian app instance.
    */
   app;
-  /**
-   * The plugin's GitHub repository, as `owner/name`.
-   */
-  gitHubRepo;
   /**
    * The id of the reporting plugin.
    */
@@ -25,27 +21,28 @@ class OpenBugReportCommandHandler extends GlobalCommandHandler {
    */
   constructor(params) {
     super({
+      gitHubRepo: params.gitHubRepo,
       icon: "bug",
       id: "report-bug",
       name: "Report a bug"
     });
     this.app = params.app;
     this.pluginId = params.pluginId;
-    this.gitHubRepo = params.gitHubRepo;
   }
   /**
-   * Executes the command, opening the prefilled issue form in the browser.
+   * Builds the prefilled bug-report URL.
+   *
+   * @returns The link.
    */
-  async execute() {
-    const url = await getBugReportIssueFormUrl({
+  async getUrl() {
+    return getBugReportIssueFormUrl({
       app: this.app,
       gitHubRepo: this.gitHubRepo,
       pluginId: this.pluginId
     });
-    window.open(url, "_blank");
   }
 }
 export {
   OpenBugReportCommandHandler
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/command-handlers/open-discussion-command-handler.d.mts

@@ -0,0 +1,45 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Handles the "Start a discussion" command.
+ */
+import type { GetGitHubDiscussionUrlParams } from '../git-hub-discussion.mjs';
+import { OpenGitHubCommandHandler } from './open-git-hub-command-handler.mjs';
+/**
+ * Constructor parameters for {@link OpenDiscussionCommandHandler}.
+ */
+export interface OpenDiscussionCommandHandlerConstructorParams extends GetGitHubDiscussionUrlParams {
+    /**
+     * Whether the repository has Discussions enabled. When `false`, the command is unavailable and
+     * execution does not open a browser. Prefer omitting registration altogether in that case.
+     */
+    readonly isDiscussionsEnabled: boolean;
+}
+/**
+ * Opens a new discussion in the plugin's repository. Unavailable when Discussions is disabled.
+ *
+ * See the [community commands guide](https://mnaoumov.dev/obsidian-lib/guides/community-commands/)
+ * and [behavioral tests](https://github.com/mnaoumov/obsidian-lib/blob/main/src/command-handlers/open-discussion-command-handler.test.ts).
+ */
+export declare class OpenDiscussionCommandHandler extends OpenGitHubCommandHandler {
+    private readonly params;
+    /**
+     * Constructs a new instance.
+     *
+     * @param params - Constructor parameters.
+     */
+    constructor(params: OpenDiscussionCommandHandlerConstructorParams);
+    /**
+     * Checks the repository's declared Discussions capability.
+     *
+     * @returns Whether the command is available.
+     */
+    protected canExecute(): boolean;
+    /**
+     * Builds the new-discussion URL.
+     *
+     * @returns The link.
+     */
+    protected getUrl(): string;
+}

package/dist/lib/esm/command-handlers/open-discussion-command-handler.mjs

@@ -0,0 +1,39 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { getGitHubDiscussionUrl } from "../git-hub-discussion.mjs";
+import { OpenGitHubCommandHandler } from "./open-git-hub-command-handler.mjs";
+class OpenDiscussionCommandHandler extends OpenGitHubCommandHandler {
+  params;
+  /**
+   * Constructs a new instance.
+   *
+   * @param params - Constructor parameters.
+   */
+  constructor(params) {
+    super({ gitHubRepo: params.gitHubRepo, icon: "messages-square", id: "start-discussion", name: "Start a discussion" });
+    this.params = params;
+  }
+  /**
+   * Checks the repository's declared Discussions capability.
+   *
+   * @returns Whether the command is available.
+   */
+  canExecute() {
+    return this.params.isDiscussionsEnabled;
+  }
+  /**
+   * Builds the new-discussion URL.
+   *
+   * @returns The link.
+   */
+  getUrl() {
+    return getGitHubDiscussionUrl(this.params);
+  }
+}
+export {
+  OpenDiscussionCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/command-handlers/open-feature-request-command-handler.d.mts

@@ -0,0 +1,33 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Handles the "Request a feature" command.
+ */
+import type { GetFeatureRequestIssueFormUrlParams } from '../feature-request.mjs';
+import { OpenGitHubCommandHandler } from './open-git-hub-command-handler.mjs';
+/**
+ * Constructor parameters for {@link OpenFeatureRequestCommandHandler}.
+ */
+export type OpenFeatureRequestCommandHandlerConstructorParams = GetFeatureRequestIssueFormUrlParams;
+/**
+ * Opens the plugin's feature-request form, prefilling only the plugin version.
+ *
+ * See the [community commands guide](https://mnaoumov.dev/obsidian-lib/guides/community-commands/)
+ * and [behavioral tests](https://github.com/mnaoumov/obsidian-lib/blob/main/src/command-handlers/open-feature-request-command-handler.test.ts).
+ */
+export declare class OpenFeatureRequestCommandHandler extends OpenGitHubCommandHandler {
+    private readonly params;
+    /**
+     * Constructs a new instance.
+     *
+     * @param params - Constructor parameters.
+     */
+    constructor(params: OpenFeatureRequestCommandHandlerConstructorParams);
+    /**
+     * Builds the prefilled feature-request URL.
+     *
+     * @returns The link.
+     */
+    protected getUrl(): string;
+}

package/dist/lib/esm/command-handlers/open-feature-request-command-handler.mjs

@@ -0,0 +1,31 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { getFeatureRequestIssueFormUrl } from "../feature-request.mjs";
+import { OpenGitHubCommandHandler } from "./open-git-hub-command-handler.mjs";
+class OpenFeatureRequestCommandHandler extends OpenGitHubCommandHandler {
+  params;
+  /**
+   * Constructs a new instance.
+   *
+   * @param params - Constructor parameters.
+   */
+  constructor(params) {
+    super({ gitHubRepo: params.gitHubRepo, icon: "lightbulb", id: "request-feature", name: "Request a feature" });
+    this.params = params;
+  }
+  /**
+   * Builds the prefilled feature-request URL.
+   *
+   * @returns The link.
+   */
+  getUrl() {
+    return getFeatureRequestIssueFormUrl(this.params);
+  }
+}
+export {
+  OpenFeatureRequestCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,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