obsidian-dev-utils 84.6.0 → 85.0.0

package/dist/lib/esm/obsidian/modals/minimizable-modal.mjs

@@ -21,13 +21,13 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import { around } from "monkey-around";
 import {
   Modal,
   setIcon
 } from "obsidian";
 import { Beeper } from "../../beeper.mjs";
-import { ensureNonNullable } from "../../type-guards.mjs";
+import { AllWindowsEventComponent } from "../components/all-windows-event-component.mjs";
+import { MonkeyAroundComponent } from "../components/monkey-around-component.mjs";
 import { CssClass } from "../css-class.mjs";
 import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
 const MINIMIZE_ICON_ID = "minus";
@@ -49,9 +49,55 @@ const MODIFIER_KEYS = /* @__PURE__ */ new Set([
   "Shift"
 ]);
 const peekLockEntries = /* @__PURE__ */ new Set();
-const documentsWithInputSuppressors = /* @__PURE__ */ new WeakSet();
 const beeper = new Beeper();
-let isModalOpenGuardInstalled = false;
+class PeekLockComponent extends MonkeyAroundComponent {
+  /**
+   * Constructs a new instance.
+   *
+   * @param app - The app whose settings modal is guarded and whose windows suppress input while locked.
+   */
+  constructor(app) {
+    super();
+    this.app = app;
+  }
+  app;
+  /**
+   * Registers the `open` patches and the input suppressors.
+   */
+  onload() {
+    super.onload();
+    this.registerMethodPatch({
+      methodName: "open",
+      obj: Modal.prototype,
+      patchHandler: ({ fallback, originalThis }) => {
+        blockOrFallback(originalThis, fallback);
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "open",
+      obj: this.app.setting,
+      patchHandler: ({ fallback, originalThis }) => {
+        blockOrFallback(originalThis, fallback);
+      }
+    });
+    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsDomEvent({
+      callback: suppressKeydownWhilePeekLocked,
+      options: { capture: true },
+      type: "keydown"
+    });
+    allWindowsEventComponent.registerAllWindowsDomEvent({
+      callback: suppressWhilePeekLocked,
+      options: { capture: true },
+      type: "beforeinput"
+    });
+    allWindowsEventComponent.registerAllWindowsDomEvent({
+      callback: suppressWhilePeekLocked,
+      options: { capture: true },
+      type: "contextmenu"
+    });
+  }
+}
 class MinimizableModal {
   /**
    * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).
@@ -65,9 +111,17 @@ class MinimizableModal {
   get isMinimized() {
     return this.isMinimizedValue;
   }
+  /**
+   * Patches the wrapped modal's `onClose` to run cleanup. Persists for the wrapper's whole life (a
+   * modal can be reopened, so the patch must survive each close), hence a dedicated component that is
+   * never unloaded — distinct from `peekLockComponent`, whose patches live only while minimized.
+   * Exposed to subclasses so they can register additional lifetime-scoped patches on the wrapper.
+   */
+  closePatchComponent = new MonkeyAroundComponent();
   isMinimizedValue = false;
   minimizeButtonEl;
   minimizedBarEl = null;
+  peekLockComponent = null;
   peekLockEntry = null;
   /**
    * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
@@ -78,6 +132,7 @@ class MinimizableModal {
     this.modal = modal;
     addPluginCssClasses(modal.containerEl, [CssClass.MinimizableModal]);
     this.minimizeButtonEl = this.createMinimizeButton();
+    this.closePatchComponent.load();
     this.patchOnClose(modal);
   }
   /**
@@ -141,6 +196,8 @@ class MinimizableModal {
     }
     peekLockEntries.delete(this.peekLockEntry);
     this.peekLockEntry = null;
+    this.peekLockComponent?.unload();
+    this.peekLockComponent = null;
   }
   enablePeekLock(barEl) {
     this.peekLockEntry = {
@@ -151,8 +208,8 @@ class MinimizableModal {
       innerModal: this.modal
     };
     peekLockEntries.add(this.peekLockEntry);
-    installModalOpenGuardOnce();
-    installInputSuppressorsOnce(this.modal.containerEl.ownerDocument);
+    this.peekLockComponent = new PeekLockComponent(this.modal.app);
+    this.peekLockComponent.load();
   }
   flashBar(barEl) {
     barEl.removeClass(CssClass.MinimizedModalBarAttention);
@@ -165,12 +222,12 @@ class MinimizableModal {
     this.isMinimizedValue = false;
   }
   patchOnClose(modal) {
-    around(modal, {
-      onClose: (next) => {
-        return () => {
-          next.call(modal);
-          this.handleClose();
-        };
+    this.closePatchComponent.registerMethodPatch({
+      methodName: "onClose",
+      obj: modal,
+      patchHandler: ({ fallback }) => {
+        fallback();
+        this.handleClose();
       }
     });
   }
@@ -184,37 +241,17 @@ function blockEvent(evt) {
   evt.stopImmediatePropagation();
   signalBlockedAttempt();
 }
-function flashMinimizedBars() {
-  for (const entry of peekLockEntries) {
-    entry.flash();
-  }
-}
-function installInputSuppressorsOnce(doc) {
-  if (documentsWithInputSuppressors.has(doc)) {
+function blockOrFallback(modal, fallback) {
+  if (shouldBlockOpen(modal)) {
+    signalBlockedAttempt();
     return;
   }
-  documentsWithInputSuppressors.add(doc);
-  const win = ensureNonNullable(doc.defaultView);
-  win.addEventListener("keydown", suppressKeydownWhilePeekLocked, { capture: true });
-  win.addEventListener("beforeinput", suppressWhilePeekLocked, { capture: true });
-  win.addEventListener("contextmenu", suppressWhilePeekLocked, { capture: true });
+  fallback();
 }
-function installModalOpenGuardOnce() {
-  if (isModalOpenGuardInstalled) {
-    return;
+function flashMinimizedBars() {
+  for (const entry of peekLockEntries) {
+    entry.flash();
   }
-  isModalOpenGuardInstalled = true;
-  around(Modal.prototype, {
-    open: (next) => {
-      return function open() {
-        if (isPeekLocked() && !isMinimizedInnerModal(this)) {
-          signalBlockedAttempt();
-          return;
-        }
-        next.call(this);
-      };
-    }
-  });
 }
 function isMinimizedInnerModal(modal) {
   for (const entry of peekLockEntries) {
@@ -238,6 +275,9 @@ function isPeekLocked() {
   }
   return peekLockEntries.size > 0;
 }
+function shouldBlockOpen(modal) {
+  return isPeekLocked() && !isMinimizedInnerModal(modal);
+}
 function signalBlockedAttempt() {
   flashMinimizedBars();
   beeper.beep();
@@ -257,4 +297,4 @@ function suppressWhilePeekLocked(evt) {
 export {
   MinimizableModal
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/minimizable-modal.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A wrapper that makes any Obsidian {@link Modal} minimizable to a floating bar \u2014 without breaking the\n * modal's blocking contract.\n *\n * Obsidian's {@link Modal} is blocking: while it is open the rest of the app is meant to be inert until\n * the modal is dismissed. {@link MinimizableModal} wraps any modal instance (plain `Modal`,\n * `FuzzySuggestModal`, the library's `ModalBase`, your own subclass, \u2026 \u2014 including modals you do not\n * own) and adds a minimize button. Minimizing hides the modal and its blocking backdrop and shows a\n * small floating bar with a restore button, so the user can peek at the notes/folders the operation\n * involves \u2014 but the modal is NOT dismissed, so its blocking contract must be preserved.\n *\n * To keep that contract while minimized, the wrapper puts the app into a **peek-only lock**: the user\n * may mouse-click and scroll to inspect content, but cannot start anything new. While any modal is\n * minimized the wrapper:\n * - blocks the keyboard (typing, hotkeys, the command-palette shortcut),\n * - blocks the right-click context menu, and\n * - blocks opening any other modal (a re-fired command, the command palette, settings, \u2026).\n *\n * A blocked attempt flashes the floating bar and beeps so the user sees (and hears) why nothing\n * happened. Restoring (or the modal closing) lifts the lock. This prevents, for example, minimizing a\n * \"merge folder\" picker and then firing the same command again to stack several concurrent merges.\n *\n * The wrapper reuses the modal's own title (`titleEl`) as the minimized bar label, so set the title\n * the usual way (`modal.setTitle(...)`). Render arbitrary content into {@link Modal.contentEl},\n * including clickable note links produced by `renderInternalLink` from\n * `obsidian-dev-utils/obsidian/markdown`:\n *\n * ```ts\n * const modal = new MyModal(app);\n * modal.setTitle('Merging notes');\n * modal.contentEl.appendChild(await renderInternalLink({ app, pathOrAbstractFile: file }));\n *\n * const minimizable = new MinimizableModal(modal);\n * minimizable.modal.open();\n * minimizable.minimize(); // a floating bar offers \"restore\"; the app is peek-only until restored\n * ```\n *\n * The wrapped modal can still be closed normally; the floating bar is cleaned up automatically when\n * the modal closes (even if it is closed while minimized).\n */\n\nimport { around } from 'monkey-around';\nimport {\n  Modal,\n  setIcon\n} from 'obsidian';\n\nimport { Beeper } from '../../beeper.ts';\nimport { ensureNonNullable } from '../../type-guards.ts';\nimport { CssClass } from '../css-class.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\n\nconst MINIMIZE_ICON_ID = 'minus';\nconst RESTORE_ICON_ID = 'maximize-2';\n\n// Navigation keys pass through while minimized so the user can move the cursor and scroll to read.\n// None of them mutate the document \u2014 text changes are caught separately by the `beforeinput` guard.\n// Shift+navigation is blocked, though, since it extends the selection that inspection does not need.\nconst NAVIGATION_KEYS = new Set<string>([\n  'ArrowDown',\n  'ArrowLeft',\n  'ArrowRight',\n  'ArrowUp',\n  'End',\n  'Home',\n  'PageDown',\n  'PageUp'\n]);\n\n// A bare modifier press does nothing on its own, so it passes through the lock.\n// This avoids a spurious flash/beep while composing a shortcut; the shortcut's command key is blocked.\nconst MODIFIER_KEYS = new Set<string>([\n  'Alt',\n  'Control',\n  'Meta',\n  'Shift'\n]);\n\n/**\n * A registered entry for a currently-minimized modal. The shared peek-only lock uses it to know a\n * modal is minimized, to leave that modal's own re-opens alone, and to flash its bar on a blocked\n * attempt.\n */\ninterface PeekLockEntry {\n  /**\n   * The floating bar element. Used to detect a stale entry (its bar has left the DOM) so it can be\n   * pruned and never keep the app locked.\n   */\n  readonly barEl: HTMLElement;\n\n  /**\n   * Flashes the floating bar to signal a blocked attempt.\n   */\n  flash(): void;\n\n  /**\n   * The wrapped modal instance, so its own `open()` is never blocked by the lock.\n   */\n  readonly innerModal: Modal;\n}\n\nconst peekLockEntries = new Set<PeekLockEntry>();\nconst documentsWithInputSuppressors = new WeakSet<Document>();\nconst beeper = new Beeper();\nlet isModalOpenGuardInstalled = false;\n\n/**\n * Wraps a {@link Modal} instance to make it minimizable to a small floating bar and restorable. While\n * minimized the app is put into a peek-only lock (keyboard, context menu, and opening other modals are\n * blocked) so the modal's blocking contract is preserved.\n *\n * @typeParam TModal - The type of the wrapped modal.\n */\nexport class MinimizableModal<TModal extends Modal> {\n  /**\n   * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).\n   */\n  public readonly modal: TModal;\n\n  /**\n   * Whether the modal is currently minimized.\n   *\n   * @returns `true` if the modal is currently minimized, `false` otherwise.\n   */\n  public get isMinimized(): boolean {\n    return this.isMinimizedValue;\n  }\n\n  private isMinimizedValue = false;\n  private readonly minimizeButtonEl: HTMLElement;\n  private minimizedBarEl: HTMLElement | null = null;\n  private peekLockEntry: null | PeekLockEntry = null;\n\n  /**\n   * Wraps the given modal, adding a minimize button and wiring up cleanup on close.\n   *\n   * @param modal - The modal instance to make minimizable.\n   */\n  public constructor(modal: TModal) {\n    this.modal = modal;\n    addPluginCssClasses(modal.containerEl, [CssClass.MinimizableModal]);\n    this.minimizeButtonEl = this.createMinimizeButton();\n    this.patchOnClose(modal);\n  }\n\n  /**\n   * Minimizes the modal: hides the modal and its backdrop, shows a floating bar with a restore button,\n   * and puts the app into the peek-only lock. A no-op if the modal is already minimized.\n   */\n  public minimize(): void {\n    if (this.isMinimizedValue) {\n      return;\n    }\n\n    this.isMinimizedValue = true;\n    this.minimizeButtonEl.hide();\n    this.modal.containerEl.hide();\n    // The modal stays open while minimized, so its keymap scope is popped to release the focus trap.\n    // Restoring re-pushes it. An active trap would steal focus back to the hidden modal, blocking the\n    // Mouse-driven inspection (clicking notes, scrolling) that minimize exists to allow.\n    // Keyboard input remains blocked by the peek-only lock, so releasing the trap keeps the app inert.\n    this.modal.app.keymap.popScope(this.modal.scope);\n    this.minimizedBarEl = this.createMinimizedBar();\n    this.enablePeekLock(this.minimizedBarEl);\n  }\n\n  /**\n   * Restores the modal from the minimized state, removing the floating bar and lifting the peek-only\n   * lock. A no-op if the modal is not minimized.\n   */\n  public restore(): void {\n    if (!this.isMinimizedValue) {\n      return;\n    }\n\n    this.isMinimizedValue = false;\n    this.disablePeekLock();\n    this.removeMinimizedBar();\n    // Re-push the scope popped in minimize() so the restored modal blocks the app again (focus trap\n    // + Escape capture).\n    this.modal.app.keymap.pushScope(this.modal.scope);\n    this.modal.containerEl.show();\n    this.minimizeButtonEl.show();\n  }\n\n  private createMinimizeButton(): HTMLElement {\n    const buttonEl = this.modal.modalEl.createEl('button', { cls: CssClass.MinimizeButton });\n    setIcon(buttonEl, MINIMIZE_ICON_ID);\n    buttonEl.addEventListener('click', () => {\n      this.minimize();\n    });\n    return buttonEl;\n  }\n\n  private createMinimizedBar(): HTMLElement {\n    const barEl = this.modal.containerEl.ownerDocument.body.createDiv();\n    addPluginCssClasses(barEl, [CssClass.MinimizedModalBar]);\n    barEl.createSpan({\n      cls: CssClass.MinimizedModalBarTitle,\n      text: this.modal.titleEl.textContent\n    });\n    const restoreButtonEl = barEl.createEl('button', { cls: CssClass.RestoreButton });\n    setIcon(restoreButtonEl, RESTORE_ICON_ID);\n    // The whole bar restores on click, not just the restore button \u2014 a larger, easier click target.\n    // `restore()` guards against a double invocation, so the restore button's own click bubbling up\n    // Here is a no-op. The restore button stays purely as a visual affordance for the click target.\n    barEl.addEventListener('click', () => {\n      this.restore();\n    });\n    // Drop the one-shot attention flash once it finishes so the bar returns to its gentle idle pulse.\n    // The idle pulse is an infinite animation, which never fires `animationend`.\n    barEl.addEventListener('animationend', () => {\n      barEl.removeClass(CssClass.MinimizedModalBarAttention);\n    });\n    return barEl;\n  }\n\n  private disablePeekLock(): void {\n    if (!this.peekLockEntry) {\n      return;\n    }\n\n    peekLockEntries.delete(this.peekLockEntry);\n    this.peekLockEntry = null;\n  }\n\n  private enablePeekLock(barEl: HTMLElement): void {\n    this.peekLockEntry = {\n      barEl,\n      flash: (): void => {\n        this.flashBar(barEl);\n      },\n      innerModal: this.modal\n    };\n    peekLockEntries.add(this.peekLockEntry);\n    installModalOpenGuardOnce();\n    installInputSuppressorsOnce(this.modal.containerEl.ownerDocument);\n  }\n\n  private flashBar(barEl: HTMLElement): void {\n    barEl.removeClass(CssClass.MinimizedModalBarAttention);\n    // Force a reflow so re-adding the class restarts the one-shot flash on rapid repeated blocks.\n    barEl.getBoundingClientRect();\n    barEl.addClass(CssClass.MinimizedModalBarAttention);\n  }\n\n  private handleClose(): void {\n    this.disablePeekLock();\n    this.removeMinimizedBar();\n    this.isMinimizedValue = false;\n  }\n\n  private patchOnClose(modal: Modal): void {\n    around(modal, {\n      onClose: (next: () => void): () => void => {\n        return (): void => {\n          next.call(modal);\n          this.handleClose();\n        };\n      }\n    });\n  }\n\n  private removeMinimizedBar(): void {\n    this.minimizedBarEl?.remove();\n    this.minimizedBarEl = null;\n  }\n}\n\nfunction blockEvent(evt: Event): void {\n  evt.preventDefault();\n  evt.stopImmediatePropagation();\n  signalBlockedAttempt();\n}\n\nfunction flashMinimizedBars(): void {\n  for (const entry of peekLockEntries) {\n    entry.flash();\n  }\n}\n\nfunction installInputSuppressorsOnce(doc: Document): void {\n  if (documentsWithInputSuppressors.has(doc)) {\n    return;\n  }\n\n  documentsWithInputSuppressors.add(doc);\n  const win = ensureNonNullable(doc.defaultView);\n  // Capture-phase window listeners run before Obsidian's own document/element handlers (including\n  // CodeMirror's). `stopImmediatePropagation()` then prevents those handlers from ever seeing a\n  // Blocked event. The listeners are permanent but inert whenever nothing is minimized.\n  // `keydown` lets navigation keys through (see isPeekAllowedKey) but blocks command hotkeys;\n  // `beforeinput` blocks all editor mutation; `contextmenu` blocks the right-click menu.\n  win.addEventListener('keydown', suppressKeydownWhilePeekLocked, { capture: true });\n  win.addEventListener('beforeinput', suppressWhilePeekLocked, { capture: true });\n  win.addEventListener('contextmenu', suppressWhilePeekLocked, { capture: true });\n}\n\nfunction installModalOpenGuardOnce(): void {\n  if (isModalOpenGuardInstalled) {\n    return;\n  }\n\n  isModalOpenGuardInstalled = true;\n  // Never uninstalled: the guard is inert whenever nothing is minimized (`isPeekLocked()` is false).\n  // One permanent patch is cheaper and leak-free versus installing and uninstalling it per minimize.\n  around(Modal.prototype, {\n    open: (next: () => void): (this: Modal) => void => {\n      return function open(this: Modal): void {\n        if (isPeekLocked() && !isMinimizedInnerModal(this)) {\n          signalBlockedAttempt();\n          return;\n        }\n\n        next.call(this);\n      };\n    }\n  });\n}\n\nfunction isMinimizedInnerModal(modal: Modal): boolean {\n  for (const entry of peekLockEntries) {\n    if (entry.innerModal === modal) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction isPeekAllowedKey(evt: KeyboardEvent): boolean {\n  // Navigation moves the cursor/scrolls (allowed), but Shift+navigation extends the selection (not\n  // Needed for inspection), so it is blocked. Bare modifier presses pass through on their own.\n  if (NAVIGATION_KEYS.has(evt.key)) {\n    return !evt.shiftKey;\n  }\n\n  return MODIFIER_KEYS.has(evt.key);\n}\n\nfunction isPeekLocked(): boolean {\n  // Drop entries whose bar has left the DOM without a restore() or close().\n  // A test teardown that empties the body is the typical cause; this keeps a stale entry from locking.\n  for (const entry of peekLockEntries) {\n    if (!entry.barEl.isConnected) {\n      peekLockEntries.delete(entry);\n    }\n  }\n\n  return peekLockEntries.size > 0;\n}\n\nfunction signalBlockedAttempt(): void {\n  flashMinimizedBars();\n  beeper.beep();\n}\n\nfunction suppressKeydownWhilePeekLocked(evt: KeyboardEvent): void {\n  if (!isPeekLocked() || isPeekAllowedKey(evt)) {\n    return;\n  }\n\n  blockEvent(evt);\n}\n\nfunction suppressWhilePeekLocked(evt: Event): void {\n  if (!isPeekLocked()) {\n    return;\n  }\n\n  blockEvent(evt);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/minimizable-modal.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A wrapper that makes any Obsidian {@link Modal} minimizable to a floating bar \u2014 without breaking the\n * modal's blocking contract.\n *\n * Obsidian's {@link Modal} is blocking: while it is open the rest of the app is meant to be inert until\n * the modal is dismissed. {@link MinimizableModal} wraps any modal instance (plain `Modal`,\n * `FuzzySuggestModal`, the library's `ModalBase`, your own subclass, \u2026 \u2014 including modals you do not\n * own) and adds a minimize button. Minimizing hides the modal and its blocking backdrop and shows a\n * small floating bar with a restore button, so the user can peek at the notes/folders the operation\n * involves \u2014 but the modal is NOT dismissed, so its blocking contract must be preserved.\n *\n * To keep that contract while minimized, the wrapper puts the app into a **peek-only lock**: the user\n * may mouse-click and scroll to inspect content, but cannot start anything new. While any modal is\n * minimized the wrapper:\n * - blocks the keyboard (typing, hotkeys, the command-palette shortcut),\n * - blocks the right-click context menu, and\n * - blocks opening any other modal (a re-fired command, the command palette, settings, \u2026).\n *\n * A blocked attempt flashes the floating bar and beeps so the user sees (and hears) why nothing\n * happened. Restoring (or the modal closing) lifts the lock. This prevents, for example, minimizing a\n * \"merge folder\" picker and then firing the same command again to stack several concurrent merges.\n *\n * The wrapper reuses the modal's own title (`titleEl`) as the minimized bar label, so set the title\n * the usual way (`modal.setTitle(...)`). Render arbitrary content into {@link Modal.contentEl},\n * including clickable note links produced by `renderInternalLink` from\n * `obsidian-dev-utils/obsidian/markdown`:\n *\n * ```ts\n * const modal = new MyModal(app);\n * modal.setTitle('Merging notes');\n * modal.contentEl.appendChild(await renderInternalLink({ app, pathOrAbstractFile: file }));\n *\n * const minimizable = new MinimizableModal(modal);\n * minimizable.modal.open();\n * minimizable.minimize(); // a floating bar offers \"restore\"; the app is peek-only until restored\n * ```\n *\n * The wrapped modal can still be closed normally; the floating bar is cleaned up automatically when\n * the modal closes (even if it is closed while minimized).\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  Modal,\n  setIcon\n} from 'obsidian';\n\nimport { Beeper } from '../../beeper.ts';\nimport { AllWindowsEventComponent } from '../components/all-windows-event-component.ts';\nimport { MonkeyAroundComponent } from '../components/monkey-around-component.ts';\nimport { CssClass } from '../css-class.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\n\nconst MINIMIZE_ICON_ID = 'minus';\nconst RESTORE_ICON_ID = 'maximize-2';\n\n// Navigation keys pass through while minimized so the user can move the cursor and scroll to read.\n// None of them mutate the document \u2014 text changes are caught separately by the `beforeinput` guard.\n// Shift+navigation is blocked, though, since it extends the selection that inspection does not need.\nconst NAVIGATION_KEYS = new Set<string>([\n  'ArrowDown',\n  'ArrowLeft',\n  'ArrowRight',\n  'ArrowUp',\n  'End',\n  'Home',\n  'PageDown',\n  'PageUp'\n]);\n\n// A bare modifier press does nothing on its own, so it passes through the lock.\n// This avoids a spurious flash/beep while composing a shortcut; the shortcut's command key is blocked.\nconst MODIFIER_KEYS = new Set<string>([\n  'Alt',\n  'Control',\n  'Meta',\n  'Shift'\n]);\n\n/**\n * A registered entry for a currently-minimized modal. The shared peek-only lock uses it to know a\n * modal is minimized, to leave that modal's own re-opens alone, and to flash its bar on a blocked\n * attempt.\n */\ninterface PeekLockEntry {\n  /**\n   * The floating bar element. Used to detect a stale entry (its bar has left the DOM) so it can be\n   * pruned and never keep the app locked.\n   */\n  readonly barEl: HTMLElement;\n\n  /**\n   * Flashes the floating bar to signal a blocked attempt.\n   */\n  flash(): void;\n\n  /**\n   * The wrapped modal instance, so its own `open()` is never blocked by the lock.\n   */\n  readonly innerModal: Modal;\n}\n\nconst peekLockEntries = new Set<PeekLockEntry>();\nconst beeper = new Beeper();\n\n/**\n * Installs the peek-only lock's `open` patches while at least one modal is minimized. Being a\n * {@link MonkeyAroundComponent}, both patches are torn down automatically on `unload`, so they exist\n * only while the lock is active. A minimized modal's own re-open is always allowed (see\n * {@link shouldBlockOpen}); every other modal open is blocked and signals a flash + beep.\n */\nclass PeekLockComponent extends MonkeyAroundComponent {\n  /**\n   * Constructs a new instance.\n   *\n   * @param app - The app whose settings modal is guarded and whose windows suppress input while locked.\n   */\n  public constructor(private readonly app: App) {\n    super();\n  }\n\n  /**\n   * Registers the `open` patches and the input suppressors.\n   */\n  public override onload(): void {\n    super.onload();\n\n    // Block opening any OTHER modal while a modal is minimized (the command palette, a re-fired\n    // Command, another plugin modal, \u2026).\n    this.registerMethodPatch<Modal, 'open'>({\n      methodName: 'open',\n      obj: Modal.prototype,\n      patchHandler: ({ fallback, originalThis }): void => {\n        blockOrFallback(originalThis, fallback);\n      }\n    });\n\n    // Obsidian's Settings is a *popout* modal: on desktop its own `open()` first creates a separate OS\n    // Window (via `shouldUsePopout()`/`getPopoutOptions()`) and only THEN delegates to\n    // `Modal.prototype.open` to render the active tab into it. Guarding only `Modal.prototype.open`\n    // Therefore blocks the render but leaves an empty settings window behind \u2014 the reported bad UX.\n    // Guarding the settings modal's own `open()` blocks it *before* the window is created.\n    this.registerMethodPatch<App['setting'], 'open'>({\n      methodName: 'open',\n      obj: this.app.setting,\n      patchHandler: ({ fallback, originalThis }): void => {\n        blockOrFallback(originalThis, fallback);\n      }\n    });\n\n    // Suppress the keyboard, editor mutation, and the context menu across ALL windows \u2014 the main window\n    // And every existing/future popout \u2014 so the lock holds wherever the user's focus is, not only in\n    // The window that owns the minimized modal. Capture-phase listeners run before Obsidian's own\n    // Document/element handlers (including CodeMirror's), so `stopImmediatePropagation()` in the\n    // Suppressors keeps a blocked event from ever reaching them. `keydown` lets navigation keys through\n    // (see `isPeekAllowedKey`) but blocks command hotkeys; `beforeinput` blocks all editor mutation;\n    // `contextmenu` blocks the right-click menu.\n    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));\n    allWindowsEventComponent.registerAllWindowsDomEvent({\n      callback: suppressKeydownWhilePeekLocked,\n      options: { capture: true },\n      type: 'keydown'\n    });\n    allWindowsEventComponent.registerAllWindowsDomEvent({\n      callback: suppressWhilePeekLocked,\n      options: { capture: true },\n      type: 'beforeinput'\n    });\n    allWindowsEventComponent.registerAllWindowsDomEvent({\n      callback: suppressWhilePeekLocked,\n      options: { capture: true },\n      type: 'contextmenu'\n    });\n  }\n}\n\n/**\n * Wraps a {@link Modal} instance to make it minimizable to a small floating bar and restorable. While\n * minimized the app is put into a peek-only lock (keyboard, context menu, and opening other modals are\n * blocked) so the modal's blocking contract is preserved.\n *\n * @typeParam TModal - The type of the wrapped modal.\n */\nexport class MinimizableModal<TModal extends Modal> {\n  /**\n   * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).\n   */\n  public readonly modal: TModal;\n\n  /**\n   * Whether the modal is currently minimized.\n   *\n   * @returns `true` if the modal is currently minimized, `false` otherwise.\n   */\n  public get isMinimized(): boolean {\n    return this.isMinimizedValue;\n  }\n\n  /**\n   * Patches the wrapped modal's `onClose` to run cleanup. Persists for the wrapper's whole life (a\n   * modal can be reopened, so the patch must survive each close), hence a dedicated component that is\n   * never unloaded \u2014 distinct from `peekLockComponent`, whose patches live only while minimized.\n   * Exposed to subclasses so they can register additional lifetime-scoped patches on the wrapper.\n   */\n  protected readonly closePatchComponent = new MonkeyAroundComponent();\n\n  private isMinimizedValue = false;\n  private readonly minimizeButtonEl: HTMLElement;\n  private minimizedBarEl: HTMLElement | null = null;\n  private peekLockComponent: null | PeekLockComponent = null;\n  private peekLockEntry: null | PeekLockEntry = null;\n\n  /**\n   * Wraps the given modal, adding a minimize button and wiring up cleanup on close.\n   *\n   * @param modal - The modal instance to make minimizable.\n   */\n  public constructor(modal: TModal) {\n    this.modal = modal;\n    addPluginCssClasses(modal.containerEl, [CssClass.MinimizableModal]);\n    this.minimizeButtonEl = this.createMinimizeButton();\n    this.closePatchComponent.load();\n    this.patchOnClose(modal);\n  }\n\n  /**\n   * Minimizes the modal: hides the modal and its backdrop, shows a floating bar with a restore button,\n   * and puts the app into the peek-only lock. A no-op if the modal is already minimized.\n   */\n  public minimize(): void {\n    if (this.isMinimizedValue) {\n      return;\n    }\n\n    this.isMinimizedValue = true;\n    this.minimizeButtonEl.hide();\n    this.modal.containerEl.hide();\n    // The modal stays open while minimized, so its keymap scope is popped to release the focus trap.\n    // Restoring re-pushes it. An active trap would steal focus back to the hidden modal, blocking the\n    // Mouse-driven inspection (clicking notes, scrolling) that minimize exists to allow.\n    // Keyboard input remains blocked by the peek-only lock, so releasing the trap keeps the app inert.\n    this.modal.app.keymap.popScope(this.modal.scope);\n    this.minimizedBarEl = this.createMinimizedBar();\n    this.enablePeekLock(this.minimizedBarEl);\n  }\n\n  /**\n   * Restores the modal from the minimized state, removing the floating bar and lifting the peek-only\n   * lock. A no-op if the modal is not minimized.\n   */\n  public restore(): void {\n    if (!this.isMinimizedValue) {\n      return;\n    }\n\n    this.isMinimizedValue = false;\n    this.disablePeekLock();\n    this.removeMinimizedBar();\n    // Re-push the scope popped in minimize() so the restored modal blocks the app again (focus trap\n    // + Escape capture).\n    this.modal.app.keymap.pushScope(this.modal.scope);\n    this.modal.containerEl.show();\n    this.minimizeButtonEl.show();\n  }\n\n  private createMinimizeButton(): HTMLElement {\n    const buttonEl = this.modal.modalEl.createEl('button', { cls: CssClass.MinimizeButton });\n    setIcon(buttonEl, MINIMIZE_ICON_ID);\n    buttonEl.addEventListener('click', () => {\n      this.minimize();\n    });\n    return buttonEl;\n  }\n\n  private createMinimizedBar(): HTMLElement {\n    const barEl = this.modal.containerEl.ownerDocument.body.createDiv();\n    addPluginCssClasses(barEl, [CssClass.MinimizedModalBar]);\n    barEl.createSpan({\n      cls: CssClass.MinimizedModalBarTitle,\n      text: this.modal.titleEl.textContent\n    });\n    const restoreButtonEl = barEl.createEl('button', { cls: CssClass.RestoreButton });\n    setIcon(restoreButtonEl, RESTORE_ICON_ID);\n    // The whole bar restores on click, not just the restore button \u2014 a larger, easier click target.\n    // `restore()` guards against a double invocation, so the restore button's own click bubbling up\n    // Here is a no-op. The restore button stays purely as a visual affordance for the click target.\n    barEl.addEventListener('click', () => {\n      this.restore();\n    });\n    // Drop the one-shot attention flash once it finishes so the bar returns to its gentle idle pulse.\n    // The idle pulse is an infinite animation, which never fires `animationend`.\n    barEl.addEventListener('animationend', () => {\n      barEl.removeClass(CssClass.MinimizedModalBarAttention);\n    });\n    return barEl;\n  }\n\n  private disablePeekLock(): void {\n    if (!this.peekLockEntry) {\n      return;\n    }\n\n    peekLockEntries.delete(this.peekLockEntry);\n    this.peekLockEntry = null;\n    // Tear the `open` patches down with the component, so they exist only while this modal is minimized.\n    this.peekLockComponent?.unload();\n    this.peekLockComponent = null;\n  }\n\n  private enablePeekLock(barEl: HTMLElement): void {\n    this.peekLockEntry = {\n      barEl,\n      flash: (): void => {\n        this.flashBar(barEl);\n      },\n      innerModal: this.modal\n    };\n    peekLockEntries.add(this.peekLockEntry);\n    // Install the `open` patches and input suppressors for as long as this modal is minimized. The\n    // Block LOGIC itself keys off the shared `peekLockEntries` (see `shouldBlockOpen`), so with several\n    // Modals minimized every one's patch reaches the same verdict; the lock lifts only once the last\n    // Modal restores/closes.\n    this.peekLockComponent = new PeekLockComponent(this.modal.app);\n    this.peekLockComponent.load();\n  }\n\n  private flashBar(barEl: HTMLElement): void {\n    barEl.removeClass(CssClass.MinimizedModalBarAttention);\n    // Force a reflow so re-adding the class restarts the one-shot flash on rapid repeated blocks.\n    barEl.getBoundingClientRect();\n    barEl.addClass(CssClass.MinimizedModalBarAttention);\n  }\n\n  private handleClose(): void {\n    this.disablePeekLock();\n    this.removeMinimizedBar();\n    this.isMinimizedValue = false;\n  }\n\n  private patchOnClose(modal: Modal): void {\n    this.closePatchComponent.registerMethodPatch<Modal, 'onClose'>({\n      methodName: 'onClose',\n      obj: modal,\n      patchHandler: ({ fallback }): void => {\n        fallback();\n        this.handleClose();\n      }\n    });\n  }\n\n  private removeMinimizedBar(): void {\n    this.minimizedBarEl?.remove();\n    this.minimizedBarEl = null;\n  }\n}\n\nfunction blockEvent(evt: Event): void {\n  evt.preventDefault();\n  evt.stopImmediatePropagation();\n  signalBlockedAttempt();\n}\n\nfunction blockOrFallback(modal: Modal, fallback: () => void): void {\n  if (shouldBlockOpen(modal)) {\n    signalBlockedAttempt();\n    return;\n  }\n\n  fallback();\n}\n\nfunction flashMinimizedBars(): void {\n  for (const entry of peekLockEntries) {\n    entry.flash();\n  }\n}\n\nfunction isMinimizedInnerModal(modal: Modal): boolean {\n  for (const entry of peekLockEntries) {\n    if (entry.innerModal === modal) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction isPeekAllowedKey(evt: KeyboardEvent): boolean {\n  // Navigation moves the cursor/scrolls (allowed), but Shift+navigation extends the selection (not\n  // Needed for inspection), so it is blocked. Bare modifier presses pass through on their own.\n  if (NAVIGATION_KEYS.has(evt.key)) {\n    return !evt.shiftKey;\n  }\n\n  return MODIFIER_KEYS.has(evt.key);\n}\n\nfunction isPeekLocked(): boolean {\n  // Drop entries whose bar has left the DOM without a restore() or close().\n  // A test teardown that empties the body is the typical cause; this keeps a stale entry from locking.\n  for (const entry of peekLockEntries) {\n    if (!entry.barEl.isConnected) {\n      peekLockEntries.delete(entry);\n    }\n  }\n\n  return peekLockEntries.size > 0;\n}\n\nfunction shouldBlockOpen(modal: Modal): boolean {\n  // A modal's own re-open is never blocked \u2014 otherwise a minimized modal could not restore/re-open\n  // Itself. Every OTHER modal open is blocked while any modal is minimized (the peek-only lock).\n  return isPeekLocked() && !isMinimizedInnerModal(modal);\n}\n\nfunction signalBlockedAttempt(): void {\n  flashMinimizedBars();\n  beeper.beep();\n}\n\nfunction suppressKeydownWhilePeekLocked(evt: KeyboardEvent): void {\n  if (!isPeekLocked() || isPeekAllowedKey(evt)) {\n    return;\n  }\n\n  blockEvent(evt);\n}\n\nfunction suppressWhilePeekLocked(evt: Event): void {\n  if (!isPeekLocked()) {\n    return;\n  }\n\n  blockEvent(evt);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/obsidian-protocol-handler-registrar.d.mts

@@ -35,7 +35,10 @@ type PluginObsidianProtocolHandlerRegistrarRegisterObsidianProtocolHandlerParams
  * Obsidian protocol handler registrar in an Obsidian plugin.
  */
 export declare class PluginObsidianProtocolHandlerRegistrar implements ObsidianProtocolHandlerRegistrar {
-    private readonly plugin;
+    /**
+     * The Obsidian plugin instance the protocol handlers are registered with.
+     */
+    protected readonly plugin: Plugin;
     /**
      * Creates a new instance of the {@link PluginObsidianProtocolHandlerRegistrar} class.
      *

package/dist/lib/esm/obsidian/obsidian-protocol-handler-registrar.mjs

@@ -23,6 +23,9 @@ if you want to view the source, please visit the github repository of this plugi
 
 import { normalizePromisable } from "../async.mjs";
 class PluginObsidianProtocolHandlerRegistrar {
+  /**
+   * The Obsidian plugin instance the protocol handlers are registered with.
+   */
   plugin;
   /**
    * Creates a new instance of the {@link PluginObsidianProtocolHandlerRegistrar} class.
@@ -44,4 +47,4 @@ class PluginObsidianProtocolHandlerRegistrar {
 export {
   PluginObsidianProtocolHandlerRegistrar
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/parse-link.d.mts

@@ -0,0 +1,268 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides utilities for parsing markdown and wiki links into structured data, and for
+ * escaping, unescaping, and encoding link components.
+ */
+import type { FrontmatterLinkCache, Reference, ReferenceCache } from 'obsidian';
+/**
+ * The result of parsing the links from a note's frontmatter via {@link parseFrontmatterLinks}. Internal
+ * single-link frontmatter values are omitted, as Obsidian natively caches them.
+ */
+export interface ParseFrontmatterLinksResult {
+    /**
+     * The external links parsed from single-link (single-value) frontmatter values.
+     */
+    readonly frontmatterExternalLinks: ParseLinkFrontmatterReference[];
+    /**
+     * The external links parsed from multi-link (multi-value) frontmatter values.
+     */
+    readonly multiValueFrontmatterExternalLinks: ParseLinkFrontmatterReferenceWithOffsets[];
+    /**
+     * The internal links parsed from multi-link (multi-value) frontmatter values.
+     */
+    readonly multiValueFrontmatterLinks: ParseLinkFrontmatterReferenceWithOffsets[];
+}
+/**
+ * A {@link FrontmatterLinkCache} for a link parsed from a single-link frontmatter value via
+ * {@link parseLinks}. It carries the full {@link ParseLinkResult} so consumers can inspect the parse
+ * details without re-parsing the link. Use this when the whole frontmatter value is a single link.
+ */
+export interface ParseLinkFrontmatterReference extends FrontmatterLinkCache {
+    /**
+     * The result of parsing the link.
+     */
+    readonly parseLinkResult: ParseLinkResult;
+}
+/**
+ * A {@link ParseLinkFrontmatterReference} for a link parsed from a multi-link frontmatter value via
+ * {@link parseLinks}, additionally carrying the offsets of the link within the frontmatter value. Use
+ * this when the frontmatter value holds multiple links.
+ */
+export interface ParseLinkFrontmatterReferenceWithOffsets extends ParseLinkFrontmatterReference {
+    /**
+     * An end offset of the link in the frontmatter value.
+     */
+    endOffset: number;
+    /**
+     * A start offset of the link in the frontmatter value.
+     */
+    startOffset: number;
+}
+/**
+ * A {@link ReferenceCache} for a link parsed from content via {@link parseLinks}. It carries the full
+ * {@link ParseLinkResult} so consumers can inspect the parse details without re-parsing the link.
+ */
+export interface ParseLinkReference extends ReferenceCache {
+    /**
+     * The result of parsing the link.
+     */
+    readonly parseLinkResult: ParseLinkResult;
+}
+/**
+ * A result of parsing a link.
+ */
+export interface ParseLinkResult {
+    /**
+     * An alias of the link.
+     *
+     * @example
+     * ```
+     * [\*alias\*](link.md) -> \*alias\*
+     * ```
+     */
+    readonly alias?: string;
+    /**
+     * An encoded URL of the link.
+     *
+     * @example
+     * ```
+     * [alias](<link with space.md>) -> link%20with%20space.md
+     * ```
+     */
+    readonly encodedUrl?: string;
+    /**
+     * An end offset of the link in the original text.
+     */
+    readonly endOffset: number;
+    /**
+     * Indicates if the link has angle brackets.
+     *
+     * @example
+     * ```
+     * [alias](<link.md>) -> true
+     * [alias](link.md) -> false
+     * ```
+     */
+    readonly hasAngleBrackets?: boolean;
+    /**
+     * Indicates if the link is an embed link.
+     *
+     * @example
+     * ```
+     * ![[alias]] -> true
+     * [[alias]] -> false
+     * ```
+     */
+    readonly isEmbed: boolean;
+    /**
+     * Indicates if the link is external.
+     *
+     * @example
+     * ```
+     * [alias](https://example.com) -> true
+     * [alias](file.md) -> false
+     * ```
+     */
+    readonly isExternal: boolean;
+    /**
+     * Indicates if the link is a `file://` URL.
+     *
+     * @example
+     * ```
+     * [alias](file:///C:/x.txt) -> true
+     * [alias](https://example.com) -> false
+     * ```
+     */
+    readonly isFileUrl: boolean;
+    /**
+     * Indicates if the link is a wikilink.
+     *
+     * @example
+     * ```
+     * [[alias]] -> true
+     * [alias](link.md) -> false
+     * ```
+     */
+    readonly isWikilink: boolean;
+    /**
+     * A raw link text.
+     *
+     * @example
+     * ```
+     * [alias](link.md) -> [alias](link.md)
+     * ```
+     */
+    readonly raw: string;
+    /**
+     * A start offset of the link in the original text.
+     */
+    readonly startOffset: number;
+    /**
+     * A title of the link.
+     *
+     * @example
+     * ```
+     * [alias](link.md "title") -> title
+     * ```
+     */
+    readonly title?: string;
+    /**
+     * An unescaped alias of the link.
+     *
+     * @example
+     * ```
+     * [\*alias\*](link.md) -> *alias*
+     * ```
+     */
+    readonly unescapedAlias?: string;
+    /**
+     * An URL of the link.
+     *
+     * @example
+     * ```
+     * [alias](link%20with%20space.md) -> link with space.md
+     * ```
+     */
+    readonly url: string;
+}
+/**
+ * Params for {@link toParseLinkReference}.
+ */
+export interface ToParseLinkReferenceParams {
+    /**
+     * The content the parsed link's offsets index into. Used to compute the line and column.
+     */
+    readonly content: string;
+    /**
+     * The parsed link to wrap.
+     */
+    readonly parseLinkResult: ParseLinkResult;
+}
+/**
+ * Encodes a URL.
+ *
+ * @param url - The URL to encode.
+ * @returns The encoded URL.
+ */
+export declare function encodeUrl(url: string): string;
+/**
+ * Escapes the alias of a markdown link.
+ *
+ * @param alias - An alias of a markdown link.
+ * @returns An escaped alias.
+ *
+ * @example
+ * ```ts
+ * escapeAlias('**alias**') // '\\*\\*alias\\*\\*'
+ * ```
+ */
+export declare function escapeAlias(alias: string): string;
+/**
+ * Determines whether a reference is a {@link ParseLinkFrontmatterReference}.
+ *
+ * @param reference - The reference to check.
+ * @returns `true` if the reference is a {@link ParseLinkFrontmatterReference}, otherwise `false`.
+ */
+export declare function isParseLinkFrontmatterReference(reference: Reference): reference is ParseLinkFrontmatterReference;
+/**
+ * Determines whether a reference is a {@link ParseLinkReference}.
+ *
+ * @param reference - The reference to check.
+ * @returns `true` if the reference is a {@link ParseLinkReference}, otherwise `false`.
+ */
+export declare function isParseLinkReference(reference: Reference): reference is ParseLinkReference;
+/**
+ * Parses the links from a note's frontmatter. Each string value is parsed via {@link parseLinks}: a value
+ * that is a single link yields an entry without offsets, and a value that holds multiple links yields
+ * offset-carrying entries. Internal single-link values are omitted, as Obsidian natively caches them.
+ *
+ * @param frontmatter - The frontmatter to parse (a value, object, or array).
+ * @returns The parsed frontmatter links.
+ */
+export declare function parseFrontmatterLinks(frontmatter: unknown): ParseFrontmatterLinksResult;
+/**
+ * Parses a link into its components.
+ *
+ * @param str - The link to parse.
+ * @returns The parsed link.
+ */
+export declare function parseLink(str: string): null | ParseLinkResult;
+/**
+ * Parses all links in a string.
+ *
+ * @param str - The string to parse the links in.
+ * @returns The parsed links.
+ */
+export declare function parseLinks(str: string): ParseLinkResult[];
+/**
+ * Wraps a {@link ParseLinkResult} into a {@link ParseLinkReference} so it can flow through the
+ * reference-based file-change pipeline.
+ *
+ * @param params - The parameters for wrapping the parsed link.
+ * @returns The {@link ParseLinkReference}.
+ */
+export declare function toParseLinkReference(params: ToParseLinkReferenceParams): ParseLinkReference;
+/**
+ * Unescapes the alias of a markdown link.
+ *
+ * @param escapedAlias - An escaped alias.
+ * @returns An unescaped alias.
+ *
+ * @example
+ * ```ts
+ * unescapeAlias('\\*\\*alias\\*\\*') // '**alias**'
+ * ```
+ */
+export declare function unescapeAlias(escapedAlias: string): string;