@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/modals/minimizable-modal.cjs

@@ -0,0 +1,441 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var minimizable_modal_exports = {};
+__export(minimizable_modal_exports, {
+  MinimizableModal: () => MinimizableModal
+});
+module.exports = __toCommonJS(minimizable_modal_exports);
+var import_beeper = require('@mnaoumov/typescript-lib/beeper');
+var import_obsidian = require('obsidian');
+var import_all_windows_event_component = require('../components/all-windows-event-component.cjs');
+var import_monkey_around_component = require('../components/monkey-around-component.cjs');
+var import_css_class = require('../css-class.cjs');
+var import_plugin_context = require('../plugin/plugin-context.cjs');
+const MINIMIZE_ICON_ID = "minus";
+const RESTORE_ICON_ID = "maximize-2";
+const CANCEL_ICON_ID = "x";
+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 beeper = new import_beeper.Beeper();
+class PeekLockComponent extends import_monkey_around_component.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({
+      $object: import_obsidian.Modal.prototype,
+      methodName: "open",
+      patchHandler: ({ fallback, originalThis }) => {
+        blockOrFallback(originalThis, fallback);
+      }
+    });
+    this.registerMethodPatch({
+      $object: this.app.setting,
+      methodName: "open",
+      patchHandler: ({ fallback, originalThis }) => {
+        blockOrFallback(originalThis, fallback);
+      }
+    });
+    const allWindowsEventComponent = this.addChild(new import_all_windows_event_component.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()`).
+   */
+  modal;
+  /**
+   * Whether the modal is currently minimized.
+   *
+   * @returns `true` if the modal is currently minimized, `false` otherwise.
+   */
+  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 import_monkey_around_component.MonkeyAroundComponent();
+  isMinimizedValue = false;
+  minimizeButtonEl;
+  minimizedBarEl = null;
+  peekLockComponent = null;
+  peekLockEntry = null;
+  shouldMinimizeOnClickOutside;
+  shouldShowCancelButton;
+  /**
+   * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
+   *
+   * @param modal - The modal instance to make minimizable.
+   * @param options - Options controlling the minimized bar. See {@link MinimizableModalConstructorOptions}.
+   */
+  constructor(modal, options = {}) {
+    this.modal = modal;
+    this.shouldMinimizeOnClickOutside = options.shouldMinimizeOnClickOutside ?? true;
+    this.shouldShowCancelButton = options.shouldShowCancelButton ?? true;
+    (0, import_plugin_context.addPluginCssClasses)(modal.containerEl, [import_css_class.CssClass.MinimizableModal]);
+    this.minimizeButtonEl = this.createMinimizeButton();
+    if (this.shouldMinimizeOnClickOutside) {
+      modal.containerEl.addEventListener("click", ($event) => {
+        this.handleContainerClick($event);
+      }, { capture: true });
+    }
+    this.closePatchComponent.load();
+    this.patchOnClose(modal);
+  }
+  /**
+   * 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) {
+      return;
+    }
+    this.isMinimizedValue = true;
+    this.minimizeButtonEl.hide();
+    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 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();
+    this.minimizeButtonEl.show();
+  }
+  createMinimizeButton() {
+    const buttonEl = this.modal.modalEl.createEl("button", { cls: import_css_class.CssClass.MinimizeButton });
+    (0, import_obsidian.setIcon)(buttonEl, MINIMIZE_ICON_ID);
+    buttonEl.addEventListener("click", () => {
+      this.minimize();
+    });
+    return buttonEl;
+  }
+  createMinimizedBar() {
+    const barEl = this.modal.containerEl.ownerDocument.body.createDiv();
+    (0, import_plugin_context.addPluginCssClasses)(barEl, [import_css_class.CssClass.MinimizedModalBar]);
+    barEl.createSpan({
+      cls: import_css_class.CssClass.MinimizedModalBarTitle,
+      text: this.modal.titleEl.textContent
+    });
+    const restoreButtonEl = barEl.createEl("button", { cls: import_css_class.CssClass.RestoreButton });
+    (0, import_obsidian.setIcon)(restoreButtonEl, RESTORE_ICON_ID);
+    if (this.shouldShowCancelButton) {
+      const cancelButtonEl = barEl.createEl("button", { cls: import_css_class.CssClass.CancelButton });
+      (0, import_obsidian.setIcon)(cancelButtonEl, CANCEL_ICON_ID);
+      (0, import_obsidian.setTooltip)(cancelButtonEl, "Cancel");
+      cancelButtonEl.addEventListener("click", ($event) => {
+        $event.stopPropagation();
+        this.modal.close();
+      });
+    }
+    barEl.addEventListener("click", () => {
+      this.restore();
+    });
+    barEl.addEventListener("animationend", () => {
+      barEl.removeClass(import_css_class.CssClass.MinimizedModalBarAttention);
+    });
+    return barEl;
+  }
+  disablePeekLock() {
+    if (!this.peekLockEntry) {
+      return;
+    }
+    peekLockEntries.delete(this.peekLockEntry);
+    this.peekLockEntry = null;
+    this.peekLockComponent?.unload();
+    this.peekLockComponent = null;
+  }
+  enablePeekLock(barEl) {
+    this.peekLockEntry = {
+      barEl,
+      flash: () => {
+        this.flashBar(barEl);
+      },
+      innerModal: this.modal
+    };
+    peekLockEntries.add(this.peekLockEntry);
+    this.peekLockComponent = new PeekLockComponent(this.modal.app);
+    this.peekLockComponent.load();
+  }
+  flashBar(barEl) {
+    barEl.removeClass(import_css_class.CssClass.MinimizedModalBarAttention);
+    barEl.getBoundingClientRect();
+    barEl.addClass(import_css_class.CssClass.MinimizedModalBarAttention);
+  }
+  handleClose() {
+    this.disablePeekLock();
+    this.removeMinimizedBar();
+    this.isMinimizedValue = false;
+  }
+  handleContainerClick($event) {
+    if (
+      // While minimized the container is hidden, so no click can reach it — but a synthetic one still can,
+      // and minimizing an already-minimized modal is meaningless.
+      this.isMinimizedValue || $event.composedPath().includes(this.modal.modalEl) || $event.target === this.modal.containerEl
+    ) {
+      return;
+    }
+    $event.preventDefault();
+    $event.stopImmediatePropagation();
+    this.minimize();
+  }
+  patchOnClose(modal) {
+    this.closePatchComponent.registerMethodPatch({
+      $object: modal,
+      methodName: "onClose",
+      patchHandler: ({ fallback }) => {
+        fallback();
+        this.handleClose();
+      }
+    });
+  }
+  removeMinimizedBar() {
+    this.minimizedBarEl?.remove();
+    this.minimizedBarEl = null;
+  }
+}
+function blockEvent($event) {
+  $event.preventDefault();
+  $event.stopImmediatePropagation();
+  signalBlockedAttempt();
+}
+function blockOrFallback(modal, fallback) {
+  if (shouldBlockOpen(modal)) {
+    signalBlockedAttempt();
+    return;
+  }
+  fallback();
+}
+function flashMinimizedBars() {
+  for (const entry of peekLockEntries) {
+    entry.flash();
+  }
+}
+function isMinimizedInnerModal(modal) {
+  for (const entry of peekLockEntries) {
+    if (entry.innerModal === modal) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPeekAllowedKey($event) {
+  return NAVIGATION_KEYS.has($event.key) ? !$event.shiftKey : MODIFIER_KEYS.has($event.key);
+}
+function isPeekLocked() {
+  for (const entry of peekLockEntries) {
+    if (!entry.barEl.isConnected) {
+      peekLockEntries.delete(entry);
+    }
+  }
+  return peekLockEntries.size > 0;
+}
+function shouldBlockOpen(modal) {
+  return isPeekLocked() && !isMinimizedInnerModal(modal);
+}
+function signalBlockedAttempt() {
+  flashMinimizedBars();
+  beeper.beep();
+}
+function suppressKeydownWhilePeekLocked($event) {
+  if (!isPeekLocked() || isPeekAllowedKey($event)) {
+    return;
+  }
+  blockEvent($event);
+}
+function suppressWhilePeekLocked($event) {
+  if (!isPeekLocked()) {
+    return;
+  }
+  blockEvent($event);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MinimizableModal
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/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 (and, by default, a Cancel button that closes the wrapped\n * modal \u2014 pass `{ shouldShowCancelButton: false }` to hide it), so the user can peek at the\n * notes/folders the operation 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 * Clicking the dimmed background behind the modal **minimizes** it rather than closing it, so a stray\n * click past the dialog no longer cancels the operation the modal is running \u2014 pass\n * `{ shouldMinimizeOnClickOutside: false }` to keep Obsidian's native close-on-background-click.\n */\n\nimport type { App } from 'obsidian';\n\nimport { Beeper } from '@mnaoumov/typescript-lib/beeper';\nimport {\n  Modal,\n  setIcon,\n  setTooltip\n} from 'obsidian';\n\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';\nconst CANCEL_ICON_ID = 'x';\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 * Options for constructing a {@link MinimizableModal}.\n */\nexport interface MinimizableModalConstructorOptions {\n  /**\n   * Whether clicking the dimmed background behind the modal minimizes it instead of closing it.\n   * Obsidian's native behavior is to close, which cancels whatever operation the modal is running;\n   * minimizing keeps that operation alive so the user can peek at the involved notes and come back.\n   *\n   * @default `true`\n   */\n  readonly shouldMinimizeOnClickOutside?: boolean;\n\n  /**\n   * Whether the minimized bar shows a Cancel button that closes the wrapped modal. Closing lets the\n   * wrapped modal's own `onClose` define what \"cancel\" means (e.g. releasing a held lock).\n   *\n   * @default `true`\n   */\n  readonly shouldShowCancelButton?: boolean;\n}\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      $object: Modal.prototype,\n      methodName: 'open',\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      $object: this.app.setting,\n      methodName: 'open',\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  private readonly shouldMinimizeOnClickOutside: boolean;\n  private readonly shouldShowCancelButton: boolean;\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   * @param options - Options controlling the minimized bar. See {@link MinimizableModalConstructorOptions}.\n   */\n  public constructor(modal: TModal, options: MinimizableModalConstructorOptions = {}) {\n    this.modal = modal;\n    this.shouldMinimizeOnClickOutside = options.shouldMinimizeOnClickOutside ?? true;\n    this.shouldShowCancelButton = options.shouldShowCancelButton ?? true;\n    addPluginCssClasses(modal.containerEl, [CssClass.MinimizableModal]);\n    this.minimizeButtonEl = this.createMinimizeButton();\n    if (this.shouldMinimizeOnClickOutside) {\n      // Obsidian dismisses a modal from a listener it registers on `bgEl` IN THE `Modal` CONSTRUCTOR \u2014\n      // on macOS desktop that listener calls `close()` directly (no overridable method, no\n      // `defaultPrevented` guard), so neither overriding `onClickOutside` nor `preventDefault()` alone can\n      // stop it. At the target phase the DOM invokes listeners in registration order regardless of the\n      // capture flag, and Obsidian registered first, so the only way to run earlier is to capture on the\n      // PARENT element. Hence: capture-phase `click` on `containerEl`.\n      modal.containerEl.addEventListener('click', ($event) => {\n        this.handleContainerClick($event);\n      }, { capture: true });\n    }\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    if (this.shouldShowCancelButton) {\n      const cancelButtonEl = barEl.createEl('button', { cls: CssClass.CancelButton });\n      setIcon(cancelButtonEl, CANCEL_ICON_ID);\n      setTooltip(cancelButtonEl, 'Cancel');\n      cancelButtonEl.addEventListener('click', ($event) => {\n        // The whole bar restores on click; stop propagation so Cancel closes the modal instead of\n        // restoring it. Closing runs the wrapped modal's onClose (peek lock lifted, bar removed), so\n        // the consumer's onClose decides what \"cancel\" means (e.g. releasing a held lock).\n        $event.stopPropagation();\n        this.modal.close();\n      });\n    }\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 handleContainerClick($event: MouseEvent): void {\n    if (\n      // While minimized the container is hidden, so no click can reach it \u2014 but a synthetic one still can,\n      // and minimizing an already-minimized modal is meaningless.\n      this.isMinimizedValue\n      // A click that passed through the modal itself is ordinary interaction with its content.\n      // `composedPath()` (rather than `modalEl.contains($event.target)`) needs no cast and stays correct\n      // across windows, where an `instanceof HTMLElement` check against another realm's element would not.\n      || $event.composedPath().includes(this.modal.modalEl)\n      // A text selection dragged from inside the modal out onto the background makes the resulting\n      // `click` fire on their common ancestor \u2014 `containerEl`. Obsidian does not dismiss on that gesture (its\n      // own listener sits on `bgEl`, which is never the target here), so neither does this.\n      || $event.target === this.modal.containerEl\n    ) {\n      return;\n    }\n\n    // What is left is a click on the dimmed background itself. `stopImmediatePropagation()` is what\n    // actually keeps it from reaching Obsidian's `bgEl` listener on BOTH platform branches;\n    // `preventDefault()` additionally satisfies the `defaultPrevented` guard in `onClickOutside`.\n    $event.preventDefault();\n    $event.stopImmediatePropagation();\n    this.minimize();\n  }\n\n  private patchOnClose(modal: Modal): void {\n    this.closePatchComponent.registerMethodPatch<Modal, 'onClose'>({\n      $object: modal,\n      methodName: 'onClose',\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($event: Event): void {\n  $event.preventDefault();\n  $event.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($event: 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  return NAVIGATION_KEYS.has($event.key) ? !$event.shiftKey : MODIFIER_KEYS.has($event.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($event: KeyboardEvent): void {\n  if (!isPeekLocked() || isPeekAllowedKey($event)) {\n    return;\n  }\n\n  blockEvent($event);\n}\n\nfunction suppressWhilePeekLocked($event: Event): void {\n  if (!isPeekLocked()) {\n    return;\n  }\n\n  blockEvent($event);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/modals/minimizable-modal.d.cts

@@ -0,0 +1,129 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * A wrapper that makes any Obsidian {@link Modal} minimizable to a floating bar — without breaking the
+ * modal's blocking contract.
+ *
+ * Obsidian's {@link Modal} is blocking: while it is open the rest of the app is meant to be inert until
+ * the modal is dismissed. {@link MinimizableModal} wraps any modal instance (plain `Modal`,
+ * `FuzzySuggestModal`, the library's `ModalBase`, your own subclass, … — including modals you do not
+ * own) and adds a minimize button. Minimizing hides the modal and its blocking backdrop and shows a
+ * small floating bar with a restore button (and, by default, a Cancel button that closes the wrapped
+ * modal — pass `{ shouldShowCancelButton: false }` to hide it), so the user can peek at the
+ * notes/folders the operation involves — but the modal is NOT dismissed, so its blocking contract must be preserved.
+ *
+ * To keep that contract while minimized, the wrapper puts the app into a **peek-only lock**: the user
+ * may mouse-click and scroll to inspect content, but cannot start anything new. While any modal is
+ * minimized the wrapper:
+ * - blocks the keyboard (typing, hotkeys, the command-palette shortcut),
+ * - blocks the right-click context menu, and
+ * - blocks opening any other modal (a re-fired command, the command palette, settings, …).
+ *
+ * A blocked attempt flashes the floating bar and beeps so the user sees (and hears) why nothing
+ * happened. Restoring (or the modal closing) lifts the lock. This prevents, for example, minimizing a
+ * "merge folder" picker and then firing the same command again to stack several concurrent merges.
+ *
+ * The wrapper reuses the modal's own title (`titleEl`) as the minimized bar label, so set the title
+ * the usual way (`modal.setTitle(...)`). Render arbitrary content into {@link Modal.contentEl},
+ * including clickable note links produced by `renderInternalLink` from
+ * `obsidian-dev-utils/obsidian/markdown`:
+ *
+ * ```ts
+ * const modal = new MyModal(app);
+ * modal.setTitle('Merging notes');
+ * modal.contentEl.appendChild(await renderInternalLink({ app, pathOrAbstractFile: file }));
+ *
+ * const minimizable = new MinimizableModal(modal);
+ * minimizable.modal.open();
+ * minimizable.minimize(); // a floating bar offers "restore"; the app is peek-only until restored
+ * ```
+ *
+ * The wrapped modal can still be closed normally; the floating bar is cleaned up automatically when
+ * the modal closes (even if it is closed while minimized).
+ *
+ * Clicking the dimmed background behind the modal **minimizes** it rather than closing it, so a stray
+ * click past the dialog no longer cancels the operation the modal is running — pass
+ * `{ shouldMinimizeOnClickOutside: false }` to keep Obsidian's native close-on-background-click.
+ */
+import { Modal } from 'obsidian';
+import { MonkeyAroundComponent } from '../components/monkey-around-component.cjs';
+/**
+ * Options for constructing a {@link MinimizableModal}.
+ */
+export interface MinimizableModalConstructorOptions {
+    /**
+     * Whether clicking the dimmed background behind the modal minimizes it instead of closing it.
+     * Obsidian's native behavior is to close, which cancels whatever operation the modal is running;
+     * minimizing keeps that operation alive so the user can peek at the involved notes and come back.
+     *
+     * @default `true`
+     */
+    readonly shouldMinimizeOnClickOutside?: boolean;
+    /**
+     * Whether the minimized bar shows a Cancel button that closes the wrapped modal. Closing lets the
+     * wrapped modal's own `onClose` define what "cancel" means (e.g. releasing a held lock).
+     *
+     * @default `true`
+     */
+    readonly shouldShowCancelButton?: boolean;
+}
+/**
+ * Wraps a {@link Modal} instance to make it minimizable to a small floating bar and restorable. While
+ * minimized the app is put into a peek-only lock (keyboard, context menu, and opening other modals are
+ * blocked) so the modal's blocking contract is preserved.
+ *
+ * @typeParam TModal - The type of the wrapped modal.
+ */
+export declare class MinimizableModal<TModal extends Modal> {
+    /**
+     * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).
+     */
+    readonly modal: TModal;
+    /**
+     * Whether the modal is currently minimized.
+     *
+     * @returns `true` if the modal is currently minimized, `false` otherwise.
+     */
+    get isMinimized(): boolean;
+    /**
+     * 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.
+     */
+    protected readonly closePatchComponent: MonkeyAroundComponent;
+    private isMinimizedValue;
+    private readonly minimizeButtonEl;
+    private minimizedBarEl;
+    private peekLockComponent;
+    private peekLockEntry;
+    private readonly shouldMinimizeOnClickOutside;
+    private readonly shouldShowCancelButton;
+    /**
+     * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
+     *
+     * @param modal - The modal instance to make minimizable.
+     * @param options - Options controlling the minimized bar. See {@link MinimizableModalConstructorOptions}.
+     */
+    constructor(modal: TModal, options?: MinimizableModalConstructorOptions);
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    private createMinimizeButton;
+    private createMinimizedBar;
+    private disablePeekLock;
+    private enablePeekLock;
+    private flashBar;
+    private handleClose;
+    private handleContainerClick;
+    private patchOnClose;
+    private removeMinimizedBar;
+}