@mnaoumov/obsidian-lib 10.5.0 → 10.6.0

package/dist/lib/esm/anchored-suggest.d.mts

@@ -0,0 +1,116 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * A suggest popover opened at an element or a rectangle, with no input behind it.
+ */
+import type { App, Scope } from 'obsidian';
+import { PopoverSuggest } from 'obsidian';
+/**
+ * Parameters for {@link AnchoredSuggest.openAt}.
+ */
+export interface AnchoredSuggestOpenAtParams {
+    /**
+     * The element or the viewport rectangle the popover is placed against. When an element is given, the popover closes
+     * once the element leaves the DOM, and a pointer-down on it does not count as an outside click.
+     */
+    readonly anchor: DOMRectReadOnly | HTMLElement;
+    /**
+     * The query handed to {@link AnchoredSuggest.getSuggestions}. Defaults to `''`.
+     */
+    readonly query?: string;
+}
+/**
+ * A suggest popover opened at an anchor, for a picker that has no text input: a toolbar button, a context-menu action,
+ * a decoration in the editor.
+ *
+ * Obsidian's `AbstractInputSuggest` opens only from an input and `EditorSuggest` only from the editor. This one is
+ * opened by {@link AnchoredSuggest.openAt} and closes on Escape, on a pointer-down outside it, and when its anchor
+ * element leaves the DOM. The keyboard works as in Obsidian's own popovers: arrows move, Enter picks.
+ *
+ * ```ts
+ * class ColorSuggest extends AnchoredSuggest<string> {
+ *   protected getSuggestions(): string[] {
+ *     return ['red', 'green', 'blue'];
+ *   }
+ *
+ *   public renderSuggestion(color: string, el: HTMLElement): void {
+ *     el.setText(color);
+ *   }
+ *
+ *   protected onChooseSuggestion(color: string): void {
+ *     console.log(color);
+ *   }
+ * }
+ *
+ * await new ColorSuggest(this.app).openAt({ anchor: buttonEl });
+ * ```
+ *
+ * It relies on `PopoverSuggest` members that `obsidian.d.ts` does not declare (`suggestions`, `reposition`,
+ * `setAutoDestroy`, `suggestEl`), read from Obsidian `1.15.0`.
+ *
+ * @typeParam T - The type of a suggestion.
+ */
+export declare abstract class AnchoredSuggest<T> extends PopoverSuggest<T> {
+    /**
+     * The maximum number of suggestions shown. `0` disables the limit. Defaults to `100`.
+     */
+    limit: number;
+    private anchorEl;
+    private anchorRect;
+    private outsidePointerDownDocument;
+    private readonly outsidePointerDownHandler;
+    private requestCount;
+    /**
+     * Creates a new anchored suggest.
+     *
+     * @param app - The Obsidian app.
+     * @param scope - The parent keymap scope.
+     */
+    constructor(app: App, scope?: Scope);
+    /**
+     * Closes the popover.
+     */
+    close(): void;
+    /**
+     * Opens the popover at an anchor, or moves it there when it is already open.
+     *
+     * @param params - The parameters.
+     * @returns Whether the popover is open: `false` when there is nothing to suggest, or when it was closed or reopened
+     *   while the suggestions were computed.
+     */
+    openAt(params: AnchoredSuggestOpenAtParams): Promise<boolean>;
+    /**
+     * Picks a suggestion: closes the popover, then hands the suggestion to {@link AnchoredSuggest.onChooseSuggestion}.
+     *
+     * @param value - The suggestion.
+     * @param $event - The event that picked it.
+     */
+    selectSuggestion(value: T, $event: KeyboardEvent | MouseEvent): void;
+    /**
+     * Recomputes the suggestions for a new query at the current anchor.
+     *
+     * @param query - The query.
+     * @returns Whether the popover is open afterwards.
+     */
+    setQuery(query: string): Promise<boolean>;
+    /**
+     * Gets the suggestions for a query.
+     *
+     * @param query - The query passed to {@link AnchoredSuggest.openAt} or {@link AnchoredSuggest.setQuery}.
+     * @returns The suggestions, directly or as a promise.
+     */
+    protected abstract getSuggestions(query: string): Promise<T[]> | T[];
+    /**
+     * Called with the suggestion the user picked, after the popover closed.
+     *
+     * @param value - The suggestion.
+     * @param $event - The event that picked it.
+     */
+    protected abstract onChooseSuggestion(value: T, $event: KeyboardEvent | MouseEvent): void;
+    private addOutsidePointerDownHandler;
+    private onOutsidePointerDown;
+    private refresh;
+    private removeOutsidePointerDownHandler;
+}

package/dist/lib/esm/anchored-suggest.mjs

@@ -0,0 +1,144 @@
+/*
+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 { PopoverSuggest } from "obsidian";
+const DEFAULT_LIMIT = 100;
+class AnchoredSuggest extends PopoverSuggest {
+  /**
+   * The maximum number of suggestions shown. `0` disables the limit. Defaults to `100`.
+   */
+  limit = DEFAULT_LIMIT;
+  anchorEl = null;
+  anchorRect = null;
+  outsidePointerDownDocument = null;
+  outsidePointerDownHandler = this.onOutsidePointerDown.bind(this);
+  requestCount = 0;
+  /**
+   * Creates a new anchored suggest.
+   *
+   * @param app - The Obsidian app.
+   * @param scope - The parent keymap scope.
+   */
+  constructor(app, scope) {
+    super(app, scope);
+  }
+  /**
+   * Closes the popover.
+   */
+  close() {
+    this.requestCount++;
+    this.removeOutsidePointerDownHandler();
+    super.close();
+  }
+  /**
+   * Opens the popover at an anchor, or moves it there when it is already open.
+   *
+   * @param params - The parameters.
+   * @returns Whether the popover is open: `false` when there is nothing to suggest, or when it was closed or reopened
+   *   while the suggestions were computed.
+   */
+  async openAt(params) {
+    const { anchor } = params;
+    if (isElement(anchor)) {
+      this.anchorEl = anchor;
+      this.anchorRect = anchor.getBoundingClientRect();
+    } else {
+      this.anchorEl = null;
+      this.anchorRect = anchor;
+    }
+    return await this.refresh(params.query ?? "", this.anchorRect);
+  }
+  /**
+   * Picks a suggestion: closes the popover, then hands the suggestion to {@link AnchoredSuggest.onChooseSuggestion}.
+   *
+   * @param value - The suggestion.
+   * @param $event - The event that picked it.
+   */
+  selectSuggestion(value, $event) {
+    this.close();
+    this.onChooseSuggestion(value, $event);
+  }
+  /**
+   * Recomputes the suggestions for a new query at the current anchor.
+   *
+   * @param query - The query.
+   * @returns Whether the popover is open afterwards.
+   */
+  async setQuery(query) {
+    return this.anchorRect ? await this.refresh(query, this.anchorRect) : false;
+  }
+  addOutsidePointerDownHandler() {
+    this.removeOutsidePointerDownHandler();
+    this.outsidePointerDownDocument = this.suggestEl.ownerDocument;
+    this.outsidePointerDownDocument.addEventListener("pointerdown", this.outsidePointerDownHandler, { capture: true });
+  }
+  onOutsidePointerDown(event_) {
+    const path = event_.composedPath();
+    if (path.includes(this.suggestEl) || this.anchorEl && path.includes(this.anchorEl)) {
+      return;
+    }
+    this.close();
+  }
+  async refresh(query, anchorRect) {
+    const requestId = ++this.requestCount;
+    let suggestions = await this.getSuggestions(query);
+    if (requestId !== this.requestCount) {
+      return false;
+    }
+    if (suggestions.length === 0) {
+      this.close();
+      return false;
+    }
+    if (this.limit > 0) {
+      suggestions = suggestions.slice(0, this.limit);
+    }
+    this.suggestions.setSuggestions(suggestions);
+    this.open();
+    this.reposition(DOMRect.fromRect(anchorRect));
+    if (this.anchorEl) {
+      this.setAutoDestroy(this.anchorEl);
+    }
+    this.addOutsidePointerDownHandler();
+    return true;
+  }
+  removeOutsidePointerDownHandler() {
+    this.outsidePointerDownDocument?.removeEventListener("pointerdown", this.outsidePointerDownHandler, { capture: true });
+    this.outsidePointerDownDocument = null;
+  }
+}
+function isElement(anchor) {
+  return "getBoundingClientRect" in anchor;
+}
+export {
+  AnchoredSuggest
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/anchored-suggest.ts"],"sourcesContent":["/**\n * @file\n *\n * A suggest popover opened at an element or a rectangle, with no input behind it.\n */\n\nimport type {\n  App,\n  Scope\n} from 'obsidian';\n\nimport { PopoverSuggest } from 'obsidian';\n\nconst DEFAULT_LIMIT = 100;\n\n/**\n * Parameters for {@link AnchoredSuggest.openAt}.\n */\nexport interface AnchoredSuggestOpenAtParams {\n  /**\n   * The element or the viewport rectangle the popover is placed against. When an element is given, the popover closes\n   * once the element leaves the DOM, and a pointer-down on it does not count as an outside click.\n   */\n  readonly anchor: DOMRectReadOnly | HTMLElement;\n\n  /**\n   * The query handed to {@link AnchoredSuggest.getSuggestions}. Defaults to `''`.\n   */\n  readonly query?: string;\n}\n\n/**\n * A suggest popover opened at an anchor, for a picker that has no text input: a toolbar button, a context-menu action,\n * a decoration in the editor.\n *\n * Obsidian's `AbstractInputSuggest` opens only from an input and `EditorSuggest` only from the editor. This one is\n * opened by {@link AnchoredSuggest.openAt} and closes on Escape, on a pointer-down outside it, and when its anchor\n * element leaves the DOM. The keyboard works as in Obsidian's own popovers: arrows move, Enter picks.\n *\n * ```ts\n * class ColorSuggest extends AnchoredSuggest<string> {\n *   protected getSuggestions(): string[] {\n *     return ['red', 'green', 'blue'];\n *   }\n *\n *   public renderSuggestion(color: string, el: HTMLElement): void {\n *     el.setText(color);\n *   }\n *\n *   protected onChooseSuggestion(color: string): void {\n *     console.log(color);\n *   }\n * }\n *\n * await new ColorSuggest(this.app).openAt({ anchor: buttonEl });\n * ```\n *\n * It relies on `PopoverSuggest` members that `obsidian.d.ts` does not declare (`suggestions`, `reposition`,\n * `setAutoDestroy`, `suggestEl`), read from Obsidian `1.15.0`.\n *\n * @typeParam T - The type of a suggestion.\n */\nexport abstract class AnchoredSuggest<T> extends PopoverSuggest<T> {\n  /**\n   * The maximum number of suggestions shown. `0` disables the limit. Defaults to `100`.\n   */\n  public limit = DEFAULT_LIMIT;\n\n  private anchorEl: HTMLElement | null = null;\n  private anchorRect: DOMRectReadOnly | null = null;\n  private outsidePointerDownDocument: Document | null = null;\n  private readonly outsidePointerDownHandler = this.onOutsidePointerDown.bind(this);\n  private requestCount = 0;\n\n  /**\n   * Creates a new anchored suggest.\n   *\n   * @param app - The Obsidian app.\n   * @param scope - The parent keymap scope.\n   */\n  public constructor(app: App, scope?: Scope) {\n    super(app, scope);\n  }\n\n  /**\n   * Closes the popover.\n   */\n  public override close(): void {\n    this.requestCount++;\n    this.removeOutsidePointerDownHandler();\n    super.close();\n  }\n\n  /**\n   * Opens the popover at an anchor, or moves it there when it is already open.\n   *\n   * @param params - The parameters.\n   * @returns Whether the popover is open: `false` when there is nothing to suggest, or when it was closed or reopened\n   *   while the suggestions were computed.\n   */\n  public async openAt(params: AnchoredSuggestOpenAtParams): Promise<boolean> {\n    const { anchor } = params;\n    if (isElement(anchor)) {\n      this.anchorEl = anchor;\n      this.anchorRect = anchor.getBoundingClientRect();\n    } else {\n      this.anchorEl = null;\n      this.anchorRect = anchor;\n    }\n    return await this.refresh(params.query ?? '', this.anchorRect);\n  }\n\n  /**\n   * Picks a suggestion: closes the popover, then hands the suggestion to {@link AnchoredSuggest.onChooseSuggestion}.\n   *\n   * @param value - The suggestion.\n   * @param $event - The event that picked it.\n   */\n  public override selectSuggestion(value: T, $event: KeyboardEvent | MouseEvent): void {\n    this.close();\n    this.onChooseSuggestion(value, $event);\n  }\n\n  /**\n   * Recomputes the suggestions for a new query at the current anchor.\n   *\n   * @param query - The query.\n   * @returns Whether the popover is open afterwards.\n   */\n  public async setQuery(query: string): Promise<boolean> {\n    return this.anchorRect ? (await this.refresh(query, this.anchorRect)) : false;\n  }\n\n  /**\n   * Gets the suggestions for a query.\n   *\n   * @param query - The query passed to {@link AnchoredSuggest.openAt} or {@link AnchoredSuggest.setQuery}.\n   * @returns The suggestions, directly or as a promise.\n   */\n  protected abstract getSuggestions(query: string): Promise<T[]> | T[];\n\n  /**\n   * Called with the suggestion the user picked, after the popover closed.\n   *\n   * @param value - The suggestion.\n   * @param $event - The event that picked it.\n   */\n  protected abstract onChooseSuggestion(value: T, $event: KeyboardEvent | MouseEvent): void;\n\n  private addOutsidePointerDownHandler(): void {\n    this.removeOutsidePointerDownHandler();\n    this.outsidePointerDownDocument = this.suggestEl.ownerDocument;\n    this.outsidePointerDownDocument.addEventListener('pointerdown', this.outsidePointerDownHandler, { capture: true });\n  }\n\n  private onOutsidePointerDown(event_: PointerEvent): void {\n    const path = event_.composedPath();\n    if (path.includes(this.suggestEl) || (this.anchorEl && path.includes(this.anchorEl))) {\n      return;\n    }\n    this.close();\n  }\n\n  private async refresh(query: string, anchorRect: DOMRectReadOnly): Promise<boolean> {\n    const requestId = ++this.requestCount;\n    let suggestions = await this.getSuggestions(query);\n    if (requestId !== this.requestCount) {\n      return false;\n    }\n    if (suggestions.length === 0) {\n      this.close();\n      return false;\n    }\n    if (this.limit > 0) {\n      suggestions = suggestions.slice(0, this.limit);\n    }\n\n    this.suggestions.setSuggestions(suggestions);\n    this.open();\n    this.reposition(DOMRect.fromRect(anchorRect));\n    if (this.anchorEl) {\n      this.setAutoDestroy(this.anchorEl);\n    }\n    this.addOutsidePointerDownHandler();\n    return true;\n  }\n\n  private removeOutsidePointerDownHandler(): void {\n    this.outsidePointerDownDocument?.removeEventListener('pointerdown', this.outsidePointerDownHandler, { capture: true });\n    this.outsidePointerDownDocument = null;\n  }\n}\n\nfunction isElement(anchor: DOMRectReadOnly | HTMLElement): anchor is HTMLElement {\n  return 'getBoundingClientRect' in anchor;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,SAAS,sBAAsB;AAE/B,MAAM,gBAAgB;AAiDf,MAAe,wBAA2B,eAAkB;AAAA;AAAA;AAAA;AAAA,EAI1D,QAAQ;AAAA,EAEP,WAA+B;AAAA,EAC/B,aAAqC;AAAA,EACrC,6BAA8C;AAAA,EACrC,4BAA4B,KAAK,qBAAqB,KAAK,IAAI;AAAA,EACxE,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQhB,YAAY,KAAU,OAAe;AAC1C,UAAM,KAAK,KAAK;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKgB,QAAc;AAC5B,SAAK;AACL,SAAK,gCAAgC;AACrC,UAAM,MAAM;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,OAAO,QAAuD;AACzE,UAAM,EAAE,OAAO,IAAI;AACnB,QAAI,UAAU,MAAM,GAAG;AACrB,WAAK,WAAW;AAChB,WAAK,aAAa,OAAO,sBAAsB;AAAA,IACjD,OAAO;AACL,WAAK,WAAW;AAChB,WAAK,aAAa;AAAA,IACpB;AACA,WAAO,MAAM,KAAK,QAAQ,OAAO,SAAS,IAAI,KAAK,UAAU;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,iBAAiB,OAAU,QAA0C;AACnF,SAAK,MAAM;AACX,SAAK,mBAAmB,OAAO,MAAM;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,SAAS,OAAiC;AACrD,WAAO,KAAK,aAAc,MAAM,KAAK,QAAQ,OAAO,KAAK,UAAU,IAAK;AAAA,EAC1E;AAAA,EAkBQ,+BAAqC;AAC3C,SAAK,gCAAgC;AACrC,SAAK,6BAA6B,KAAK,UAAU;AACjD,SAAK,2BAA2B,iBAAiB,eAAe,KAAK,2BAA2B,EAAE,SAAS,KAAK,CAAC;AAAA,EACnH;AAAA,EAEQ,qBAAqB,QAA4B;AACvD,UAAM,OAAO,OAAO,aAAa;AACjC,QAAI,KAAK,SAAS,KAAK,SAAS,KAAM,KAAK,YAAY,KAAK,SAAS,KAAK,QAAQ,GAAI;AACpF;AAAA,IACF;AACA,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,MAAc,QAAQ,OAAe,YAA+C;AAClF,UAAM,YAAY,EAAE,KAAK;AACzB,QAAI,cAAc,MAAM,KAAK,eAAe,KAAK;AACjD,QAAI,cAAc,KAAK,cAAc;AACnC,aAAO;AAAA,IACT;AACA,QAAI,YAAY,WAAW,GAAG;AAC5B,WAAK,MAAM;AACX,aAAO;AAAA,IACT;AACA,QAAI,KAAK,QAAQ,GAAG;AAClB,oBAAc,YAAY,MAAM,GAAG,KAAK,KAAK;AAAA,IAC/C;AAEA,SAAK,YAAY,eAAe,WAAW;AAC3C,SAAK,KAAK;AACV,SAAK,WAAW,QAAQ,SAAS,UAAU,CAAC;AAC5C,QAAI,KAAK,UAAU;AACjB,WAAK,eAAe,KAAK,QAAQ;AAAA,IACnC;AACA,SAAK,6BAA6B;AAClC,WAAO;AAAA,EACT;AAAA,EAEQ,kCAAwC;AAC9C,SAAK,4BAA4B,oBAAoB,eAAe,KAAK,2BAA2B,EAAE,SAAS,KAAK,CAAC;AACrH,SAAK,6BAA6B;AAAA,EACpC;AACF;AAEA,SAAS,UAAU,QAA8D;AAC/E,SAAO,2BAA2B;AACpC;","names":[]}

package/dist/lib/esm/backlink-index.d.mts

@@ -40,6 +40,10 @@
  */
 import type { CustomArrayDict } from '@obsidian-typings/obsidian-public-latest';
 import type { App, Reference, TFile } from 'obsidian';
+/**
+ * The callback Obsidian's `metadataCache.iterateAllRefs` takes.
+ */
+export type IterateReferencesCallback = Parameters<App['metadataCache']['iterateAllRefs']>[0];
 /**
  * The same answer as `app.metadataCache.getBacklinksForFile(file)` (Obsidian's own, unpatched), from the candidate
  * notes only. See the file header for why the answer is exact.
@@ -49,3 +53,22 @@ import type { App, Reference, TFile } from 'obsidian';
  * @returns The references that resolve to `file`, keyed by the path of the note or canvas holding them.
  */
 export declare function getIndexedBacklinksForFile(app: App, file: TFile): CustomArrayDict<Reference>;
+/**
+ * Visits the references `app.metadataCache.iterateAllRefs` would visit, minus every reference whose resolution
+ * cannot change when `file` is renamed to `newPath`.
+ *
+ * Obsidian's `FileManager.runAsyncLinkUpdate` resolves EVERY reference in the vault before each rename, to diff
+ * the resolutions afterwards in `updateAllLinks`; that is the whole cost of a rename in a large vault. A reference
+ * can resolve to `file` only if its linkpath's last segment matches `file`'s name before the rename or its name
+ * after it (see the file header), and a reference that resolves to neither keeps resolving to whatever it did. So
+ * the references that can change are those of the index's candidates for both names, plus the references held by
+ * `file` itself, whose relative links resolve from its new folder afterwards. `linkUpdaters` references are walked
+ * in full, as in {@link getIndexedBacklinksForFile}.
+ *
+ * @param app - The Obsidian app instance.
+ * @param file - The file being renamed, still at its old path.
+ * @param newPath - The path it is being renamed to.
+ * @param callback - Called with each reference and the path of the note holding it. Returning `true` stops the
+ *   walk over that note's references, as in Obsidian's own walk.
+ */
+export declare function iterateReferencesAffectedByRename(app: App, file: TFile, newPath: string, callback: IterateReferencesCallback): void;

package/dist/lib/esm/backlink-index.mjs

@@ -60,6 +60,27 @@ function getIndexedBacklinksForFile(app, file) {
     }
   }
 }
+function iterateReferencesAffectedByRename(app, file, newPath, callback) {
+  const data = getBacklinkIndexData();
+  refresh(app, data);
+  const newName = newPath.slice(newPath.lastIndexOf("/") + 1);
+  const candidateSourcePaths = /* @__PURE__ */ new Set([file.path]);
+  for (const nameKey of [...getTargetNameKeys(file.name), ...getTargetNameKeys(newName)]) {
+    for (const sourcePath of data.nameKeySourcePaths.get(nameKey) ?? []) {
+      candidateSourcePaths.add(sourcePath);
+    }
+  }
+  for (const sourcePath of candidateSourcePaths) {
+    for (const reference of getCacheReferences(getCachedMetadata(app, sourcePath))) {
+      if (callback(sourcePath, reference) === true) {
+        break;
+      }
+    }
+  }
+  for (const linkUpdater of Object.values(app.metadataCache.linkUpdaters)) {
+    linkUpdater?.iterateReferences(callback);
+  }
+}
 function getBacklinkIndexData() {
   return getObsidianLibState("backlinkIndexV1", {
     indexedHashes: /* @__PURE__ */ new Map(),
@@ -109,16 +130,29 @@ function indexSource(app, data, sourcePath, hash) {
 }
 function refresh(app, data) {
   const fileCache = app.metadataCache.fileCache;
+  const indexedCountBefore = data.indexedHashes.size;
+  let seenIndexedCount = 0;
+  for (const sourcePath in fileCache) {
+    const entry = Object.hasOwn(fileCache, sourcePath) ? fileCache[sourcePath] : void 0;
+    if (!entry) {
+      continue;
+    }
+    const indexedHash = data.indexedHashes.get(sourcePath);
+    if (indexedHash !== void 0) {
+      seenIndexedCount++;
+    }
+    if (indexedHash !== entry.hash) {
+      indexSource(app, data, sourcePath, entry.hash);
+    }
+  }
+  if (seenIndexedCount === indexedCountBefore) {
+    return;
+  }
   for (const sourcePath of data.sourcePathNameKeys.keys()) {
     if (!Object.hasOwn(fileCache, sourcePath)) {
       removeSource(data, sourcePath);
     }
   }
-  for (const [sourcePath, { hash }] of Object.entries(fileCache)) {
-    if (data.indexedHashes.get(sourcePath) !== hash) {
-      indexSource(app, data, sourcePath, hash);
-    }
-  }
 }
 function removeSource(data, sourcePath) {
   for (const nameKey of data.sourcePathNameKeys.get(sourcePath) ?? []) {
@@ -132,6 +166,7 @@ function removeSource(data, sourcePath) {
   data.indexedHashes.delete(sourcePath);
 }
 export {
-  getIndexedBacklinksForFile
+  getIndexedBacklinksForFile,
+  iterateReferencesAffectedByRename
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/backlink-index.ts"],"sourcesContent":["/**\n * @file\n *\n * Answers \"which references resolve to this file?\" by looking only at the notes that COULD hold one, instead of\n * resolving every reference in the vault.\n *\n * Obsidian's `metadataCache.getBacklinksForFile(file)` is not an index lookup. Read out of the 1.14.2 bundle, it is\n * `iterateAllRefs` — every `frontmatterLinks`, `links` and `embeds` entry of every cached note, plus every\n * reference each `linkUpdaters` entry (the canvas one) reports — with one `getFirstLinkpathDest` per reference,\n * keeping those that resolve to `file`. That is ~115 ms at 100k references and ~320 ms at 250k, paid once per file\n * by every per-file backlink lookup, so a 1000-note folder rename in a 50k-note vault took 924 s.\n *\n * What makes a narrower answer exact is a property of Obsidian's `getLinkpathDest`: every branch of it can only\n * return a file whose lowercased name is the lowercased last `/` segment of the linkpath, or that segment plus\n * `.md`. The one exception is the empty linkpath (`[[#Heading]]`), which returns the source note itself. So a\n * note can hold a reference to `file` only if it holds a reference whose last segment matches one of `file`'s\n * name keys, or if it IS `file`. This module indexes notes by those segments, takes the candidates for `file`,\n * and runs Obsidian's own predicate — `getFirstLinkpathDest(linkpath, source) === file` — over the candidates'\n * references only. The candidates are a superset of the real backlinks and the predicate is the same one, so\n * the answer is the one the full walk gives, a file registered at a non-existing path included. Only the ORDER\n * of the notes in the answer differs: the file itself first, then the candidates in index order.\n *\n * The index is kept fresh without listening to anything. `metadataCache.fileCache` maps a note to the hash of\n * its content, and the references are a function of that hash, so each query compares every note's hash\n * against the one it was indexed at and re-reads only the notes that changed. That is one property comparison\n * per note and no resolution at all, the same order as the scan Obsidian itself runs on every rename\n * (`updateRelatedLinks`). Depending on no event also means depending on no event ORDER, which matters because\n * rename handlers query from inside the vault `rename` event.\n *\n * There is one index per renderer realm, held in the realm-global shared-state bag, so every plugin bundling this library\n * shares it rather than each building its own. What is stored there is plain data read structurally (maps and\n * sets, never a class instance), because the bag crosses copies of this library at different versions. The key\n * carries a version: a change to what a key MEANS (how a name key is derived) must move to a new key, so an older\n * copy never reads an index built by different rules.\n *\n * The `linkUpdaters` side is still walked in full on every query. In 1.14.2 the only updater is the canvas\n * one, whose references live in the canvas index rather than in `fileCache`, so there is no hash to key them\n * by; a vault's canvases hold a small fraction of its references.\n */\n\nimport type { CustomArrayDict } from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  CachedMetadata,\n  Reference,\n  TFile\n} from 'obsidian';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { CustomArrayDictImpl } from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\ninterface BacklinkIndexData {\n  readonly indexedHashes: Map<string, string>;\n  readonly nameKeySourcePaths: Map<string, Set<string>>;\n  readonly sourcePathNameKeys: Map<string, Set<string>>;\n}\n\nconst MARKDOWN_SUFFIX = '.md';\n\n/**\n * The same answer as `app.metadataCache.getBacklinksForFile(file)` (Obsidian's own, unpatched), from the candidate\n * notes only. See the file header for why the answer is exact.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file whose backlinks to find. It may be a non-existing file registered for the query.\n * @returns The references that resolve to `file`, keyed by the path of the note or canvas holding them.\n */\nexport function getIndexedBacklinksForFile(app: App, file: TFile): CustomArrayDict<Reference> {\n  const data = getBacklinkIndexData();\n  refresh(app, data);\n\n  const metadataCache = app.metadataCache;\n  const backlinks = new CustomArrayDictImpl<Reference>();\n\n  // The file itself is a candidate for its own `[[#Heading]]` references, whose empty linkpath names no segment.\n  const candidateSourcePaths = new Set<string>([file.path]);\n  for (const nameKey of getTargetNameKeys(file.name)) {\n    for (const sourcePath of data.nameKeySourcePaths.get(nameKey) ?? []) {\n      candidateSourcePaths.add(sourcePath);\n    }\n  }\n\n  for (const sourcePath of candidateSourcePaths) {\n    for (const reference of getCacheReferences(getCachedMetadata(app, sourcePath))) {\n      collect(sourcePath, reference);\n    }\n  }\n\n  for (const linkUpdater of Object.values(metadataCache.linkUpdaters)) {\n    linkUpdater?.iterateReferences(collect);\n  }\n\n  return backlinks;\n\n  function collect(sourcePath: string, reference: Reference): void {\n    if (metadataCache.getFirstLinkpathDest(getLinkpath(reference.link), sourcePath) === file) {\n      backlinks.add(sourcePath, reference);\n    }\n  }\n}\n\nfunction getBacklinkIndexData(): BacklinkIndexData {\n  return getObsidianLibState<BacklinkIndexData>('backlinkIndexV1', {\n    indexedHashes: new Map<string, string>(),\n    nameKeySourcePaths: new Map<string, Set<string>>(),\n    sourcePathNameKeys: new Map<string, Set<string>>()\n  }).value;\n}\nfunction getCachedMetadata(app: App, sourcePath: string): CachedMetadata | undefined {\n  const hash = app.metadataCache.fileCache[sourcePath]?.hash;\n  return hash === undefined ? undefined : app.metadataCache.metadataCache[hash];\n}\n\n/**\n * Lists a cached note's references in the order Obsidian's own walk visits them: `frontmatterLinks`, then\n * `links`, then `embeds`.\n *\n * @param cache - The note's cached metadata.\n * @returns The note's references.\n */\nfunction getCacheReferences(cache: CachedMetadata | undefined): Reference[] {\n  return cache ? [...cache.frontmatterLinks ?? [], ...cache.links ?? [], ...cache.embeds ?? []] : [];\n}\n\n/**\n * Strips the subpath from a link, the way Obsidian's `getLinkpath` does.\n *\n * @param link - The link text, such as `folder/Note#Heading`.\n * @returns The linkpath, such as `folder/Note`.\n */\nfunction getLinkpath(link: string): string {\n  const hashIndex = link.indexOf('#');\n  return hashIndex === -1 ? link : link.slice(0, hashIndex);\n}\n\n/**\n * The key a reference is indexed under: the lowercased last `/` segment of its linkpath.\n *\n * @param link - The reference's link text.\n * @returns The key.\n */\nfunction getReferenceNameKey(link: string): string {\n  const linkpath = getLinkpath(link).toLowerCase();\n  return linkpath.slice(linkpath.lastIndexOf('/') + 1);\n}\n\n/**\n * The keys under which a reference to a file with this name can be indexed. `getLinkpathDest` matches a\n * segment against the file's name, and against the name with `.md` appended, so a note named `Note.md` is\n * reachable from both `note.md` and `note`.\n *\n * @param fileName - The file's name, extension included.\n * @returns The keys.\n */\nfunction getTargetNameKeys(fileName: string): string[] {\n  const nameKey = fileName.toLowerCase();\n  return nameKey.endsWith(MARKDOWN_SUFFIX) ? [nameKey, nameKey.slice(0, -MARKDOWN_SUFFIX.length)] : [nameKey];\n}\n\nfunction indexSource(app: App, data: BacklinkIndexData, sourcePath: string, hash: string): void {\n  removeSource(data, sourcePath);\n  const cache = app.metadataCache.metadataCache[hash];\n  /*\n   * A note's `fileCache` entry can carry its new hash before the metadata for that hash is stored. Recording\n   * the hash then would pin the note at \"no references\" until its content changed again, so leave it\n   * unrecorded and let the next query look again.\n   */\n  if (!cache) {\n    return;\n  }\n\n  const nameKeys = new Set<string>();\n  for (const reference of getCacheReferences(cache)) {\n    nameKeys.add(getReferenceNameKey(reference.link));\n  }\n  for (const nameKey of nameKeys) {\n    let sourcePaths = data.nameKeySourcePaths.get(nameKey);\n    if (!sourcePaths) {\n      sourcePaths = new Set<string>();\n      data.nameKeySourcePaths.set(nameKey, sourcePaths);\n    }\n    sourcePaths.add(sourcePath);\n  }\n  data.sourcePathNameKeys.set(sourcePath, nameKeys);\n  data.indexedHashes.set(sourcePath, hash);\n}\n\nfunction refresh(app: App, data: BacklinkIndexData): void {\n  const fileCache = app.metadataCache.fileCache;\n\n  for (const sourcePath of data.sourcePathNameKeys.keys()) {\n    if (!Object.hasOwn(fileCache, sourcePath)) {\n      removeSource(data, sourcePath);\n    }\n  }\n\n  for (const [sourcePath, { hash }] of Object.entries(fileCache)) {\n    if (data.indexedHashes.get(sourcePath) !== hash) {\n      indexSource(app, data, sourcePath, hash);\n    }\n  }\n}\n\nfunction removeSource(data: BacklinkIndexData, sourcePath: string): void {\n  for (const nameKey of data.sourcePathNameKeys.get(sourcePath) ?? []) {\n    const sourcePaths = ensureNonNullable(data.nameKeySourcePaths.get(nameKey));\n    sourcePaths.delete(sourcePath);\n    if (sourcePaths.size === 0) {\n      data.nameKeySourcePaths.delete(nameKey);\n    }\n  }\n  data.sourcePathNameKeys.delete(sourcePath);\n  data.indexedHashes.delete(sourcePath);\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/backlink-index.ts"],"sourcesContent":["/**\n * @file\n *\n * Answers \"which references resolve to this file?\" by looking only at the notes that COULD hold one, instead of\n * resolving every reference in the vault.\n *\n * Obsidian's `metadataCache.getBacklinksForFile(file)` is not an index lookup. Read out of the 1.14.2 bundle, it is\n * `iterateAllRefs` — every `frontmatterLinks`, `links` and `embeds` entry of every cached note, plus every\n * reference each `linkUpdaters` entry (the canvas one) reports — with one `getFirstLinkpathDest` per reference,\n * keeping those that resolve to `file`. That is ~115 ms at 100k references and ~320 ms at 250k, paid once per file\n * by every per-file backlink lookup, so a 1000-note folder rename in a 50k-note vault took 924 s.\n *\n * What makes a narrower answer exact is a property of Obsidian's `getLinkpathDest`: every branch of it can only\n * return a file whose lowercased name is the lowercased last `/` segment of the linkpath, or that segment plus\n * `.md`. The one exception is the empty linkpath (`[[#Heading]]`), which returns the source note itself. So a\n * note can hold a reference to `file` only if it holds a reference whose last segment matches one of `file`'s\n * name keys, or if it IS `file`. This module indexes notes by those segments, takes the candidates for `file`,\n * and runs Obsidian's own predicate — `getFirstLinkpathDest(linkpath, source) === file` — over the candidates'\n * references only. The candidates are a superset of the real backlinks and the predicate is the same one, so\n * the answer is the one the full walk gives, a file registered at a non-existing path included. Only the ORDER\n * of the notes in the answer differs: the file itself first, then the candidates in index order.\n *\n * The index is kept fresh without listening to anything. `metadataCache.fileCache` maps a note to the hash of\n * its content, and the references are a function of that hash, so each query compares every note's hash\n * against the one it was indexed at and re-reads only the notes that changed. That is one property comparison\n * per note and no resolution at all, the same order as the scan Obsidian itself runs on every rename\n * (`updateRelatedLinks`). Depending on no event also means depending on no event ORDER, which matters because\n * rename handlers query from inside the vault `rename` event.\n *\n * There is one index per renderer realm, held in the realm-global shared-state bag, so every plugin bundling this library\n * shares it rather than each building its own. What is stored there is plain data read structurally (maps and\n * sets, never a class instance), because the bag crosses copies of this library at different versions. The key\n * carries a version: a change to what a key MEANS (how a name key is derived) must move to a new key, so an older\n * copy never reads an index built by different rules.\n *\n * The `linkUpdaters` side is still walked in full on every query. In 1.14.2 the only updater is the canvas\n * one, whose references live in the canvas index rather than in `fileCache`, so there is no hash to key them\n * by; a vault's canvases hold a small fraction of its references.\n */\n\nimport type { CustomArrayDict } from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  CachedMetadata,\n  Reference,\n  TFile\n} from 'obsidian';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { CustomArrayDictImpl } from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\n/**\n * The callback Obsidian's `metadataCache.iterateAllRefs` takes.\n */\nexport type IterateReferencesCallback = Parameters<App['metadataCache']['iterateAllRefs']>[0];\n\ninterface BacklinkIndexData {\n  readonly indexedHashes: Map<string, string>;\n  readonly nameKeySourcePaths: Map<string, Set<string>>;\n  readonly sourcePathNameKeys: Map<string, Set<string>>;\n}\n\nconst MARKDOWN_SUFFIX = '.md';\n\n/**\n * The same answer as `app.metadataCache.getBacklinksForFile(file)` (Obsidian's own, unpatched), from the candidate\n * notes only. See the file header for why the answer is exact.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file whose backlinks to find. It may be a non-existing file registered for the query.\n * @returns The references that resolve to `file`, keyed by the path of the note or canvas holding them.\n */\nexport function getIndexedBacklinksForFile(app: App, file: TFile): CustomArrayDict<Reference> {\n  const data = getBacklinkIndexData();\n  refresh(app, data);\n\n  const metadataCache = app.metadataCache;\n  const backlinks = new CustomArrayDictImpl<Reference>();\n\n  // The file itself is a candidate for its own `[[#Heading]]` references, whose empty linkpath names no segment.\n  const candidateSourcePaths = new Set<string>([file.path]);\n  for (const nameKey of getTargetNameKeys(file.name)) {\n    for (const sourcePath of data.nameKeySourcePaths.get(nameKey) ?? []) {\n      candidateSourcePaths.add(sourcePath);\n    }\n  }\n\n  for (const sourcePath of candidateSourcePaths) {\n    for (const reference of getCacheReferences(getCachedMetadata(app, sourcePath))) {\n      collect(sourcePath, reference);\n    }\n  }\n\n  for (const linkUpdater of Object.values(metadataCache.linkUpdaters)) {\n    linkUpdater?.iterateReferences(collect);\n  }\n\n  return backlinks;\n\n  function collect(sourcePath: string, reference: Reference): void {\n    if (metadataCache.getFirstLinkpathDest(getLinkpath(reference.link), sourcePath) === file) {\n      backlinks.add(sourcePath, reference);\n    }\n  }\n}\n\n/**\n * Visits the references `app.metadataCache.iterateAllRefs` would visit, minus every reference whose resolution\n * cannot change when `file` is renamed to `newPath`.\n *\n * Obsidian's `FileManager.runAsyncLinkUpdate` resolves EVERY reference in the vault before each rename, to diff\n * the resolutions afterwards in `updateAllLinks`; that is the whole cost of a rename in a large vault. A reference\n * can resolve to `file` only if its linkpath's last segment matches `file`'s name before the rename or its name\n * after it (see the file header), and a reference that resolves to neither keeps resolving to whatever it did. So\n * the references that can change are those of the index's candidates for both names, plus the references held by\n * `file` itself, whose relative links resolve from its new folder afterwards. `linkUpdaters` references are walked\n * in full, as in {@link getIndexedBacklinksForFile}.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file being renamed, still at its old path.\n * @param newPath - The path it is being renamed to.\n * @param callback - Called with each reference and the path of the note holding it. Returning `true` stops the\n *   walk over that note's references, as in Obsidian's own walk.\n */\nexport function iterateReferencesAffectedByRename(\n  app: App,\n  file: TFile,\n  newPath: string,\n  callback: IterateReferencesCallback\n): void {\n  const data = getBacklinkIndexData();\n  refresh(app, data);\n\n  const newName = newPath.slice(newPath.lastIndexOf('/') + 1);\n  const candidateSourcePaths = new Set<string>([file.path]);\n  for (const nameKey of [...getTargetNameKeys(file.name), ...getTargetNameKeys(newName)]) {\n    for (const sourcePath of data.nameKeySourcePaths.get(nameKey) ?? []) {\n      candidateSourcePaths.add(sourcePath);\n    }\n  }\n\n  for (const sourcePath of candidateSourcePaths) {\n    for (const reference of getCacheReferences(getCachedMetadata(app, sourcePath))) {\n      if (callback(sourcePath, reference) === true) {\n        break;\n      }\n    }\n  }\n\n  for (const linkUpdater of Object.values(app.metadataCache.linkUpdaters)) {\n    linkUpdater?.iterateReferences(callback);\n  }\n}\n\nfunction getBacklinkIndexData(): BacklinkIndexData {\n  return getObsidianLibState<BacklinkIndexData>('backlinkIndexV1', {\n    indexedHashes: new Map<string, string>(),\n    nameKeySourcePaths: new Map<string, Set<string>>(),\n    sourcePathNameKeys: new Map<string, Set<string>>()\n  }).value;\n}\nfunction getCachedMetadata(app: App, sourcePath: string): CachedMetadata | undefined {\n  const hash = app.metadataCache.fileCache[sourcePath]?.hash;\n  return hash === undefined ? undefined : app.metadataCache.metadataCache[hash];\n}\n\n/**\n * Lists a cached note's references in the order Obsidian's own walk visits them: `frontmatterLinks`, then\n * `links`, then `embeds`.\n *\n * @param cache - The note's cached metadata.\n * @returns The note's references.\n */\nfunction getCacheReferences(cache: CachedMetadata | undefined): Reference[] {\n  return cache ? [...cache.frontmatterLinks ?? [], ...cache.links ?? [], ...cache.embeds ?? []] : [];\n}\n\n/**\n * Strips the subpath from a link, the way Obsidian's `getLinkpath` does.\n *\n * @param link - The link text, such as `folder/Note#Heading`.\n * @returns The linkpath, such as `folder/Note`.\n */\nfunction getLinkpath(link: string): string {\n  const hashIndex = link.indexOf('#');\n  return hashIndex === -1 ? link : link.slice(0, hashIndex);\n}\n\n/**\n * The key a reference is indexed under: the lowercased last `/` segment of its linkpath.\n *\n * @param link - The reference's link text.\n * @returns The key.\n */\nfunction getReferenceNameKey(link: string): string {\n  const linkpath = getLinkpath(link).toLowerCase();\n  return linkpath.slice(linkpath.lastIndexOf('/') + 1);\n}\n\n/**\n * The keys under which a reference to a file with this name can be indexed. `getLinkpathDest` matches a\n * segment against the file's name, and against the name with `.md` appended, so a note named `Note.md` is\n * reachable from both `note.md` and `note`.\n *\n * @param fileName - The file's name, extension included.\n * @returns The keys.\n */\nfunction getTargetNameKeys(fileName: string): string[] {\n  const nameKey = fileName.toLowerCase();\n  return nameKey.endsWith(MARKDOWN_SUFFIX) ? [nameKey, nameKey.slice(0, -MARKDOWN_SUFFIX.length)] : [nameKey];\n}\n\nfunction indexSource(app: App, data: BacklinkIndexData, sourcePath: string, hash: string): void {\n  removeSource(data, sourcePath);\n  const cache = app.metadataCache.metadataCache[hash];\n  /*\n   * A note's `fileCache` entry can carry its new hash before the metadata for that hash is stored. Recording\n   * the hash then would pin the note at \"no references\" until its content changed again, so leave it\n   * unrecorded and let the next query look again.\n   */\n  if (!cache) {\n    return;\n  }\n\n  const nameKeys = new Set<string>();\n  for (const reference of getCacheReferences(cache)) {\n    nameKeys.add(getReferenceNameKey(reference.link));\n  }\n  for (const nameKey of nameKeys) {\n    let sourcePaths = data.nameKeySourcePaths.get(nameKey);\n    if (!sourcePaths) {\n      sourcePaths = new Set<string>();\n      data.nameKeySourcePaths.set(nameKey, sourcePaths);\n    }\n    sourcePaths.add(sourcePath);\n  }\n  data.sourcePathNameKeys.set(sourcePath, nameKeys);\n  data.indexedHashes.set(sourcePath, hash);\n}\n\n/**\n * Brings the index in line with `metadataCache.fileCache`. It runs on every query, so it is one pass over\n * `fileCache` with no allocation per note (a rename in a large vault queries several times), and the pass over the\n * index that finds notes gone from `fileCache` runs only when that first pass did not see every indexed note.\n *\n * @param app - The Obsidian app instance.\n * @param data - The index.\n */\nfunction refresh(app: App, data: BacklinkIndexData): void {\n  const fileCache = app.metadataCache.fileCache;\n  const indexedCountBefore = data.indexedHashes.size;\n  let seenIndexedCount = 0;\n\n  // eslint-disable-next-line guard-for-in -- `Object.hasOwn` below is the guard; `for...in` avoids an entry array per note.\n  for (const sourcePath in fileCache) {\n    const entry = Object.hasOwn(fileCache, sourcePath) ? fileCache[sourcePath] : undefined;\n    if (!entry) {\n      continue;\n    }\n    const indexedHash = data.indexedHashes.get(sourcePath);\n    if (indexedHash !== undefined) {\n      seenIndexedCount++;\n    }\n    if (indexedHash !== entry.hash) {\n      indexSource(app, data, sourcePath, entry.hash);\n    }\n  }\n\n  if (seenIndexedCount === indexedCountBefore) {\n    return;\n  }\n\n  for (const sourcePath of data.sourcePathNameKeys.keys()) {\n    if (!Object.hasOwn(fileCache, sourcePath)) {\n      removeSource(data, sourcePath);\n    }\n  }\n}\n\nfunction removeSource(data: BacklinkIndexData, sourcePath: string): void {\n  for (const nameKey of data.sourcePathNameKeys.get(sourcePath) ?? []) {\n    const sourcePaths = ensureNonNullable(data.nameKeySourcePaths.get(nameKey));\n    sourcePaths.delete(sourcePath);\n    if (sourcePaths.size === 0) {\n      data.nameKeySourcePaths.delete(nameKey);\n    }\n  }\n  data.sourcePathNameKeys.delete(sourcePath);\n  data.indexedHashes.delete(sourcePath);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/bug-report.d.mts

@@ -45,7 +45,7 @@ export declare const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
  */
 export interface BugReportEnvironment {
     /**
-     * The other enabled plugins, sorted by id.
+     * The other loaded plugins, sorted by id.
      */
     readonly enabledPlugins: readonly BugReportPluginInfo[];
     /**

package/dist/lib/esm/bug-report.mjs

@@ -56,7 +56,9 @@ async function getBugReportEnvironment(params) {
   const { app, pluginId } = params;
   const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();
   return {
-    enabledPlugins: [...app.plugins.enabledPlugins].filter((id) => id !== pluginId).sort().map((id) => getPluginInfo(app, id)),
+    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id
+    // whose folder was deleted, or whose load failed.
+    enabledPlugins: Object.keys(app.plugins.plugins).filter((id) => id !== pluginId).sort().map((id) => getPluginInfo(app, id)),
     installerVersion,
     obsidianVersion: apiVersion,
     operatingSystem,
@@ -138,4 +140,4 @@ export {
   getBugReportIssueFormUrl,
   getGitHubIssueFormUrl
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other enabled plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    enabledPlugins: [...app.plugins.enabledPlugins]\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other loaded plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}

package/dist/lib/esm/bulk-operation-progress.d.mts

@@ -10,6 +10,11 @@
  * {@link loop} reports after every item it processes. Code that drives a bulk operation without `loop()` calls
  * {@link reportBulkOperationProgress} itself.
  *
+ * An operation waiting on the user (a confirmation, a picker) makes no progress, yet it is not hung. While such a
+ * dialog is open, {@link holdBulkOperationWhile} reports on an interval, scoped to that one promise: the timer
+ * stops the moment the dialog settles, so a hung operation outside a dialog still goes stale. Every modal helper of
+ * this library already holds through `showModal`.
+ *
  * The listener set lives in the shared-state bag under a versioned key, so a `loop()` bundled by one plugin's copy
  * of this library reaches a listener registered by another's. Its shape is a cross-copy wire format: a `Set` of
  * plain functions, read structurally.
@@ -18,6 +23,23 @@
  * A listener notified whenever a bulk operation makes progress.
  */
 export type BulkOperationProgressListener = () => void;
+/**
+ * How often {@link holdBulkOperationWhile} reports progress while its promise is pending, well inside the lock's
+ * staleness window.
+ */
+export declare const BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS = 10000;
+/**
+ * Keeps a bulk operation's lease lock fresh while it waits on something that is not progress but not a hang either,
+ * such as a dialog waiting for the user.
+ *
+ * Reports progress at once, then every {@link BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS} while the promise is
+ * pending, and once more when it settles. Outside a bulk operation it costs one interval and nothing else.
+ *
+ * @typeParam T - The type of the promise's value.
+ * @param promise - The promise to wait for.
+ * @returns The promise's value.
+ */
+export declare function holdBulkOperationWhile<T>(promise: Promise<T>): Promise<T>;
 /**
  * Subscribes to bulk-operation progress.
  *