@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/modals/suggest-modal-command-builder.d.mts

@@ -0,0 +1,35 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * The former home of the `SuggestModal` instruction-bar builder.
+ *
+ * The builder is no longer tied to `SuggestModal` — it renders into a plain `Modal` and into a bare
+ * element + `Scope` too — so it moved to `modal-command-builder.ts` under the honest name
+ * {@link ModalCommandBuilder}. This module stays as a deprecated alias so existing importers keep working
+ * unchanged; it re-exports the very same class, not a copy.
+ */
+import type { ModalCommandBuilderBuildOptions } from './modal-command-builder.mjs';
+import { ModalCommandBuilder } from './modal-command-builder.mjs';
+export type { CheckboxCommand, DropDownCommand, KeyboardCommand } from './modal-command-builder.mjs';
+/**
+ * Options for {@link SuggestModalCommandBuilder.build}.
+ *
+ * @deprecated Use {@link ModalCommandBuilderBuildOptions} from
+ * `obsidian-dev-utils/obsidian/modals/modal-command-builder` instead.
+ */
+export type SuggestModalCommandBuilderBuildOptions = ModalCommandBuilderBuildOptions;
+/**
+ * Builds a `SuggestModal`'s instruction bar.
+ *
+ * @deprecated Use {@link ModalCommandBuilder} from
+ * `obsidian-dev-utils/obsidian/modals/modal-command-builder` instead.
+ */
+export declare const SuggestModalCommandBuilder: typeof ModalCommandBuilder;
+/**
+ * Builds a `SuggestModal`'s instruction bar.
+ *
+ * @deprecated Use {@link ModalCommandBuilder} from
+ * `obsidian-dev-utils/obsidian/modals/modal-command-builder` instead.
+ */
+export type SuggestModalCommandBuilder = ModalCommandBuilder;

package/dist/lib/esm/modals/suggest-modal-command-builder.mjs

@@ -0,0 +1,55 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { ModalCommandBuilder } from "./modal-command-builder.mjs";
+const SuggestModalCommandBuilder = ModalCommandBuilder;
+export {
+  SuggestModalCommandBuilder
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/note-priority.d.mts

@@ -0,0 +1,154 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @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/esm/note-priority.mjs

@@ -0,0 +1,143 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { isValidRegExp } from "@mnaoumov/typescript-lib/reg-exp";
+import {
+  checkPropertyEntryMatches,
+  isPropertyEntry
+} from "./property-entry.mjs";
+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 (isPropertyEntry(entry)) {
+    return 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 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);
+}
+export {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,qBAAqB;AAE9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;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,MAAI,gBAAgB,KAAK,GAAG;AAC1B,WAAO,0BAA0B,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,WAAO,cAAc,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/esm/notebook-navigator.d.mts

@@ -0,0 +1,132 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * The slice of Notebook Navigator's public API this library talks to, and the runtime narrowing that
+ * gets hold of it.
+ *
+ * **Notebook Navigator draws its own file tree, so it never raises Obsidian's `file-menu` /
+ * `files-menu` workspace events** — which is why a plugin's context-menu items simply disappear for
+ * anyone browsing through it. What it offers instead is a documented extension API
+ * (`docs/api-reference.md` + `src/api/public/notebook-navigator.d.ts` in `johansan/notebook-navigator`,
+ * API 2.0.0), reachable at runtime as `app.plugins.getPlugin('notebook-navigator').api`.
+ *
+ * The types below are DECLARED HERE rather than imported: Notebook Navigator ships its `.d.ts` for
+ * download, not as an npm package, and depending on it would turn an optional integration into a
+ * build-time dependency. They are deliberately the narrowest shape this library uses — the API also
+ * carries `metadata`, `navigation`, `selection`, `tagCollections`, `propertyNodes` and an event bus,
+ * none of which apply to a file/folder command surface.
+ */
+import type { App, MenuItem, TFile, TFolder } from 'obsidian';
+/**
+ * Notebook Navigator's public API object, narrowed to what this library uses.
+ */
+export interface NotebookNavigatorApi {
+    /**
+     * The menu-extension namespace.
+     */
+    readonly menus: NotebookNavigatorMenus;
+}
+/**
+ * What `menus.registerFileMenu` hands a subscriber when a FILE is right-clicked.
+ *
+ * There is no `Menu` here — an item is contributed through `addItem` alone, which is why the
+ * file/files menu handlers cannot simply be forwarded to it and have to be bridged (see
+ * `components/notebook-navigator-menu-event-registrar-component.ts`).
+ */
+export interface NotebookNavigatorFileMenuContext extends NotebookNavigatorMenuContext {
+    /**
+     * The file that was right-clicked.
+     */
+    readonly file: TFile;
+    /**
+     * What the tree had selected when the menu was raised.
+     */
+    readonly selection: NotebookNavigatorFileMenuSelection;
+}
+/**
+ * The selection a file menu was raised on.
+ */
+export interface NotebookNavigatorFileMenuSelection {
+    /**
+     * Every selected file, which for `single` is just the right-clicked one.
+     */
+    readonly files: readonly TFile[];
+    /**
+     * Whether one file or several are selected.
+     */
+    readonly mode: NotebookNavigatorFileMenuSelectionMode;
+}
+/**
+ * Whether a file menu covers one file or a multi-selection.
+ */
+export type NotebookNavigatorFileMenuSelectionMode = 'multiple' | 'single';
+/**
+ * What `menus.registerFolderMenu` hands a subscriber when a FOLDER is right-clicked.
+ */
+export interface NotebookNavigatorFolderMenuContext extends NotebookNavigatorMenuContext {
+    /**
+     * The folder that was right-clicked.
+     */
+    readonly folder: TFolder;
+}
+/**
+ * What every Notebook Navigator menu context has in common: a way to add an item, and nothing else.
+ *
+ * The absence of a `Menu` is the whole shape of the integration problem — command handlers write into
+ * a `Menu`, so something has to sit between them and this.
+ */
+export interface NotebookNavigatorMenuContext {
+    /**
+     * Adds an item to the menu Notebook Navigator is building.
+     *
+     * @param callback - Receives the created item, to be configured in place.
+     */
+    addItem: (callback: (item: MenuItem) => void) => void;
+}
+/**
+ * Unregisters a menu extension. Notebook Navigator returns a bare function rather than a disposable,
+ * so it is registered with the bridging component's `register`.
+ */
+export type NotebookNavigatorMenuDispose = () => void;
+/**
+ * The `menus` namespace of Notebook Navigator's API.
+ *
+ * Only the file and folder registrars are declared: the tag and property registrars extend menus
+ * raised on things a file/folder command handler has no counterpart for.
+ */
+export interface NotebookNavigatorMenus {
+    /**
+     * Registers a contributor to the file context menu.
+     *
+     * @param callback - Invoked while the menu is being built.
+     * @returns A function that unregisters the contributor.
+     */
+    registerFileMenu: (callback: (context: NotebookNavigatorFileMenuContext) => void) => NotebookNavigatorMenuDispose;
+    /**
+     * Registers a contributor to the folder context menu.
+     *
+     * @param callback - Invoked while the menu is being built.
+     * @returns A function that unregisters the contributor.
+     */
+    registerFolderMenu: (callback: (context: NotebookNavigatorFolderMenuContext) => void) => NotebookNavigatorMenuDispose;
+}
+/**
+ * The `source` handed to the menu event handlers for a Notebook Navigator menu.
+ *
+ * Obsidian's own File Explorer sends `file-explorer-context-menu`; nothing in this library gates on
+ * the value, but the handlers are contracted to receive one, and a distinct string is what makes a
+ * handler able to tell the two surfaces apart.
+ */
+export declare const NOTEBOOK_NAVIGATOR_MENU_SOURCE = "notebook-navigator-context-menu";
+/**
+ * Notebook Navigator's plugin id, as its manifest declares it.
+ */
+export declare const NOTEBOOK_NAVIGATOR_PLUGIN_ID = "notebook-navigator";
+/**
+ * Gets Notebook Navigator's API, when it is installed, enabled and new enough.
+ *
+ * @param app - The application instance.
+ * @returns The API, or `null` when Notebook Navigator is not there to talk to.
+ */
+export declare function resolveNotebookNavigatorApi(app: App): NotebookNavigatorApi | null;

package/dist/lib/esm/notebook-navigator.mjs

@@ -0,0 +1,72 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+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";
+}
+export {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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": []
}
