@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/cjs/broken-link-candidates.cjs

@@ -0,0 +1,366 @@
+/*
+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();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var broken_link_candidates_exports = {};
+__export(broken_link_candidates_exports, {
+  BrokenLinkCandidateFinder: () => BrokenLinkCandidateFinder,
+  BrokenLinkEvidenceKind: () => BrokenLinkEvidenceKind,
+  getParentPath: () => getParentPath,
+  getPathMapping: () => getPathMapping
+});
+module.exports = __toCommonJS(broken_link_candidates_exports);
+var import_type_guards = require('@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((0, import_type_guards.ensureNonNullable)(candidate1.evidence[0])) - getEvidenceRank((0, import_type_guards.ensureNonNullable)(candidate2.evidence[0]));
+    return rankDifference || candidate1.path.localeCompare(candidate2.path);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/cjs/broken-link-candidates.d.cts

@@ -0,0 +1,181 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Where did a missing link target go? Pure, no `App`: every question about which file a broken link most likely
+ * meant is answerable from a list of paths, the notes' aliases and titles, and the vault's git renames.
+ *
+ * A rename is not recoverable from the link alone: a link to `alpha/bravo/charlie/!.md` says nothing about
+ * `charlie` having become `delta`. So every candidate carries the evidence that produced it, from outside the
+ * link, and the finder never picks one of several: a caller offers a one-click fix only when exactly one
+ * candidate exists.
+ */
+/**
+ * The kind of evidence that makes a file a candidate for a missing link target.
+ *
+ * Candidates list evidence strongest first, in EVIDENCE_KIND_ORDER below.
+ */
+export declare enum BrokenLinkEvidenceKind {
+    /**
+     * The candidate's `aliases` hold the missing target's old name.
+     */
+    Alias = "Alias",
+    /**
+     * The candidate's path differs from the missing one only in letter case.
+     */
+    CaseChange = "CaseChange",
+    /**
+     * The vault's git history records the missing path being renamed to the candidate.
+     */
+    GitRename = "GitRename",
+    /**
+     * The missing target's folder is gone, and a sibling folder holds every missing target that was under it.
+     */
+    RenamedFolder = "RenamedFolder",
+    /**
+     * A file with the same name, and the longest run of the same parent folders, sits elsewhere.
+     */
+    SameName = "SameName",
+    /**
+     * The candidate's `title` is the missing target's old name.
+     */
+    Title = "Title"
+}
+/**
+ * One file that a missing link target may have become, and why.
+ */
+export interface BrokenLinkCandidate {
+    /**
+     * Every reason this file is a candidate, strongest first.
+     */
+    readonly evidence: readonly BrokenLinkEvidence[];
+    /**
+     * The candidate's vault path.
+     */
+    readonly path: string;
+}
+/**
+ * The parameters for {@link BrokenLinkCandidateFinder}.
+ */
+export interface BrokenLinkCandidateFinderConstructorParams {
+    /**
+     * Each note's `aliases`, by note path.
+     */
+    readonly aliasesByPath: ReadonlyMap<string, readonly string[]>;
+    /**
+     * Every file in the vault.
+     */
+    readonly filePaths: readonly string[];
+    /**
+     * The file names a folder note is stored under, such as `index.md`. Such a name says nothing about which
+     * note it is, so a same-name candidate must share its folder's name too, and the old name an alias is
+     * matched against is the folder's.
+     */
+    readonly folderNoteFileNames: readonly string[];
+    /**
+     * The vault's git renames: each old vault path to the path it was renamed to, chains already followed.
+     */
+    readonly gitRenames: ReadonlyMap<string, GitRename>;
+    /**
+     * Each note's `title`, by note path.
+     */
+    readonly titlesByPath: ReadonlyMap<string, string>;
+}
+/**
+ * One reason a file is a candidate for a missing link target.
+ */
+export interface BrokenLinkEvidence {
+    /**
+     * A sentence naming the evidence, for the user to judge it by.
+     */
+    readonly description: string;
+    /**
+     * The kind of evidence.
+     */
+    readonly kind: BrokenLinkEvidenceKind;
+}
+/**
+ * A rename recorded in the vault's git history.
+ */
+export interface GitRename {
+    /**
+     * The abbreviated hash of the commit that made the last rename of the chain.
+     */
+    readonly commit: string;
+    /**
+     * The vault path the file was last renamed to.
+     */
+    readonly newPath: string;
+}
+/**
+ * The part of a missing path that a candidate replaced: what a "fix all like this" applies to every other link.
+ */
+export interface PathMapping {
+    /**
+     * The part of the candidate path that replaced {@link oldPrefix}; `''` for the vault root.
+     */
+    readonly newPrefix: string;
+    /**
+     * The leading part of the missing path that no longer exists; `''` for the vault root.
+     */
+    readonly oldPrefix: string;
+}
+/**
+ * Finds the candidates for missing link targets, from one snapshot of the vault.
+ */
+export declare class BrokenLinkCandidateFinder {
+    private readonly aliasesByPath;
+    private readonly childFoldersByFolder;
+    private readonly filePathSet;
+    private readonly filesByLowerCasePath;
+    private readonly filesByName;
+    private readonly folderNoteFileNames;
+    private readonly folderPaths;
+    private readonly gitRenames;
+    private readonly titlesByPath;
+    /**
+     * Indexes the vault snapshot.
+     *
+     * @param params - The snapshot.
+     */
+    constructor(params: BrokenLinkCandidateFinderConstructorParams);
+    /**
+     * 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: Iterable<string>): Map<string, BrokenLinkCandidate[]>;
+    private addAliasAndTitleCandidates;
+    private addCaseChangeCandidates;
+    private addGitRenameCandidate;
+    private addRenamedFolderCandidates;
+    private addSameNameCandidates;
+    /**
+     * 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.
+     */
+    private getMissingSubtrees;
+}
+/**
+ * The parent folder of a vault path.
+ *
+ * @param path - The path.
+ * @returns The parent folder; `''` for the vault root.
+ */
+export declare function getParentPath(path: string): string;
+/**
+ * The part of a missing path that a candidate path replaced, found by dropping the path segments they end with
+ * in common.
+ *
+ * @param oldPath - The missing path.
+ * @param newPath - The candidate path.
+ * @returns The prefixes that differ.
+ */
+export declare function getPathMapping(oldPath: string, newPath: string): PathMapping;