@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/modals/prompt.d.mts

@@ -0,0 +1,83 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * 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 type { MaybeReturn } from '@mnaoumov/typescript-lib/type';
+import type { Promisable } from 'type-fest';
+import type { ModalCommandBuilder, ModalCommandsRenderMode } from './modal-command-builder.mjs';
+import type { ModalParamsBase } from './modal.mjs';
+import { SpellcheckMode } from '../obsidian-settings.mjs';
+/**
+ * Options for {@link prompt}.
+ */
+export interface PromptParams extends ModalParamsBase {
+    /**
+     * A text for the "Cancel" button.
+     */
+    readonly cancelButtonText?: string;
+    /**
+     * Extra controls — checkboxes, dropdowns and keyboard shortcuts — rendered as a strip along the bottom
+     * of the modal, so a caller gets a text input plus options with no bespoke modal of its own.
+     *
+     * Hand it a configured {@link ModalCommandBuilder}; the modal builds it. The strip is rendered after
+     * the buttons, so it sits along the bottom edge where a `SuggestModal`'s instruction bar sits.
+     */
+    readonly commandBuilder?: ModalCommandBuilder;
+    /**
+     * The way {@link PromptParams.commandBuilder}'s controls are rendered.
+     *
+     * @default `ModalCommandsRenderMode.Instructions`
+     */
+    readonly commandsRenderMode?: ModalCommandsRenderMode;
+    /**
+     * A default value to pre-fill the input field.
+     *
+     * @default `''`
+     */
+    readonly defaultValue?: string;
+    /**
+     * A text for the "OK" button.
+     */
+    readonly okButtonText?: string;
+    /**
+     * A placeholder text for the input field.
+     *
+     * @default `''`
+     */
+    readonly placeholder?: string;
+    /**
+     * The mode deciding whether the input is spell-checked.
+     *
+     * The default is what this modal has always done, so passing nothing changes nothing: the input follows
+     * `Editor > Spellcheck`, like Obsidian's own name-entry surfaces. Pass {@link SpellcheckMode.Off} for a
+     * box that is really a search field, or {@link SpellcheckMode.AlwaysOn} to spell-check it whatever the
+     * vault setting says.
+     *
+     * @default `SpellcheckMode.FollowObsidianSetting`
+     */
+    readonly spellcheckMode?: SpellcheckMode;
+    /**
+     * A title of the modal.
+     *
+     * @default `''`
+     */
+    readonly 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.
+     */
+    readonly valueValidator?: (value: string) => Promisable<MaybeReturn<string>>;
+}
+/**
+ * Displays a prompt modal in Obsidian to get user input.
+ *
+ * @param params - The parameters for the prompt modal.
+ * @returns A {@link Promise} that resolves with the user input or `null` if the prompt was cancelled.
+ */
+export declare function prompt(params: PromptParams): Promise<null | string>;

package/dist/lib/esm/modals/prompt.mjs

@@ -0,0 +1,168 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  convertAsyncToSync,
+  invokeAsyncSafely
+} from "@mnaoumov/typescript-lib/async";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  ButtonComponent,
+  TextComponent
+} from "obsidian";
+import { CssClass } from "../css-class.mjs";
+import { applySpellcheckMode } from "../html-element.mjs";
+import { t } from "../i18n/i18n.mjs";
+import { SpellcheckMode } from "../obsidian-settings.mjs";
+import {
+  ModalBase,
+  showModal
+} from "./modal.mjs";
+class PromptModal extends ModalBase {
+  cancelButtonText;
+  commandBuilder;
+  commandsRenderMode;
+  isOkClicked = false;
+  isTouched = false;
+  okButtonText;
+  placeholder;
+  spellcheckMode;
+  title;
+  value;
+  valueValidator;
+  constructor(params) {
+    super(params);
+    this.addCssClasses(CssClass.PromptModal);
+    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel);
+    this.commandBuilder = params.commandBuilder ?? null;
+    this.commandsRenderMode = params.commandsRenderMode;
+    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok);
+    this.placeholder = params.placeholder ?? "";
+    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.FollowObsidianSetting;
+    this.title = params.title ?? "";
+    this.valueValidator = params.valueValidator ?? noop;
+    this.value = params.defaultValue ?? "";
+  }
+  onClose() {
+    this.promiseResolve(this.isOkClicked ? this.value : null);
+  }
+  onOpen() {
+    this.titleEl.setText(this.title);
+    const textComponent = new TextComponent(this.contentEl);
+    const inputEl = textComponent.inputEl;
+    applySpellcheckMode({
+      app: this.app,
+      element: inputEl,
+      spellcheckMode: this.spellcheckMode
+    });
+    const validate = async (shouldReport) => {
+      const errorMessage = await this.valueValidator(inputEl.value);
+      inputEl.setCustomValidity(errorMessage ?? "");
+      if (shouldReport) {
+        inputEl.reportValidity();
+      }
+    };
+    const handleInput = async () => {
+      this.markTouched(inputEl);
+      await validate(true);
+    };
+    const handleFocus = async () => {
+      await validate(this.isTouched);
+    };
+    textComponent.setValue(this.value);
+    textComponent.inputEl.select();
+    textComponent.setPlaceholder(this.placeholder);
+    inputEl.addClass(CssClass.TextBox);
+    inputEl.addClass(CssClass.Untouched);
+    textComponent.onChange((newValue) => {
+      this.value = newValue;
+    });
+    inputEl.addEventListener("keydown", (event) => {
+      if (event.key === "Enter") {
+        this.handleOk(event, textComponent);
+      } else if (event.key === "Escape") {
+        this.close();
+      }
+    });
+    inputEl.addEventListener("input", convertAsyncToSync(handleInput));
+    inputEl.addEventListener("focus", convertAsyncToSync(handleFocus));
+    invokeAsyncSafely(() => validate(false));
+    const okButton = new ButtonComponent(this.contentEl);
+    okButton.setButtonText(this.okButtonText);
+    okButton.setCta();
+    okButton.onClick((event) => {
+      this.handleOk(event, textComponent);
+    });
+    okButton.setClass(CssClass.OkButton);
+    const cancelButton = new ButtonComponent(this.contentEl);
+    cancelButton.setButtonText(this.cancelButtonText);
+    cancelButton.onClick(this.close.bind(this));
+    cancelButton.setClass(CssClass.CancelButton);
+    this.commandBuilder?.build(this, normalizeOptionalProperties({ renderMode: this.commandsRenderMode }));
+  }
+  handleOk(event, textComponent) {
+    event.preventDefault();
+    if (!textComponent.inputEl.checkValidity()) {
+      this.markTouched(textComponent.inputEl);
+      textComponent.inputEl.reportValidity();
+      return;
+    }
+    this.isOkClicked = true;
+    this.close();
+  }
+  markTouched(inputEl) {
+    this.isTouched = true;
+    inputEl.removeClass(CssClass.Untouched);
+  }
+}
+async function prompt(params) {
+  return await showModal(
+    (promiseResolve) => new PromptModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+export {
+  prompt
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/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 { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type {\n  ModalCommandBuilder,\n  ModalCommandBuilderBuildOptions,\n  ModalCommandsRenderMode\n} from './modal-command-builder.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { applySpellcheckMode } from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { SpellcheckMode } from '../obsidian-settings.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   * Extra controls \u2014 checkboxes, dropdowns and keyboard shortcuts \u2014 rendered as a strip along the bottom\n   * of the modal, so a caller gets a text input plus options with no bespoke modal of its own.\n   *\n   * Hand it a configured {@link ModalCommandBuilder}; the modal builds it. The strip is rendered after\n   * the buttons, so it sits along the bottom edge where a `SuggestModal`'s instruction bar sits.\n   */\n  readonly commandBuilder?: ModalCommandBuilder;\n\n  /**\n   * The way {@link PromptParams.commandBuilder}'s controls are rendered.\n   *\n   * @default `ModalCommandsRenderMode.Instructions`\n   */\n  readonly commandsRenderMode?: ModalCommandsRenderMode;\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   * The mode deciding whether the input is spell-checked.\n   *\n   * The default is what this modal has always done, so passing nothing changes nothing: the input follows\n   * `Editor > Spellcheck`, like Obsidian's own name-entry surfaces. Pass {@link SpellcheckMode.Off} for a\n   * box that is really a search field, or {@link SpellcheckMode.AlwaysOn} to spell-check it whatever the\n   * vault setting says.\n   *\n   * @default `SpellcheckMode.FollowObsidianSetting`\n   */\n  readonly spellcheckMode?: SpellcheckMode;\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  readonly valueValidator?: (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 readonly commandBuilder: ModalCommandBuilder | null;\n  private readonly commandsRenderMode: ModalCommandsRenderMode | undefined;\n  private isOkClicked = false;\n  private isTouched = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly spellcheckMode: SpellcheckMode;\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.commandBuilder = params.commandBuilder ?? null;\n    this.commandsRenderMode = params.commandsRenderMode;\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.FollowObsidianSetting;\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    // `AbstractTextComponent` forces `spellcheck=\"false\"` on every text component, so the mode has to be applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    applySpellcheckMode({\n      app: this.app,\n      element: inputEl,\n      spellcheckMode: this.spellcheckMode\n    });\n\n    const validate = async (shouldReport: boolean): Promise<void> => {\n      const errorMessage = await this.valueValidator(inputEl.value) as string | undefined;\n      inputEl.setCustomValidity(errorMessage ?? '');\n      if (shouldReport) {\n        inputEl.reportValidity();\n      }\n    };\n\n    const handleInput = async (): Promise<void> => {\n      this.markTouched(inputEl);\n      await validate(true);\n    };\n\n    const handleFocus = async (): Promise<void> => {\n      await validate(this.isTouched);\n    };\n\n    textComponent.setValue(this.value);\n    textComponent.inputEl.select();\n    textComponent.setPlaceholder(this.placeholder);\n    inputEl.addClass(CssClass.TextBox);\n    // The modal opens invalid by design (see below), so the invalid styling is deferred until touched.\n    inputEl.addClass(CssClass.Untouched);\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(handleInput));\n    inputEl.addEventListener('focus', convertAsyncToSync(handleFocus));\n    // The modal must start out invalid so OK refuses, but the validity is not reported until the user types or submits.\n    invokeAsyncSafely(() => validate(false));\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    // Built last so the strip lands along the modal's bottom edge, where a `SuggestModal`'s instruction\n    // bar sits.\n    this.commandBuilder?.build(this, normalizeOptionalProperties<ModalCommandBuilderBuildOptions>({ renderMode: this.commandsRenderMode }));\n  }\n\n  private handleOk(event: Event, textComponent: TextComponent): void {\n    event.preventDefault();\n    if (!textComponent.inputEl.checkValidity()) {\n      this.markTouched(textComponent.inputEl);\n      textComponent.inputEl.reportValidity();\n      return;\n    }\n\n    this.isOkClicked = true;\n    this.close();\n  }\n\n  private markTouched(inputEl: HTMLInputElement): void {\n    this.isTouched = true;\n    inputEl.removeClass(CssClass.Untouched);\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": "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",
  "names": []
}


package/dist/lib/esm/modals/select-item.d.mts

@@ -0,0 +1,55 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * 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 type { ModalParamsBase } from './modal.mjs';
+import { SpellcheckMode } from '../obsidian-settings.mjs';
+/**
+ * Options for {@link selectItem}.
+ *
+ * @typeParam T - The type of the selectable items.
+ */
+export interface SelectItemParams<T> extends ModalParamsBase {
+    /**
+     * A list of items to choose from.
+     */
+    readonly items: T[];
+    /**
+     * Get the display text for each item
+     *
+     * @param item - The item to get the display text for.
+     * @returns The display text for the item.
+     */
+    readonly itemTextFunction: (item: T) => string;
+    /**
+     * A placeholder text for the input field.
+     *
+     * @default `''`
+     */
+    readonly placeholder?: string;
+    /**
+     * The mode deciding whether the search box is spell-checked.
+     *
+     * The default is what this modal has always done, so passing nothing changes nothing. It differs from
+     * the `prompt()` parameter's default on purpose: Obsidian builds every `SuggestModal` input
+     * with a hardcoded `spellcheck="false"` and never consults `Editor > Spellcheck` there, so `Off` — not
+     * `FollowObsidianSetting` — is the value that leaves the box exactly as Obsidian built it.
+     *
+     * Raise it for a picker whose box can NAME the thing it is about to create, rather than only find one.
+     *
+     * @default `SpellcheckMode.Off`
+     */
+    readonly spellcheckMode?: SpellcheckMode;
+}
+/**
+ * Displays a selection modal in Obsidian for choosing an item from a list.
+ *
+ * @typeParam T - The type of the selectable items.
+ * @param params - The parameters for the selection modal.
+ * @returns A {@link Promise} that resolves with the selected item or `null` if no item was selected.
+ */
+export declare function selectItem<T>(params: SelectItemParams<T>): Promise<null | T>;

package/dist/lib/esm/modals/select-item.mjs

@@ -0,0 +1,104 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { FuzzySuggestModal } from "obsidian";
+import { CssClass } from "../css-class.mjs";
+import { applySpellcheckMode } from "../html-element.mjs";
+import { SpellcheckMode } from "../obsidian-settings.mjs";
+import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
+import { showModal } from "./modal.mjs";
+class ItemSelectModal extends FuzzySuggestModal {
+  isSelected = false;
+  items;
+  itemTextFunction;
+  placeholder;
+  promiseResolve;
+  spellcheckMode;
+  constructor(params) {
+    super(params.app);
+    this.items = params.items;
+    this.itemTextFunction = params.itemTextFunction;
+    this.placeholder = params.placeholder;
+    this.promiseResolve = params.promiseResolve;
+    this.spellcheckMode = params.spellcheckMode ?? SpellcheckMode.Off;
+    this.setPlaceholder(this.placeholder ?? "");
+    addPluginCssClasses(this.containerEl, params.cssClasses);
+    addPluginCssClasses(this.containerEl, CssClass.SelectItemModal);
+  }
+  getItems() {
+    return this.items;
+  }
+  getItemText(item) {
+    return this.itemTextFunction(item);
+  }
+  onChooseItem(item) {
+    this.promiseResolve(item);
+  }
+  onClose() {
+    if (!this.isSelected) {
+      this.promiseResolve(null);
+    }
+  }
+  onOpen() {
+    super.onOpen();
+    applySpellcheckMode({
+      app: this.app,
+      element: this.inputEl,
+      spellcheckMode: this.spellcheckMode
+    });
+  }
+  selectSuggestion(value, $event) {
+    this.isSelected = true;
+    super.selectSuggestion(value, $event);
+  }
+}
+async function selectItem(params) {
+  return await showModal(
+    (promiseResolve) => new ItemSelectModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+export {
+  selectItem
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/modals/select-option.d.mts

@@ -0,0 +1,65 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Utility for displaying a modal that offers a fixed set of labelled options as buttons.
+ *
+ * Unlike {@link selectItem} (a fuzzy-search picker over an arbitrary list), this modal renders one
+ * button per option — useful for a small, fixed set of mutually-exclusive choices where each choice
+ * has its own label and resolved value. It resolves with the chosen value, or `null` if the modal is
+ * dismissed without a choice.
+ */
+import type { ModalParamsBase } from './modal.mjs';
+/**
+ * A single selectable option rendered as a button in the {@link selectOption} modal.
+ *
+ * @typeParam T - The type of the value resolved when this option is chosen.
+ */
+export interface SelectOptionItem<T> {
+    /**
+     * Whether to render this option as the call-to-action (primary) button.
+     *
+     * @default `false`
+     */
+    readonly isCta?: boolean;
+    /**
+     * The button label.
+     */
+    readonly text: string;
+    /**
+     * The value the modal resolves with when this option is chosen.
+     */
+    readonly value: T;
+}
+/**
+ * Parameters for {@link selectOption}.
+ *
+ * @typeParam T - The type of the value resolved when an option is chosen.
+ */
+export interface SelectOptionParams<T> extends ModalParamsBase {
+    /**
+     * A message displayed above the option buttons.
+     *
+     * @default `''`
+     */
+    readonly message?: DocumentFragment | string;
+    /**
+     * The selectable options, each rendered as a button.
+     */
+    readonly options: SelectOptionItem<T>[];
+    /**
+     * A title of the modal.
+     *
+     * @default `''`
+     */
+    readonly title?: DocumentFragment | string;
+}
+/**
+ * Displays a modal in Obsidian offering a fixed set of labelled options as buttons.
+ *
+ * @typeParam T - The type of the value resolved when an option is chosen.
+ * @param params - The parameters for the modal.
+ * @returns A {@link Promise} that resolves with the chosen option's value, or `null` if the modal
+ * was dismissed without a choice.
+ */
+export declare function selectOption<T>(params: SelectOptionParams<T>): Promise<null | T>;

package/dist/lib/esm/modals/select-option.mjs

@@ -0,0 +1,95 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { ButtonComponent } from "obsidian";
+import { CssClass } from "../css-class.mjs";
+import {
+  ModalBase,
+  showModal
+} from "./modal.mjs";
+class SelectOptionModal extends ModalBase {
+  isSelected = false;
+  message;
+  options;
+  title;
+  constructor(params) {
+    super(params);
+    this.addCssClasses(CssClass.SelectOptionModal);
+    this.message = params.message ?? "";
+    this.options = params.options;
+    this.title = params.title ?? "";
+  }
+  onClose() {
+    if (!this.isSelected) {
+      this.promiseResolve(null);
+    }
+  }
+  onOpen() {
+    this.titleEl.setText(this.title);
+    if (this.message) {
+      this.contentEl.createEl("p", { text: this.message });
+    }
+    for (const option of this.options) {
+      const button = new ButtonComponent(this.contentEl);
+      button.setButtonText(option.text);
+      if (option.isCta) {
+        button.setCta();
+      }
+      button.onClick(() => {
+        this.isSelected = true;
+        this.promiseResolve(option.value);
+        this.close();
+      });
+    }
+  }
+}
+async function selectOption(params) {
+  return await showModal(
+    (promiseResolve) => new SelectOptionModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+export {
+  selectOption
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/modals/suggest-modal-command-builder.d.mts

@@ -0,0 +1,35 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * The former home of the `SuggestModal` instruction-bar builder.
+ *
+ * The builder is no longer tied to `SuggestModal` — it renders into a plain `Modal` and into a bare
+ * element + `Scope` too — so it moved to `modal-command-builder.ts` under the honest name
+ * {@link ModalCommandBuilder}. This module stays as a deprecated alias so existing importers keep working
+ * unchanged; it re-exports the very same class, not a copy.
+ */
+import type { ModalCommandBuilderBuildOptions } from './modal-command-builder.mjs';
+import { ModalCommandBuilder } from './modal-command-builder.mjs';
+export type { CheckboxCommand, DropDownCommand, KeyboardCommand } from './modal-command-builder.mjs';
+/**
+ * Options for {@link SuggestModalCommandBuilder.build}.
+ *
+ * @deprecated Use {@link ModalCommandBuilderBuildOptions} from
+ * `obsidian-dev-utils/obsidian/modals/modal-command-builder` instead.
+ */
+export type SuggestModalCommandBuilderBuildOptions = ModalCommandBuilderBuildOptions;
+/**
+ * Builds a `SuggestModal`'s instruction bar.
+ *
+ * @deprecated Use {@link ModalCommandBuilder} from
+ * `obsidian-dev-utils/obsidian/modals/modal-command-builder` instead.
+ */
+export declare const SuggestModalCommandBuilder: typeof ModalCommandBuilder;
+/**
+ * Builds a `SuggestModal`'s instruction bar.
+ *
+ * @deprecated Use {@link ModalCommandBuilder} from
+ * `obsidian-dev-utils/obsidian/modals/modal-command-builder` instead.
+ */
+export type SuggestModalCommandBuilder = ModalCommandBuilder;