@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/note-priority.cjs

@@ -0,0 +1,234 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(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);
+    }
+    if (globalThis.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 note_priority_exports = {};
+__export(note_priority_exports, {
+  NO_PRIORITY_MATCH: () => NO_PRIORITY_MATCH,
+  NoPriorityWinnerReason: () => NoPriorityWinnerReason,
+  filterHighestPriorityNotePaths: () => filterHighestPriorityNotePaths,
+  findNoPriorityWinnerReason: () => findNoPriorityWinnerReason,
+  findNotePriorityRank: () => findNotePriorityRank,
+  pickHighestPriorityNotePath: () => pickHighestPriorityNotePath
+});
+module.exports = __toCommonJS(note_priority_exports);
+var import_reg_exp = require('@mnaoumov/typescript-lib/reg-exp');
+var import_property_entry = require('./property-entry.cjs');
+const REG_EXP_DELIMITER = "/";
+const EXTENSION_PREFIX = ".";
+var NoPriorityWinnerReason = /* @__PURE__ */ ((NoPriorityWinnerReason2) => {
+  NoPriorityWinnerReason2["EmptyList"] = "EmptyList";
+  NoPriorityWinnerReason2["NoMatch"] = "NoMatch";
+  NoPriorityWinnerReason2["Tie"] = "Tie";
+  return NoPriorityWinnerReason2;
+})(NoPriorityWinnerReason || {});
+const NO_PRIORITY_MATCH = Infinity;
+function filterHighestPriorityNotePaths(params) {
+  const rankedNotePaths = params.notePaths.map((notePath) => ({
+    notePath,
+    rank: params.rank(notePath)
+  }));
+  let bestRank = NO_PRIORITY_MATCH;
+  for (const ranked of rankedNotePaths) {
+    if (ranked.rank < bestRank) {
+      bestRank = ranked.rank;
+    }
+  }
+  return rankedNotePaths.filter((ranked) => ranked.rank === bestRank).map((ranked) => ranked.notePath);
+}
+function findNoPriorityWinnerReason(params) {
+  if (params.entries.length === 0) {
+    return "EmptyList" /* EmptyList */;
+  }
+  let bestRank = NO_PRIORITY_MATCH;
+  for (const notePath of params.notePaths) {
+    const currentRank = params.rank(notePath);
+    if (currentRank < bestRank) {
+      bestRank = currentRank;
+    }
+  }
+  return bestRank === NO_PRIORITY_MATCH ? "NoMatch" /* NoMatch */ : "Tie" /* Tie */;
+}
+function findNotePriorityRank(params) {
+  let bestRank = NO_PRIORITY_MATCH;
+  let bestLength = -1;
+  for (const [index, entry] of params.entries.entries()) {
+    if (entry.length <= bestLength || !checkEntryMatches(entry, params)) {
+      continue;
+    }
+    bestRank = index;
+    bestLength = entry.length;
+  }
+  return bestRank;
+}
+function pickHighestPriorityNotePath(params) {
+  let bestRank = NO_PRIORITY_MATCH;
+  let bestNotePath = null;
+  let bestCount = 0;
+  for (const notePath of params.notePaths) {
+    const currentRank = params.rank(notePath);
+    if (currentRank < bestRank) {
+      bestRank = currentRank;
+      bestNotePath = notePath;
+      bestCount = 1;
+    } else if (currentRank === bestRank) {
+      bestCount++;
+    }
+  }
+  return bestCount !== 1 || bestRank === NO_PRIORITY_MATCH ? null : bestNotePath;
+}
+function checkEntryMatches(entry, params) {
+  if (!entry) {
+    return false;
+  }
+  if ((0, import_property_entry.isPropertyEntry)(entry)) {
+    return (0, import_property_entry.checkPropertyEntryMatches)({ entry, frontmatter: params.frontmatter });
+  }
+  if (entry.length > 1 && entry.startsWith(REG_EXP_DELIMITER) && entry.endsWith(REG_EXP_DELIMITER)) {
+    const source = entry.slice(1, -1);
+    return (0, import_reg_exp.isValidRegExp)(source) && new RegExp(source).test(params.notePath);
+  }
+  if (entry.startsWith(EXTENSION_PREFIX)) {
+    return params.notePath.toLowerCase().endsWith(entry.toLowerCase());
+  }
+  const prefix = entry.endsWith("/") ? entry : `${entry}/`;
+  return params.notePath === entry || params.notePath.startsWith(prefix);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NO_PRIORITY_MATCH,
+  NoPriorityWinnerReason,
+  filterHighestPriorityNotePaths,
+  findNoPriorityWinnerReason,
+  findNotePriorityRank,
+  pickHighestPriorityNotePath
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/note-priority.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides which of several notes referencing the same attachment owns it.\n *\n * An attachment referenced from more than one note has no single correct home, so collecting it falls\n * back to whatever `collectAttachmentUsedByMultipleNotesMode` says \u2014 skip, copy, cancel, or ask. A\n * priority list lets the user answer the question once instead: put `.md` above `.excalidraw` and an\n * image shared by both lands in the markdown note's folder.\n *\n * A tie is deliberately NOT resolved here. Two notes of equal priority is exactly the ambiguity the\n * existing mode setting already exists to handle, and inventing a second, silent rule for it would\n * move a file the user never named.\n *\n * The tie is also the whole of what gets REPORTED. A note the list ranked below the best rank cannot\n * resolve the ambiguity, so listing it only adds noise \u2014 and worse in a picker, where offering it\n * invites an answer the priority list itself would not have given. That is why\n * {@link filterHighestPriorityNotePaths} exists alongside the two functions that decide.\n */\n\nimport { isValidRegExp } from '@mnaoumov/typescript-lib/reg-exp';\n\nimport {\n  checkPropertyEntryMatches,\n  isPropertyEntry\n} from './property-entry.ts';\n\nconst REG_EXP_DELIMITER = '/';\nconst EXTENSION_PREFIX = '.';\n\n/**\n * Why the priority list did not settle which note owns an attachment.\n *\n * The three values are exactly the three ways {@link pickHighestPriorityNotePath} (plus its empty-list\n * guard) can fail to name a winner, so a caller can tell the user the real reason instead of only\n * reporting that the attachment is referenced by several notes.\n */\nexport enum NoPriorityWinnerReason {\n  /**\n   * The priority list is empty \u2014 its default. Nothing was configured to decide between the notes.\n   */\n  EmptyList = 'EmptyList',\n\n  /**\n   * The list has entries, but none of the referencing notes matches any of them.\n   */\n  NoMatch = 'NoMatch',\n\n  /**\n   * Several referencing notes tie for the best rank, so the list names no single owner.\n   */\n  Tie = 'Tie'\n}\n\n/**\n * Parameters for {@link filterHighestPriorityNotePaths}.\n *\n * The same question as {@link pickHighestPriorityNotePath} asks, so deliberately the same parameters:\n * the two must be answered from identical inputs or they could disagree.\n */\nexport type FilterHighestPriorityNotePathsParams = PickHighestPriorityNotePathParams;\n\n/**\n * Parameters for {@link findNoPriorityWinnerReason}.\n */\nexport interface FindNoPriorityWinnerReasonParams extends PickHighestPriorityNotePathParams {\n  /**\n   * The priority list, highest priority first.\n   */\n  readonly entries: readonly string[];\n}\n\n/**\n * Parameters for {@link findNotePriorityRank}.\n */\nexport interface FindNotePriorityRankParams {\n  /**\n   * The priority list, highest priority first.\n   */\n  readonly entries: readonly string[];\n\n  /**\n   * The note's frontmatter, or `null` when it has none.\n   */\n  readonly frontmatter: null | Readonly<Record<string, unknown>>;\n\n  /**\n   * The vault-relative path of the note.\n   */\n  readonly notePath: string;\n}\n\n/**\n * Parameters for {@link pickHighestPriorityNotePath}.\n */\nexport interface PickHighestPriorityNotePathParams {\n  /**\n   * The vault-relative paths of the notes referencing the attachment.\n   */\n  readonly notePaths: readonly string[];\n\n  /**\n   * The priority rank of a note. Lower wins; {@link NO_PRIORITY_MATCH} means the note matched nothing.\n   *\n   * @param notePath - The vault-relative path of the note.\n   * @returns The rank.\n   */\n  readonly rank: (notePath: string) => number;\n}\n\n/**\n * The rank of a note that matches no entry in the priority list. Higher than any real rank, so a note\n * that matches nothing always loses to one that matches something.\n */\nexport const NO_PRIORITY_MATCH = Infinity;\n\n/**\n * Narrows the referencing notes to the ones sharing the best rank.\n *\n * Those notes are the whole of the ambiguity: one the list ranked below them cannot resolve anything,\n * so reporting it only adds noise. This mirrors {@link pickHighestPriorityNotePath}'s conditions\n * rather than re-deciding anything, so the two can only ever agree \u2014 whenever that names a winner,\n * this returns exactly that one note.\n *\n * A list that decides nothing at all \u2014 empty, or matching no note \u2014 ranks every note\n * {@link NO_PRIORITY_MATCH}, so they all tie and every one of them is kept. That is the same list the\n * user saw before, which is correct: nothing has ruled any of them out.\n *\n * @param params - The referencing notes and how to rank one.\n * @returns The notes holding the best rank, in the order they were given.\n */\nexport function filterHighestPriorityNotePaths(params: FilterHighestPriorityNotePathsParams): string[] {\n  // Ranking can hit the vault and the metadata cache, so each note is ranked once and carried.\n  const rankedNotePaths = params.notePaths.map((notePath) => ({\n    notePath,\n    rank: params.rank(notePath)\n  }));\n\n  let bestRank = NO_PRIORITY_MATCH;\n  for (const ranked of rankedNotePaths) {\n    if (ranked.rank < bestRank) {\n      bestRank = ranked.rank;\n    }\n  }\n\n  return rankedNotePaths\n    .filter((ranked) => ranked.rank === bestRank)\n    .map((ranked) => ranked.notePath);\n}\n\n/**\n * Explains why the priority list named no owner for an attachment.\n *\n * Only meaningful once {@link pickHighestPriorityNotePath} has returned `null` (or the list was empty\n * and was never consulted); it mirrors that function's own conditions rather than re-deciding\n * anything, so the two can only ever agree.\n *\n * @param params - The priority list, the referencing notes, and how to rank one.\n * @returns Which of the three ways the list failed to settle it.\n */\nexport function findNoPriorityWinnerReason(params: FindNoPriorityWinnerReasonParams): NoPriorityWinnerReason {\n  if (params.entries.length === 0) {\n    return NoPriorityWinnerReason.EmptyList;\n  }\n\n  let bestRank = NO_PRIORITY_MATCH;\n  for (const notePath of params.notePaths) {\n    const currentRank = params.rank(notePath);\n    if (currentRank < bestRank) {\n      bestRank = currentRank;\n    }\n  }\n\n  return bestRank === NO_PRIORITY_MATCH ? NoPriorityWinnerReason.NoMatch : NoPriorityWinnerReason.Tie;\n}\n\n/**\n * Finds how highly a note ranks in the priority list.\n *\n * An entry matches in one of four ways, picked by its shape so that one list can express all of them:\n *\n * - `property:name` \u2014 the note's frontmatter has `name`; `property:name=value` also compares the value.\n * - `/regular expression/` \u2014 tested against the note's path.\n * - `.ext` \u2014 the note's path ends with it, case-insensitively. This is the form the request asked for.\n * - anything else \u2014 a path from the vault root, matching the vocabulary of the include / exclude\n *   path settings.\n *\n * When a note matches several entries the **longest** one decides its rank, so the most specific\n * entry wins and the order of the list is left to express priority. Without this an Excalidraw note\n * could never rank below a plain markdown one: `drawing.excalidraw.md` also ends with `.md`, so\n * `.md` above `.excalidraw.md` \u2014 the very example the request is built on \u2014 would tie instead of\n * resolving. Equal-length matches fall to the earlier entry.\n *\n * @param params - The parameters for finding the rank.\n * @returns The index of the most specific matching entry, or {@link NO_PRIORITY_MATCH} when none match.\n */\nexport function findNotePriorityRank(params: FindNotePriorityRankParams): number {\n  let bestRank = NO_PRIORITY_MATCH;\n  let bestLength = -1;\n\n  for (const [index, entry] of params.entries.entries()) {\n    // A shorter entry can never beat one that already matched, so it is not worth testing.\n    if ((entry.length <= bestLength) || !checkEntryMatches(entry, params)) {\n      continue;\n    }\n\n    bestRank = index;\n    bestLength = entry.length;\n  }\n\n  return bestRank;\n}\n\n/**\n * Picks the single highest-priority note among those referencing an attachment.\n *\n * Returns `null` when the best rank is shared by more than one note, or when no note matches\n * anything. Both are ties, and a tie is the caller's problem: it is what the multiple-notes mode\n * setting is for.\n *\n * @param params - The parameters for picking the note.\n * @returns The winning note's path, or `null` when there is no single winner.\n */\nexport function pickHighestPriorityNotePath(params: PickHighestPriorityNotePathParams): null | string {\n  let bestRank = NO_PRIORITY_MATCH;\n  let bestNotePath: null | string = null;\n  let bestCount = 0;\n\n  for (const notePath of params.notePaths) {\n    const currentRank = params.rank(notePath);\n    if (currentRank < bestRank) {\n      bestRank = currentRank;\n      bestNotePath = notePath;\n      bestCount = 1;\n    } else if (currentRank === bestRank) {\n      bestCount++;\n    }\n  }\n\n  return bestCount !== 1 || bestRank === NO_PRIORITY_MATCH ? null : bestNotePath;\n}\n\nfunction checkEntryMatches(entry: string, params: FindNotePriorityRankParams): boolean {\n  if (!entry) {\n    return false;\n  }\n\n  if (isPropertyEntry(entry)) {\n    return checkPropertyEntryMatches({ entry, frontmatter: params.frontmatter });\n  }\n\n  if (entry.length > 1 && entry.startsWith(REG_EXP_DELIMITER) && entry.endsWith(REG_EXP_DELIMITER)) {\n    const source = entry.slice(1, -1);\n    // An unparseable expression must not throw mid-collection; it simply matches nothing.\n    return isValidRegExp(source) && new RegExp(source).test(params.notePath);\n  }\n\n  if (entry.startsWith(EXTENSION_PREFIX)) {\n    return params.notePath.toLowerCase().endsWith(entry.toLowerCase());\n  }\n\n  const prefix = entry.endsWith('/') ? entry : `${entry}/`;\n  return params.notePath === entry || params.notePath.startsWith(prefix);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,qBAA8B;AAE9B,4BAGO;AAEP,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB;AASlB,IAAK,yBAAL,kBAAKA,4BAAL;AAIL,EAAAA,wBAAA,eAAY;AAKZ,EAAAA,wBAAA,aAAU;AAKV,EAAAA,wBAAA,SAAM;AAdI,SAAAA;AAAA,GAAA;AA6EL,MAAM,oBAAoB;AAiB1B,SAAS,+BAA+B,QAAwD;AAErG,QAAM,kBAAkB,OAAO,UAAU,IAAI,CAAC,cAAc;AAAA,IAC1D;AAAA,IACA,MAAM,OAAO,KAAK,QAAQ;AAAA,EAC5B,EAAE;AAEF,MAAI,WAAW;AACf,aAAW,UAAU,iBAAiB;AACpC,QAAI,OAAO,OAAO,UAAU;AAC1B,iBAAW,OAAO;AAAA,IACpB;AAAA,EACF;AAEA,SAAO,gBACJ,OAAO,CAAC,WAAW,OAAO,SAAS,QAAQ,EAC3C,IAAI,CAAC,WAAW,OAAO,QAAQ;AACpC;AAYO,SAAS,2BAA2B,QAAkE;AAC3G,MAAI,OAAO,QAAQ,WAAW,GAAG;AAC/B,WAAO;AAAA,EACT;AAEA,MAAI,WAAW;AACf,aAAW,YAAY,OAAO,WAAW;AACvC,UAAM,cAAc,OAAO,KAAK,QAAQ;AACxC,QAAI,cAAc,UAAU;AAC1B,iBAAW;AAAA,IACb;AAAA,EACF;AAEA,SAAO,aAAa,oBAAoB,0BAAiC;AAC3E;AAsBO,SAAS,qBAAqB,QAA4C;AAC/E,MAAI,WAAW;AACf,MAAI,aAAa;AAEjB,aAAW,CAAC,OAAO,KAAK,KAAK,OAAO,QAAQ,QAAQ,GAAG;AAErD,QAAK,MAAM,UAAU,cAAe,CAAC,kBAAkB,OAAO,MAAM,GAAG;AACrE;AAAA,IACF;AAEA,eAAW;AACX,iBAAa,MAAM;AAAA,EACrB;AAEA,SAAO;AACT;AAYO,SAAS,4BAA4B,QAA0D;AACpG,MAAI,WAAW;AACf,MAAI,eAA8B;AAClC,MAAI,YAAY;AAEhB,aAAW,YAAY,OAAO,WAAW;AACvC,UAAM,cAAc,OAAO,KAAK,QAAQ;AACxC,QAAI,cAAc,UAAU;AAC1B,iBAAW;AACX,qBAAe;AACf,kBAAY;AAAA,IACd,WAAW,gBAAgB,UAAU;AACnC;AAAA,IACF;AAAA,EACF;AAEA,SAAO,cAAc,KAAK,aAAa,oBAAoB,OAAO;AACpE;AAEA,SAAS,kBAAkB,OAAe,QAA6C;AACrF,MAAI,CAAC,OAAO;AACV,WAAO;AAAA,EACT;AAEA,UAAI,uCAAgB,KAAK,GAAG;AAC1B,eAAO,iDAA0B,EAAE,OAAO,aAAa,OAAO,YAAY,CAAC;AAAA,EAC7E;AAEA,MAAI,MAAM,SAAS,KAAK,MAAM,WAAW,iBAAiB,KAAK,MAAM,SAAS,iBAAiB,GAAG;AAChG,UAAM,SAAS,MAAM,MAAM,GAAG,EAAE;AAEhC,eAAO,8BAAc,MAAM,KAAK,IAAI,OAAO,MAAM,EAAE,KAAK,OAAO,QAAQ;AAAA,EACzE;AAEA,MAAI,MAAM,WAAW,gBAAgB,GAAG;AACtC,WAAO,OAAO,SAAS,YAAY,EAAE,SAAS,MAAM,YAAY,CAAC;AAAA,EACnE;AAEA,QAAM,SAAS,MAAM,SAAS,GAAG,IAAI,QAAQ,GAAG,KAAK;AACrD,SAAO,OAAO,aAAa,SAAS,OAAO,SAAS,WAAW,MAAM;AACvE;",
  "names": ["NoPriorityWinnerReason"]
}


package/dist/lib/cjs/note-priority.d.cts

@@ -0,0 +1,154 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Decides which of several notes referencing the same attachment owns it.
+ *
+ * An attachment referenced from more than one note has no single correct home, so collecting it falls
+ * back to whatever `collectAttachmentUsedByMultipleNotesMode` says — skip, copy, cancel, or ask. A
+ * priority list lets the user answer the question once instead: put `.md` above `.excalidraw` and an
+ * image shared by both lands in the markdown note's folder.
+ *
+ * A tie is deliberately NOT resolved here. Two notes of equal priority is exactly the ambiguity the
+ * existing mode setting already exists to handle, and inventing a second, silent rule for it would
+ * move a file the user never named.
+ *
+ * The tie is also the whole of what gets REPORTED. A note the list ranked below the best rank cannot
+ * resolve the ambiguity, so listing it only adds noise — and worse in a picker, where offering it
+ * invites an answer the priority list itself would not have given. That is why
+ * {@link filterHighestPriorityNotePaths} exists alongside the two functions that decide.
+ */
+/**
+ * Why the priority list did not settle which note owns an attachment.
+ *
+ * The three values are exactly the three ways {@link pickHighestPriorityNotePath} (plus its empty-list
+ * guard) can fail to name a winner, so a caller can tell the user the real reason instead of only
+ * reporting that the attachment is referenced by several notes.
+ */
+export declare enum NoPriorityWinnerReason {
+    /**
+     * The priority list is empty — its default. Nothing was configured to decide between the notes.
+     */
+    EmptyList = "EmptyList",
+    /**
+     * The list has entries, but none of the referencing notes matches any of them.
+     */
+    NoMatch = "NoMatch",
+    /**
+     * Several referencing notes tie for the best rank, so the list names no single owner.
+     */
+    Tie = "Tie"
+}
+/**
+ * Parameters for {@link filterHighestPriorityNotePaths}.
+ *
+ * The same question as {@link pickHighestPriorityNotePath} asks, so deliberately the same parameters:
+ * the two must be answered from identical inputs or they could disagree.
+ */
+export type FilterHighestPriorityNotePathsParams = PickHighestPriorityNotePathParams;
+/**
+ * Parameters for {@link findNoPriorityWinnerReason}.
+ */
+export interface FindNoPriorityWinnerReasonParams extends PickHighestPriorityNotePathParams {
+    /**
+     * The priority list, highest priority first.
+     */
+    readonly entries: readonly string[];
+}
+/**
+ * Parameters for {@link findNotePriorityRank}.
+ */
+export interface FindNotePriorityRankParams {
+    /**
+     * The priority list, highest priority first.
+     */
+    readonly entries: readonly string[];
+    /**
+     * The note's frontmatter, or `null` when it has none.
+     */
+    readonly frontmatter: null | Readonly<Record<string, unknown>>;
+    /**
+     * The vault-relative path of the note.
+     */
+    readonly notePath: string;
+}
+/**
+ * Parameters for {@link pickHighestPriorityNotePath}.
+ */
+export interface PickHighestPriorityNotePathParams {
+    /**
+     * The vault-relative paths of the notes referencing the attachment.
+     */
+    readonly notePaths: readonly string[];
+    /**
+     * The priority rank of a note. Lower wins; {@link NO_PRIORITY_MATCH} means the note matched nothing.
+     *
+     * @param notePath - The vault-relative path of the note.
+     * @returns The rank.
+     */
+    readonly rank: (notePath: string) => number;
+}
+/**
+ * The rank of a note that matches no entry in the priority list. Higher than any real rank, so a note
+ * that matches nothing always loses to one that matches something.
+ */
+export declare const NO_PRIORITY_MATCH: number;
+/**
+ * Narrows the referencing notes to the ones sharing the best rank.
+ *
+ * Those notes are the whole of the ambiguity: one the list ranked below them cannot resolve anything,
+ * so reporting it only adds noise. This mirrors {@link pickHighestPriorityNotePath}'s conditions
+ * rather than re-deciding anything, so the two can only ever agree — whenever that names a winner,
+ * this returns exactly that one note.
+ *
+ * A list that decides nothing at all — empty, or matching no note — ranks every note
+ * {@link NO_PRIORITY_MATCH}, so they all tie and every one of them is kept. That is the same list the
+ * user saw before, which is correct: nothing has ruled any of them out.
+ *
+ * @param params - The referencing notes and how to rank one.
+ * @returns The notes holding the best rank, in the order they were given.
+ */
+export declare function filterHighestPriorityNotePaths(params: FilterHighestPriorityNotePathsParams): string[];
+/**
+ * Explains why the priority list named no owner for an attachment.
+ *
+ * Only meaningful once {@link pickHighestPriorityNotePath} has returned `null` (or the list was empty
+ * and was never consulted); it mirrors that function's own conditions rather than re-deciding
+ * anything, so the two can only ever agree.
+ *
+ * @param params - The priority list, the referencing notes, and how to rank one.
+ * @returns Which of the three ways the list failed to settle it.
+ */
+export declare function findNoPriorityWinnerReason(params: FindNoPriorityWinnerReasonParams): NoPriorityWinnerReason;
+/**
+ * Finds how highly a note ranks in the priority list.
+ *
+ * An entry matches in one of four ways, picked by its shape so that one list can express all of them:
+ *
+ * - `property:name` — the note's frontmatter has `name`; `property:name=value` also compares the value.
+ * - `/regular expression/` — tested against the note's path.
+ * - `.ext` — the note's path ends with it, case-insensitively. This is the form the request asked for.
+ * - anything else — a path from the vault root, matching the vocabulary of the include / exclude
+ *   path settings.
+ *
+ * When a note matches several entries the **longest** one decides its rank, so the most specific
+ * entry wins and the order of the list is left to express priority. Without this an Excalidraw note
+ * could never rank below a plain markdown one: `drawing.excalidraw.md` also ends with `.md`, so
+ * `.md` above `.excalidraw.md` — the very example the request is built on — would tie instead of
+ * resolving. Equal-length matches fall to the earlier entry.
+ *
+ * @param params - The parameters for finding the rank.
+ * @returns The index of the most specific matching entry, or {@link NO_PRIORITY_MATCH} when none match.
+ */
+export declare function findNotePriorityRank(params: FindNotePriorityRankParams): number;
+/**
+ * Picks the single highest-priority note among those referencing an attachment.
+ *
+ * Returns `null` when the best rank is shared by more than one note, or when no note matches
+ * anything. Both are ties, and a tie is the caller's problem: it is what the multiple-notes mode
+ * setting is for.
+ *
+ * @param params - The parameters for picking the note.
+ * @returns The winning note's path, or `null` when there is no single winner.
+ */
+export declare function pickHighestPriorityNotePath(params: PickHighestPriorityNotePathParams): null | string;

package/dist/lib/cjs/notebook-navigator.cjs

@@ -0,0 +1,163 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(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);
+    }
+    if (globalThis.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 notebook_navigator_exports = {};
+__export(notebook_navigator_exports, {
+  NOTEBOOK_NAVIGATOR_MENU_SOURCE: () => NOTEBOOK_NAVIGATOR_MENU_SOURCE,
+  NOTEBOOK_NAVIGATOR_PLUGIN_ID: () => NOTEBOOK_NAVIGATOR_PLUGIN_ID,
+  resolveNotebookNavigatorApi: () => resolveNotebookNavigatorApi
+});
+module.exports = __toCommonJS(notebook_navigator_exports);
+const NOTEBOOK_NAVIGATOR_MENU_SOURCE = "notebook-navigator-context-menu";
+const NOTEBOOK_NAVIGATOR_PLUGIN_ID = "notebook-navigator";
+function resolveNotebookNavigatorApi(app) {
+  const plugin = app.plugins.getPlugin(NOTEBOOK_NAVIGATOR_PLUGIN_ID);
+  if (!plugin || !("api" in plugin)) {
+    return null;
+  }
+  const api = plugin.api;
+  return isNotebookNavigatorApi(api) ? api : null;
+}
+function isNotebookNavigatorApi(value) {
+  if (typeof value !== "object" || value === null || !("menus" in value)) {
+    return false;
+  }
+  const menus = value.menus;
+  return typeof menus === "object" && menus !== null && "registerFileMenu" in menus && typeof menus.registerFileMenu === "function" && "registerFolderMenu" in menus && typeof menus.registerFolderMenu === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NOTEBOOK_NAVIGATOR_MENU_SOURCE,
+  NOTEBOOK_NAVIGATOR_PLUGIN_ID,
+  resolveNotebookNavigatorApi
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/notebook-navigator.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The slice of Notebook Navigator's public API this library talks to, and the runtime narrowing that\n * gets hold of it.\n *\n * **Notebook Navigator draws its own file tree, so it never raises Obsidian's `file-menu` /\n * `files-menu` workspace events** \u2014 which is why a plugin's context-menu items simply disappear for\n * anyone browsing through it. What it offers instead is a documented extension API\n * (`docs/api-reference.md` + `src/api/public/notebook-navigator.d.ts` in `johansan/notebook-navigator`,\n * API 2.0.0), reachable at runtime as `app.plugins.getPlugin('notebook-navigator').api`.\n *\n * The types below are DECLARED HERE rather than imported: Notebook Navigator ships its `.d.ts` for\n * download, not as an npm package, and depending on it would turn an optional integration into a\n * build-time dependency. They are deliberately the narrowest shape this library uses \u2014 the API also\n * carries `metadata`, `navigation`, `selection`, `tagCollections`, `propertyNodes` and an event bus,\n * none of which apply to a file/folder command surface.\n */\n\nimport type {\n  App,\n  MenuItem,\n  TFile,\n  TFolder\n} from 'obsidian';\n\n/**\n * Notebook Navigator's public API object, narrowed to what this library uses.\n */\nexport interface NotebookNavigatorApi {\n  /**\n   * The menu-extension namespace.\n   */\n  readonly menus: NotebookNavigatorMenus;\n}\n\n/**\n * What `menus.registerFileMenu` hands a subscriber when a FILE is right-clicked.\n *\n * There is no `Menu` here \u2014 an item is contributed through `addItem` alone, which is why the\n * file/files menu handlers cannot simply be forwarded to it and have to be bridged (see\n * `components/notebook-navigator-menu-event-registrar-component.ts`).\n */\nexport interface NotebookNavigatorFileMenuContext extends NotebookNavigatorMenuContext {\n  /**\n   * The file that was right-clicked.\n   */\n  readonly file: TFile;\n\n  /**\n   * What the tree had selected when the menu was raised.\n   */\n  readonly selection: NotebookNavigatorFileMenuSelection;\n}\n\n/**\n * The selection a file menu was raised on.\n */\nexport interface NotebookNavigatorFileMenuSelection {\n  /**\n   * Every selected file, which for `single` is just the right-clicked one.\n   */\n  readonly files: readonly TFile[];\n\n  /**\n   * Whether one file or several are selected.\n   */\n  readonly mode: NotebookNavigatorFileMenuSelectionMode;\n}\n\n/**\n * Whether a file menu covers one file or a multi-selection.\n */\nexport type NotebookNavigatorFileMenuSelectionMode = 'multiple' | 'single';\n\n/**\n * What `menus.registerFolderMenu` hands a subscriber when a FOLDER is right-clicked.\n */\nexport interface NotebookNavigatorFolderMenuContext extends NotebookNavigatorMenuContext {\n  /**\n   * The folder that was right-clicked.\n   */\n  readonly folder: TFolder;\n}\n\n/**\n * What every Notebook Navigator menu context has in common: a way to add an item, and nothing else.\n *\n * The absence of a `Menu` is the whole shape of the integration problem \u2014 command handlers write into\n * a `Menu`, so something has to sit between them and this.\n */\nexport interface NotebookNavigatorMenuContext {\n  /**\n   * Adds an item to the menu Notebook Navigator is building.\n   *\n   * @param callback - Receives the created item, to be configured in place.\n   */\n  addItem: (callback: (item: MenuItem) => void) => void;\n}\n\n/**\n * Unregisters a menu extension. Notebook Navigator returns a bare function rather than a disposable,\n * so it is registered with the bridging component's `register`.\n */\nexport type NotebookNavigatorMenuDispose = () => void;\n\n/**\n * The `menus` namespace of Notebook Navigator's API.\n *\n * Only the file and folder registrars are declared: the tag and property registrars extend menus\n * raised on things a file/folder command handler has no counterpart for.\n */\nexport interface NotebookNavigatorMenus {\n  /**\n   * Registers a contributor to the file context menu.\n   *\n   * @param callback - Invoked while the menu is being built.\n   * @returns A function that unregisters the contributor.\n   */\n  registerFileMenu: (callback: (context: NotebookNavigatorFileMenuContext) => void) => NotebookNavigatorMenuDispose;\n\n  /**\n   * Registers a contributor to the folder context menu.\n   *\n   * @param callback - Invoked while the menu is being built.\n   * @returns A function that unregisters the contributor.\n   */\n  registerFolderMenu: (callback: (context: NotebookNavigatorFolderMenuContext) => void) => NotebookNavigatorMenuDispose;\n}\n\n/**\n * The `source` handed to the menu event handlers for a Notebook Navigator menu.\n *\n * Obsidian's own File Explorer sends `file-explorer-context-menu`; nothing in this library gates on\n * the value, but the handlers are contracted to receive one, and a distinct string is what makes a\n * handler able to tell the two surfaces apart.\n */\nexport const NOTEBOOK_NAVIGATOR_MENU_SOURCE = 'notebook-navigator-context-menu';\n\n/**\n * Notebook Navigator's plugin id, as its manifest declares it.\n */\nexport const NOTEBOOK_NAVIGATOR_PLUGIN_ID = 'notebook-navigator';\n\n/**\n * Gets Notebook Navigator's API, when it is installed, enabled and new enough.\n *\n * @param app - The application instance.\n * @returns The API, or `null` when Notebook Navigator is not there to talk to.\n */\nexport function resolveNotebookNavigatorApi(app: App): NotebookNavigatorApi | null {\n  const plugin = app.plugins.getPlugin(NOTEBOOK_NAVIGATOR_PLUGIN_ID);\n  if (!plugin || !('api' in plugin)) {\n    return null;\n  }\n\n  const api: unknown = plugin.api;\n  return isNotebookNavigatorApi(api) ? api : null;\n}\n\n/**\n * Checks that a value is Notebook Navigator's API, by the members this library actually calls.\n *\n * A predicate rather than a cast on purpose: `api` is not part of Obsidian's `Plugin` type, so the\n * value arrives as `unknown` and the only honest way to type it is to VERIFY it. A Notebook Navigator\n * old enough to predate the menus namespace, or a future one that renames it, therefore reads as\n * \"no API\" and the integration stays dormant instead of throwing at menu time.\n *\n * @param value - The candidate `api` object.\n * @returns Whether it carries both menu registrars.\n */\nfunction isNotebookNavigatorApi(value: unknown): value is NotebookNavigatorApi {\n  if (typeof value !== 'object' || value === null || !('menus' in value)) {\n    return false;\n  }\n\n  const menus: unknown = value.menus;\n  return typeof menus === 'object' && menus !== null\n    && 'registerFileMenu' in menus && typeof menus.registerFileMenu === 'function'\n    && 'registerFolderMenu' in menus && typeof menus.registerFolderMenu === 'function';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyIO,MAAM,iCAAiC;AAKvC,MAAM,+BAA+B;AAQrC,SAAS,4BAA4B,KAAuC;AACjF,QAAM,SAAS,IAAI,QAAQ,UAAU,4BAA4B;AACjE,MAAI,CAAC,UAAU,EAAE,SAAS,SAAS;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,MAAe,OAAO;AAC5B,SAAO,uBAAuB,GAAG,IAAI,MAAM;AAC7C;AAaA,SAAS,uBAAuB,OAA+C;AAC7E,MAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,EAAE,WAAW,QAAQ;AACtE,WAAO;AAAA,EACT;AAEA,QAAM,QAAiB,MAAM;AAC7B,SAAO,OAAO,UAAU,YAAY,UAAU,QACzC,sBAAsB,SAAS,OAAO,MAAM,qBAAqB,cACjE,wBAAwB,SAAS,OAAO,MAAM,uBAAuB;AAC5E;",
  "names": []
}
