@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,280 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // 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
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // 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.`);
+
+        return 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 prompt_exports = {};
+__export(prompt_exports, {
+  prompt: () => prompt
+});
+module.exports = __toCommonJS(prompt_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_function = require('@mnaoumov/typescript-lib/function');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_obsidian = require('obsidian');
+var import_css_class = require('../css-class.cjs');
+var import_html_element = require('../html-element.cjs');
+var import_i18n = require('../i18n/i18n.cjs');
+var import_obsidian_settings = require('../obsidian-settings.cjs');
+var import_modal = require('./modal.cjs');
+class PromptModal extends import_modal.ModalBase {
+  cancelButtonText;
+  commandBuilder;
+  commandsRenderMode;
+  isOkClicked = false;
+  isTouched = false;
+  okButtonText;
+  placeholder;
+  spellcheckMode;
+  title;
+  value;
+  valueValidator;
+  constructor(params) {
+    super(params);
+    this.addCssClasses(import_css_class.CssClass.PromptModal);
+    this.cancelButtonText = params.cancelButtonText ?? (0, import_i18n.t)(($) => $.obsidianDevUtils.buttons.cancel);
+    this.commandBuilder = params.commandBuilder ?? null;
+    this.commandsRenderMode = params.commandsRenderMode;
+    this.okButtonText = params.okButtonText ?? (0, import_i18n.t)(($) => $.obsidianDevUtils.buttons.ok);
+    this.placeholder = params.placeholder ?? "";
+    this.spellcheckMode = params.spellcheckMode ?? import_obsidian_settings.SpellcheckMode.FollowObsidianSetting;
+    this.title = params.title ?? "";
+    this.valueValidator = params.valueValidator ?? import_function.noop;
+    this.value = params.defaultValue ?? "";
+  }
+  onClose() {
+    this.promiseResolve(this.isOkClicked ? this.value : null);
+  }
+  onOpen() {
+    this.titleEl.setText(this.title);
+    const textComponent = new import_obsidian.TextComponent(this.contentEl);
+    const inputEl = textComponent.inputEl;
+    (0, import_html_element.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(import_css_class.CssClass.TextBox);
+    inputEl.addClass(import_css_class.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", (0, import_async.convertAsyncToSync)(handleInput));
+    inputEl.addEventListener("focus", (0, import_async.convertAsyncToSync)(handleFocus));
+    (0, import_async.invokeAsyncSafely)(() => validate(false));
+    const okButton = new import_obsidian.ButtonComponent(this.contentEl);
+    okButton.setButtonText(this.okButtonText);
+    okButton.setCta();
+    okButton.onClick((event) => {
+      this.handleOk(event, textComponent);
+    });
+    okButton.setClass(import_css_class.CssClass.OkButton);
+    const cancelButton = new import_obsidian.ButtonComponent(this.contentEl);
+    cancelButton.setButtonText(this.cancelButtonText);
+    cancelButton.onClick(this.close.bind(this));
+    cancelButton.setClass(import_css_class.CssClass.CancelButton);
+    this.commandBuilder?.build(this, (0, import_object_utils.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(import_css_class.CssClass.Untouched);
+  }
+}
+async function prompt(params) {
+  return await (0, import_modal.showModal)(
+    (promiseResolve) => new PromptModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/cjs/modals/prompt.d.cts

@@ -0,0 +1,83 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @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' with { 'resolution-mode': 'import' };
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+import type { ModalCommandBuilder, ModalCommandsRenderMode } from './modal-command-builder.cjs';
+import type { ModalParamsBase } from './modal.cjs';
+import { SpellcheckMode } from '../obsidian-settings.cjs';
+/**
+ * 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/cjs/modals/select-item.cjs

@@ -0,0 +1,225 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // 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
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // 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.`);
+
+        return 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 select_item_exports = {};
+__export(select_item_exports, {
+  selectItem: () => selectItem
+});
+module.exports = __toCommonJS(select_item_exports);
+var import_obsidian = require('obsidian');
+var import_css_class = require('../css-class.cjs');
+var import_html_element = require('../html-element.cjs');
+var import_obsidian_settings = require('../obsidian-settings.cjs');
+var import_plugin_context = require('../plugin/plugin-context.cjs');
+var import_modal = require('./modal.cjs');
+class ItemSelectModal extends import_obsidian.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 ?? import_obsidian_settings.SpellcheckMode.Off;
+    this.setPlaceholder(this.placeholder ?? "");
+    (0, import_plugin_context.addPluginCssClasses)(this.containerEl, params.cssClasses);
+    (0, import_plugin_context.addPluginCssClasses)(this.containerEl, import_css_class.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();
+    (0, import_html_element.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 (0, import_modal.showModal)(
+    (promiseResolve) => new ItemSelectModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectItem
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,55 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @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.cjs';
+import { SpellcheckMode } from '../obsidian-settings.cjs';
+/**
+ * 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>;