obsidian-dev-utils 18.4.0 → 19.0.0

package/dist/lib/obsidian/Modals/Alert.d.mts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation Alert
+ * Utility for displaying alert modals in Obsidian.
+ *
+ * This module exports a function to display a modal with a message in Obsidian. The modal includes an "OK" button to close it.
+ */
+import type { App } from 'obsidian';
+/**
+ * The options for the alert modal.
+ */
+export interface AlertOptions {
+    /**
+     * The Obsidian app instance.
+     */
+    app: App;
+    /**
+     * The CSS class to apply to the modal.
+     */
+    cssClass?: string;
+    /**
+     * The message to display in the modal.
+     */
+    message: DocumentFragment | string;
+    /**
+     * The text for the "OK" button.
+     */
+    okButtonText?: string;
+    /**
+     * The title of the modal.
+     */
+    title?: DocumentFragment | string;
+}
+/**
+ * Displays an alert modal in Obsidian with a specified message.
+ *
+ * @param options - The options for the alert modal.
+ * @returns A promise that resolves when the modal is closed.
+ */
+export declare function alert(options: AlertOptions): Promise<void>;

package/dist/lib/obsidian/Modals/Confirm.d.mts

@@ -0,0 +1,43 @@
+/**
+ * @packageDocumentation Confirm
+ * Utility for displaying confirm modals in Obsidian.
+ *
+ * This module exports a function to display a modal with a message in Obsidian. The modal includes "OK" and "Cancel" buttons to confirm or cancel the action.
+ */
+import type { App } from 'obsidian';
+/**
+ * The options for the confirm modal.
+ */
+export interface ConfirmOptions {
+    /**
+     * The Obsidian app instance.
+     */
+    app: App;
+    /**
+     * The text for the "Cancel" button.
+     */
+    cancelButtonText?: string;
+    /**
+     * The CSS class to apply to the modal.
+     */
+    cssClass?: string;
+    /**
+     * The message to display in the modal.
+     */
+    message: DocumentFragment | string;
+    /**
+     * The text for the "OK" button.
+     */
+    okButtonText?: string;
+    /**
+     * The title of the modal.
+     */
+    title?: DocumentFragment | string;
+}
+/**
+ * Displays an confirm modal in Obsidian with a specified message.
+ *
+ * @param options - The options for the confirm modal.
+ * @returns A promise that resolves with a boolean indicating whether the "OK" button was clicked.
+ */
+export declare function confirm(options: ConfirmOptions): Promise<boolean>;

package/dist/lib/obsidian/Modals/{ModalBase.d.ts → ModalBase.d.cts}

@@ -5,7 +5,7 @@
  */
 import type { App } from 'obsidian';
 import { Modal } from 'obsidian';
-import type { PromiseResolve } from '../../Async.ts';
+import type { PromiseResolve } from '../../Async.cjs';
 /**
  * The base options for a modal.
  */

package/dist/lib/obsidian/Modals/ModalBase.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @packageDocumentation ModalBase
+ *
+ * This module exports a base class for displaying modals in Obsidian.
+ */
+import type { App } from 'obsidian';
+import { Modal } from 'obsidian';
+import type { PromiseResolve } from '../../Async.mjs';
+/**
+ * The base options for a modal.
+ */
+export interface ModalOptionsBase {
+    /**
+     * The application instance.
+     */
+    app: App;
+    /**
+     * The CSS class to apply to the modal.
+     */
+    cssClass?: string;
+}
+/**
+ * A base class for displaying modals in Obsidian.
+ */
+export declare abstract class ModalBase<Value, Options extends ModalOptionsBase> extends Modal {
+    protected resolve: PromiseResolve<Value>;
+    constructor(options: Options, resolve: PromiseResolve<Value>, modalCssClass: string);
+}
+/**
+ * Displays a modal in Obsidian.
+ *
+ * @param modalCreator - A function that creates a modal.
+ * @returns A promise that resolves when the modal is closed.
+ */
+export declare function showModal<T>(modalCreator: (resolve: PromiseResolve<T>) => Modal): Promise<T>;

package/dist/lib/obsidian/Modals/Prompt.cjs

@@ -69,7 +69,7 @@ class PromptModal extends import_ModalBase.ModalBase {
     textComponent.onChange((newValue) => {
       this.value = newValue;
     });
-    addEventListener("keydown", (event) => {
+    inputEl.addEventListener("keydown", (event) => {
       if (event.key === "Enter") {
         this.handleOk(event, textComponent);
       } else if (event.key === "Escape") {
@@ -107,4 +107,4 @@ async function prompt(options) {
 0 && (module.exports = {
   prompt
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Modals/Prompt.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Prompt\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 {\n  App,\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  MaybePromise,\n  PromiseResolve\n} from '../../Async.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport {\n  ModalBase,\n  showModal\n} from './ModalBase.ts';\n\n/**\n * The options for the prompt modal.\n */\nexport interface PromptOptions {\n  /**\n   * The Obsidian app instance.\n   */\n  app: App;\n\n  /**\n   * The text for the \"Cancel\" button.\n   */\n  cancelButtonText?: string;\n\n  /**\n   * The default value to pre-fill the input field.\n   */\n  defaultValue?: string;\n\n  /**\n   * The text for the \"OK\" button.\n   */\n  okButtonText?: string;\n\n  /**\n   * The placeholder text for the input field.\n   */\n  placeholder?: string;\n\n  /**\n   * The title of the modal.\n   */\n  title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\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  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  valueValidator?: (value: string) => MaybePromise<string | void>;\n}\n\nclass PromptModal extends ModalBase<null | string, PromptOptions> {\n  private isOkClicked = false;\n  private options: Required<PromptOptions>;\n  private value: string;\n\n  public constructor(options: PromptOptions, resolve: PromiseResolve<null | string>) {\n    super(options, resolve, CssClass.PromptModal);\n    const DEFAULT_OPTIONS: Required<PromptOptions> = {\n      app: options.app,\n      cancelButtonText: 'Cancel',\n      defaultValue: '',\n      okButtonText: 'OK',\n      placeholder: '',\n      title: '',\n      valueValidator: noop\n    };\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n    this.value = options.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.resolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.options.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.options.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      inputEl.reportValidity();\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.setPlaceholder(this.options.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    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.options.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.options.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 options - The options for the prompt modal.\n * @returns A promise that resolves with the user input or null if the prompt was cancelled.\n */\nexport async function prompt(options: PromptOptions): Promise<null | string> {\n  return await showModal<null | string>((resolve) => new PromptModal(options, resolve));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAIO;AAOP,mBAGO;AACP,sBAAyB;AACzB,sBAAqB;AACrB,uBAGO;AA6CP,MAAM,oBAAoB,2BAAwC;AAAA,EACxD,cAAc;AAAA,EACd;AAAA,EACA;AAAA,EAED,YAAY,SAAwB,SAAwC;AACjF,UAAM,SAAS,SAAS,yBAAS,WAAW;AAC5C,UAAM,kBAA2C;AAAA,MAC/C,KAAK,QAAQ;AAAA,MACb,kBAAkB;AAAA,MAClB,cAAc;AAAA,MACd,cAAc;AAAA,MACd,aAAa;AAAA,MACb,OAAO;AAAA,MACP,gBAAgB;AAAA,IAClB;AACA,SAAK,UAAU,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAChD,SAAK,QAAQ,QAAQ,gBAAgB;AAAA,EACvC;AAAA,EAEgB,UAAgB;AAC9B,SAAK,QAAQ,KAAK,cAAc,KAAK,QAAQ,IAAI;AAAA,EACnD;AAAA,EAEgB,SAAe;AAC7B,SAAK,QAAQ,QAAQ,KAAK,QAAQ,KAAK;AACvC,UAAM,gBAAgB,IAAI,8BAAc,KAAK,SAAS;AACtD,UAAM,UAAU,cAAc;AAE9B,UAAM,WAAW,YAA2B;AAC1C,YAAM,eAAe,MAAM,KAAK,QAAQ,eAAe,QAAQ,KAAK;AACpE,cAAQ,kBAAkB,gBAAgB,EAAE;AAC5C,cAAQ,eAAe;AAAA,IACzB;AAEA,kBAAc,SAAS,KAAK,KAAK;AACjC,kBAAc,eAAe,KAAK,QAAQ,WAAW;AACrD,YAAQ,SAAS,yBAAS,OAAO;AACjC,kBAAc,SAAS,CAAC,aAAa;AACnC,WAAK,QAAQ;AAAA,IACf,CAAC;AACD,qBAAiB,WAAW,CAAC,UAAyB;AACpD,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,QAAQ,YAAY;AAChD,aAAS,OAAO;AAChB,aAAS,QAAQ,CAAC,UAAU;AAC1B,WAAK,SAAS,OAAO,aAAa;AAAA,IACpC,CAAC;AACD,aAAS,SAAS,yBAAS,QAAQ;AACnC,UAAM,eAAe,IAAI,gCAAgB,KAAK,SAAS;AACvD,iBAAa,cAAc,KAAK,QAAQ,gBAAgB;AACxD,iBAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,CAAC;AAC1C,iBAAa,SAAS,yBAAS,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,SAAgD;AAC3E,SAAO,UAAM,4BAAyB,CAAC,YAAY,IAAI,YAAY,SAAS,OAAO,CAAC;AACtF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Modals/Prompt.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Prompt\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 {\n  App,\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  MaybePromise,\n  PromiseResolve\n} from '../../Async.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport {\n  ModalBase,\n  showModal\n} from './ModalBase.ts';\n\n/**\n * The options for the prompt modal.\n */\nexport interface PromptOptions {\n  /**\n   * The Obsidian app instance.\n   */\n  app: App;\n\n  /**\n   * The text for the \"Cancel\" button.\n   */\n  cancelButtonText?: string;\n\n  /**\n   * The default value to pre-fill the input field.\n   */\n  defaultValue?: string;\n\n  /**\n   * The text for the \"OK\" button.\n   */\n  okButtonText?: string;\n\n  /**\n   * The placeholder text for the input field.\n   */\n  placeholder?: string;\n\n  /**\n   * The title of the modal.\n   */\n  title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\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  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  valueValidator?: (value: string) => MaybePromise<string | void>;\n}\n\nclass PromptModal extends ModalBase<null | string, PromptOptions> {\n  private isOkClicked = false;\n  private options: Required<PromptOptions>;\n  private value: string;\n\n  public constructor(options: PromptOptions, resolve: PromiseResolve<null | string>) {\n    super(options, resolve, CssClass.PromptModal);\n    const DEFAULT_OPTIONS: Required<PromptOptions> = {\n      app: options.app,\n      cancelButtonText: 'Cancel',\n      defaultValue: '',\n      okButtonText: 'OK',\n      placeholder: '',\n      title: '',\n      valueValidator: noop\n    };\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n    this.value = options.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.resolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.options.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.options.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      inputEl.reportValidity();\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.setPlaceholder(this.options.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.options.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.options.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 options - The options for the prompt modal.\n * @returns A promise that resolves with the user input or null if the prompt was cancelled.\n */\nexport async function prompt(options: PromptOptions): Promise<null | string> {\n  return await showModal<null | string>((resolve) => new PromptModal(options, resolve));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAIO;AAOP,mBAGO;AACP,sBAAyB;AACzB,sBAAqB;AACrB,uBAGO;AA6CP,MAAM,oBAAoB,2BAAwC;AAAA,EACxD,cAAc;AAAA,EACd;AAAA,EACA;AAAA,EAED,YAAY,SAAwB,SAAwC;AACjF,UAAM,SAAS,SAAS,yBAAS,WAAW;AAC5C,UAAM,kBAA2C;AAAA,MAC/C,KAAK,QAAQ;AAAA,MACb,kBAAkB;AAAA,MAClB,cAAc;AAAA,MACd,cAAc;AAAA,MACd,aAAa;AAAA,MACb,OAAO;AAAA,MACP,gBAAgB;AAAA,IAClB;AACA,SAAK,UAAU,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAChD,SAAK,QAAQ,QAAQ,gBAAgB;AAAA,EACvC;AAAA,EAEgB,UAAgB;AAC9B,SAAK,QAAQ,KAAK,cAAc,KAAK,QAAQ,IAAI;AAAA,EACnD;AAAA,EAEgB,SAAe;AAC7B,SAAK,QAAQ,QAAQ,KAAK,QAAQ,KAAK;AACvC,UAAM,gBAAgB,IAAI,8BAAc,KAAK,SAAS;AACtD,UAAM,UAAU,cAAc;AAE9B,UAAM,WAAW,YAA2B;AAC1C,YAAM,eAAe,MAAM,KAAK,QAAQ,eAAe,QAAQ,KAAK;AACpE,cAAQ,kBAAkB,gBAAgB,EAAE;AAC5C,cAAQ,eAAe;AAAA,IACzB;AAEA,kBAAc,SAAS,KAAK,KAAK;AACjC,kBAAc,eAAe,KAAK,QAAQ,WAAW;AACrD,YAAQ,SAAS,yBAAS,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,QAAQ,YAAY;AAChD,aAAS,OAAO;AAChB,aAAS,QAAQ,CAAC,UAAU;AAC1B,WAAK,SAAS,OAAO,aAAa;AAAA,IACpC,CAAC;AACD,aAAS,SAAS,yBAAS,QAAQ;AACnC,UAAM,eAAe,IAAI,gCAAgB,KAAK,SAAS;AACvD,iBAAa,cAAc,KAAK,QAAQ,gBAAgB;AACxD,iBAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,CAAC;AAC1C,iBAAa,SAAS,yBAAS,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,SAAgD;AAC3E,SAAO,UAAM,4BAAyB,CAAC,YAAY,IAAI,YAAY,SAAS,OAAO,CAAC;AACtF;",
  "names": []
}


package/dist/lib/obsidian/Modals/{Prompt.d.ts → Prompt.d.cts}

@@ -5,7 +5,7 @@
  * This module exports a function to display a modal that prompts the user for input. The modal includes "OK" and "Cancel" buttons.
  */
 import { App } from 'obsidian';
-import type { MaybePromise } from '../../Async.ts';
+import type { MaybePromise } from '../../Async.cjs';
 /**
  * The options for the prompt modal.
  */

package/dist/lib/obsidian/Modals/Prompt.d.mts

@@ -0,0 +1,50 @@
+/**
+ * @packageDocumentation Prompt
+ * Utility for displaying a prompt modal in Obsidian.
+ *
+ * This module exports a function to display a modal that prompts the user for input. The modal includes "OK" and "Cancel" buttons.
+ */
+import { App } from 'obsidian';
+import type { MaybePromise } from '../../Async.mjs';
+/**
+ * The options for the prompt modal.
+ */
+export interface PromptOptions {
+    /**
+     * The Obsidian app instance.
+     */
+    app: App;
+    /**
+     * The text for the "Cancel" button.
+     */
+    cancelButtonText?: string;
+    /**
+     * The default value to pre-fill the input field.
+     */
+    defaultValue?: string;
+    /**
+     * The text for the "OK" button.
+     */
+    okButtonText?: string;
+    /**
+     * The placeholder text for the input field.
+     */
+    placeholder?: string;
+    /**
+     * The title of the modal.
+     */
+    title?: DocumentFragment | string;
+    /**
+     * A function to validate the input value.
+     * @param value - The input value to validate.
+     * @returns an error message if the value is invalid, or null if the value is valid.
+     */
+    valueValidator?: (value: string) => MaybePromise<string | void>;
+}
+/**
+ * Displays a prompt modal in Obsidian to get user input.
+ *
+ * @param options - The options for the prompt modal.
+ * @returns A promise that resolves with the user input or null if the prompt was cancelled.
+ */
+export declare function prompt(options: PromptOptions): Promise<null | string>;

package/dist/lib/obsidian/Modals/Prompt.mjs

@@ -56,7 +56,7 @@ class PromptModal extends ModalBase {
     textComponent.onChange((newValue) => {
       this.value = newValue;
     });
-    addEventListener("keydown", (event) => {
+    inputEl.addEventListener("keydown", (event) => {
       if (event.key === "Enter") {
         this.handleOk(event, textComponent);
       } else if (event.key === "Escape") {
@@ -93,4 +93,4 @@ async function prompt(options) {
 export {
   prompt
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Modals/Prompt.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Prompt\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 {\n  App,\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  MaybePromise,\n  PromiseResolve\n} from '../../Async.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport {\n  ModalBase,\n  showModal\n} from './ModalBase.ts';\n\n/**\n * The options for the prompt modal.\n */\nexport interface PromptOptions {\n  /**\n   * The Obsidian app instance.\n   */\n  app: App;\n\n  /**\n   * The text for the \"Cancel\" button.\n   */\n  cancelButtonText?: string;\n\n  /**\n   * The default value to pre-fill the input field.\n   */\n  defaultValue?: string;\n\n  /**\n   * The text for the \"OK\" button.\n   */\n  okButtonText?: string;\n\n  /**\n   * The placeholder text for the input field.\n   */\n  placeholder?: string;\n\n  /**\n   * The title of the modal.\n   */\n  title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\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  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  valueValidator?: (value: string) => MaybePromise<string | void>;\n}\n\nclass PromptModal extends ModalBase<null | string, PromptOptions> {\n  private isOkClicked = false;\n  private options: Required<PromptOptions>;\n  private value: string;\n\n  public constructor(options: PromptOptions, resolve: PromiseResolve<null | string>) {\n    super(options, resolve, CssClass.PromptModal);\n    const DEFAULT_OPTIONS: Required<PromptOptions> = {\n      app: options.app,\n      cancelButtonText: 'Cancel',\n      defaultValue: '',\n      okButtonText: 'OK',\n      placeholder: '',\n      title: '',\n      valueValidator: noop\n    };\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n    this.value = options.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.resolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.options.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.options.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      inputEl.reportValidity();\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.setPlaceholder(this.options.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    textComponent.onChange((newValue) => {\n      this.value = newValue;\n    });\n    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.options.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.options.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 options - The options for the prompt modal.\n * @returns A promise that resolves with the user input or null if the prompt was cancelled.\n */\nexport async function prompt(options: PromptOptions): Promise<null | string> {\n  return await showModal<null | string>((resolve) => new PromptModal(options, resolve));\n}\n"],
  "mappings": ";;;;;;;AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA6CP,MAAM,oBAAoB,UAAwC;AAAA,EACxD,cAAc;AAAA,EACd;AAAA,EACA;AAAA,EAED,YAAY,SAAwB,SAAwC;AACjF,UAAM,SAAS,SAAS,SAAS,WAAW;AAC5C,UAAM,kBAA2C;AAAA,MAC/C,KAAK,QAAQ;AAAA,MACb,kBAAkB;AAAA,MAClB,cAAc;AAAA,MACd,cAAc;AAAA,MACd,aAAa;AAAA,MACb,OAAO;AAAA,MACP,gBAAgB;AAAA,IAClB;AACA,SAAK,UAAU,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAChD,SAAK,QAAQ,QAAQ,gBAAgB;AAAA,EACvC;AAAA,EAEgB,UAAgB;AAC9B,SAAK,QAAQ,KAAK,cAAc,KAAK,QAAQ,IAAI;AAAA,EACnD;AAAA,EAEgB,SAAe;AAC7B,SAAK,QAAQ,QAAQ,KAAK,QAAQ,KAAK;AACvC,UAAM,gBAAgB,IAAI,cAAc,KAAK,SAAS;AACtD,UAAM,UAAU,cAAc;AAE9B,UAAM,WAAW,YAA2B;AAC1C,YAAM,eAAe,MAAM,KAAK,QAAQ,eAAe,QAAQ,KAAK;AACpE,cAAQ,kBAAkB,gBAAgB,EAAE;AAC5C,cAAQ,eAAe;AAAA,IACzB;AAEA,kBAAc,SAAS,KAAK,KAAK;AACjC,kBAAc,eAAe,KAAK,QAAQ,WAAW;AACrD,YAAQ,SAAS,SAAS,OAAO;AACjC,kBAAc,SAAS,CAAC,aAAa;AACnC,WAAK,QAAQ;AAAA,IACf,CAAC;AACD,qBAAiB,WAAW,CAAC,UAAyB;AACpD,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,SAAS,mBAAmB,QAAQ,CAAC;AAC9D,YAAQ,iBAAiB,SAAS,mBAAmB,QAAQ,CAAC;AAC9D,sBAAkB,QAAQ;AAC1B,UAAM,WAAW,IAAI,gBAAgB,KAAK,SAAS;AACnD,aAAS,cAAc,KAAK,QAAQ,YAAY;AAChD,aAAS,OAAO;AAChB,aAAS,QAAQ,CAAC,UAAU;AAC1B,WAAK,SAAS,OAAO,aAAa;AAAA,IACpC,CAAC;AACD,aAAS,SAAS,SAAS,QAAQ;AACnC,UAAM,eAAe,IAAI,gBAAgB,KAAK,SAAS;AACvD,iBAAa,cAAc,KAAK,QAAQ,gBAAgB;AACxD,iBAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,CAAC;AAC1C,iBAAa,SAAS,SAAS,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,SAAgD;AAC3E,SAAO,MAAM,UAAyB,CAAC,YAAY,IAAI,YAAY,SAAS,OAAO,CAAC;AACtF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Modals/Prompt.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Prompt\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 {\n  App,\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  MaybePromise,\n  PromiseResolve\n} from '../../Async.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../Async.ts';\nimport { CssClass } from '../../CssClass.ts';\nimport { noop } from '../../Function.ts';\nimport {\n  ModalBase,\n  showModal\n} from './ModalBase.ts';\n\n/**\n * The options for the prompt modal.\n */\nexport interface PromptOptions {\n  /**\n   * The Obsidian app instance.\n   */\n  app: App;\n\n  /**\n   * The text for the \"Cancel\" button.\n   */\n  cancelButtonText?: string;\n\n  /**\n   * The default value to pre-fill the input field.\n   */\n  defaultValue?: string;\n\n  /**\n   * The text for the \"OK\" button.\n   */\n  okButtonText?: string;\n\n  /**\n   * The placeholder text for the input field.\n   */\n  placeholder?: string;\n\n  /**\n   * The title of the modal.\n   */\n  title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\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  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  valueValidator?: (value: string) => MaybePromise<string | void>;\n}\n\nclass PromptModal extends ModalBase<null | string, PromptOptions> {\n  private isOkClicked = false;\n  private options: Required<PromptOptions>;\n  private value: string;\n\n  public constructor(options: PromptOptions, resolve: PromiseResolve<null | string>) {\n    super(options, resolve, CssClass.PromptModal);\n    const DEFAULT_OPTIONS: Required<PromptOptions> = {\n      app: options.app,\n      cancelButtonText: 'Cancel',\n      defaultValue: '',\n      okButtonText: 'OK',\n      placeholder: '',\n      title: '',\n      valueValidator: noop\n    };\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n    this.value = options.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.resolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.options.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.options.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      inputEl.reportValidity();\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.setPlaceholder(this.options.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.options.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.options.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 options - The options for the prompt modal.\n * @returns A promise that resolves with the user input or null if the prompt was cancelled.\n */\nexport async function prompt(options: PromptOptions): Promise<null | string> {\n  return await showModal<null | string>((resolve) => new PromptModal(options, resolve));\n}\n"],
  "mappings": ";;;;;;;AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA6CP,MAAM,oBAAoB,UAAwC;AAAA,EACxD,cAAc;AAAA,EACd;AAAA,EACA;AAAA,EAED,YAAY,SAAwB,SAAwC;AACjF,UAAM,SAAS,SAAS,SAAS,WAAW;AAC5C,UAAM,kBAA2C;AAAA,MAC/C,KAAK,QAAQ;AAAA,MACb,kBAAkB;AAAA,MAClB,cAAc;AAAA,MACd,cAAc;AAAA,MACd,aAAa;AAAA,MACb,OAAO;AAAA,MACP,gBAAgB;AAAA,IAClB;AACA,SAAK,UAAU,EAAE,GAAG,iBAAiB,GAAG,QAAQ;AAChD,SAAK,QAAQ,QAAQ,gBAAgB;AAAA,EACvC;AAAA,EAEgB,UAAgB;AAC9B,SAAK,QAAQ,KAAK,cAAc,KAAK,QAAQ,IAAI;AAAA,EACnD;AAAA,EAEgB,SAAe;AAC7B,SAAK,QAAQ,QAAQ,KAAK,QAAQ,KAAK;AACvC,UAAM,gBAAgB,IAAI,cAAc,KAAK,SAAS;AACtD,UAAM,UAAU,cAAc;AAE9B,UAAM,WAAW,YAA2B;AAC1C,YAAM,eAAe,MAAM,KAAK,QAAQ,eAAe,QAAQ,KAAK;AACpE,cAAQ,kBAAkB,gBAAgB,EAAE;AAC5C,cAAQ,eAAe;AAAA,IACzB;AAEA,kBAAc,SAAS,KAAK,KAAK;AACjC,kBAAc,eAAe,KAAK,QAAQ,WAAW;AACrD,YAAQ,SAAS,SAAS,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,SAAS,mBAAmB,QAAQ,CAAC;AAC9D,YAAQ,iBAAiB,SAAS,mBAAmB,QAAQ,CAAC;AAC9D,sBAAkB,QAAQ;AAC1B,UAAM,WAAW,IAAI,gBAAgB,KAAK,SAAS;AACnD,aAAS,cAAc,KAAK,QAAQ,YAAY;AAChD,aAAS,OAAO;AAChB,aAAS,QAAQ,CAAC,UAAU;AAC1B,WAAK,SAAS,OAAO,aAAa;AAAA,IACpC,CAAC;AACD,aAAS,SAAS,SAAS,QAAQ;AACnC,UAAM,eAAe,IAAI,gBAAgB,KAAK,SAAS;AACvD,iBAAa,cAAc,KAAK,QAAQ,gBAAgB;AACxD,iBAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,CAAC;AAC1C,iBAAa,SAAS,SAAS,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,SAAgD;AAC3E,SAAO,MAAM,UAAyB,CAAC,YAAY,IAAI,YAAY,SAAS,OAAO,CAAC;AACtF;",
  "names": []
}


package/dist/lib/obsidian/Modals/SelectItem.d.mts

@@ -0,0 +1,41 @@
+/**
+ * @packageDocumentation selectItem
+ * Utility for displaying a selection modal in Obsidian.
+ *
+ * This module exports a function to display a modal that allows the user to select an item from a list. The modal uses fuzzy search to help the user find the item.
+ */
+import { App } from 'obsidian';
+/**
+ * The parameters for the selection modal.
+ */
+export interface SelectItemOptions<T> {
+    /**
+     * The Obsidian app instance.
+     */
+    app: App;
+    /**
+     * The CSS class to apply to the modal.
+     */
+    cssClass?: string;
+    /**
+     * The list of items to choose from.
+     */
+    items: T[];
+    /**
+     * A function to get the display text for each item
+     * @param item - The item to get the display text for.
+     * @returns The display text for the item.
+     */
+    itemTextFunc: (item: T) => string;
+    /**
+     * The placeholder text for the input field.
+     */
+    placeholder?: string;
+}
+/**
+ * Displays a selection modal in Obsidian for choosing an item from a list.
+ *
+ * @param options - The options for the selection modal.
+ * @returns A promise that resolves with the selected item or null if no item was selected.
+ */
+export declare function selectItem<T>(options: SelectItemOptions<T>): Promise<null | T>;

package/dist/lib/obsidian/Modals/index.cjs

@@ -0,0 +1,58 @@
+/*
+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(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;const originalRequire=require;if(originalRequire&&!originalRequire.__isPatched){require=Object.assign(id=>requirePatched(id),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>{const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};return browserProcess},"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id){const module=originalRequire?.(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Modals_exports = {};
+__export(Modals_exports, {
+  Alert: () => Alert,
+  Confirm: () => Confirm,
+  ModalBase: () => ModalBase,
+  Prompt: () => Prompt,
+  SelectItem: () => SelectItem
+});
+module.exports = __toCommonJS(Modals_exports);
+var Alert = __toESM(__extractDefault(require('./Alert.cjs')), 1);
+var Confirm = __toESM(__extractDefault(require('./Confirm.cjs')), 1);
+var ModalBase = __toESM(__extractDefault(require('./ModalBase.cjs')), 1);
+var Prompt = __toESM(__extractDefault(require('./Prompt.cjs')), 1);
+var SelectItem = __toESM(__extractDefault(require('./SelectItem.cjs')), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Alert,
+  Confirm,
+  ModalBase,
+  Prompt,
+  SelectItem
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL01vZGFscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzIEFsZXJ0IGZyb20gJy4vQWxlcnQudHMnO1xuZXhwb3J0ICogYXMgQ29uZmlybSBmcm9tICcuL0NvbmZpcm0udHMnO1xuZXhwb3J0ICogYXMgTW9kYWxCYXNlIGZyb20gJy4vTW9kYWxCYXNlLnRzJztcbmV4cG9ydCAqIGFzIFByb21wdCBmcm9tICcuL1Byb21wdC50cyc7XG5leHBvcnQgKiBhcyBTZWxlY3RJdGVtIGZyb20gJy4vU2VsZWN0SXRlbS50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUVBLFlBQXVCO0FBQ3ZCLGNBQXlCO0FBQ3pCLGdCQUEyQjtBQUMzQixhQUF3QjtBQUN4QixpQkFBNEI7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/obsidian/Modals/index.d.cts

@@ -0,0 +1,5 @@
+export * as Alert from './Alert.cjs';
+export * as Confirm from './Confirm.cjs';
+export * as ModalBase from './ModalBase.cjs';
+export * as Prompt from './Prompt.cjs';
+export * as SelectItem from './SelectItem.cjs';

package/dist/lib/obsidian/Modals/index.d.mts

@@ -0,0 +1,5 @@
+export * as Alert from './Alert.mjs';
+export * as Confirm from './Confirm.mjs';
+export * as ModalBase from './ModalBase.mjs';
+export * as Prompt from './Prompt.mjs';
+export * as SelectItem from './SelectItem.mjs';

package/dist/lib/obsidian/Modals/index.mjs

@@ -0,0 +1,20 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm(){if(globalThis.process){return}const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};globalThis.process=browserProcess})();
+
+import * as Alert from "./Alert.mjs";
+import * as Confirm from "./Confirm.mjs";
+import * as ModalBase from "./ModalBase.mjs";
+import * as Prompt from "./Prompt.mjs";
+import * as SelectItem from "./SelectItem.mjs";
+export {
+  Alert,
+  Confirm,
+  ModalBase,
+  Prompt,
+  SelectItem
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL01vZGFscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzIEFsZXJ0IGZyb20gJy4vQWxlcnQudHMnO1xuZXhwb3J0ICogYXMgQ29uZmlybSBmcm9tICcuL0NvbmZpcm0udHMnO1xuZXhwb3J0ICogYXMgTW9kYWxCYXNlIGZyb20gJy4vTW9kYWxCYXNlLnRzJztcbmV4cG9ydCAqIGFzIFByb21wdCBmcm9tICcuL1Byb21wdC50cyc7XG5leHBvcnQgKiBhcyBTZWxlY3RJdGVtIGZyb20gJy4vU2VsZWN0SXRlbS50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7O0FBRUEsWUFBWSxXQUFXO0FBQ3ZCLFlBQVksYUFBYTtBQUN6QixZQUFZLGVBQWU7QUFDM0IsWUFBWSxZQUFZO0FBQ3hCLFlBQVksZ0JBQWdCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/obsidian/ObsidianSettings.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ * This module provides utility functions for working with Obsidian settings.
+ */
+import type { App } from 'obsidian';
+/**
+ * Retrieves whether to use relative links based on the Obsidian settings.
+ * @param app - The Obsidian app instance.
+ * @returns Whether to use relative links.
+ */
+export declare function shouldUseRelativeLinks(app: App): boolean;
+/**
+ * Retrieves whether to use wikilinks based on the Obsidian settings.
+ * @param app - The Obsidian app instance.
+ * @returns Whether to use wikilinks.
+ */
+export declare function shouldUseWikilinks(app: App): boolean;

package/dist/lib/obsidian/Pdf.d.mts

@@ -0,0 +1,24 @@
+/**
+ * @packageDocumentation Pdf
+ * Contains utility functions for printing to PDF.
+ */
+interface PrintToPdfOptions {
+    filepath: string;
+    includeName: boolean;
+    landscape: boolean;
+    marginsType: number;
+    open: boolean;
+    pageSize: string;
+    scale: number;
+    scaleFactor: number;
+}
+/**
+ * Print the given element to a PDF file.
+ *
+ * Works only on desktop.
+ *
+ * @param el - The element to print.
+ * @param options - The options to use for the print.
+ */
+export declare function printToPdf(el: HTMLElement, options: Partial<PrintToPdfOptions>): Promise<void>;
+export {};

package/dist/lib/obsidian/Plugin/{EmptySettings.d.ts → EmptySettings.d.cts}

@@ -2,7 +2,7 @@
  * @packageDocumentation EmptySettings
  * Empty settings class.
  */
-import { PluginSettingsBase } from './PluginSettingsBase.ts';
+import { PluginSettingsBase } from './PluginSettingsBase.cjs';
 /**
  * @packageDocumentation EmptySettings
  * Empty settings class.

package/dist/lib/obsidian/Plugin/EmptySettings.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation EmptySettings
+ * Empty settings class.
+ */
+import { PluginSettingsBase } from './PluginSettingsBase.mjs';
+/**
+ * @packageDocumentation EmptySettings
+ * Empty settings class.
+ */
+/**
+ * Empty settings class.
+ */
+export declare class EmptySettings extends PluginSettingsBase {
+}

package/dist/lib/obsidian/Plugin/ObsidianPluginRepoPaths.d.mts

@@ -0,0 +1,55 @@
+/**
+ * @packageDocumentation ObsidianPluginRepoPaths
+ * This file defines an enumeration for common file and directory paths used in Obsidian plugin development.
+ */
+/**
+ * Enumeration of commonly used file and directory paths in Obsidian plugin development.
+ */
+export declare enum ObsidianPluginRepoPaths {
+    /** Represents any path recursively. */
+    AnyPath = "**",
+    /** Represents any TypeScript file. */
+    AnyTs = "*.ts",
+    /** Represents the changelog file. */
+    ChangelogMd = "CHANGELOG.md",
+    /** Represents the distribution directory. */
+    Dist = "dist",
+    /** Represents the build directory within the distribution directory. */
+    DistBuild = "dist/build",
+    /** Represents the development directory within the distribution directory. */
+    DistDev = "dist/dev",
+    /** Represents the ESLint configuration file. */
+    EslintConfigMjs = "eslint.config.mjs",
+    /** Represents the hot reload file. */
+    HotReload = ".hotreload",
+    /** Represents the lib directory. */
+    Lib = "lib",
+    /** Represents the Library.cjs file. */
+    LibraryCjs = "Library.cjs",
+    /** Represents the Library.mjs file. */
+    LibraryMjs = "Library.mjs",
+    /** Represents the main CSS file. */
+    MainCss = "main.css",
+    /** Represents the main JavaScript file. */
+    MainJs = "main.js",
+    /** Represents the main TypeScript file. */
+    MainTs = "main.ts",
+    /** Represents the manifest file for beta releases. */
+    ManifestBetaJson = "manifest-beta.json",
+    /** Represents the manifest file. */
+    ManifestJson = "manifest.json",
+    /** Represents the npm-shrinkwrap.json file. */
+    NpmShrinkwrapJson = "npm-shrinkwrap.json",
+    /** Represents the package.json file. */
+    PackageJson = "package.json",
+    /** Represents the package-lock.json file. */
+    PackageLockJson = "package-lock.json",
+    /** Represents the source directory. */
+    Src = "src",
+    /** Represents the styles.css file. */
+    StylesCss = "styles.css",
+    /** Represents the TypeScript configuration file. */
+    TsConfigJson = "tsconfig.json",
+    /** Represents the versions.json file. */
+    VersionsJson = "versions.json"
+}

package/dist/lib/obsidian/Plugin/Plugin.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @packageDocumentation Plugin
+ * This module provides utility functions for managing Obsidian plugins,
+ * including displaying error messages, disabling plugins, and reloading them.
+ */
+import { Plugin } from 'obsidian';
+/**
+ * Reloads the specified plugin by disabling and then re-enabling it.
+ *
+ * @param plugin - The plugin to reload.
+ * @returns A promise that resolves when the plugin is reloaded.
+ */
+export declare function reloadPlugin(plugin: Plugin): Promise<void>;
+/**
+ * Displays an error message as a notice, logs it to the console, and disables the specified plugin.
+ *
+ * @param plugin - The plugin to disable.
+ * @param message - The error message to display and log.
+ * @returns A promise that resolves when the plugin is disabled.
+ */
+export declare function showErrorAndDisablePlugin(plugin: Plugin, message: string): Promise<void>;

package/dist/lib/obsidian/Plugin/{PluginBase.d.ts → PluginBase.d.cts}

@@ -8,9 +8,9 @@
  */
 import type { ReadonlyDeep } from 'type-fest';
 import { Plugin, PluginSettingTab } from 'obsidian';
-import type { MaybePromise } from '../../Async.ts';
-import type { EmptySettings } from './EmptySettings.ts';
-import type { PluginSettingsBase } from './PluginSettingsBase.ts';
+import type { MaybePromise } from '../../Async.cjs';
+import type { EmptySettings } from './EmptySettings.cjs';
+import type { PluginSettingsBase } from './PluginSettingsBase.cjs';
 /**
  * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.
  *