obsidian-dev-utils 84.5.4 → 84.6.0

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

@@ -22,11 +22,36 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { around } from "monkey-around";
-import { setIcon } from "obsidian";
+import {
+  Modal,
+  setIcon
+} from "obsidian";
+import { Beeper } from "../../beeper.mjs";
+import { ensureNonNullable } from "../../type-guards.mjs";
 import { CssClass } from "../css-class.mjs";
 import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
 const MINIMIZE_ICON_ID = "minus";
 const RESTORE_ICON_ID = "maximize-2";
+const NAVIGATION_KEYS = /* @__PURE__ */ new Set([
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "ArrowUp",
+  "End",
+  "Home",
+  "PageDown",
+  "PageUp"
+]);
+const MODIFIER_KEYS = /* @__PURE__ */ new Set([
+  "Alt",
+  "Control",
+  "Meta",
+  "Shift"
+]);
+const peekLockEntries = /* @__PURE__ */ new Set();
+const documentsWithInputSuppressors = /* @__PURE__ */ new WeakSet();
+const beeper = new Beeper();
+let isModalOpenGuardInstalled = false;
 class MinimizableModal {
   /**
    * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).
@@ -43,6 +68,7 @@ class MinimizableModal {
   isMinimizedValue = false;
   minimizeButtonEl;
   minimizedBarEl = null;
+  peekLockEntry = null;
   /**
    * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
    *
@@ -55,8 +81,8 @@ class MinimizableModal {
     this.patchOnClose(modal);
   }
   /**
-   * Minimizes the modal: hides the modal and its backdrop and shows a floating bar with a restore
-   * button. A no-op if the modal is already minimized.
+   * Minimizes the modal: hides the modal and its backdrop, shows a floating bar with a restore button,
+   * and puts the app into the peek-only lock. A no-op if the modal is already minimized.
    */
   minimize() {
     if (this.isMinimizedValue) {
@@ -67,16 +93,18 @@ class MinimizableModal {
     this.modal.containerEl.hide();
     this.modal.app.keymap.popScope(this.modal.scope);
     this.minimizedBarEl = this.createMinimizedBar();
+    this.enablePeekLock(this.minimizedBarEl);
   }
   /**
-   * Restores the modal from the minimized state, removing the floating bar. A no-op if the modal is
-   * not minimized.
+   * Restores the modal from the minimized state, removing the floating bar and lifting the peek-only
+   * lock. A no-op if the modal is not minimized.
    */
   restore() {
     if (!this.isMinimizedValue) {
       return;
     }
     this.isMinimizedValue = false;
+    this.disablePeekLock();
     this.removeMinimizedBar();
     this.modal.app.keymap.pushScope(this.modal.scope);
     this.modal.containerEl.show();
@@ -102,9 +130,37 @@ class MinimizableModal {
     barEl.addEventListener("click", () => {
       this.restore();
     });
+    barEl.addEventListener("animationend", () => {
+      barEl.removeClass(CssClass.MinimizedModalBarAttention);
+    });
     return barEl;
   }
+  disablePeekLock() {
+    if (!this.peekLockEntry) {
+      return;
+    }
+    peekLockEntries.delete(this.peekLockEntry);
+    this.peekLockEntry = null;
+  }
+  enablePeekLock(barEl) {
+    this.peekLockEntry = {
+      barEl,
+      flash: () => {
+        this.flashBar(barEl);
+      },
+      innerModal: this.modal
+    };
+    peekLockEntries.add(this.peekLockEntry);
+    installModalOpenGuardOnce();
+    installInputSuppressorsOnce(this.modal.containerEl.ownerDocument);
+  }
+  flashBar(barEl) {
+    barEl.removeClass(CssClass.MinimizedModalBarAttention);
+    barEl.getBoundingClientRect();
+    barEl.addClass(CssClass.MinimizedModalBarAttention);
+  }
   handleClose() {
+    this.disablePeekLock();
     this.removeMinimizedBar();
     this.isMinimizedValue = false;
   }
@@ -123,7 +179,82 @@ class MinimizableModal {
     this.minimizedBarEl = null;
   }
 }
+function blockEvent(evt) {
+  evt.preventDefault();
+  evt.stopImmediatePropagation();
+  signalBlockedAttempt();
+}
+function flashMinimizedBars() {
+  for (const entry of peekLockEntries) {
+    entry.flash();
+  }
+}
+function installInputSuppressorsOnce(doc) {
+  if (documentsWithInputSuppressors.has(doc)) {
+    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 });
+}
+function installModalOpenGuardOnce() {
+  if (isModalOpenGuardInstalled) {
+    return;
+  }
+  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) {
+    if (entry.innerModal === modal) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPeekAllowedKey(evt) {
+  if (NAVIGATION_KEYS.has(evt.key)) {
+    return !evt.shiftKey;
+  }
+  return MODIFIER_KEYS.has(evt.key);
+}
+function isPeekLocked() {
+  for (const entry of peekLockEntries) {
+    if (!entry.barEl.isConnected) {
+      peekLockEntries.delete(entry);
+    }
+  }
+  return peekLockEntries.size > 0;
+}
+function signalBlockedAttempt() {
+  flashMinimizedBars();
+  beeper.beep();
+}
+function suppressKeydownWhilePeekLocked(evt) {
+  if (!isPeekLocked() || isPeekAllowedKey(evt)) {
+    return;
+  }
+  blockEvent(evt);
+}
+function suppressWhilePeekLocked(evt) {
+  if (!isPeekLocked()) {
+    return;
+  }
+  blockEvent(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.\n *\n * Obsidian's {@link Modal} is blocking \u2014 while it is open the rest of the app is dimmed and\n * inert \u2014 and it cannot be minimized. {@link MinimizableModal} wraps any modal instance (plain\n * `Modal`, `FuzzySuggestModal`, the library's `ModalBase`, your own subclass, \u2026 \u2014 including modals\n * you do not own) and adds a minimize button: when minimized, the modal (and its blocking backdrop)\n * is hidden and a small floating bar with a restore button is shown instead, so the app stays fully\n * usable while a long-running operation continues in the background.\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(); // app is usable again; a floating bar offers \"restore\"\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 { Modal } from 'obsidian';\n\nimport { around } from 'monkey-around';\nimport { setIcon } from 'obsidian';\n\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/**\n * Wraps a {@link Modal} instance to make it minimizable to a small floating bar and restorable,\n * keeping the app usable while minimized.\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\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 and shows a floating bar with a restore\n   * button. 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 would otherwise stay active.\n    // Obsidian's focus trap then steals focus back to the hidden modal, so the editor cannot type.\n    // Popping the scope releases the trap and the `Escape` capture; `restore()` re-pushes it.\n    this.modal.app.keymap.popScope(this.modal.scope);\n    this.minimizedBarEl = this.createMinimizedBar();\n  }\n\n  /**\n   * Restores the modal from the minimized state, removing the floating bar. A no-op if the modal is\n   * not minimized.\n   */\n  public restore(): void {\n    if (!this.isMinimizedValue) {\n      return;\n    }\n\n    this.isMinimizedValue = false;\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    return barEl;\n  }\n\n  private handleClose(): void {\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"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAS,cAAc;AACvB,SAAS,eAAe;AAExB,SAAS,gBAAgB;AACzB,SAAS,2BAA2B;AAEpC,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AAQjB,MAAM,iBAAuC;AAAA;AAAA;AAAA;AAAA,EAIlC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,IAAW,cAAuB;AAChC,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ,mBAAmB;AAAA,EACV;AAAA,EACT,iBAAqC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOtC,YAAY,OAAe;AAChC,SAAK,QAAQ;AACb,wBAAoB,MAAM,aAAa,CAAC,SAAS,gBAAgB,CAAC;AAClE,SAAK,mBAAmB,KAAK,qBAAqB;AAClD,SAAK,aAAa,KAAK;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,WAAiB;AACtB,QAAI,KAAK,kBAAkB;AACzB;AAAA,IACF;AAEA,SAAK,mBAAmB;AACxB,SAAK,iBAAiB,KAAK;AAC3B,SAAK,MAAM,YAAY,KAAK;AAI5B,SAAK,MAAM,IAAI,OAAO,SAAS,KAAK,MAAM,KAAK;AAC/C,SAAK,iBAAiB,KAAK,mBAAmB;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAgB;AACrB,QAAI,CAAC,KAAK,kBAAkB;AAC1B;AAAA,IACF;AAEA,SAAK,mBAAmB;AACxB,SAAK,mBAAmB;AAGxB,SAAK,MAAM,IAAI,OAAO,UAAU,KAAK,MAAM,KAAK;AAChD,SAAK,MAAM,YAAY,KAAK;AAC5B,SAAK,iBAAiB,KAAK;AAAA,EAC7B;AAAA,EAEQ,uBAAoC;AAC1C,UAAM,WAAW,KAAK,MAAM,QAAQ,SAAS,UAAU,EAAE,KAAK,SAAS,eAAe,CAAC;AACvF,YAAQ,UAAU,gBAAgB;AAClC,aAAS,iBAAiB,SAAS,MAAM;AACvC,WAAK,SAAS;AAAA,IAChB,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAEQ,qBAAkC;AACxC,UAAM,QAAQ,KAAK,MAAM,YAAY,cAAc,KAAK,UAAU;AAClE,wBAAoB,OAAO,CAAC,SAAS,iBAAiB,CAAC;AACvD,UAAM,WAAW;AAAA,MACf,KAAK,SAAS;AAAA,MACd,MAAM,KAAK,MAAM,QAAQ;AAAA,IAC3B,CAAC;AACD,UAAM,kBAAkB,MAAM,SAAS,UAAU,EAAE,KAAK,SAAS,cAAc,CAAC;AAChF,YAAQ,iBAAiB,eAAe;AAIxC,UAAM,iBAAiB,SAAS,MAAM;AACpC,WAAK,QAAQ;AAAA,IACf,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAEQ,cAAoB;AAC1B,SAAK,mBAAmB;AACxB,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEQ,aAAa,OAAoB;AACvC,WAAO,OAAO;AAAA,MACZ,SAAS,CAAC,SAAiC;AACzC,eAAO,MAAY;AACjB,eAAK,KAAK,KAAK;AACf,eAAK,YAAY;AAAA,QACnB;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEQ,qBAA2B;AACjC,SAAK,gBAAgB,OAAO;AAC5B,SAAK,iBAAiB;AAAA,EACxB;AACF;",
  "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 { 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": []
}
