obsidian-dev-utils 96.5.4 → 97.0.0

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

@@ -0,0 +1,281 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @file
+ *
+ * A builder for a modal's control strip.
+ *
+ * {@link ModalCommandBuilder} assembles the strip of controls shown at the bottom of a modal:
+ * keyboard-command hints ({@link ModalCommandBuilder.addKeyboardCommand}), interactive checkboxes bound to
+ * a modifier+key shortcut ({@link ModalCommandBuilder.addCheckbox}), and dropdowns bound to a modifier+key
+ * shortcut ({@link ModalCommandBuilder.addDropDown}). Chain the `add*` calls, then apply everything to a
+ * modal with {@link ModalCommandBuilder.build}:
+ *
+ * ```ts
+ * new ModalCommandBuilder()
+ *   .addKeyboardCommand({ key: 'Enter', modifiers: ['Mod'], onKey, purpose: 'to create' })
+ *   .addCheckbox({ key: '1', modifiers: ['Alt'], onChange, onInit, purpose: 'Fix footnotes' })
+ *   .build(modal);
+ * ```
+ *
+ * The strip is described by two independent axes:
+ *
+ * - **Where it is hosted.** A {@link SuggestModal} in {@link ModalCommandsRenderMode.Instructions} mode
+ *   keeps Obsidian's own instruction bar (`setInstructions` + `instructionsEl`). Every other target — a
+ *   plain {@link Modal}, or a bare {@link ModalCommandsHost} of an element plus a `Scope` — gets a strip
+ *   element the builder creates itself.
+ * - **How each control looks.** {@link ModalCommandsRenderMode.Instructions} renders the purpose text with
+ *   an inline checkbox or dropdown; {@link ModalCommandsRenderMode.Buttons} renders one clickable button
+ *   per control, carrying its pressed and disabled state.
+ *
+ * The axes are independent because a button strip inside a {@link SuggestModal} is a real combination.
+ *
+ * {@link ModalCommandBuilder.build} always registers the essential navigation/action key handlers, but
+ * only renders the control UI and registers the option-toggle shortcuts when
+ * {@link ModalCommandBuilderBuildOptions.shouldShowInstructions} is `true` (the default).
+ */
+import type { KeymapContext, Modal, Modifier, Scope, SuggestModal } from 'obsidian' with { 'resolution-mode': 'import' };
+import { DropdownComponent } from 'obsidian';
+/**
+ * The way {@link ModalCommandBuilder.build} renders each control.
+ */
+export declare enum ModalCommandsRenderMode {
+    /**
+     * One clickable button per control, carrying its pressed (`aria-pressed`) and disabled state.
+     *
+     * Only controls reachable by pointer are rendered — checkboxes, and keyboard commands that supply
+     * {@link KeyboardCommand.onActivate}. A hint-only or keyboard-only command still registers its handler
+     * but renders no button, because a button nobody can press is worse than no button. A dropdown throws:
+     * a control that CYCLES has no button form.
+     */
+    Buttons = "buttons",
+    /**
+     * Obsidian's instruction-bar look: the shortcut, then the purpose text with an inline checkbox or
+     * dropdown.
+     */
+    Instructions = "instructions"
+}
+/**
+ * A checkbox command shown in a modal's control strip and bound to a modifier+key shortcut that toggles
+ * it.
+ */
+export interface CheckboxCommand extends CommandBase {
+    /**
+     * Called when the checkbox value changes.
+     *
+     * @param isChecked - The new checked state.
+     */
+    onChange(isChecked: boolean): void;
+    /**
+     * Called once with the created checkbox element, to initialize its state.
+     *
+     * In {@link ModalCommandsRenderMode.Buttons} mode the element is created but never appended — the
+     * button is a view of it — so the same initialization code serves both render modes.
+     *
+     * @param checkboxEl - The created checkbox element.
+     */
+    onInit(checkboxEl: HTMLInputElement): void;
+}
+/**
+ * The members every command shares.
+ */
+export interface CommandBase {
+    /**
+     * Whether the control can be used right now. When it returns `false` the control is rendered
+     * **disabled rather than removed**, so the strip does not reflow under the pointer as modes change —
+     * which on a phone means a mis-tap.
+     *
+     * Re-read by {@link ModalCommands.refresh}. When omitted, the builder never touches the control's
+     * disabled state, leaving whatever {@link CheckboxCommand.onInit} / {@link DropDownCommand.onInit} set.
+     *
+     * @returns Whether the control can be used right now.
+     */
+    checkIsAvailable?(this: void): boolean;
+    /**
+     * The key that activates the command.
+     */
+    key: string;
+    /**
+     * The modifiers combined with {@link CommandBase.key}. When omitted, no modifiers are required.
+     */
+    modifiers?: Modifier[];
+    /**
+     * The human-readable description shown next to the control.
+     */
+    purpose: string;
+}
+/**
+ * A dropdown command shown in a modal's control strip and bound to a modifier+key shortcut that cycles
+ * through its options.
+ *
+ * Supported in {@link ModalCommandsRenderMode.Instructions} mode only.
+ */
+export interface DropDownCommand extends CommandBase {
+    /**
+     * Called when the dropdown value changes.
+     *
+     * @param value - The newly selected value.
+     */
+    onChange(value: string): void;
+    /**
+     * Called once with the created dropdown component, to initialize its options and state.
+     *
+     * @param dropdownComponent - The created dropdown component.
+     */
+    onInit(dropdownComponent: DropdownComponent): void;
+}
+/**
+ * A keyboard command shown in a modal's control strip and optionally bound to a modifier+key handler.
+ */
+export interface KeyboardCommand extends CommandBase {
+    /**
+     * Whether the command reads as ON. Supply it for a toggle whose state lives outside the strip; omit it
+     * for an action, which does something and is done. A {@link CheckboxCommand} needs no equivalent — its
+     * checkbox element is the state.
+     *
+     * Re-read by {@link ModalCommands.refresh}.
+     *
+     * @returns Whether the command reads as ON.
+     */
+    checkIsOn?(this: void): boolean;
+    /**
+     * The pointer route into the same handler the shortcut runs. Required for the command to render a
+     * button in {@link ModalCommandsRenderMode.Buttons} mode — on a phone there is no modifier key to
+     * press, so this is the only way in.
+     *
+     * @param $event - The click event, so a command that picks something has one to hand on.
+     */
+    onActivate?(this: void, $event: MouseEvent): void;
+    /**
+     * The handler invoked when the shortcut is pressed. When omitted, the command is a hint only and no
+     * scope handler is registered.
+     *
+     * @param $event - The keyboard event.
+     * @param context - The keymap context.
+     * @returns `false` to prevent Obsidian's default handling, or `void`/`true` otherwise.
+     */
+    onKey?($event: KeyboardEvent, context: KeymapContext): boolean;
+}
+/**
+ * Options for {@link ModalCommandBuilder.build}.
+ */
+export interface ModalCommandBuilderBuildOptions {
+    /**
+     * The way each control is rendered.
+     *
+     * @default {@link ModalCommandsRenderMode.Instructions}
+     */
+    readonly renderMode?: ModalCommandsRenderMode;
+    /**
+     * Whether to render the control strip (checkboxes, dropdowns, keyboard hints) and register the
+     * option-toggle keyboard shortcuts. When `false`, no control UI is shown and the option-toggle
+     * shortcuts are not registered; only the essential navigation key handlers remain active.
+     *
+     * @default `true`
+     */
+    readonly shouldShowInstructions?: boolean;
+}
+/**
+ * The handle returned by {@link ModalCommandBuilder.build}.
+ */
+export interface ModalCommands {
+    /**
+     * Brings every rendered control's disabled and pressed state up to date, by re-reading
+     * {@link CommandBase.checkIsAvailable} and {@link KeyboardCommand.checkIsOn}.
+     *
+     * The strip is built once and only re-stated afterwards, because rebuilding it would replace an element
+     * the pointer may be about to click.
+     */
+    refresh(): void;
+}
+/**
+ * A bare host for a control strip: the element to render into, plus the scope to register shortcuts with.
+ */
+export interface ModalCommandsHost {
+    /**
+     * The element the control strip is appended to.
+     */
+    readonly containerEl: HTMLElement;
+    /**
+     * The scope the shortcuts are registered with.
+     */
+    readonly scope: Scope;
+}
+/**
+ * Every target {@link ModalCommandBuilder.build} accepts.
+ */
+export type ModalCommandsTarget = Modal | ModalCommandsHost | SuggestModal<unknown>;
+/**
+ * Builds a modal's control strip from keyboard commands, interactive checkboxes, and dropdowns, then
+ * applies them to a modal via {@link ModalCommandBuilder.build}.
+ */
+export declare class ModalCommandBuilder {
+    private readonly entries;
+    /**
+     * Adds an interactive checkbox to the control strip, bound to a modifier+key shortcut that toggles it.
+     *
+     * @param command - The checkbox command to add.
+     * @returns The builder instance for chaining.
+     */
+    addCheckbox(command: CheckboxCommand): this;
+    /**
+     * Adds a dropdown to the control strip, bound to a modifier+key shortcut that cycles through its
+     * options.
+     *
+     * @param command - The dropdown command to add.
+     * @returns The builder instance for chaining.
+     */
+    addDropDown(command: DropDownCommand): this;
+    /**
+     * Adds a keyboard command to the control strip. When {@link KeyboardCommand.onKey} is provided, its
+     * handler is registered with the modal scope; otherwise the command is a hint only.
+     *
+     * @param command - The keyboard command to add.
+     * @returns The builder instance for chaining.
+     */
+    addKeyboardCommand(command: KeyboardCommand): this;
+    /**
+     * Applies the accumulated commands to a modal. Always registers the essential navigation/action key
+     * handlers; only renders the control strip and registers the option-toggle shortcuts when
+     * {@link ModalCommandBuilderBuildOptions.shouldShowInstructions} is `true`.
+     *
+     * @param target - The modal, or the bare element + scope, to apply the commands to.
+     * @param options - The build options.
+     * @returns A handle whose {@link ModalCommands.refresh} re-states every rendered control.
+     */
+    build(target: ModalCommandsTarget, options?: ModalCommandBuilderBuildOptions): ModalCommands;
+    private buildCommandText;
+    private getModifierString;
+    /**
+     * Resolves the element a self-created strip is appended to.
+     *
+     * A {@link Modal} carries both `modalEl` and a `containerEl` that is the OUTER `.modal-container`, so
+     * `modalEl` has to win — otherwise the strip lands outside the modal frame. Discriminated with `in`
+     * rather than a property read, because tests hand `build` a `strictProxy` mock whose `get` trap throws
+     * on unmocked members.
+     *
+     * @param target - The build target.
+     * @returns The element to append the strip to.
+     */
+    private getStripContainerEl;
+    private renderButtons;
+    private renderInstructions;
+    /**
+     * Renders through Obsidian's own instruction bar, the way every {@link SuggestModal} consumer has always
+     * had it.
+     *
+     * @param modal - The suggest modal.
+     * @param instructions - The instructions to render.
+     * @returns The purpose element of each rendered instruction.
+     */
+    private renderNativeInstructions;
+    /**
+     * Renders an instruction bar of the builder's own, for a host that has none.
+     *
+     * The markup mirrors what `setInstructions` produces, so Obsidian's own styling applies unchanged.
+     *
+     * @param containerEl - The element to append the bar to.
+     * @param instructions - The instructions to render.
+     * @returns The purpose element of each rendered instruction.
+     */
+    private renderOwnInstructions;
+}

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

@@ -148,12 +148,15 @@ module.exports = __toCommonJS(prompt_exports);
 var import_obsidian = require('obsidian');
 var import_async = require('../../async.cjs');
 var import_function = require('../../function.cjs');
+var import_object_utils = require('../../object-utils.cjs');
 var import_css_class = require('../css-class.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;
@@ -165,6 +168,8 @@ class PromptModal extends import_modal.ModalBase {
     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.title = params.title ?? "";
@@ -222,6 +227,7 @@ class PromptModal extends import_modal.ModalBase {
     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();
@@ -250,4 +256,4 @@ async function prompt(params) {
 0 && (module.exports = {
   prompt
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/prompt.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type { MaybeReturn } from '../../type.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport { noop } from '../../function.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { isSpellcheckEnabled } 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   * A default value to pre-fill the input field.\n   *\n   * @default `''`\n   */\n  readonly defaultValue?: string;\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n\n  /**\n   * A placeholder text for the input field.\n   *\n   * @default `''`\n   */\n  readonly placeholder?: string;\n\n  /**\n   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  valueValidator?(this: void, value: string): Promisable<MaybeReturn<string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private isOkClicked = false;\n  private isTouched = false;\n  private readonly okButtonText: string;\n  private readonly placeholder: string;\n  private readonly title: DocumentFragment | string;\n  private value: string;\n  private readonly valueValidator: (value: string) => Promisable<MaybeReturn<string>>;\n\n  public constructor(params: PromptModalConstructorParams) {\n    super(params);\n    this.addCssClasses(CssClass.PromptModal);\n    this.cancelButtonText = params.cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel);\n    this.okButtonText = params.okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok);\n    this.placeholder = params.placeholder ?? '';\n    this.title = params.title ?? '';\n    this.valueValidator = params.valueValidator ?? noop;\n    this.value = params.defaultValue ?? '';\n  }\n\n  public override onClose(): void {\n    this.promiseResolve(this.isOkClicked ? this.value : null);\n  }\n\n  public override onOpen(): void {\n    this.titleEl.setText(this.title);\n    const textComponent = new TextComponent(this.contentEl);\n    const inputEl = textComponent.inputEl;\n    // `AbstractTextComponent` forces `spellcheck=\"false\"` on every text component, so the vault setting has to be re-applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    inputEl.setAttribute('spellcheck', String(isSpellcheckEnabled(this.app)));\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\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": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/prompt.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Utility for displaying a prompt modal in Obsidian.\n *\n * This module exports a function to display a modal that prompts the user for input. The modal includes \"OK\" and \"Cancel\" buttons.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport {\n  ButtonComponent,\n  TextComponent\n} from 'obsidian';\n\nimport type { MaybeReturn } from '../../type.ts';\nimport type {\n  ModalCommandBuilder,\n  ModalCommandBuilderBuildOptions,\n  ModalCommandsRenderMode\n} from './modal-command-builder.ts';\nimport type {\n  ModalBaseConstructorParams,\n  ModalParamsBase\n} from './modal.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely\n} from '../../async.ts';\nimport { noop } from '../../function.ts';\nimport { normalizeOptionalProperties } from '../../object-utils.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { isSpellcheckEnabled } 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   * A title of the modal.\n   *\n   * @default `''`\n   */\n  readonly title?: DocumentFragment | string;\n\n  /**\n   * A function to validate the input value.\n   *\n   * @param value - The input value to validate.\n   * @returns an error message if the value is invalid, or `null` if the value is valid.\n   */\n  valueValidator?(this: void, value: string): Promisable<MaybeReturn<string>>;\n}\n\ntype PromptModalConstructorParams = ModalBaseConstructorParams<null | string> & PromptParams;\n\nclass PromptModal extends ModalBase<null | string> {\n  private readonly cancelButtonText: string;\n  private 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 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.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 vault setting has to be re-applied here.\n    // Obsidian's own file explorer reads the same config when it starts an inline rename.\n    inputEl.setAttribute('spellcheck', String(isSpellcheckEnabled(this.app)));\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/obsidian/modals/prompt.d.cts

@@ -8,6 +8,7 @@
  */
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { MaybeReturn } from '../../type.cjs';
+import type { ModalCommandBuilder, ModalCommandsRenderMode } from './modal-command-builder.cjs';
 import type { ModalParamsBase } from './modal.cjs';
 /**
  * Options for {@link prompt}.
@@ -17,6 +18,20 @@ 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.
      *

package/dist/lib/cjs/obsidian/modals/suggest-modal-command-builder.cjs

@@ -145,144 +145,10 @@ __export(suggest_modal_command_builder_exports, {
   SuggestModalCommandBuilder: () => SuggestModalCommandBuilder
 });
 module.exports = __toCommonJS(suggest_modal_command_builder_exports);
-var import_obsidian = require('obsidian');
-const KEYS_MAP = /* @__PURE__ */ new Map([
-  ["Enter", "\u21B5"],
-  ["UpDown", "\u2191\u2193"]
-]);
-class SuggestModalCommandBuilder {
-  instructions = [];
-  /**
-   * Adds an interactive checkbox to the instruction bar, bound to a modifier+key shortcut that toggles
-   * it.
-   *
-   * @param command - The checkbox command to add.
-   * @returns The builder instance for chaining.
-   */
-  addCheckbox(command) {
-    this.instructions.push({
-      command: this.buildCommand(command),
-      init: (purposeEl, scope) => {
-        const checkboxEl = purposeEl.createEl("input", { type: "checkbox" });
-        command.onInit(checkboxEl);
-        checkboxEl.addEventListener("change", () => {
-          command.onChange(checkboxEl.checked);
-        });
-        scope.register(command.modifiers ?? [], command.key, () => {
-          if (checkboxEl.disabled) {
-            return;
-          }
-          checkboxEl.checked = !checkboxEl.checked;
-          checkboxEl.trigger("change");
-        });
-      },
-      purpose: command.purpose
-    });
-    return this;
-  }
-  /**
-   * Adds a dropdown to the instruction bar, bound to a modifier+key shortcut that cycles through its
-   * options.
-   *
-   * @param command - The dropdown command to add.
-   * @returns The builder instance for chaining.
-   */
-  addDropDown(command) {
-    this.instructions.push({
-      command: this.buildCommand(command),
-      init: (purposeEl, scope) => {
-        purposeEl.appendText(" ");
-        const dropdownComponent = new import_obsidian.DropdownComponent(purposeEl);
-        command.onInit(dropdownComponent);
-        dropdownComponent.onChange((value) => {
-          command.onChange(value);
-        });
-        scope.register(command.modifiers ?? [], command.key, () => {
-          if (dropdownComponent.disabled) {
-            return;
-          }
-          const selectEl = dropdownComponent.selectEl;
-          selectEl.selectedIndex = (selectEl.selectedIndex + 1) % selectEl.options.length;
-          selectEl.trigger("change");
-        });
-      },
-      purpose: command.purpose
-    });
-    return this;
-  }
-  /**
-   * Adds a keyboard command to the instruction bar. When {@link KeyboardCommand.onKey} is provided, its
-   * handler is registered with the modal scope; otherwise the command is a hint only.
-   *
-   * @param command - The keyboard command to add.
-   * @returns The builder instance for chaining.
-   */
-  addKeyboardCommand(command) {
-    this.instructions.push({
-      command: this.buildCommand(command),
-      purpose: command.purpose,
-      registerScope: (scope) => {
-        if (command.onKey) {
-          scope.register(command.modifiers ?? [], command.key, command.onKey.bind(command));
-        }
-      }
-    });
-    return this;
-  }
-  /**
-   * Applies the accumulated commands to a modal. Always registers the essential navigation/action key
-   * handlers; only renders the instruction UI and registers the option-toggle shortcuts when
-   * {@link SuggestModalCommandBuilderBuildOptions.shouldShowInstructions} is `true`.
-   *
-   * @param modal - The modal to apply the commands to.
-   * @param options - The build options.
-   */
-  build(modal, options = {}) {
-    const { shouldShowInstructions = true } = options;
-    for (const instruction of this.instructions) {
-      instruction.registerScope?.(modal.scope);
-    }
-    if (!shouldShowInstructions) {
-      return;
-    }
-    modal.setInstructions(this.instructions);
-    const purposeEls = [...modal.instructionsEl.findAll(".prompt-instruction > span:nth-child(2)")];
-    for (const [index, purposeEl] of purposeEls.entries()) {
-      this.instructions[index]?.init?.(purposeEl, modal.scope);
-    }
-  }
-  buildCommand(entry) {
-    let command = KEYS_MAP.get(entry.key) ?? entry.key;
-    for (const modifier of entry.modifiers ?? []) {
-      command = `${this.getModifierString(modifier)} ${command}`;
-    }
-    return command;
-  }
-  getModifierString(modifier) {
-    switch (modifier) {
-      case "Alt": {
-        return "alt";
-      }
-      case "Ctrl": {
-        return "ctrl";
-      }
-      case "Meta": {
-        return import_obsidian.Platform.isMacOS ? "cmd" : "win";
-      }
-      case "Mod": {
-        return import_obsidian.Platform.isMacOS ? "cmd" : "ctrl";
-      }
-      case "Shift": {
-        return "shift";
-      }
-      default: {
-        return modifier;
-      }
-    }
-  }
-}
+var import_modal_command_builder = require('./modal-command-builder.cjs');
+const SuggestModalCommandBuilder = import_modal_command_builder.ModalCommandBuilder;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SuggestModalCommandBuilder
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/modals/suggest-modal-command-builder.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A builder for a {@link SuggestModal}'s instruction bar.\n *\n * {@link SuggestModalCommandBuilder} assembles the instruction bar shown at the bottom of a\n * {@link SuggestModal}: keyboard-command hints ({@link SuggestModalCommandBuilder.addKeyboardCommand}),\n * interactive checkboxes bound to a modifier+key shortcut\n * ({@link SuggestModalCommandBuilder.addCheckbox}), and dropdowns bound to a modifier+key shortcut\n * ({@link SuggestModalCommandBuilder.addDropDown}). Chain the `add*` calls, then apply everything to a\n * modal with {@link SuggestModalCommandBuilder.build}:\n *\n * ```ts\n * new SuggestModalCommandBuilder()\n *   .addKeyboardCommand({ key: 'Enter', modifiers: ['Mod'], onKey, purpose: 'to create' })\n *   .addCheckbox({ key: '1', modifiers: ['Alt'], onChange, onInit, purpose: 'Fix footnotes' })\n *   .build(modal);\n * ```\n *\n * {@link SuggestModalCommandBuilder.build} always registers the essential navigation/action key\n * handlers, but only renders the instruction UI and registers the option-toggle shortcuts when\n * {@link SuggestModalCommandBuilderBuildOptions.shouldShowInstructions} is `true` (the default).\n */\n\nimport type {\n  Instruction,\n  KeymapContext,\n  Modifier,\n  Scope,\n  SuggestModal\n} from 'obsidian';\n\nimport {\n  DropdownComponent,\n  Platform\n} from 'obsidian';\n\nconst KEYS_MAP = new Map<string, string>([\n  ['Enter', '\u21B5'],\n  ['UpDown', '\u2191\u2193']\n]);\n\n/**\n * A checkbox command shown in a {@link SuggestModal}'s instruction bar and bound to a modifier+key\n * shortcut that toggles it.\n */\nexport interface CheckboxCommand {\n  /**\n   * The key that toggles the checkbox.\n   */\n  key: string;\n\n  /**\n   * The modifiers combined with {@link CheckboxCommand.key} to toggle the checkbox. When omitted, no\n   * modifiers are required.\n   */\n  modifiers?: Modifier[];\n\n  /**\n   * Called when the checkbox value changes.\n   *\n   * @param isChecked - The new checked state.\n   */\n  onChange(isChecked: boolean): void;\n\n  /**\n   * Called once with the created checkbox element, to initialize its state.\n   *\n   * @param checkboxEl - The created checkbox element.\n   */\n  onInit(checkboxEl: HTMLInputElement): void;\n\n  /**\n   * The human-readable description shown next to the checkbox in the instruction bar.\n   */\n  purpose: string;\n}\n\n/**\n * A dropdown command shown in a {@link SuggestModal}'s instruction bar and bound to a modifier+key\n * shortcut that cycles through its options.\n */\nexport interface DropDownCommand {\n  /**\n   * The key that cycles the dropdown to its next option.\n   */\n  key: string;\n\n  /**\n   * The modifiers combined with {@link DropDownCommand.key} to cycle the dropdown. When omitted, no\n   * modifiers are required.\n   */\n  modifiers?: Modifier[];\n\n  /**\n   * Called when the dropdown value changes.\n   *\n   * @param value - The newly selected value.\n   */\n  onChange(value: string): void;\n\n  /**\n   * Called once with the created dropdown component, to initialize its options and state.\n   *\n   * @param dropdownComponent - The created dropdown component.\n   */\n  onInit(dropdownComponent: DropdownComponent): void;\n\n  /**\n   * The human-readable description shown next to the dropdown in the instruction bar.\n   */\n  purpose: string;\n}\n\n/**\n * A keyboard command shown in a {@link SuggestModal}'s instruction bar and optionally bound to a\n * modifier+key handler.\n */\nexport interface KeyboardCommand {\n  /**\n   * The key shown in the instruction bar (and registered with the modal scope when\n   * {@link KeyboardCommand.onKey} is provided).\n   */\n  key: string;\n\n  /**\n   * The modifiers combined with {@link KeyboardCommand.key}. When omitted, no modifiers are required.\n   */\n  modifiers?: Modifier[];\n\n  /**\n   * The handler invoked when the shortcut is pressed. When omitted, the command is a hint only and no\n   * scope handler is registered.\n   *\n   * @param $event - The keyboard event.\n   * @param context - The keymap context.\n   * @returns `false` to prevent Obsidian's default handling, or `void`/`true` otherwise.\n   */\n  onKey?($event: KeyboardEvent, context: KeymapContext): boolean;\n\n  /**\n   * The human-readable description shown next to the key in the instruction bar.\n   */\n  purpose: string;\n}\n\n/**\n * Options for {@link SuggestModalCommandBuilder.build}.\n */\nexport interface SuggestModalCommandBuilderBuildOptions {\n  /**\n   * Whether to render the instruction bar (checkboxes, dropdowns, keyboard hints) and register the\n   * option-toggle keyboard shortcuts. When `false`, no instruction UI is shown and the option-toggle\n   * shortcuts are not registered; only the essential navigation key handlers remain active.\n   *\n   * @default `true`\n   */\n  readonly shouldShowInstructions?: boolean;\n}\n\ninterface InstructionEx extends Instruction {\n  init?(purposeEl: HTMLSpanElement, scope: Scope): void;\n  registerScope?(scope: Scope): void;\n}\n\n/**\n * Builds a {@link SuggestModal}'s instruction bar from keyboard commands, interactive checkboxes, and\n * dropdowns, then applies them to a modal via {@link SuggestModalCommandBuilder.build}.\n */\nexport class SuggestModalCommandBuilder {\n  private readonly instructions: InstructionEx[] = [];\n\n  /**\n   * Adds an interactive checkbox to the instruction bar, bound to a modifier+key shortcut that toggles\n   * it.\n   *\n   * @param command - The checkbox command to add.\n   * @returns The builder instance for chaining.\n   */\n  public addCheckbox(command: CheckboxCommand): this {\n    this.instructions.push({\n      command: this.buildCommand(command),\n      init: (purposeEl, scope) => {\n        const checkboxEl = purposeEl.createEl('input', { type: 'checkbox' });\n        command.onInit(checkboxEl);\n        checkboxEl.addEventListener('change', () => {\n          command.onChange(checkboxEl.checked);\n        });\n\n        scope.register(command.modifiers ?? [], command.key, () => {\n          if (checkboxEl.disabled) {\n            return;\n          }\n          checkboxEl.checked = !checkboxEl.checked;\n          checkboxEl.trigger('change');\n        });\n      },\n      purpose: command.purpose\n    });\n    return this;\n  }\n\n  /**\n   * Adds a dropdown to the instruction bar, bound to a modifier+key shortcut that cycles through its\n   * options.\n   *\n   * @param command - The dropdown command to add.\n   * @returns The builder instance for chaining.\n   */\n  public addDropDown(command: DropDownCommand): this {\n    this.instructions.push({\n      command: this.buildCommand(command),\n      init: (purposeEl, scope) => {\n        purposeEl.appendText(' ');\n        const dropdownComponent = new DropdownComponent(purposeEl);\n        command.onInit(dropdownComponent);\n        dropdownComponent.onChange((value) => {\n          command.onChange(value);\n        });\n\n        /* v8 ignore start -- defensive ?? on optional modifiers. */\n        scope.register(command.modifiers ?? [], command.key, () => {\n          /* v8 ignore stop */\n          if (dropdownComponent.disabled) {\n            return;\n          }\n          const selectEl = dropdownComponent.selectEl;\n          selectEl.selectedIndex = (selectEl.selectedIndex + 1) % selectEl.options.length;\n          selectEl.trigger('change');\n        });\n      },\n      purpose: command.purpose\n    });\n    return this;\n  }\n\n  /**\n   * Adds a keyboard command to the instruction bar. When {@link KeyboardCommand.onKey} is provided, its\n   * handler is registered with the modal scope; otherwise the command is a hint only.\n   *\n   * @param command - The keyboard command to add.\n   * @returns The builder instance for chaining.\n   */\n  public addKeyboardCommand(command: KeyboardCommand): this {\n    this.instructions.push({\n      command: this.buildCommand(command),\n      purpose: command.purpose,\n      registerScope: (scope) => {\n        if (command.onKey) {\n          /* v8 ignore start -- defensive ?? on optional modifiers. */\n          scope.register(command.modifiers ?? [], command.key, command.onKey.bind(command));\n          /* v8 ignore stop */\n        }\n      }\n    });\n    return this;\n  }\n\n  /**\n   * Applies the accumulated commands to a modal. Always registers the essential navigation/action key\n   * handlers; only renders the instruction UI and registers the option-toggle shortcuts when\n   * {@link SuggestModalCommandBuilderBuildOptions.shouldShowInstructions} is `true`.\n   *\n   * @param modal - The modal to apply the commands to.\n   * @param options - The build options.\n   */\n  public build(modal: SuggestModal<unknown>, options: SuggestModalCommandBuilderBuildOptions = {}): void {\n    const { shouldShowInstructions = true } = options;\n\n    // Essential navigation/action key handlers must stay active even when the instruction bar is hidden.\n    for (const instruction of this.instructions) {\n      instruction.registerScope?.(modal.scope);\n    }\n\n    if (!shouldShowInstructions) {\n      return;\n    }\n\n    modal.setInstructions(this.instructions);\n    const purposeEls = [...modal.instructionsEl.findAll('.prompt-instruction > span:nth-child(2)')] as HTMLSpanElement[];\n    for (const [index, purposeEl] of purposeEls.entries()) {\n      /* v8 ignore stop */\n\n      this.instructions[index]?.init?.(purposeEl, modal.scope);\n    }\n  }\n\n  private buildCommand(entry: KeyboardCommand): string {\n    let command = KEYS_MAP.get(entry.key) ?? entry.key;\n\n    for (const modifier of entry.modifiers ?? []) {\n      command = `${this.getModifierString(modifier)} ${command}`;\n    }\n\n    return command;\n  }\n\n  private getModifierString(modifier: Modifier): string {\n    switch (modifier) {\n      case 'Alt': {\n        return 'alt';\n      }\n      case 'Ctrl': {\n        return 'ctrl';\n      }\n      case 'Meta': {\n        return Platform.isMacOS ? 'cmd' : 'win';\n      }\n      case 'Mod': {\n        return Platform.isMacOS ? 'cmd' : 'ctrl';\n      }\n      case 'Shift': {\n        return 'shift';\n      }\n      default: {\n        return modifier;\n      }\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,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