obsidian-dev-utils 101.4.1 → 101.6.0

package/dist/lib/cjs/obsidian/link.d.cts

@@ -73,6 +73,18 @@ export interface ConvertLinkParams {
      * An Obsidian app instance.
      */
     readonly app: App;
+    /**
+     * Whether to allow an empty alias for embeds.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `![](foo.png)`.
+     *
+     * If `false`: `![foo](foo.png)`.
+     *
+     * @default `true`
+     */
+    readonly isEmptyEmbedAliasAllowed?: boolean;
     /**
      * A reference for the link.
      */
@@ -93,12 +105,72 @@ export interface ConvertLinkParams {
      * An old path of the link.
      */
     readonly oldSourcePathOrFile?: PathOrFile;
+    /**
+     * Whether to escape the alias.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[\*\*alias\*\*](link.md)`.
+     *
+     * If `false`: `[**alias**](link.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldEscapeAlias?: boolean;
+    /**
+     * Whether to include the attachment extension in the embed alias.
+     *
+     * Applicable only if {@link isEmptyEmbedAliasAllowed} is `false`.
+     *
+     * If `true`: `[foo.png](foo.png)`.
+     *
+     * If `false`: `[foo](foo.png)`.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeAttachmentExtensionToEmbedAlias?: boolean;
     /**
      * Whether to update file name alias.
      *
      * @default `true`
      */
     readonly shouldUpdateFileNameAlias?: boolean;
+    /**
+     * Indicates if the link should use angle brackets.
+     *
+     * Applicable only if {@link linkStyle} is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[alias](<path with spaces.md>)`.
+     *
+     * If `false`: `[alias](path%20with%20spaces.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldUseAngleBrackets?: boolean;
+    /**
+     * Indicates if the link should use a leading dot.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.RelativePathToTheSource}.
+     *
+     * If `true`: `[[./relative/path/to/target]]`
+     *
+     * If `false`: `[[relative/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingDotForRelativePaths?: boolean;
+    /**
+     * Indicates if the link should use a leading slash.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.AbsolutePathInVault}.
+     *
+     * If `true`: `[[/absolute/path/to/target]]`
+     *
+     * If `false`: `[[absolute/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingSlashForAbsolutePaths?: boolean;
 }
 /**
  * Options for {@link editBacklinks}.
@@ -385,7 +457,7 @@ export interface GenerateMarkdownLinkParams {
     /**
      * Indicates if the link should use a leading dot.
      *
-     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.RelativePathToSource}.
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.RelativePathToTheSource}.
      *
      * If `true`: `[[./relative/path/to/target]]`
      *
@@ -561,6 +633,18 @@ export interface UpdateLinkParams {
      * An Obsidian app instance.
      */
     readonly app: App;
+    /**
+     * Whether to allow an empty alias for embeds.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `![](foo.png)`.
+     *
+     * If `false`: `![foo](foo.png)`.
+     *
+     * @default `true`
+     */
+    readonly isEmptyEmbedAliasAllowed?: boolean;
     /**
      * A reference for the link.
      */
@@ -589,12 +673,72 @@ export interface UpdateLinkParams {
      * An old path of the file.
      */
     readonly oldTargetPathOrFile?: PathOrFile;
+    /**
+     * Whether to escape the alias.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[\*\*alias\*\*](link.md)`.
+     *
+     * If `false`: `[**alias**](link.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldEscapeAlias?: boolean;
+    /**
+     * Whether to include the attachment extension in the embed alias.
+     *
+     * Applicable only if {@link isEmptyEmbedAliasAllowed} is `false`.
+     *
+     * If `true`: `[foo.png](foo.png)`.
+     *
+     * If `false`: `[foo](foo.png)`.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeAttachmentExtensionToEmbedAlias?: boolean;
     /**
      * Whether to update file name alias.
      *
      * @default `true`
      */
     readonly shouldUpdateFileNameAlias?: boolean;
+    /**
+     * Indicates if the link should use angle brackets.
+     *
+     * Applicable only if {@link linkStyle} is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[alias](<path with spaces.md>)`.
+     *
+     * If `false`: `[alias](path%20with%20spaces.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldUseAngleBrackets?: boolean;
+    /**
+     * Indicates if the link should use a leading dot.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.RelativePathToTheSource}.
+     *
+     * If `true`: `[[./relative/path/to/target]]`
+     *
+     * If `false`: `[[relative/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingDotForRelativePaths?: boolean;
+    /**
+     * Indicates if the link should use a leading slash.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.AbsolutePathInVault}.
+     *
+     * If `true`: `[[/absolute/path/to/target]]`
+     *
+     * If `false`: `[[absolute/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingSlashForAbsolutePaths?: boolean;
 }
 /**
  * Params for {@link updateLinksInFile}.
@@ -604,6 +748,18 @@ export interface UpdateLinksInFileParams extends ProcessOptions {
      * An Obsidian app instance.
      */
     readonly app: App;
+    /**
+     * Whether to allow an empty alias for embeds.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `![](foo.png)`.
+     *
+     * If `false`: `![foo](foo.png)`.
+     *
+     * @default `true`
+     */
+    readonly isEmptyEmbedAliasAllowed?: boolean;
     /**
      * A style of the link path.
      */
@@ -620,6 +776,30 @@ export interface UpdateLinksInFileParams extends ProcessOptions {
      * An old path of the file.
      */
     readonly oldSourcePathOrFile?: PathOrFile;
+    /**
+     * Whether to escape the alias.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[\*\*alias\*\*](link.md)`.
+     *
+     * If `false`: `[**alias**](link.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldEscapeAlias?: boolean;
+    /**
+     * Whether to include the attachment extension in the embed alias.
+     *
+     * Applicable only if {@link isEmptyEmbedAliasAllowed} is `false`.
+     *
+     * If `true`: `[foo.png](foo.png)`.
+     *
+     * If `false`: `[foo](foo.png)`.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeAttachmentExtensionToEmbedAlias?: boolean;
     /**
      * Whether to update only embedded links.
      */
@@ -630,6 +810,42 @@ export interface UpdateLinksInFileParams extends ProcessOptions {
      * @default `true`
      */
     readonly shouldUpdateFileNameAlias?: boolean;
+    /**
+     * Indicates if the link should use angle brackets.
+     *
+     * Applicable only if {@link linkStyle} is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[alias](<path with spaces.md>)`.
+     *
+     * If `false`: `[alias](path%20with%20spaces.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldUseAngleBrackets?: boolean;
+    /**
+     * Indicates if the link should use a leading dot.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.RelativePathToTheSource}.
+     *
+     * If `true`: `[[./relative/path/to/target]]`
+     *
+     * If `false`: `[[relative/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingDotForRelativePaths?: boolean;
+    /**
+     * Indicates if the link should use a leading slash.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.AbsolutePathInVault}.
+     *
+     * If `true`: `[[/absolute/path/to/target]]`
+     *
+     * If `false`: `[[absolute/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingSlashForAbsolutePaths?: boolean;
 }
 /**
  * Params for {@link updateLinksInContent}.
@@ -643,6 +859,18 @@ interface UpdateLinksInContentParams {
      * A content to update the links in.
      */
     readonly content: string;
+    /**
+     * Whether to allow an empty alias for embeds.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `![](foo.png)`.
+     *
+     * If `false`: `![foo](foo.png)`.
+     *
+     * @default `true`
+     */
+    readonly isEmptyEmbedAliasAllowed?: boolean;
     /**
      * A style of the link path.
      */
@@ -659,6 +887,30 @@ interface UpdateLinksInContentParams {
      * An old source path or file.
      */
     readonly oldSourcePathOrFile?: PathOrFile;
+    /**
+     * Whether to escape the alias.
+     *
+     * Applicable only if the result link style is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[\*\*alias\*\*](link.md)`.
+     *
+     * If `false`: `[**alias**](link.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldEscapeAlias?: boolean;
+    /**
+     * Whether to include the attachment extension in the embed alias.
+     *
+     * Applicable only if {@link isEmptyEmbedAliasAllowed} is `false`.
+     *
+     * If `true`: `[foo.png](foo.png)`.
+     *
+     * If `false`: `[foo](foo.png)`.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeAttachmentExtensionToEmbedAlias?: boolean;
     /**
      * Whether to update only embedded links.
      */
@@ -669,6 +921,42 @@ interface UpdateLinksInContentParams {
      * @default `true`
      */
     readonly shouldUpdateFileNameAlias?: boolean;
+    /**
+     * Indicates if the link should use angle brackets.
+     *
+     * Applicable only if {@link linkStyle} is {@link LinkStyle.Markdown}.
+     *
+     * If `true`: `[alias](<path with spaces.md>)`.
+     *
+     * If `false`: `[alias](path%20with%20spaces.md)`.
+     *
+     * @default `false`
+     */
+    readonly shouldUseAngleBrackets?: boolean;
+    /**
+     * Indicates if the link should use a leading dot.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.RelativePathToTheSource}.
+     *
+     * If `true`: `[[./relative/path/to/target]]`
+     *
+     * If `false`: `[[relative/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingDotForRelativePaths?: boolean;
+    /**
+     * Indicates if the link should use a leading slash.
+     *
+     * Applicable only if {@link linkPathStyle} is {@link LinkPathStyle.AbsolutePathInVault}.
+     *
+     * If `true`: `[[/absolute/path/to/target]]`
+     *
+     * If `false`: `[[absolute/path/to/target]]`
+     *
+     * @default `false`
+     */
+    readonly shouldUseLeadingSlashForAbsolutePaths?: boolean;
 }
 /**
  * Converts a link to a new path.

package/dist/lib/cjs/obsidian/mobile-trusted-input.cjs

@@ -192,4 +192,4 @@ function getSeamFunction(name) {
   typeIntoEditor,
   unhoverElement
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/mobile-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone \u2014\n * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted \u2014 so the injection\n * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's\n * binding channel, and the host injects it into the WebView over CDP.\n *\n * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the\n * harness rather than reimplementing the wire format: they call\n * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness\n * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics \u2014\n * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws\n * for the `:hover` helpers \u2014 identical to the harness's own copy for free, instead of a second\n * implementation to hand-sync (see the project `AGENTS.md` **L4**).\n *\n * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in\n * either direction, at runtime or in types.\n *\n * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.\n * Outside one they throw a message saying so, rather than silently doing nothing \u2014 a no-op would recreate\n * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct\n * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.\n */\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n  // The parameter contracts live with the desktop twin and are shared verbatim, so the two platforms\n  // Cannot drift apart on what a caller passes. A type-only import loads nothing (L5).\n} from './desktop-trusted-input.ts';\n\n/**\n * The global the harness bootstraps its namespace onto.\n */\ninterface ObsidianIntegrationTestingHolder {\n  __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;\n}\n\n/**\n * The part of the harness namespace this module reads. Everything else on it is none of this module's\n * business.\n */\ninterface ObsidianIntegrationTestingNamespace {\n  trustedInput?: Partial<TrustedInputSeam>;\n}\n\n/**\n * The trusted-input seam the `obsidian-integration-testing` harness publishes on its namespace.\n *\n * Declared here rather than imported: the harness is not a dependency of this library. It mirrors\n * `namespace-bootstrap.ts`'s `trustedInput` object, and the mirroring is by hand \u2014 the same\n * behavioral-sync obligation the desktop twin carries.\n */\ninterface TrustedInputSeam {\n  clickElement(params: ClickElementParams): Promise<void>;\n  clickMouse(params: ClickMouseParams): Promise<void>;\n  hoverElement(params: HoverElementParams): Promise<void>;\n  moveMouse(params: MoveMouseParams): Promise<void>;\n  pressKey(params: PressKeyParams): Promise<void>;\n  typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;\n  unhoverElement(params: UnhoverElementParams): Promise<void>;\n}\n\n/**\n * Clicks the center of an element using **trusted** touch input \u2014 a CDP tap in the WebView, injected by\n * the host.\n *\n * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens\n * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing\n * one would be worse than saying so.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  await getSeamFunction('clickElement')(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.\n *\n * The coordinates are CSS pixels in the WebView's own viewport \u2014 which is what CDP takes \u2014 so\n * `devicePixelRatio` never enters the picture.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  await getSeamFunction('clickMouse')(params);\n}\n\n/**\n * Always throws: `:hover` has no touch equivalent.\n *\n * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm\n * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with\n * {@link clickElement}.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  await getSeamFunction('hoverElement')(params);\n}\n\n/**\n * Always throws: a touch screen has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  await getSeamFunction('moveMouse')(params);\n}\n\n/**\n * Presses a single key using **trusted** keyboard input, injected by the host over CDP.\n *\n * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable\n * characters are supported; anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  await getSeamFunction('pressKey')(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.\n *\n * Focuses the editor (caret to the end), presses every code point of the text, then polls until the\n * document reflects the input or a bounded timeout elapses.\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  await getSeamFunction('typeIntoEditor')(params);\n}\n\n/**\n * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  await getSeamFunction('unhoverElement')(params);\n}\n\nfunction getSeamFunction<Key extends keyof TrustedInputSeam>(name: Key): TrustedInputSeam[Key] {\n  // eslint-disable-next-line obsidianmd/no-global-this -- The harness installs its namespace on the realm global; there is nowhere else to read it from.\n  const holder = globalThis as Partial<ObsidianIntegrationTestingHolder>;\n  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];\n  if (!seamFunction) {\n    throw new Error(\n      `Trusted input is unavailable on mobile: \\`window.__obsidianIntegrationTesting.trustedInput.${name}\\` is not installed. `\n        + 'A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the '\n        + '`obsidian-integration-testing` Appium transport\\'s channel \u2014 which means these helpers only work inside an app that '\n        + 'harness bootstrapped.'\n    );\n  }\n\n  return seamFunction;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgFA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAWA,eAAsB,WAAW,QAAyC;AACxE,QAAM,gBAAgB,YAAY,EAAE,MAAM;AAC5C;AAYA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAQA,eAAsB,UAAU,QAAwC;AACtE,QAAM,gBAAgB,WAAW,EAAE,MAAM;AAC3C;AAWA,eAAsB,SAAS,QAAuC;AACpE,QAAM,gBAAgB,UAAU,EAAE,MAAM;AAC1C;AAWA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAQA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAEA,SAAS,gBAAoD,MAAkC;AAE7F,QAAM,SAAS;AACf,QAAM,eAAe,OAAO,8BAA8B,eAAe,IAAI;AAC7E,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR,8FAA8F,IAAI;AAAA,IAIpG;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/mobile-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone \u2014\n * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted \u2014 so the injection\n * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's\n * binding channel, and the host injects it into the WebView over CDP \u2014 as `Input.dispatchTouchEvent` for\n * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past\n * Android's gesture recognizer and so is classified as a tap at any dwell.\n *\n * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the\n * harness rather than reimplementing the wire format: they call\n * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness\n * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics \u2014\n * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws\n * for the `:hover` helpers \u2014 identical to the harness's own copy for free, instead of a second\n * implementation to hand-sync (see the project `AGENTS.md` **L4**).\n *\n * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in\n * either direction, at runtime or in types.\n *\n * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.\n * Outside one they throw a message saying so, rather than silently doing nothing \u2014 a no-op would recreate\n * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct\n * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.\n */\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n  // The parameter contracts live with the desktop twin and are shared verbatim, so the two platforms\n  // Cannot drift apart on what a caller passes. A type-only import loads nothing (L5).\n} from './desktop-trusted-input.ts';\n\n/**\n * The global the harness bootstraps its namespace onto.\n */\ninterface ObsidianIntegrationTestingHolder {\n  __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;\n}\n\n/**\n * The part of the harness namespace this module reads. Everything else on it is none of this module's\n * business.\n */\ninterface ObsidianIntegrationTestingNamespace {\n  trustedInput?: Partial<TrustedInputSeam>;\n}\n\n/**\n * The trusted-input seam the `obsidian-integration-testing` harness publishes on its namespace.\n *\n * Declared here rather than imported: the harness is not a dependency of this library. It mirrors\n * `namespace-bootstrap.ts`'s `trustedInput` object, and the mirroring is by hand \u2014 the same\n * behavioral-sync obligation the desktop twin carries.\n */\ninterface TrustedInputSeam {\n  clickElement(params: ClickElementParams): Promise<void>;\n  clickMouse(params: ClickMouseParams): Promise<void>;\n  hoverElement(params: HoverElementParams): Promise<void>;\n  moveMouse(params: MoveMouseParams): Promise<void>;\n  pressKey(params: PressKeyParams): Promise<void>;\n  typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;\n  unhoverElement(params: UnhoverElementParams): Promise<void>;\n}\n\n/**\n * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host\n * over CDP.\n *\n * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens\n * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing\n * one would be worse than saying so.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  await getSeamFunction('clickElement')(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.\n *\n * The coordinates are CSS pixels in the WebView's own viewport \u2014 which is what CDP takes \u2014 so\n * `devicePixelRatio` never enters the picture.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  await getSeamFunction('clickMouse')(params);\n}\n\n/**\n * Always throws: `:hover` has no touch equivalent.\n *\n * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm\n * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with\n * {@link clickElement}.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  await getSeamFunction('hoverElement')(params);\n}\n\n/**\n * Always throws: a touch screen has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  await getSeamFunction('moveMouse')(params);\n}\n\n/**\n * Presses a single key using **trusted** keyboard input, injected by the host over CDP.\n *\n * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable\n * characters are supported; anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  await getSeamFunction('pressKey')(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.\n *\n * Focuses the editor (caret to the end), presses every code point of the text, then polls until the\n * document reflects the input or a bounded timeout elapses.\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  await getSeamFunction('typeIntoEditor')(params);\n}\n\n/**\n * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  await getSeamFunction('unhoverElement')(params);\n}\n\nfunction getSeamFunction<Key extends keyof TrustedInputSeam>(name: Key): TrustedInputSeam[Key] {\n  // eslint-disable-next-line obsidianmd/no-global-this -- The harness installs its namespace on the realm global; there is nowhere else to read it from.\n  const holder = globalThis as Partial<ObsidianIntegrationTestingHolder>;\n  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];\n  if (!seamFunction) {\n    throw new Error(\n      `Trusted input is unavailable on mobile: \\`window.__obsidianIntegrationTesting.trustedInput.${name}\\` is not installed. `\n        + 'A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the '\n        + '`obsidian-integration-testing` Appium transport\\'s channel \u2014 which means these helpers only work inside an app that '\n        + 'harness bootstrapped.'\n    );\n  }\n\n  return seamFunction;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkFA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAWA,eAAsB,WAAW,QAAyC;AACxE,QAAM,gBAAgB,YAAY,EAAE,MAAM;AAC5C;AAYA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAQA,eAAsB,UAAU,QAAwC;AACtE,QAAM,gBAAgB,WAAW,EAAE,MAAM;AAC3C;AAWA,eAAsB,SAAS,QAAuC;AACpE,QAAM,gBAAgB,UAAU,EAAE,MAAM;AAC1C;AAWA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAQA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAEA,SAAS,gBAAoD,MAAkC;AAE7F,QAAM,SAAS;AACf,QAAM,eAAe,OAAO,8BAA8B,eAAe,IAAI;AAC7E,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR,8FAA8F,IAAI;AAAA,IAIpG;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/obsidian/mobile-trusted-input.d.cts

@@ -5,7 +5,9 @@
  * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone —
  * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted — so the injection
  * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's
- * binding channel, and the host injects it into the WebView over CDP.
+ * binding channel, and the host injects it into the WebView over CDP — as `Input.dispatchTouchEvent` for
+ * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past
+ * Android's gesture recognizer and so is classified as a tap at any dwell.
  *
  * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the
  * harness rather than reimplementing the wire format: they call
@@ -25,8 +27,8 @@
  */
 import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.cjs';
 /**
- * Clicks the center of an element using **trusted** touch input — a CDP tap in the WebView, injected by
- * the host.
+ * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host
+ * over CDP.
  *
  * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens
  * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing

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

@@ -150,6 +150,7 @@ 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_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');
@@ -161,6 +162,7 @@ class PromptModal extends import_modal.ModalBase {
   isTouched = false;
   okButtonText;
   placeholder;
+  spellcheckMode;
   title;
   value;
   valueValidator;
@@ -172,6 +174,7 @@ class PromptModal extends import_modal.ModalBase {
     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 ?? "";
@@ -183,7 +186,11 @@ class PromptModal extends import_modal.ModalBase {
     this.titleEl.setText(this.title);
     const textComponent = new import_obsidian.TextComponent(this.contentEl);
     const inputEl = textComponent.inputEl;
-    inputEl.setAttribute("spellcheck", String((0, import_obsidian_settings.isSpellcheckEnabled)(this.app)));
+    (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 ?? "");
@@ -256,4 +263,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  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": []
}

+//# 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 { 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  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 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/obsidian/modals/prompt.d.cts

@@ -10,6 +10,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';
+import { SpellcheckMode } from '../obsidian-settings.cjs';
 /**
  * Options for {@link prompt}.
  */
@@ -48,6 +49,17 @@ export interface PromptParams extends ModalParamsBase {
      * @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.
      *

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

@@ -147,6 +147,8 @@ __export(select_item_exports, {
 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 {
@@ -155,12 +157,14 @@ class ItemSelectModal extends import_obsidian.FuzzySuggestModal {
   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);
@@ -179,6 +183,14 @@ class ItemSelectModal extends import_obsidian.FuzzySuggestModal {
       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);
@@ -196,4 +208,4 @@ async function selectItem(params) {
 0 && (module.exports = {
   selectItem
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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