obsidian-dev-utils 81.0.0 → 82.0.0-beta.0

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

@@ -0,0 +1,234 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@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.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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_monkey_around = require('monkey-around');
+var import_obsidian = require('obsidian');
+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";
+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;
+  }
+  isMinimizedValue = false;
+  minimizeButtonEl;
+  minimizedBarEl = null;
+  /**
+   * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
+   *
+   * @param modal - The modal instance to make minimizable.
+   */
+  constructor(modal) {
+    this.modal = modal;
+    (0, import_plugin_context.addPluginCssClasses)(modal.containerEl, [import_css_class.CssClass.MinimizableModal]);
+    this.minimizeButtonEl = this.createMinimizeButton();
+    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.
+   */
+  minimize() {
+    if (this.isMinimizedValue) {
+      return;
+    }
+    this.isMinimizedValue = true;
+    this.minimizeButtonEl.hide();
+    this.modal.containerEl.hide();
+    this.minimizedBarEl = this.createMinimizedBar();
+  }
+  /**
+   * Restores the modal from the minimized state, removing the floating bar. A no-op if the modal is
+   * not minimized.
+   */
+  restore() {
+    if (!this.isMinimizedValue) {
+      return;
+    }
+    this.isMinimizedValue = false;
+    this.removeMinimizedBar();
+    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({ cls: 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);
+    restoreButtonEl.addEventListener("click", () => {
+      this.restore();
+    });
+    return barEl;
+  }
+  handleClose() {
+    this.removeMinimizedBar();
+    this.isMinimizedValue = false;
+  }
+  patchOnClose(modal) {
+    (0, import_monkey_around.around)(modal, {
+      onClose: (next) => {
+        return () => {
+          next.call(modal);
+          this.handleClose();
+        };
+      }
+    });
+  }
+  removeMinimizedBar() {
+    this.minimizedBarEl?.remove();
+    this.minimizedBarEl = null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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    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    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({ cls: 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    restoreButtonEl.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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,2BAAuB;AACvB,sBAAwB;AAExB,uBAAyB;AACzB,4BAAoC;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,mDAAoB,MAAM,aAAa,CAAC,0BAAS,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;AAC5B,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;AACxB,SAAK,MAAM,YAAY,KAAK;AAC5B,SAAK,iBAAiB,KAAK;AAAA,EAC7B;AAAA,EAEQ,uBAAoC;AAC1C,UAAM,WAAW,KAAK,MAAM,QAAQ,SAAS,UAAU,EAAE,KAAK,0BAAS,eAAe,CAAC;AACvF,iCAAQ,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,EAAE,KAAK,0BAAS,kBAAkB,CAAC;AACrG,UAAM,WAAW;AAAA,MACf,KAAK,0BAAS;AAAA,MACd,MAAM,KAAK,MAAM,QAAQ;AAAA,IAC3B,CAAC;AACD,UAAM,kBAAkB,MAAM,SAAS,UAAU,EAAE,KAAK,0BAAS,cAAc,CAAC;AAChF,iCAAQ,iBAAiB,eAAe;AACxC,oBAAgB,iBAAiB,SAAS,MAAM;AAC9C,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,qCAAO,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": []
}


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

@@ -0,0 +1,74 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @file
+ *
+ * A wrapper that makes any Obsidian {@link Modal} minimizable.
+ *
+ * Obsidian's {@link Modal} is blocking — while it is open the rest of the app is dimmed and
+ * inert — and it cannot be minimized. {@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: when minimized, the modal (and its blocking backdrop)
+ * is hidden and a small floating bar with a restore button is shown instead, so the app stays fully
+ * usable while a long-running operation continues in the background.
+ *
+ * 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(); // app is usable again; a floating bar offers "restore"
+ * ```
+ *
+ * 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).
+ */
+import type { Modal } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Wraps a {@link Modal} instance to make it minimizable to a small floating bar and restorable,
+ * keeping the app usable while minimized.
+ *
+ * @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;
+    private isMinimizedValue;
+    private readonly minimizeButtonEl;
+    private minimizedBarEl;
+    /**
+     * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
+     *
+     * @param modal - The modal instance to make minimizable.
+     */
+    constructor(modal: TModal);
+    /**
+     * 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.
+     */
+    minimize(): void;
+    /**
+     * Restores the modal from the minimized state, removing the floating bar. A no-op if the modal is
+     * not minimized.
+     */
+    restore(): void;
+    private createMinimizeButton;
+    private createMinimizedBar;
+    private handleClose;
+    private patchOnClose;
+    private removeMinimizedBar;
+}

package/dist/lib/cjs/obsidian/modals/modal.d.cts

@@ -4,7 +4,7 @@
  *
  * This module exports a base class for displaying modals in Obsidian.
  */
-import type { App } from 'obsidian';
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
 import { Modal } from 'obsidian';
 import type { PromiseResolve } from '../../async.cjs';
 /**

package/dist/lib/cjs/obsidian/modals/prompt.cjs

@@ -214,4 +214,4 @@ async function prompt(params) {
 0 && (module.exports = {
   prompt
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/prompt.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type { MaybeReturn } from '../../type.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport { CssClass } from '../../css-class.ts';\nimport { noop } from '../../function.ts';\nimport { t } from '../i18n/i18n.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Options for {@link prompt}.\n */\nexport interface PromptParams extends ModalParamsBase {\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * A default value to pre-fill the input field.\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   */\n  readonly placeholder?: string;\n\n  /**\n   * A title of the modal.\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  valueValidator?(this: void, value: string): Promisable<MaybeReturn<string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private isOkClicked = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel);\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n\n    const validate = async (): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      inputEl.reportValidity();\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    inputEl.addEventListener('keydown', (event: KeyboardEvent) => {\n      if (event.key === 'Enter') {\n        this.handleOk(event, textComponent);\n      } else if (event.key === 'Escape') {\n        this.close();\n      }\n    });\n    inputEl.addEventListener('input', convertAsyncToSync(validate));\n    inputEl.addEventListener('focus', convertAsyncToSync(validate));\n    invokeAsyncSafely(validate);\n    const okButton = new ButtonComponent(this.contentEl);\n    okButton.setButtonText(this.okButtonText);\n    okButton.setCta();\n    okButton.onClick((event) => {\n      this.handleOk(event, textComponent);\n    });\n    okButton.setClass(CssClass.OkButton);\n    const cancelButton = new ButtonComponent(this.contentEl);\n    cancelButton.setButtonText(this.cancelButtonText);\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n  }\n\n  private handleOk(event: Event, textComponent: TextComponent): void {\n    event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n}\n\n/**\n * Displays a prompt modal in Obsidian to get user input.\n *\n * @param params - The parameters for the prompt modal.\n * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.\n */\nexport async function prompt(params: PromptParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new PromptModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,sBAGO;AAQP,mBAGO;AACP,uBAAyB;AACzB,sBAAqB;AACrB,kBAAkB;AAClB,mBAGO;AA0CP,MAAM,oBAAoB,uBAAyB;AAAA,EAChC;AAAA,EACT,cAAc;AAAA,EACL;AAAA,EACA;AAAA,EACA;AAAA,EACT;AAAA,EACS;AAAA,EAEV,YAAY,QAAsC;AACvD,UAAM,MAAM;AACZ,SAAK,cAAc,0BAAS,WAAW;AACvC,SAAK,mBAAmB,OAAO,wBAAoB,eAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,MAAM;AAC7F,SAAK,eAAe,OAAO,oBAAgB,eAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,EAAE;AACjF,SAAK,cAAc,OAAO,eAAe;AACzC,SAAK,QAAQ,OAAO,SAAS;AAC7B,SAAK,iBAAiB,OAAO,kBAAkB;AAC/C,SAAK,QAAQ,OAAO,gBAAgB;AAAA,EACtC;AAAA,EAEgB,UAAgB;AAC9B,SAAK,eAAe,KAAK,cAAc,KAAK,QAAQ,IAAI;AAAA,EAC1D;AAAA,EAEgB,SAAe;AAC7B,SAAK,QAAQ,QAAQ,KAAK,KAAK;AAC/B,UAAM,gBAAgB,IAAI,8BAAc,KAAK,SAAS;AACtD,UAAM,UAAU,cAAc;AAE9B,UAAM,WAAW,YAA2B;AAC1C,YAAM,eAAe,MAAM,KAAK,eAAe,QAAQ,KAAK;AAC5D,cAAQ,kBAAkB,gBAAgB,EAAE;AAC5C,cAAQ,eAAe;AAAA,IACzB;AAEA,kBAAc,SAAS,KAAK,KAAK;AACjC,kBAAc,QAAQ,OAAO;AAC7B,kBAAc,eAAe,KAAK,WAAW;AAC7C,YAAQ,SAAS,0BAAS,OAAO;AACjC,kBAAc,SAAS,CAAC,aAAa;AACnC,WAAK,QAAQ;AAAA,IACf,CAAC;AACD,YAAQ,iBAAiB,WAAW,CAAC,UAAyB;AAC5D,UAAI,MAAM,QAAQ,SAAS;AACzB,aAAK,SAAS,OAAO,aAAa;AAAA,MACpC,WAAW,MAAM,QAAQ,UAAU;AACjC,aAAK,MAAM;AAAA,MACb;AAAA,IACF,CAAC;AACD,YAAQ,iBAAiB,aAAS,iCAAmB,QAAQ,CAAC;AAC9D,YAAQ,iBAAiB,aAAS,iCAAmB,QAAQ,CAAC;AAC9D,wCAAkB,QAAQ;AAC1B,UAAM,WAAW,IAAI,gCAAgB,KAAK,SAAS;AACnD,aAAS,cAAc,KAAK,YAAY;AACxC,aAAS,OAAO;AAChB,aAAS,QAAQ,CAAC,UAAU;AAC1B,WAAK,SAAS,OAAO,aAAa;AAAA,IACpC,CAAC;AACD,aAAS,SAAS,0BAAS,QAAQ;AACnC,UAAM,eAAe,IAAI,gCAAgB,KAAK,SAAS;AACvD,iBAAa,cAAc,KAAK,gBAAgB;AAChD,iBAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,CAAC;AAC1C,iBAAa,SAAS,0BAAS,YAAY;AAAA,EAC7C;AAAA,EAEQ,SAAS,OAAc,eAAoC;AACjE,UAAM,eAAe;AACrB,QAAI,CAAC,cAAc,QAAQ,cAAc,GAAG;AAC1C;AAAA,IACF;AAEA,SAAK,cAAc;AACnB,SAAK,MAAM;AAAA,EACb;AACF;AAQA,eAAsB,OAAO,QAA8C;AACzE,SAAO,UAAM;AAAA,IAAyB,CAAC,mBACrC,IAAI,YAAY;AAAA,MACd,GAAG;AAAA,MACH;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/prompt.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type { MaybeReturn } from '../../type.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport { CssClass } from '../../css-class.ts';\nimport { noop } from '../../function.ts';\nimport { t } from '../i18n/i18n.ts';\nimport {\n  ModalBase,\n  showModal\n} from './modal.ts';\n\n/**\n * Options for {@link prompt}.\n */\nexport interface PromptParams extends ModalParamsBase {\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * A default value to pre-fill the input field.\n   *\n   * @default `''`\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   *\n   * @default `''`\n   */\n  readonly placeholder?: string;\n\n  /**\n   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  valueValidator?(this: void, value: string): Promisable<MaybeReturn<string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private isOkClicked = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel);\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n\n    const validate = async (): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      inputEl.reportValidity();\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    inputEl.addEventListener('keydown', (event: KeyboardEvent) => {\n      if (event.key === 'Enter') {\n        this.handleOk(event, textComponent);\n      } else if (event.key === 'Escape') {\n        this.close();\n      }\n    });\n    inputEl.addEventListener('input', convertAsyncToSync(validate));\n    inputEl.addEventListener('focus', convertAsyncToSync(validate));\n    invokeAsyncSafely(validate);\n    const okButton = new ButtonComponent(this.contentEl);\n    okButton.setButtonText(this.okButtonText);\n    okButton.setCta();\n    okButton.onClick((event) => {\n      this.handleOk(event, textComponent);\n    });\n    okButton.setClass(CssClass.OkButton);\n    const cancelButton = new ButtonComponent(this.contentEl);\n    cancelButton.setButtonText(this.cancelButtonText);\n    cancelButton.onClick(this.close.bind(this));\n    cancelButton.setClass(CssClass.CancelButton);\n  }\n\n  private handleOk(event: Event, textComponent: TextComponent): void {\n    event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n}\n\n/**\n * Displays a prompt modal in Obsidian to get user input.\n *\n * @param params - The parameters for the prompt modal.\n * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.\n */\nexport async function prompt(params: PromptParams): Promise<null | string> {\n  return await showModal<null | string>((promiseResolve) =>\n    new PromptModal({\n      ...params,\n      promiseResolve\n    })\n  );\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,sBAGO;AAQP,mBAGO;AACP,uBAAyB;AACzB,sBAAqB;AACrB,kBAAkB;AAClB,mBAGO;AAgDP,MAAM,oBAAoB,uBAAyB;AAAA,EAChC;AAAA,EACT,cAAc;AAAA,EACL;AAAA,EACA;AAAA,EACA;AAAA,EACT;AAAA,EACS;AAAA,EAEV,YAAY,QAAsC;AACvD,UAAM,MAAM;AACZ,SAAK,cAAc,0BAAS,WAAW;AACvC,SAAK,mBAAmB,OAAO,wBAAoB,eAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,MAAM;AAC7F,SAAK,eAAe,OAAO,oBAAgB,eAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,EAAE;AACjF,SAAK,cAAc,OAAO,eAAe;AACzC,SAAK,QAAQ,OAAO,SAAS;AAC7B,SAAK,iBAAiB,OAAO,kBAAkB;AAC/C,SAAK,QAAQ,OAAO,gBAAgB;AAAA,EACtC;AAAA,EAEgB,UAAgB;AAC9B,SAAK,eAAe,KAAK,cAAc,KAAK,QAAQ,IAAI;AAAA,EAC1D;AAAA,EAEgB,SAAe;AAC7B,SAAK,QAAQ,QAAQ,KAAK,KAAK;AAC/B,UAAM,gBAAgB,IAAI,8BAAc,KAAK,SAAS;AACtD,UAAM,UAAU,cAAc;AAE9B,UAAM,WAAW,YAA2B;AAC1C,YAAM,eAAe,MAAM,KAAK,eAAe,QAAQ,KAAK;AAC5D,cAAQ,kBAAkB,gBAAgB,EAAE;AAC5C,cAAQ,eAAe;AAAA,IACzB;AAEA,kBAAc,SAAS,KAAK,KAAK;AACjC,kBAAc,QAAQ,OAAO;AAC7B,kBAAc,eAAe,KAAK,WAAW;AAC7C,YAAQ,SAAS,0BAAS,OAAO;AACjC,kBAAc,SAAS,CAAC,aAAa;AACnC,WAAK,QAAQ;AAAA,IACf,CAAC;AACD,YAAQ,iBAAiB,WAAW,CAAC,UAAyB;AAC5D,UAAI,MAAM,QAAQ,SAAS;AACzB,aAAK,SAAS,OAAO,aAAa;AAAA,MACpC,WAAW,MAAM,QAAQ,UAAU;AACjC,aAAK,MAAM;AAAA,MACb;AAAA,IACF,CAAC;AACD,YAAQ,iBAAiB,aAAS,iCAAmB,QAAQ,CAAC;AAC9D,YAAQ,iBAAiB,aAAS,iCAAmB,QAAQ,CAAC;AAC9D,wCAAkB,QAAQ;AAC1B,UAAM,WAAW,IAAI,gCAAgB,KAAK,SAAS;AACnD,aAAS,cAAc,KAAK,YAAY;AACxC,aAAS,OAAO;AAChB,aAAS,QAAQ,CAAC,UAAU;AAC1B,WAAK,SAAS,OAAO,aAAa;AAAA,IACpC,CAAC;AACD,aAAS,SAAS,0BAAS,QAAQ;AACnC,UAAM,eAAe,IAAI,gCAAgB,KAAK,SAAS;AACvD,iBAAa,cAAc,KAAK,gBAAgB;AAChD,iBAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,CAAC;AAC1C,iBAAa,SAAS,0BAAS,YAAY;AAAA,EAC7C;AAAA,EAEQ,SAAS,OAAc,eAAoC;AACjE,UAAM,eAAe;AACrB,QAAI,CAAC,cAAc,QAAQ,cAAc,GAAG;AAC1C;AAAA,IACF;AAEA,SAAK,cAAc;AACnB,SAAK,MAAM;AAAA,EACb;AACF;AAQA,eAAsB,OAAO,QAA8C;AACzE,SAAO,UAAM;AAAA,IAAyB,CAAC,mBACrC,IAAI,YAAY;AAAA,MACd,GAAG;AAAA,MACH;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
  "names": []
}


package/dist/lib/cjs/obsidian/modals/prompt.d.cts

@@ -6,7 +6,7 @@
  *
  * This module exports a function to display a modal that prompts the user for input. The modal includes "OK" and "Cancel" buttons.
  */
-import type { Promisable } from 'type-fest';
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { MaybeReturn } from '../../type.cjs';
 import type { ModalParamsBase } from './modal.cjs';
 /**
@@ -19,6 +19,8 @@ export interface PromptParams extends ModalParamsBase {
     readonly cancelButtonText?: string;
     /**
      * A default value to pre-fill the input field.
+     *
+     * @default `''`
      */
     readonly defaultValue?: string;
     /**
@@ -27,10 +29,14 @@ export interface PromptParams extends ModalParamsBase {
     readonly okButtonText?: string;
     /**
      * A placeholder text for the input field.
+     *
+     * @default `''`
      */
     readonly placeholder?: string;
     /**
      * A title of the modal.
+     *
+     * @default `''`
      */
     readonly title?: DocumentFragment | string;
     /**

package/dist/lib/cjs/obsidian/modals/select-item.cjs

@@ -179,4 +179,4 @@ async function selectItem(params) {
 0 && (module.exports = {
   selectItem
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/modals/select-item.d.cts

@@ -26,6 +26,8 @@ export interface SelectItemParams<T> extends ModalParamsBase {
     itemTextFunc(this: void, item: T): string;
     /**
      * A placeholder text for the input field.
+     *
+     * @default `''`
      */
     readonly placeholder?: string;
 }

package/dist/lib/cjs/obsidian/obsidian-protocol-handler-registrar.d.cts

@@ -4,8 +4,8 @@
  *
  * Obsidian protocol handler registrars.
  */
-import type { ObsidianProtocolData, Plugin } from 'obsidian';
-import type { Promisable } from 'type-fest';
+import type { ObsidianProtocolData, Plugin } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 /**
  * A registrar for Obsidian protocol handlers.
  */

package/dist/lib/cjs/obsidian/obsidian-settings.d.cts

@@ -4,7 +4,7 @@
  *
  * This module provides utility functions for working with Obsidian settings.
  */
-import type { App } from 'obsidian';
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
 /**
  * A format of the new link.
  */

package/dist/lib/cjs/obsidian/plugin/plugin-context.d.cts

@@ -4,7 +4,7 @@
  *
  * Initializes the plugin context and sets up the plugin ID.
  */
-import type { Component } from 'obsidian';
+import type { Component } from 'obsidian' with { 'resolution-mode': 'import' };
 /**
  * Sets the CSS class of an element.
  *

package/dist/lib/cjs/obsidian/plugin/plugin-event-source.d.cts

@@ -4,7 +4,7 @@
  *
  * Contains the implementation of the plugin event source.
  */
-import type { Promisable } from 'type-fest';
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { AsyncEventRef, AsyncEventSource } from '../../async-events.cjs';
 import type { StringKeys } from '../../type.cjs';
 import type { PluginBase } from './plugin.cjs';