@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/esm/misplaced-attachment.d.mts

@@ -0,0 +1,228 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Whether an attachment sits outside the attachment folder of the notes that use it, and which notes are its
+ * proper home.
+ *
+ * Two things here are easy to get wrong:
+ *
+ * - **The judgement is about the FOLDER, not the path.** `getAttachmentFilePath` answers about the proper
+ *   path, folder and templated base name both, so judging on it raw flags every attachment whose NAME does not
+ *   match a rename template. That is a different defect. So the comparison is folder against folder, through
+ *   `getAttachmentFolderPathForAttachment`, which also skips the name generation that dominates the cost of
+ *   the question when `Custom Attachment Location` answers it.
+ * - **The proper folder is asked for the REAL attachment, never a dummy.** A folder template may read the
+ *   attachment's own name, extension or stats, so `getAttachmentFolderPath`'s dummy-file route can answer
+ *   about a file that does not exist.
+ *
+ * A reference is judged from the note that makes it: `A.md` linking `B/image.png`, which sits in `B.md`'s folder,
+ * is A linking an EXTERNAL attachment, even when B uses it too. Whether such a reference is worth reporting depends
+ * on whether the attachment has a proper note anywhere, which is known only after every note has been judged, so
+ * {@link MisplacedAttachmentIndex} collects the verdicts and {@link MisplacedAttachmentIndex.getReported} applies
+ * the {@link ExternalAttachmentLinkMode} at the end.
+ *
+ * Rendering is the caller's: this module only judges and collects.
+ */
+import type { App, Reference, TFile } from 'obsidian';
+/**
+ * Which references to an attachment outside the referencing note's attachment folder are reported.
+ */
+export declare enum ExternalAttachmentLinkMode {
+    /**
+     * Never report one: nothing is judged at all.
+     */
+    Ignore = "Ignore",
+    /**
+     * Report every such reference, including one to an attachment filed in the folder of another note that
+     * references it too.
+     */
+    Report = "Report",
+    /**
+     * Report such a reference only when no note that references the attachment has it in its own folder.
+     */
+    ReportUnowned = "ReportUnowned"
+}
+/**
+ * The folder an attachment sits in, judged against the folder one note's configuration puts its attachments in.
+ */
+export interface AttachmentPlacement {
+    /**
+     * Whether the attachment sits in {@link AttachmentPlacement.properAttachmentFolderPath}, compared the way the
+     * vault's adapter compares names (case-folded on a case-insensitive adapter).
+     */
+    readonly isInProperFolder: boolean;
+    /**
+     * The vault-relative folder the note's configuration puts this attachment in, `/` for the vault root.
+     */
+    readonly properAttachmentFolderPath: string;
+}
+/**
+ * Parameters for {@link getAttachmentPlacement}.
+ */
+export interface GetAttachmentPlacementParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The attachment to judge.
+     */
+    readonly attachmentFile: TFile;
+    /**
+     * The vault-relative path of the note whose configuration the attachment is judged against.
+     */
+    readonly notePath: string;
+}
+/**
+ * One reference to an attachment outside the attachment folder of the note that makes it.
+ *
+ * The same attachment referenced from two notes is two entries, because the two notes can configure different
+ * attachment folders.
+ */
+export interface MisplacedAttachmentEntry {
+    /**
+     * The attachment's current vault-relative path.
+     */
+    readonly attachmentPath: string;
+    /**
+     * The vault-relative folder the referencing note's configuration puts the attachment in.
+     */
+    readonly properAttachmentFolderPath: string;
+    /**
+     * The reference that reaches the attachment.
+     */
+    readonly reference: Reference;
+}
+/**
+ * Parameters for {@link recordAttachmentPlacement}.
+ */
+export interface RecordAttachmentPlacementParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The file the reference resolved to. Pass only references that resolved: an unresolved one is a broken link,
+     * not a misplaced attachment.
+     */
+    readonly attachmentFile: TFile;
+    /**
+     * The index the verdict is recorded in.
+     */
+    readonly index: MisplacedAttachmentIndex;
+    /**
+     * Whether a path is never judged, for example because the user excluded it. Defaults to judging every path.
+     */
+    readonly isPathIgnored?: (path: string) => boolean;
+    /**
+     * Whether a path lies in a shared attachment location, which is anybody's folder, so no reference into it is
+     * external. Defaults to no shared location.
+     */
+    readonly isSharedAttachmentPath?: (path: string) => boolean;
+    /**
+     * Whether a note is treated as an attachment (an `.excalidraw.md` file, say), and so judged here. Defaults to
+     * no note being one.
+     */
+    readonly isTreatedAsAttachment?: (path: string) => boolean;
+    /**
+     * The vault-relative path of the note that makes the reference.
+     */
+    readonly notePath: string;
+    /**
+     * The reference, kept in the entry so a report can name its line or frontmatter key.
+     */
+    readonly reference: Reference;
+}
+/**
+ * The verdicts of a walk over every reference to an attachment, grouped by the note that makes the reference.
+ *
+ * It keeps every external reference, every note that uses each attachment, and each attachment's proper notes:
+ * the notes that reference it and whose own folder holds it. Which entries count as reported depends on the
+ * {@link ExternalAttachmentLinkMode} and on the proper notes, which are known only once the whole vault has been
+ * walked, so ask {@link MisplacedAttachmentIndex.getReported} after the walk.
+ */
+export declare class MisplacedAttachmentIndex extends Map<string, MisplacedAttachmentEntry[]> {
+    readonly mode: ExternalAttachmentLinkMode;
+    private readonly properNotePathsByAttachment;
+    private readonly userNotePathsByAttachment;
+    /**
+     * Creates an empty index.
+     *
+     * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.
+     */
+    constructor(mode?: ExternalAttachmentLinkMode);
+    /**
+     * Records a reference to an attachment outside the referencing note's folder.
+     *
+     * @param notePath - The referencing note's vault-relative path.
+     * @param entry - The reference and the folder the note wants the attachment in.
+     */
+    add(notePath: string, entry: MisplacedAttachmentEntry): void;
+    /**
+     * Records that a note references an attachment, wherever the attachment sits.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The referencing note's vault-relative path.
+     */
+    addUser(attachmentPath: string, notePath: string): void;
+    /**
+     * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The note to leave out: the one whose reference is being reported.
+     * @returns The other notes' paths.
+     */
+    getOtherUserNotePaths(attachmentPath: string, notePath: string): string[];
+    /**
+     * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @returns The proper notes' paths, empty when the attachment has none.
+     */
+    getProperNotePaths(attachmentPath: string): string[];
+    /**
+     * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its
+     * entries survive.
+     *
+     * @returns The entries to report.
+     */
+    getReported(): Map<string, MisplacedAttachmentEntry[]>;
+    /**
+     * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The note's vault-relative path.
+     * @returns `true` when the note's own attachment folder holds the attachment.
+     */
+    isProperNote(attachmentPath: string, notePath: string): boolean;
+    /**
+     * Records that an attachment sits in the folder configured for a note that references it, which makes that
+     * note its proper note.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The referencing note whose folder holds it.
+     */
+    markHomed(attachmentPath: string, notePath: string): void;
+}
+/**
+ * Judges where an attachment sits against the attachment folder of one note.
+ *
+ * Asks the attachment-path seam once, folder-only, for the REAL attachment, so a `Custom Attachment Location`
+ * folder template that reads the attachment's own name is honoured and no name is generated.
+ *
+ * @param params - The attachment and the note.
+ * @returns The note's proper folder for the attachment, and whether the attachment is in it.
+ */
+export declare function getAttachmentPlacement(params: GetAttachmentPlacementParams): Promise<AttachmentPlacement>;
+/**
+ * Judges one resolved reference and records the verdict in the index.
+ *
+ * Records nothing under {@link ExternalAttachmentLinkMode.Ignore}, for a note that is not treated as an
+ * attachment, and for an ignored or shared path. Otherwise the referencing note becomes a proper note of the
+ * attachment when its folder holds it, and the reference becomes an entry when it does not.
+ *
+ * @param params - The reference, its note, its target and the index.
+ * @returns A {@link Promise} that resolves once the verdict is recorded.
+ */
+export declare function recordAttachmentPlacement(params: RecordAttachmentPlacementParams): Promise<void>;

package/dist/lib/esm/misplaced-attachment.mjs

@@ -0,0 +1,212 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import {
+  getDataAdapterEx,
+  parentFolderPath
+} from "@obsidian-typings/obsidian-public-latest/implementations";
+import {
+  AttachmentPathContext,
+  getAttachmentFolderPathForAttachment
+} from "./attachment-path.mjs";
+import { isNote } from "./file-system.mjs";
+var ExternalAttachmentLinkMode = /* @__PURE__ */ ((ExternalAttachmentLinkMode2) => {
+  ExternalAttachmentLinkMode2["Ignore"] = "Ignore";
+  ExternalAttachmentLinkMode2["Report"] = "Report";
+  ExternalAttachmentLinkMode2["ReportUnowned"] = "ReportUnowned";
+  return ExternalAttachmentLinkMode2;
+})(ExternalAttachmentLinkMode || {});
+class MisplacedAttachmentIndex extends Map {
+  /**
+   * Creates an empty index.
+   *
+   * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.
+   */
+  constructor(mode = "Report" /* Report */) {
+    super();
+    this.mode = mode;
+  }
+  mode;
+  properNotePathsByAttachment = /* @__PURE__ */ new Map();
+  userNotePathsByAttachment = /* @__PURE__ */ new Map();
+  /**
+   * Records a reference to an attachment outside the referencing note's folder.
+   *
+   * @param notePath - The referencing note's vault-relative path.
+   * @param entry - The reference and the folder the note wants the attachment in.
+   */
+  add(notePath, entry) {
+    let entries = this.get(notePath);
+    if (!entries) {
+      entries = [];
+      this.set(notePath, entries);
+    }
+    entries.push(entry);
+    this.addUser(entry.attachmentPath, notePath);
+  }
+  /**
+   * Records that a note references an attachment, wherever the attachment sits.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The referencing note's vault-relative path.
+   */
+  addUser(attachmentPath, notePath) {
+    addToSetMap(this.userNotePathsByAttachment, attachmentPath, notePath);
+  }
+  /**
+   * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The note to leave out: the one whose reference is being reported.
+   * @returns The other notes' paths.
+   */
+  getOtherUserNotePaths(attachmentPath, notePath) {
+    const properNotePaths = this.getProperNotePaths(attachmentPath);
+    const userNotePaths = [...this.userNotePathsByAttachment.get(attachmentPath) ?? []];
+    return [...properNotePaths, ...userNotePaths.filter((path) => !properNotePaths.includes(path))].filter((path) => path !== notePath);
+  }
+  /**
+   * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @returns The proper notes' paths, empty when the attachment has none.
+   */
+  getProperNotePaths(attachmentPath) {
+    return [...this.properNotePathsByAttachment.get(attachmentPath) ?? []];
+  }
+  /**
+   * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its
+   * entries survive.
+   *
+   * @returns The entries to report.
+   */
+  getReported() {
+    const reported = /* @__PURE__ */ new Map();
+    if (this.mode === "Ignore" /* Ignore */) {
+      return reported;
+    }
+    for (const [notePath, entries] of this) {
+      const surviving = this.mode === "ReportUnowned" /* ReportUnowned */ ? entries.filter((entry) => !this.properNotePathsByAttachment.has(entry.attachmentPath)) : entries;
+      if (surviving.length > 0) {
+        reported.set(notePath, surviving);
+      }
+    }
+    return reported;
+  }
+  /**
+   * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The note's vault-relative path.
+   * @returns `true` when the note's own attachment folder holds the attachment.
+   */
+  isProperNote(attachmentPath, notePath) {
+    return this.properNotePathsByAttachment.get(attachmentPath)?.has(notePath) ?? false;
+  }
+  /**
+   * Records that an attachment sits in the folder configured for a note that references it, which makes that
+   * note its proper note.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The referencing note whose folder holds it.
+   */
+  markHomed(attachmentPath, notePath) {
+    addToSetMap(this.properNotePathsByAttachment, attachmentPath, notePath);
+    this.addUser(attachmentPath, notePath);
+  }
+}
+async function getAttachmentPlacement(params) {
+  const { app, attachmentFile, notePath } = params;
+  const properAttachmentFolderPath = await getAttachmentFolderPathForAttachment({
+    app,
+    attachmentPathOrFile: attachmentFile,
+    context: AttachmentPathContext.Unknown,
+    notePathOrFile: notePath
+  });
+  const isInsensitive = getDataAdapterEx(app).insensitive;
+  return {
+    isInProperFolder: fold(parentFolderPath(attachmentFile.path)) === fold(properAttachmentFolderPath),
+    properAttachmentFolderPath
+  };
+  function fold(value) {
+    return isInsensitive ? value.toLowerCase() : value;
+  }
+}
+async function recordAttachmentPlacement(params) {
+  const {
+    app,
+    attachmentFile,
+    index,
+    isPathIgnored = isNone,
+    isSharedAttachmentPath = isNone,
+    isTreatedAsAttachment = isNone,
+    notePath,
+    reference
+  } = params;
+  if (index.mode === "Ignore" /* Ignore */) {
+    return;
+  }
+  if (isNote(attachmentFile) && !isTreatedAsAttachment(attachmentFile.path)) {
+    return;
+  }
+  if (isPathIgnored(attachmentFile.path) || isSharedAttachmentPath(attachmentFile.path)) {
+    return;
+  }
+  const placement = await getAttachmentPlacement({ app, attachmentFile, notePath });
+  if (placement.isInProperFolder) {
+    index.markHomed(attachmentFile.path, notePath);
+    return;
+  }
+  index.add(notePath, {
+    attachmentPath: attachmentFile.path,
+    properAttachmentFolderPath: placement.properAttachmentFolderPath,
+    reference
+  });
+}
+function addToSetMap(map, key, value) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+function isNone() {
+  return false;
+}
+export {
+  ExternalAttachmentLinkMode,
+  MisplacedAttachmentIndex,
+  getAttachmentPlacement,
+  recordAttachmentPlacement
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/misplaced-attachment.ts"],"sourcesContent":["/**\n * @file\n *\n * Whether an attachment sits outside the attachment folder of the notes that use it, and which notes are its\n * proper home.\n *\n * Two things here are easy to get wrong:\n *\n * - **The judgement is about the FOLDER, not the path.** `getAttachmentFilePath` answers about the proper\n *   path, folder and templated base name both, so judging on it raw flags every attachment whose NAME does not\n *   match a rename template. That is a different defect. So the comparison is folder against folder, through\n *   `getAttachmentFolderPathForAttachment`, which also skips the name generation that dominates the cost of\n *   the question when `Custom Attachment Location` answers it.\n * - **The proper folder is asked for the REAL attachment, never a dummy.** A folder template may read the\n *   attachment's own name, extension or stats, so `getAttachmentFolderPath`'s dummy-file route can answer\n *   about a file that does not exist.\n *\n * A reference is judged from the note that makes it: `A.md` linking `B/image.png`, which sits in `B.md`'s folder,\n * is A linking an EXTERNAL attachment, even when B uses it too. Whether such a reference is worth reporting depends\n * on whether the attachment has a proper note anywhere, which is known only after every note has been judged, so\n * {@link MisplacedAttachmentIndex} collects the verdicts and {@link MisplacedAttachmentIndex.getReported} applies\n * the {@link ExternalAttachmentLinkMode} at the end.\n *\n * Rendering is the caller's: this module only judges and collects.\n */\n\nimport type {\n  App,\n  Reference,\n  TFile\n} from 'obsidian';\n\nimport {\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport {\n  AttachmentPathContext,\n  getAttachmentFolderPathForAttachment\n} from './attachment-path.ts';\nimport { isNote } from './file-system.ts';\n\n/**\n * Which references to an attachment outside the referencing note's attachment folder are reported.\n */\nexport enum ExternalAttachmentLinkMode {\n  /**\n   * Never report one: nothing is judged at all.\n   */\n  Ignore = 'Ignore',\n\n  /**\n   * Report every such reference, including one to an attachment filed in the folder of another note that\n   * references it too.\n   */\n  Report = 'Report',\n\n  /**\n   * Report such a reference only when no note that references the attachment has it in its own folder.\n   */\n  ReportUnowned = 'ReportUnowned'\n}\n\n/**\n * The folder an attachment sits in, judged against the folder one note's configuration puts its attachments in.\n */\nexport interface AttachmentPlacement {\n  /**\n   * Whether the attachment sits in {@link AttachmentPlacement.properAttachmentFolderPath}, compared the way the\n   * vault's adapter compares names (case-folded on a case-insensitive adapter).\n   */\n  readonly isInProperFolder: boolean;\n\n  /**\n   * The vault-relative folder the note's configuration puts this attachment in, `/` for the vault root.\n   */\n  readonly properAttachmentFolderPath: string;\n}\n\n/**\n * Parameters for {@link getAttachmentPlacement}.\n */\nexport interface GetAttachmentPlacementParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The attachment to judge.\n   */\n  readonly attachmentFile: TFile;\n\n  /**\n   * The vault-relative path of the note whose configuration the attachment is judged against.\n   */\n  readonly notePath: string;\n}\n\n/**\n * One reference to an attachment outside the attachment folder of the note that makes it.\n *\n * The same attachment referenced from two notes is two entries, because the two notes can configure different\n * attachment folders.\n */\nexport interface MisplacedAttachmentEntry {\n  /**\n   * The attachment's current vault-relative path.\n   */\n  readonly attachmentPath: string;\n\n  /**\n   * The vault-relative folder the referencing note's configuration puts the attachment in.\n   */\n  readonly properAttachmentFolderPath: string;\n\n  /**\n   * The reference that reaches the attachment.\n   */\n  readonly reference: Reference;\n}\n\n/**\n * Parameters for {@link recordAttachmentPlacement}.\n */\nexport interface RecordAttachmentPlacementParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The file the reference resolved to. Pass only references that resolved: an unresolved one is a broken link,\n   * not a misplaced attachment.\n   */\n  readonly attachmentFile: TFile;\n\n  /**\n   * The index the verdict is recorded in.\n   */\n  readonly index: MisplacedAttachmentIndex;\n\n  /**\n   * Whether a path is never judged, for example because the user excluded it. Defaults to judging every path.\n   */\n  readonly isPathIgnored?: (path: string) => boolean;\n\n  /**\n   * Whether a path lies in a shared attachment location, which is anybody's folder, so no reference into it is\n   * external. Defaults to no shared location.\n   */\n  readonly isSharedAttachmentPath?: (path: string) => boolean;\n\n  /**\n   * Whether a note is treated as an attachment (an `.excalidraw.md` file, say), and so judged here. Defaults to\n   * no note being one.\n   */\n  readonly isTreatedAsAttachment?: (path: string) => boolean;\n\n  /**\n   * The vault-relative path of the note that makes the reference.\n   */\n  readonly notePath: string;\n\n  /**\n   * The reference, kept in the entry so a report can name its line or frontmatter key.\n   */\n  readonly reference: Reference;\n}\n\n/**\n * The verdicts of a walk over every reference to an attachment, grouped by the note that makes the reference.\n *\n * It keeps every external reference, every note that uses each attachment, and each attachment's proper notes:\n * the notes that reference it and whose own folder holds it. Which entries count as reported depends on the\n * {@link ExternalAttachmentLinkMode} and on the proper notes, which are known only once the whole vault has been\n * walked, so ask {@link MisplacedAttachmentIndex.getReported} after the walk.\n */\nexport class MisplacedAttachmentIndex extends Map<string, MisplacedAttachmentEntry[]> {\n  private readonly properNotePathsByAttachment = new Map<string, Set<string>>();\n  private readonly userNotePathsByAttachment = new Map<string, Set<string>>();\n\n  /**\n   * Creates an empty index.\n   *\n   * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.\n   */\n  public constructor(public readonly mode = ExternalAttachmentLinkMode.Report) {\n    super();\n  }\n\n  /**\n   * Records a reference to an attachment outside the referencing note's folder.\n   *\n   * @param notePath - The referencing note's vault-relative path.\n   * @param entry - The reference and the folder the note wants the attachment in.\n   */\n  public add(notePath: string, entry: MisplacedAttachmentEntry): void {\n    let entries = this.get(notePath);\n    if (!entries) {\n      entries = [];\n      this.set(notePath, entries);\n    }\n    entries.push(entry);\n    this.addUser(entry.attachmentPath, notePath);\n  }\n\n  /**\n   * Records that a note references an attachment, wherever the attachment sits.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The referencing note's vault-relative path.\n   */\n  public addUser(attachmentPath: string, notePath: string): void {\n    addToSetMap(this.userNotePathsByAttachment, attachmentPath, notePath);\n  }\n\n  /**\n   * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The note to leave out: the one whose reference is being reported.\n   * @returns The other notes' paths.\n   */\n  public getOtherUserNotePaths(attachmentPath: string, notePath: string): string[] {\n    const properNotePaths = this.getProperNotePaths(attachmentPath);\n    const userNotePaths = [...this.userNotePathsByAttachment.get(attachmentPath) ?? []];\n    return [...properNotePaths, ...userNotePaths.filter((path) => !properNotePaths.includes(path))].filter((path) => path !== notePath);\n  }\n\n  /**\n   * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @returns The proper notes' paths, empty when the attachment has none.\n   */\n  public getProperNotePaths(attachmentPath: string): string[] {\n    return [...this.properNotePathsByAttachment.get(attachmentPath) ?? []];\n  }\n\n  /**\n   * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its\n   * entries survive.\n   *\n   * @returns The entries to report.\n   */\n  public getReported(): Map<string, MisplacedAttachmentEntry[]> {\n    const reported = new Map<string, MisplacedAttachmentEntry[]>();\n    if (this.mode === ExternalAttachmentLinkMode.Ignore) {\n      return reported;\n    }\n\n    for (const [notePath, entries] of this) {\n      const surviving = this.mode === ExternalAttachmentLinkMode.ReportUnowned\n        ? entries.filter((entry) => !this.properNotePathsByAttachment.has(entry.attachmentPath))\n        : entries;\n      if (surviving.length > 0) {\n        reported.set(notePath, surviving);\n      }\n    }\n    return reported;\n  }\n\n  /**\n   * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The note's vault-relative path.\n   * @returns `true` when the note's own attachment folder holds the attachment.\n   */\n  public isProperNote(attachmentPath: string, notePath: string): boolean {\n    return this.properNotePathsByAttachment.get(attachmentPath)?.has(notePath) ?? false;\n  }\n\n  /**\n   * Records that an attachment sits in the folder configured for a note that references it, which makes that\n   * note its proper note.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The referencing note whose folder holds it.\n   */\n  public markHomed(attachmentPath: string, notePath: string): void {\n    addToSetMap(this.properNotePathsByAttachment, attachmentPath, notePath);\n    this.addUser(attachmentPath, notePath);\n  }\n}\n\n/**\n * Judges where an attachment sits against the attachment folder of one note.\n *\n * Asks the attachment-path seam once, folder-only, for the REAL attachment, so a `Custom Attachment Location`\n * folder template that reads the attachment's own name is honoured and no name is generated.\n *\n * @param params - The attachment and the note.\n * @returns The note's proper folder for the attachment, and whether the attachment is in it.\n */\nexport async function getAttachmentPlacement(params: GetAttachmentPlacementParams): Promise<AttachmentPlacement> {\n  const { app, attachmentFile, notePath } = params;\n  const properAttachmentFolderPath = await getAttachmentFolderPathForAttachment({\n    app,\n    attachmentPathOrFile: attachmentFile,\n    context: AttachmentPathContext.Unknown,\n    notePathOrFile: notePath\n  });\n\n  // Fold as `isAtProperAttachmentPath` does, so a case-insensitive adapter does not report a folder that differs\n  // only in case.\n  const isInsensitive = getDataAdapterEx(app).insensitive;\n  return {\n    isInProperFolder: fold(parentFolderPath(attachmentFile.path)) === fold(properAttachmentFolderPath),\n    properAttachmentFolderPath\n  };\n\n  function fold(value: string): string {\n    return isInsensitive ? value.toLowerCase() : value;\n  }\n}\n\n/**\n * Judges one resolved reference and records the verdict in the index.\n *\n * Records nothing under {@link ExternalAttachmentLinkMode.Ignore}, for a note that is not treated as an\n * attachment, and for an ignored or shared path. Otherwise the referencing note becomes a proper note of the\n * attachment when its folder holds it, and the reference becomes an entry when it does not.\n *\n * @param params - The reference, its note, its target and the index.\n * @returns A {@link Promise} that resolves once the verdict is recorded.\n */\nexport async function recordAttachmentPlacement(params: RecordAttachmentPlacementParams): Promise<void> {\n  const {\n    app,\n    attachmentFile,\n    index,\n    isPathIgnored = isNone,\n    isSharedAttachmentPath = isNone,\n    isTreatedAsAttachment = isNone,\n    notePath,\n    reference\n  } = params;\n\n  if (index.mode === ExternalAttachmentLinkMode.Ignore) {\n    return;\n  }\n\n  if (isNote(attachmentFile) && !isTreatedAsAttachment(attachmentFile.path)) {\n    return;\n  }\n\n  if (isPathIgnored(attachmentFile.path) || isSharedAttachmentPath(attachmentFile.path)) {\n    return;\n  }\n\n  const placement = await getAttachmentPlacement({ app, attachmentFile, notePath });\n\n  if (placement.isInProperFolder) {\n    index.markHomed(attachmentFile.path, notePath);\n    return;\n  }\n\n  index.add(notePath, {\n    attachmentPath: attachmentFile.path,\n    properAttachmentFolderPath: placement.properAttachmentFolderPath,\n    reference\n  });\n}\n\nfunction addToSetMap(map: Map<string, Set<string>>, key: string, value: string): void {\n  let set = map.get(key);\n  if (!set) {\n    set = new Set<string>();\n    map.set(key, set);\n  }\n  set.add(value);\n}\n\nfunction isNone(): boolean {\n  return false;\n}\n"],"mappings":"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","names":["ExternalAttachmentLinkMode"]}

package/dist/lib/esm/modals/prompt.d.mts

@@ -73,7 +73,7 @@ export interface PromptParams extends ModalParamsBase {
      * @param value - The input value to validate.
      * @returns an error message if the value is invalid, or `null` if the value is valid.
      */
-    readonly valueValidator?: (value: string) => Promisable<MaybeReturn<string>>;
+    readonly valueValidator?: (value: string) => Promisable<MaybeReturn<null | string>>;
 }
 /**
  * Displays a prompt modal in Obsidian to get user input.

package/dist/lib/esm/modals/prompt.mjs

@@ -156,4 +156,4 @@ async function prompt(params) {
 export {
   prompt
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/modals/prompt.ts"],"sourcesContent":["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  ModalCommandBuilder,\n  ModalCommandBuilderBuildOptions,\n  ModalCommandsRenderMode\n} from './modal-command-builder.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { applySpellcheckMode } from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { SpellcheckMode } from '../obsidian-settings.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Options for {@link prompt}.\n */\nexport interface PromptParams extends ModalParamsBase {\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * Extra controls — checkboxes, dropdowns and keyboard shortcuts — rendered as a strip along the bottom\n   * of the modal, so a caller gets a text input plus options with no bespoke modal of its own.\n   *\n   * Hand it a configured {@link ModalCommandBuilder}; the modal builds it. The strip is rendered after\n   * the buttons, so it sits along the bottom edge where a `SuggestModal`'s instruction bar sits.\n   */\n  readonly commandBuilder?: ModalCommandBuilder;\n\n  /**\n   * The way {@link PromptParams.commandBuilder}'s controls are rendered.\n   *\n   * @default `ModalCommandsRenderMode.Instructions`\n   */\n  readonly commandsRenderMode?: ModalCommandsRenderMode;\n\n  /**\n   * A default value to pre-fill the input field.\n   *\n   * @default `''`\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   *\n   * @default `''`\n   */\n  readonly placeholder?: string;\n\n  /**\n   * The mode deciding whether the input is spell-checked.\n   *\n   * The default is what this modal has always done, so passing nothing changes nothing: the input follows\n   * `Editor > Spellcheck`, like Obsidian's own name-entry surfaces. Pass {@link SpellcheckMode.Off} for a\n   * box that is really a search field, or {@link SpellcheckMode.AlwaysOn} to spell-check it whatever the\n   * vault setting says.\n   *\n   * @default `SpellcheckMode.FollowObsidianSetting`\n   */\n  readonly spellcheckMode?: SpellcheckMode;\n\n  /**\n   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  readonly valueValidator?: (value: string) => Promisable<MaybeReturn<string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private readonly commandBuilder: ModalCommandBuilder | null;\n  private readonly commandsRenderMode: ModalCommandsRenderMode | undefined;\n  private isOkClicked = false;\n  private isTouched = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly spellcheckMode: SpellcheckMode;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianLib.buttons.cancel);\n    this.commandBuilder = params.commandBuilder ?? null;\n    this.commandsRenderMode = params.commandsRenderMode;\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianLib.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.FollowObsidianSetting;\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n    // `AbstractTextComponent` forces `spellcheck=\"false\"` on every text component, so the mode has to be applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    applySpellcheckMode({\n      app: this.app,\n      element: inputEl,\n      spellcheckMode: this.spellcheckMode\n    });\n\n    const validate = async (shouldReport: boolean): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      if (shouldReport) {\n        inputEl.reportValidity();\n      }\n    };\n\n    const handleInput = async (): Promise<void> => {\n      this.markTouched(inputEl);\n      await validate(true);\n    };\n\n    const handleFocus = async (): Promise<void> => {\n      await validate(this.isTouched);\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    // The modal opens invalid by design (see below), so the invalid styling is deferred until touched.\n    inputEl.addClass(CssClass.Untouched);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    inputEl.addEventListener('keydown', ($event: KeyboardEvent) => {\n      if ($event.key === 'Enter') {\n        this.handleOk($event, textComponent);\n      } else if ($event.key === 'Escape') {\n        this.close();\n      }\n    });\n    inputEl.addEventListener('input', convertAsyncToSync(handleInput));\n    inputEl.addEventListener('focus', convertAsyncToSync(handleFocus));\n    // The modal must start out invalid so OK refuses, but the validity is not reported until the user types or submits.\n    invokeAsyncSafely(() => validate(false));\n    const okButton = new ButtonComponent(this.contentEl);\n    okButton.setButtonText(this.okButtonText);\n    okButton.setCta();\n    okButton.onClick(($event) => {\n      this.handleOk($event, textComponent);\n    });\n    okButton.setClass(CssClass.OkButton);\n    const cancelButton = new ButtonComponent(this.contentEl);\n    cancelButton.setButtonText(this.cancelButtonText);\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n\n    // Built last so the strip lands along the modal's bottom edge, where a `SuggestModal`'s instruction\n    // bar sits.\n    this.commandBuilder?.build(this, normalizeOptionalProperties<ModalCommandBuilderBuildOptions>({ renderMode: this.commandsRenderMode }));\n  }\n\n  private handleOk($event: Event, textComponent: TextComponent): void {\n    $event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      this.markTouched(textComponent.inputEl);\n      textComponent.inputEl.reportValidity();\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n\n  private markTouched(inputEl: HTMLInputElement): void {\n    this.isTouched = true;\n    inputEl.removeClass(CssClass.Untouched);\n  }\n}\n\n/**\n * Displays a prompt modal in Obsidian to get user input.\n *\n * @param params - The parameters for the prompt modal.\n * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.\n */\nexport async function prompt(params: PromptParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new PromptModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/modals/prompt.ts"],"sourcesContent":["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  ModalCommandBuilder,\n  ModalCommandBuilderBuildOptions,\n  ModalCommandsRenderMode\n} from './modal-command-builder.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { applySpellcheckMode } from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { SpellcheckMode } from '../obsidian-settings.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Options for {@link prompt}.\n */\nexport interface PromptParams extends ModalParamsBase {\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * Extra controls — checkboxes, dropdowns and keyboard shortcuts — rendered as a strip along the bottom\n   * of the modal, so a caller gets a text input plus options with no bespoke modal of its own.\n   *\n   * Hand it a configured {@link ModalCommandBuilder}; the modal builds it. The strip is rendered after\n   * the buttons, so it sits along the bottom edge where a `SuggestModal`'s instruction bar sits.\n   */\n  readonly commandBuilder?: ModalCommandBuilder;\n\n  /**\n   * The way {@link PromptParams.commandBuilder}'s controls are rendered.\n   *\n   * @default `ModalCommandsRenderMode.Instructions`\n   */\n  readonly commandsRenderMode?: ModalCommandsRenderMode;\n\n  /**\n   * A default value to pre-fill the input field.\n   *\n   * @default `''`\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   *\n   * @default `''`\n   */\n  readonly placeholder?: string;\n\n  /**\n   * The mode deciding whether the input is spell-checked.\n   *\n   * The default is what this modal has always done, so passing nothing changes nothing: the input follows\n   * `Editor > Spellcheck`, like Obsidian's own name-entry surfaces. Pass {@link SpellcheckMode.Off} for a\n   * box that is really a search field, or {@link SpellcheckMode.AlwaysOn} to spell-check it whatever the\n   * vault setting says.\n   *\n   * @default `SpellcheckMode.FollowObsidianSetting`\n   */\n  readonly spellcheckMode?: SpellcheckMode;\n\n  /**\n   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  readonly valueValidator?: (value: string) => Promisable<MaybeReturn<null | string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private readonly commandBuilder: ModalCommandBuilder | null;\n  private readonly commandsRenderMode: ModalCommandsRenderMode | undefined;\n  private isOkClicked = false;\n  private isTouched = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly spellcheckMode: SpellcheckMode;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<null | string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianLib.buttons.cancel);\n    this.commandBuilder = params.commandBuilder ?? null;\n    this.commandsRenderMode = params.commandsRenderMode;\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianLib.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.FollowObsidianSetting;\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n    // `AbstractTextComponent` forces `spellcheck=\"false\"` on every text component, so the mode has to be applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    applySpellcheckMode({\n      app: this.app,\n      element: inputEl,\n      spellcheckMode: this.spellcheckMode\n    });\n\n    const validate = async (shouldReport: boolean): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as null | string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      if (shouldReport) {\n        inputEl.reportValidity();\n      }\n    };\n\n    const handleInput = async (): Promise<void> => {\n      this.markTouched(inputEl);\n      await validate(true);\n    };\n\n    const handleFocus = async (): Promise<void> => {\n      await validate(this.isTouched);\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    // The modal opens invalid by design (see below), so the invalid styling is deferred until touched.\n    inputEl.addClass(CssClass.Untouched);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    inputEl.addEventListener('keydown', ($event: KeyboardEvent) => {\n      if ($event.key === 'Enter') {\n        this.handleOk($event, textComponent);\n      } else if ($event.key === 'Escape') {\n        this.close();\n      }\n    });\n    inputEl.addEventListener('input', convertAsyncToSync(handleInput));\n    inputEl.addEventListener('focus', convertAsyncToSync(handleFocus));\n    // The modal must start out invalid so OK refuses, but the validity is not reported until the user types or submits.\n    invokeAsyncSafely(() => validate(false));\n    const okButton = new ButtonComponent(this.contentEl);\n    okButton.setButtonText(this.okButtonText);\n    okButton.setCta();\n    okButton.onClick(($event) => {\n      this.handleOk($event, textComponent);\n    });\n    okButton.setClass(CssClass.OkButton);\n    const cancelButton = new ButtonComponent(this.contentEl);\n    cancelButton.setButtonText(this.cancelButtonText);\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n\n    // Built last so the strip lands along the modal's bottom edge, where a `SuggestModal`'s instruction\n    // bar sits.\n    this.commandBuilder?.build(this, normalizeOptionalProperties<ModalCommandBuilderBuildOptions>({ renderMode: this.commandsRenderMode }));\n  }\n\n  private handleOk($event: Event, textComponent: TextComponent): void {\n    $event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      this.markTouched(textComponent.inputEl);\n      textComponent.inputEl.reportValidity();\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n\n  private markTouched(inputEl: HTMLInputElement): void {\n    this.isTouched = true;\n    inputEl.removeClass(CssClass.Untouched);\n  }\n}\n\n/**\n * Displays a prompt modal in Obsidian to get user input.\n *\n * @param params - The parameters for the prompt modal.\n * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.\n */\nexport async function prompt(params: PromptParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new PromptModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/notebook-navigator.d.mts

@@ -18,6 +18,7 @@
  * none of which apply to a file/folder command surface.
  */
 import type { App, MenuItem, TFile, TFolder } from 'obsidian';
+import type { ThirdPartyPluginAdapter } from './plugin/third-party-plugin.mjs';
 /**
  * `Notebook Navigator`'s public API object, narrowed to what this library uses.
  */
@@ -130,3 +131,8 @@ export declare const NOTEBOOK_NAVIGATOR_PLUGIN_ID = "notebook-navigator";
  * @returns The API, or `null` when `Notebook Navigator` is not there to talk to.
  */
 export declare function resolveNotebookNavigatorApi(app: App): NotebookNavigatorApi | null;
+/**
+ * The {@link ThirdPartyPluginAdapter} of `Notebook Navigator`, for `watchThirdPartyPluginApi`, the waits and
+ * `createThirdPartyPluginDependency`. It reads `plugin.api` and verifies both menu registrars.
+ */
+export declare const NOTEBOOK_NAVIGATOR_PLUGIN_ADAPTER: ThirdPartyPluginAdapter<NotebookNavigatorApi>;