@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/desktop-trusted-input.cjs

@@ -0,0 +1,301 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var desktop_trusted_input_exports = {};
+__export(desktop_trusted_input_exports, {
+  clickElement: () => clickElement,
+  clickMouse: () => clickMouse,
+  hoverElement: () => hoverElement,
+  moveMouse: () => moveMouse,
+  pressKey: () => pressKey,
+  typeIntoEditor: () => typeIntoEditor,
+  unhoverElement: () => unhoverElement
+});
+module.exports = __toCommonJS(desktop_trusted_input_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_obsidian = require('obsidian');
+const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;
+const INPUT_TIMEOUT_IN_MILLISECONDS = 5e3;
+const CENTER_DIVISOR = 2;
+const SINGLE_CLICK_COUNT = 1;
+async function clickElement(params) {
+  const { button = "left", element, modifiers = [] } = params;
+  const rect = element.getBoundingClientRect();
+  await clickMouse({
+    button,
+    modifiers,
+    window: getElementWindow(element),
+    x: rect.left + rect.width / CENTER_DIVISOR,
+    y: rect.top + rect.height / CENTER_DIVISOR
+  });
+}
+async function clickMouse(params) {
+  const { button = "left", modifiers = [], x, y } = params;
+  const electronModifiers = toElectronModifiers(modifiers);
+  const roundedX = Math.round(x);
+  const roundedY = Math.round(y);
+  const webContents = getTargetWebContents(params.window);
+  webContents.sendInputEvent({ modifiers: electronModifiers, type: "mouseMove", x: roundedX, y: roundedY });
+  webContents.sendInputEvent({
+    button,
+    clickCount: SINGLE_CLICK_COUNT,
+    modifiers: electronModifiers,
+    type: "mouseDown",
+    x: roundedX,
+    y: roundedY
+  });
+  webContents.sendInputEvent({
+    button,
+    clickCount: SINGLE_CLICK_COUNT,
+    modifiers: electronModifiers,
+    type: "mouseUp",
+    x: roundedX,
+    y: roundedY
+  });
+}
+async function hoverElement(params) {
+  const { element } = params;
+  const rect = element.getBoundingClientRect();
+  await moveMouse({
+    window: getElementWindow(element),
+    x: rect.left + rect.width / CENTER_DIVISOR,
+    y: rect.top + rect.height / CENTER_DIVISOR
+  });
+  const startTime = Date.now();
+  while (!element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+  if (!element.matches(":hover")) {
+    throw new Error(
+      `The pointer was moved to the center of the element, but it never matched \`:hover\` within ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. Most often the center belongs to something on top of the element, or the element moved after its box was read.`
+    );
+  }
+}
+async function moveMouse(params) {
+  getTargetWebContents(params.window).sendInputEvent({ type: "mouseMove", x: Math.round(params.x), y: Math.round(params.y) });
+}
+async function pressKey(params) {
+  const { key, modifiers = [] } = params;
+  const electronModifiers = toElectronModifiers(modifiers);
+  const webContents = getTargetWebContents(params.window);
+  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: "keyDown" });
+  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: "char" });
+  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: "keyUp" });
+}
+async function typeIntoEditor(params) {
+  const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;
+  const { editor, text } = params;
+  const valueBeforeTyping = editor.getValue();
+  const targetWindow = getEditorWindow(editor);
+  editor.focus();
+  const lastLine = editor.lastLine();
+  editor.setCursor(lastLine, editor.getLine(lastLine).length);
+  await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);
+  for (const char of text) {
+    await pressKey({ key: char, window: targetWindow });
+  }
+  const startTime = Date.now();
+  while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+}
+async function unhoverElement(params) {
+  const OUTSIDE_OFFSET_IN_PIXELS = 1;
+  const { element } = params;
+  const rect = element.getBoundingClientRect();
+  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? Math.floor(rect.left) - OUTSIDE_OFFSET_IN_PIXELS : Math.ceil(rect.right) + OUTSIDE_OFFSET_IN_PIXELS;
+  const y = rect.top + rect.height / CENTER_DIVISOR;
+  await moveMouse({ window: getElementWindow(element), x, y });
+  const startTime = Date.now();
+  while (element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+  if (element.matches(":hover")) {
+    throw new Error(
+      `The pointer was moved outside the element's box, but it still matched \`:hover\` after ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. An element that spans the full viewport has no point outside its box to move to \u2014 use \`moveMouse\` to a known empty coordinate instead.`
+    );
+  }
+}
+function getEditorWindow(editor) {
+  return editor.cm.dom.ownerDocument.defaultView ?? window;
+}
+function getElementWindow(element) {
+  return element.ownerDocument.defaultView ?? window;
+}
+function getTargetWebContents(targetWindow) {
+  if (targetWindow === void 0 || targetWindow === window) {
+    return window.electron.remote.getCurrentWebContents();
+  }
+  const { electron } = targetWindow;
+  if (!electron) {
+    throw new Error(
+      "Trusted input cannot reach this window: it has no Electron bridge (`window.electron`). Pass an Obsidian window, the main one or a popout (`leaf.view.containerEl.win`), not an iframe's."
+    );
+  }
+  return electron.remote.getCurrentWebContents();
+}
+function toElectronModifiers(modifiers) {
+  const isMacOS = import_obsidian.Platform.isMacOS;
+  return modifiers.map((modifier) => {
+    switch (modifier) {
+      case "Alt": {
+        return "alt";
+      }
+      case "Ctrl": {
+        return "control";
+      }
+      case "Meta": {
+        return "meta";
+      }
+      case "Mod": {
+        return isMacOS ? "meta" : "control";
+      }
+      case "Shift": {
+        return "shift";
+      }
+      default: {
+        return (0, import_type_guards.assertNever)(modifier);
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clickElement,
+  clickMouse,
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/desktop-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop-only trusted input helpers that drive the real Electron renderer via\n * `webContents.sendInputEvent`, so keystrokes, pointer moves and clicks flow through the same trusted\n * input pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror, the CSS\n * `:hover` engine and every `e.isTrusted` guard in Obsidian ignore).\n *\n * These are the importable-module twins of the base helpers the `obsidian-integration-testing` harness\n * seeds into the `lib` bag; the two copies are kept behaviorally in sync by hand (see the project\n * `CLAUDE.md`). Desktop-only: they depend on `window.electron`.\n *\n * This is the **desktop arm**. Import it directly only as a deliberate platform commitment; the\n * cross-platform entry point is the {@link ./trusted-input.ts | trusted-input} facade, which dispatches\n * to this module or to {@link ./mobile-trusted-input.ts | mobile-trusted-input} per call.\n */\n\nimport type {\n  Editor,\n  Modifier\n} from 'obsidian';\n\nimport { assertNever } from '@mnaoumov/typescript-lib/type-guards';\nimport { Platform } from 'obsidian';\n\n/**\n * Parameters for {@link clickElement}.\n */\nexport interface ClickElementParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The element to click. The pointer is moved to its center.\n   *\n   * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in\n   * a popout is driven in that popout with no extra parameter.\n   */\n  readonly element: HTMLElement;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link clickMouse}.\n */\nexport interface ClickMouseParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n\n  /**\n   * The Obsidian window to click in: the main window or a popout. Pass the window that owns the target,\n   * e.g. `leaf.view.containerEl.win` for a popout leaf. Each Obsidian window is its own Electron web\n   * contents, so a click sent to one never reaches another, and the coordinates are in the named window's\n   * viewport.\n   *\n   * **On mobile** there are no popouts, so any window but the main one throws.\n   *\n   * @default the main window (`window`)\n   */\n  readonly window?: Window;\n\n  /**\n   * The x coordinate (web-contents DIP) to click at.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to click at.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center.\n   *\n   * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in\n   * a popout is driven in that popout with no extra parameter.\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The mouse button a trusted click presses, in Electron's `sendInputEvent` spelling.\n */\nexport type MouseButton = NonNullable<ElectronMouseInputEvent['button']>;\n\n/**\n * Parameters for {@link moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The Obsidian window to move the pointer in: the main window or a popout. Each Obsidian window is its\n   * own Electron web contents with its own pointer, and the coordinates are in the named window's viewport.\n   *\n   * Mobile has no pointer to move, so {@link moveMouse} throws there whatever this is.\n   *\n   * @default the main window (`window`)\n   */\n  readonly window?: Window;\n\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g. `'Enter'`, `'Escape'`, `'Tab'`,\n   * an arrow key, or a printable character (`'a'`, `'1'`).\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n\n  /**\n   * The Obsidian window to press the key in: the main window or a popout. Pass the window that owns the\n   * focused target, e.g. `leaf.view.containerEl.win` for a popout leaf. Each Obsidian window is its own\n   * Electron web contents, so the key goes to the DOM-focused element of the window named here, whichever\n   * window the OS has focused, and never reaches another window.\n   *\n   * **On mobile** there are no popouts, so any window but the main one throws.\n   *\n   * @default the main window (`window`)\n   */\n  readonly window?: Window;\n}\n\n/**\n * Parameters for {@link typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (caret moved to the end of the document) before the keystrokes\n   * are injected.\n   *\n   * The keystrokes go to the window that owns the editor, so an editor in a popout is typed into in that\n   * popout with no extra parameter.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link pressKey}, exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point just outside its bounding\n   * box.\n   *\n   * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in\n   * a popout is driven in that popout with no extra parameter.\n   */\n  readonly element: HTMLElement;\n}\n\ntype CurrentWebContents = ReturnType<Window['electron']['remote']['getCurrentWebContents']>;\n\n// The Electron modifier-key names `sendInputEvent` accepts (e.g. 'meta', 'control', 'shift', 'alt').\n// The type is derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronModifier = NonNullable<Parameters<CurrentWebContents['sendInputEvent']>[0]['modifiers']>[number];\n\n// The pointer variant of the `sendInputEvent` union, picked out by the coordinates only it carries.\n// Derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronMouseInputEvent = Extract<Parameters<CurrentWebContents['sendInputEvent']>[0], PointerCoordinates>;\n\n// The shape that discriminates a pointer `sendInputEvent` payload from a keyboard one.\ninterface PointerCoordinates {\n  x: number;\n}\n\n/**\n * Interval (in ms) between polls while waiting for a trusted input event to take effect (the editor\n * document updates, or an element's `:hover` state flips).\n */\nconst INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;\n\n/**\n * Maximum time (in ms) to wait for a trusted input event to take effect before giving up (the expected\n * outcome when the input is rejected \u2014 e.g. a read-only editor).\n */\nconst INPUT_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/**\n * Divisor used to find the center of an element's bounding box.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * The `clickCount` a single (non-double) trusted click carries.\n */\nconst SINGLE_CLICK_COUNT = 1;\n\n/**\n * Clicks the center of an element using **trusted** Electron pointer input.\n *\n * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /\n * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the\n * element's center \u2014 the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside\n * `.cm-sizer`, so no element's center lands on it.\n *\n * **Must be awaited.** Nothing here needs to wait, but the cross-platform twins do \u2014 on mobile the\n * injection is a round-trip to the host, because the renderer cannot produce a trusted event itself \u2014 so\n * the signature is the same on both platforms and a caller never rewrites its `await`s when it grows a\n * mobile lane.\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  const { button = 'left', element, modifiers = [] } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`. The rect is in the\n  // viewport of the window that owns the element, so the click goes to that window.\n  const rect = element.getBoundingClientRect();\n  await clickMouse({\n    button,\n    modifiers,\n    window: getElementWindow(element),\n    x: rect.left + rect.width / CENTER_DIVISOR,\n    y: rect.top + rect.height / CENTER_DIVISOR\n  });\n}\n\n/**\n * Clicks at the given web-contents coordinates using **trusted** Electron pointer input, so Chromium\n * synthesizes a real `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do: Obsidian and CodeMirror gate\n * on `isTrusted`, so a dispatched event silently exercises nothing while the test still passes. Obsidian\n * 1.13.7's markdown viewport (margin) menu, for example, opens from\n * `cm.scrollDOM.addEventListener('contextmenu', (e) => { if (!e.defaultPrevented && e.isTrusted && \u2026) })`\n * \u2014 a dispatched `contextmenu` never gets past that check.\n *\n * It is the low-level primitive: a single trusted `mouseMove` \u2192 `mouseDown` \u2192 `mouseUp` at one point,\n * with no waiting for any effect (callers poll their own readiness signal). The leading move is what puts\n * the pointer over the hit-test target before the button goes down. Prefer {@link clickElement} for\n * element-relative clicks.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The web-contents DIP coordinates to click at, the button to press and any modifiers to\n * hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  const { button = 'left', modifiers = [], x, y } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const roundedX = Math.round(x);\n  const roundedY = Math.round(y);\n  const webContents = getTargetWebContents(params.window);\n\n  webContents.sendInputEvent({ modifiers: electronModifiers, type: 'mouseMove', x: roundedX, y: roundedY });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseDown',\n    x: roundedX,\n    y: roundedY\n  });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseUp',\n    x: roundedX,\n    y: roundedY\n  });\n}\n\n/**\n * Moves the mouse pointer to the center of an element using **trusted** Electron pointer input, then polls\n * until the element actually matches `:hover`.\n *\n * Because the move is trusted, the real `:hover` state takes effect in the CSS engine \u2014 unlike\n * `dispatchEvent(new MouseEvent('mouseover'))`, which is untrusted and never sets `:hover`. It targets the\n * single window's **global** pointer, so only one element is hovered at a time.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that resolves once the element matches `:hover`.\n * @throws When the element never matches `:hover`. Resolving quietly there would let a test read an\n * element that is not hovered and pass on whatever its base style happens to be.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  const { element } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n  const rect = element.getBoundingClientRect();\n  await moveMouse({\n    window: getElementWindow(element),\n    x: rect.left + rect.width / CENTER_DIVISOR,\n    y: rect.top + rect.height / CENTER_DIVISOR\n  });\n\n  // Poll until the real `:hover` state has actually taken, instead of a fixed settle.\n  const startTime = Date.now();\n  while (!element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n\n  if (!element.matches(':hover')) {\n    throw new Error(\n      `The pointer was moved to the center of the element, but it never matched \\`:hover\\` within ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. `\n        + 'Most often the center belongs to something on top of the element, or the element moved after its box was read.'\n    );\n  }\n}\n\n/**\n * Moves the mouse pointer to the given web-contents coordinates using a **trusted** Electron pointer move.\n *\n * A trusted move updates the real pointer state in the CSS engine, so `:hover` rules genuinely apply. This\n * is the low-level primitive: it performs a single move and does **not** wait for any state to settle\n * (callers poll their own readiness signal). Prefer {@link hoverElement} / {@link unhoverElement} for\n * element-relative moves.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The web-contents DIP coordinates to move to.\n * @returns A {@link Promise} that resolves once the move has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  getTargetWebContents(params.window).sendInputEvent({ type: 'mouseMove', x: Math.round(params.x), y: Math.round(params.y) });\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** Electron keyboard input, firing the\n * full real key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It injects a trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence, delivered to the window's DOM-focused\n * element \u2014 unlike `dispatchEvent(new KeyboardEvent(...))`, which is untrusted and ignored by CodeMirror.\n * Use it for special keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations. It does\n * **not** poll for any effect; the caller focuses the target first, then awaits the expected effect.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\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 */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  const { key, modifiers = [] } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const webContents = getTargetWebContents(params.window);\n\n  // A trusted key press is keyDown -> char -> keyUp: the full real key pipeline.\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyDown' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'char' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyUp' });\n}\n\n/**\n * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.\n *\n * This focuses the editor (caret to end) and presses every code point of `text` via {@link pressKey} \u2014 the\n * same trusted sequence a real user produces \u2014 so the text reaches the document **only if the editor\n * genuinely holds focus**. After injecting the keystrokes it polls until the document reflects the input,\n * or a bounded timeout elapses (the expected outcome when the editor is read-only or focus was stolen).\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  const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;\n\n  const { editor, text } = params;\n  const valueBeforeTyping = editor.getValue();\n  const targetWindow = getEditorWindow(editor);\n\n  // Focus the editor and place the caret at the end of the document.\n  editor.focus();\n  const lastLine = editor.lastLine();\n  editor.setCursor(lastLine, editor.getLine(lastLine).length);\n\n  // Let any focus trap (a `setTimeout(0)` re-focus) fire before typing, so stolen focus is detected.\n  await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);\n\n  // Typing is pressing each character key in turn.\n  for (const char of text) {\n    await pressKey({ key: char, window: targetWindow });\n  }\n\n  // Poll until the document reflects the input or the timeout elapses, instead of a fixed settle.\n  const startTime = Date.now();\n  while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to a point just outside an element's bounding box using a **trusted** Electron\n * pointer move, then polls until the element no longer matches `:hover`.\n *\n * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box is\n * reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.\n * @throws When the element keeps matching `:hover`, which is what a full-viewport element does.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const OUTSIDE_OFFSET_IN_PIXELS = 1;\n\n  const { element } = params;\n\n  /*\n   * Move to a point just outside the element's box. When flush against the viewport's left edge, use just\n   * past the right edge. A full-viewport-width element should use `moveMouse` directly instead.\n   *\n   * The edge is SNAPPED away from the box before the offset is applied, and that is the whole correctness\n   * of this function. A layout box rarely lands on a whole pixel, and `moveMouse` rounds \u2014 so subtracting\n   * one from a fractional left edge rounds straight back onto the element's own pixel column and the\n   * pointer never leaves. Measured on a bar whose `left` was 859.796875: the plain `left - 1` becomes 859\n   * and `:hover` never clears, while `Math.floor(left) - 1` becomes 858 and it clears in 26 ms. Snapping\n   * first means the offset is a whole pixel of real clearance instead of whatever the fraction leaves.\n   */\n  const rect = element.getBoundingClientRect();\n  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS\n    ? Math.floor(rect.left) - OUTSIDE_OFFSET_IN_PIXELS\n    : Math.ceil(rect.right) + OUTSIDE_OFFSET_IN_PIXELS;\n  const y = rect.top + rect.height / CENTER_DIVISOR;\n  await moveMouse({ window: getElementWindow(element), x, y });\n\n  // Poll until the real `:hover` state has actually cleared, instead of a fixed settle.\n  const startTime = Date.now();\n  while (element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n\n  if (element.matches(':hover')) {\n    throw new Error(\n      `The pointer was moved outside the element's box, but it still matched \\`:hover\\` after ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. `\n        + 'An element that spans the full viewport has no point outside its box to move to \u2014 use `moveMouse` to a known empty coordinate instead.'\n    );\n  }\n}\n\n// The window that owns an editor's DOM, so typing into an editor in a popout goes to that popout.\nfunction getEditorWindow(editor: Editor): Window {\n  return editor.cm.dom.ownerDocument.defaultView ?? window;\n}\n\n// The window that owns an element, which is the window its viewport coordinates belong to.\nfunction getElementWindow(element: Element): Window {\n  return element.ownerDocument.defaultView ?? window;\n}\n\n/*\n * The Electron web contents trusted input is injected into. Every Obsidian window, the main one and each\n * popout, is its own web contents, and `remote.getCurrentWebContents()` answers for the window whose\n * `electron` bridge it is called through. So asking the TARGET window's own bridge is what aims the input\n * there; asking the main window's always delivered it to the main window, whatever the caller meant.\n * A window with no bridge (an iframe's) throws: falling back to the main window would be exactly that\n * misdirection.\n */\nfunction getTargetWebContents(targetWindow: undefined | Window): CurrentWebContents {\n  if (targetWindow === undefined || targetWindow === window) {\n    return window.electron.remote.getCurrentWebContents();\n  }\n\n  const { electron } = targetWindow as Partial<Pick<Window, 'electron'>>;\n  if (!electron) {\n    throw new Error(\n      'Trusted input cannot reach this window: it has no Electron bridge (`window.electron`). '\n        + 'Pass an Obsidian window, the main one or a popout (`leaf.view.containerEl.win`), not an iframe\\'s.'\n    );\n  }\n\n  return electron.remote.getCurrentWebContents();\n}\n\n// Maps Obsidian's `Modifier` names to Electron's lowercase `sendInputEvent` modifier names.\n// Shared by every trusted-input helper, so a key press and a click cannot disagree on `'Mod'`.\nfunction toElectronModifiers(modifiers: readonly Modifier[]): ElectronModifier[] {\n  // 'Mod' is Obsidian's platform-agnostic modifier: Cmd (meta) on macOS, Ctrl elsewhere.\n  const isMacOS = Platform.isMacOS;\n\n  return modifiers.map((modifier): ElectronModifier => {\n    switch (modifier) {\n      case 'Alt': {\n        return 'alt';\n      }\n      case 'Ctrl': {\n        return 'control';\n      }\n      case 'Meta': {\n        return 'meta';\n      }\n      case 'Mod': {\n        return isMacOS ? 'meta' : 'control';\n      }\n      case 'Shift': {\n        return 'shift';\n      }\n      default: {\n        return assertNever(modifier);\n      }\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/desktop-trusted-input.d.cts

@@ -0,0 +1,288 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Desktop-only trusted input helpers that drive the real Electron renderer via
+ * `webContents.sendInputEvent`, so keystrokes, pointer moves and clicks flow through the same trusted
+ * input pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror, the CSS
+ * `:hover` engine and every `e.isTrusted` guard in Obsidian ignore).
+ *
+ * These are the importable-module twins of the base helpers the `obsidian-integration-testing` harness
+ * seeds into the `lib` bag; the two copies are kept behaviorally in sync by hand (see the project
+ * `CLAUDE.md`). Desktop-only: they depend on `window.electron`.
+ *
+ * This is the **desktop arm**. Import it directly only as a deliberate platform commitment; the
+ * cross-platform entry point is the {@link ./trusted-input.ts | trusted-input} facade, which dispatches
+ * to this module or to {@link ./mobile-trusted-input.ts | mobile-trusted-input} per call.
+ */
+import type { Editor, Modifier } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Parameters for {@link clickElement}.
+ */
+export interface ClickElementParams {
+    /**
+     * The mouse button to click with.
+     *
+     * @default `'left'`
+     */
+    readonly button?: MouseButton;
+    /**
+     * The element to click. The pointer is moved to its center.
+     *
+     * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in
+     * a popout is driven in that popout with no extra parameter.
+     */
+    readonly element: HTMLElement;
+    /**
+     * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform
+     * (Cmd on macOS, Ctrl elsewhere).
+     *
+     * @default `[]`
+     */
+    readonly modifiers?: readonly Modifier[];
+}
+/**
+ * Parameters for {@link clickMouse}.
+ */
+export interface ClickMouseParams {
+    /**
+     * The mouse button to click with.
+     *
+     * @default `'left'`
+     */
+    readonly button?: MouseButton;
+    /**
+     * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform
+     * (Cmd on macOS, Ctrl elsewhere).
+     *
+     * @default `[]`
+     */
+    readonly modifiers?: readonly Modifier[];
+    /**
+     * The Obsidian window to click in: the main window or a popout. Pass the window that owns the target,
+     * e.g. `leaf.view.containerEl.win` for a popout leaf. Each Obsidian window is its own Electron web
+     * contents, so a click sent to one never reaches another, and the coordinates are in the named window's
+     * viewport.
+     *
+     * **On mobile** there are no popouts, so any window but the main one throws.
+     *
+     * @default the main window (`window`)
+     */
+    readonly window?: Window;
+    /**
+     * The x coordinate (web-contents DIP) to click at.
+     */
+    readonly x: number;
+    /**
+     * The y coordinate (web-contents DIP) to click at.
+     */
+    readonly y: number;
+}
+/**
+ * Parameters for {@link hoverElement}.
+ */
+export interface HoverElementParams {
+    /**
+     * The element to hover. The pointer is moved to its center.
+     *
+     * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in
+     * a popout is driven in that popout with no extra parameter.
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * The mouse button a trusted click presses, in Electron's `sendInputEvent` spelling.
+ */
+export type MouseButton = NonNullable<ElectronMouseInputEvent['button']>;
+/**
+ * Parameters for {@link moveMouse}.
+ */
+export interface MoveMouseParams {
+    /**
+     * The Obsidian window to move the pointer in: the main window or a popout. Each Obsidian window is its
+     * own Electron web contents with its own pointer, and the coordinates are in the named window's viewport.
+     *
+     * Mobile has no pointer to move, so {@link moveMouse} throws there whatever this is.
+     *
+     * @default the main window (`window`)
+     */
+    readonly window?: Window;
+    /**
+     * The x coordinate (web-contents DIP) to move the pointer to.
+     */
+    readonly x: number;
+    /**
+     * The y coordinate (web-contents DIP) to move the pointer to.
+     */
+    readonly y: number;
+}
+/**
+ * Parameters for {@link pressKey}.
+ */
+export interface PressKeyParams {
+    /**
+     * The key to press, given as an Electron Accelerator key name — e.g. `'Enter'`, `'Escape'`, `'Tab'`,
+     * an arrow key, or a printable character (`'a'`, `'1'`).
+     */
+    readonly key: string;
+    /**
+     * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform
+     * (Cmd on macOS, Ctrl elsewhere).
+     *
+     * @default `[]`
+     */
+    readonly modifiers?: readonly Modifier[];
+    /**
+     * The Obsidian window to press the key in: the main window or a popout. Pass the window that owns the
+     * focused target, e.g. `leaf.view.containerEl.win` for a popout leaf. Each Obsidian window is its own
+     * Electron web contents, so the key goes to the DOM-focused element of the window named here, whichever
+     * window the OS has focused, and never reaches another window.
+     *
+     * **On mobile** there are no popouts, so any window but the main one throws.
+     *
+     * @default the main window (`window`)
+     */
+    readonly window?: Window;
+}
+/**
+ * Parameters for {@link typeIntoEditor}.
+ */
+export interface TypeIntoEditorParams {
+    /**
+     * The editor to type into. It is focused (caret moved to the end of the document) before the keystrokes
+     * are injected.
+     *
+     * The keystrokes go to the window that owns the editor, so an editor in a popout is typed into in that
+     * popout with no extra parameter.
+     */
+    readonly editor: Editor;
+    /**
+     * The text to type. Each code point is pressed via {@link pressKey}, exactly as a real user typing.
+     */
+    readonly text: string;
+}
+/**
+ * Parameters for {@link unhoverElement}.
+ */
+export interface UnhoverElementParams {
+    /**
+     * The element to move the pointer away from. The pointer is moved to a point just outside its bounding
+     * box.
+     *
+     * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in
+     * a popout is driven in that popout with no extra parameter.
+     */
+    readonly element: HTMLElement;
+}
+type CurrentWebContents = ReturnType<Window['electron']['remote']['getCurrentWebContents']>;
+type ElectronMouseInputEvent = Extract<Parameters<CurrentWebContents['sendInputEvent']>[0], PointerCoordinates>;
+interface PointerCoordinates {
+    x: number;
+}
+/**
+ * Clicks the center of an element using **trusted** Electron pointer input.
+ *
+ * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /
+ * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the
+ * element's center — the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside
+ * `.cm-sizer`, so no element's center lands on it.
+ *
+ * **Must be awaited.** Nothing here needs to wait, but the cross-platform twins do — on mobile the
+ * injection is a round-trip to the host, because the renderer cannot produce a trusted event itself — so
+ * the signature is the same on both platforms and a caller never rewrites its `await`s when it grows a
+ * mobile lane.
+ *
+ * @param params - The element to click, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickElement(params: ClickElementParams): Promise<void>;
+/**
+ * Clicks at the given web-contents coordinates using **trusted** Electron pointer input, so Chromium
+ * synthesizes a real `click` (or `contextmenu`, for the right button) with `isTrusted === true`.
+ *
+ * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do: Obsidian and CodeMirror gate
+ * on `isTrusted`, so a dispatched event silently exercises nothing while the test still passes. Obsidian
+ * 1.13.7's markdown viewport (margin) menu, for example, opens from
+ * `cm.scrollDOM.addEventListener('contextmenu', (e) => { if (!e.defaultPrevented && e.isTrusted && …) })`
+ * — a dispatched `contextmenu` never gets past that check.
+ *
+ * It is the low-level primitive: a single trusted `mouseMove` → `mouseDown` → `mouseUp` at one point,
+ * with no waiting for any effect (callers poll their own readiness signal). The leading move is what puts
+ * the pointer over the hit-test target before the button goes down. Prefer {@link clickElement} for
+ * element-relative clicks.
+ *
+ * **Must be awaited** — see {@link clickElement}.
+ *
+ * @param params - The web-contents DIP coordinates to click at, the button to press and any modifiers to
+ * hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickMouse(params: ClickMouseParams): Promise<void>;
+/**
+ * Moves the mouse pointer to the center of an element using **trusted** Electron pointer input, then polls
+ * until the element actually matches `:hover`.
+ *
+ * Because the move is trusted, the real `:hover` state takes effect in the CSS engine — unlike
+ * `dispatchEvent(new MouseEvent('mouseover'))`, which is untrusted and never sets `:hover`. It targets the
+ * single window's **global** pointer, so only one element is hovered at a time.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that resolves once the element matches `:hover`.
+ * @throws When the element never matches `:hover`. Resolving quietly there would let a test read an
+ * element that is not hovered and pass on whatever its base style happens to be.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Moves the mouse pointer to the given web-contents coordinates using a **trusted** Electron pointer move.
+ *
+ * A trusted move updates the real pointer state in the CSS engine, so `:hover` rules genuinely apply. This
+ * is the low-level primitive: it performs a single move and does **not** wait for any state to settle
+ * (callers poll their own readiness signal). Prefer {@link hoverElement} / {@link unhoverElement} for
+ * element-relative moves.
+ *
+ * **Must be awaited** — see {@link clickElement}.
+ *
+ * @param params - The web-contents DIP coordinates to move to.
+ * @returns A {@link Promise} that resolves once the move has been injected.
+ */
+export declare function moveMouse(params: MoveMouseParams): Promise<void>;
+/**
+ * Presses a single key (optionally with modifiers) using **trusted** Electron keyboard input, firing the
+ * full real key pipeline — `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
+ *
+ * It injects a trusted `keyDown` → `char` → `keyUp` sequence, delivered to the window's DOM-focused
+ * element — unlike `dispatchEvent(new KeyboardEvent(...))`, which is untrusted and ignored by CodeMirror.
+ * Use it for special keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations. It does
+ * **not** poll for any effect; the caller focuses the target first, then awaits the expected effect.
+ *
+ * **Must be awaited** — see {@link clickElement}.
+ *
+ * @param params - The key to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the key press has been injected.
+ */
+export declare function pressKey(params: PressKeyParams): Promise<void>;
+/**
+ * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.
+ *
+ * This focuses the editor (caret to end) and presses every code point of `text` via {@link pressKey} — the
+ * same trusted sequence a real user produces — so the text reaches the document **only if the editor
+ * genuinely holds focus**. After injecting the keystrokes it polls until the document reflects the input,
+ * or a bounded timeout elapses (the expected outcome when the editor is read-only or focus was stolen).
+ *
+ * @param params - The editor to type into and the text to type.
+ * @returns A {@link Promise} that resolves once the keystrokes have settled.
+ */
+export declare function typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;
+/**
+ * Moves the mouse pointer to a point just outside an element's bounding box using a **trusted** Electron
+ * pointer move, then polls until the element no longer matches `:hover`.
+ *
+ * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box is
+ * reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.
+ * @throws When the element keeps matching `:hover`, which is what a full-viewport element does.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;
+export {};