@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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 {};

package/dist/lib/cjs/editor-extension-registrar.cjs

@@ -0,0 +1,186 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editor_extension_registrar_exports = {};
+__export(editor_extension_registrar_exports, {
+  PluginEditorExtensionRegistrar: () => PluginEditorExtensionRegistrar
+});
+module.exports = __toCommonJS(editor_extension_registrar_exports);
+var import_obsidian = require('obsidian');
+class PluginEditorExtensionRegistrar {
+  /**
+   * Creates a new instance of the {@link PluginEditorExtensionRegistrar} class.
+   *
+   * @param plugin - The Obsidian plugin instance.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  plugin;
+  /**
+   * Registers an editor extension.
+   *
+   * @param extension - The editor extension to register.
+   */
+  registerEditorExtension(extension) {
+    this.plugin.registerEditorExtension(extension);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginEditorExtensionRegistrar
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/editor-extension-registrar.d.cts

@@ -0,0 +1,37 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Editor extension registrars.
+ */
+import type { Extension } from '@codemirror/state' with { 'resolution-mode': 'import' };
+import { Plugin } from 'obsidian';
+/**
+ * Editor extension registrar.
+ */
+export interface EditorExtensionRegistrar {
+    /**
+     * Registers an editor extension.
+     *
+     * @param extension - The editor extension to register.
+     */
+    registerEditorExtension: (extension: Extension) => void;
+}
+/**
+ * Editor extension registrar in an Obsidian plugin.
+ */
+export declare class PluginEditorExtensionRegistrar implements EditorExtensionRegistrar {
+    protected readonly plugin: Plugin;
+    /**
+     * Creates a new instance of the {@link PluginEditorExtensionRegistrar} class.
+     *
+     * @param plugin - The Obsidian plugin instance.
+     */
+    constructor(plugin: Plugin);
+    /**
+     * Registers an editor extension.
+     *
+     * @param extension - The editor extension to register.
+     */
+    registerEditorExtension(extension: Extension): void;
+}