@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/transformers/duration-transformer.d.mts

@@ -0,0 +1,39 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * A transformer that can transform Duration to an ISO string and back.
+ */
+import { TypedTransformer } from '@mnaoumov/typescript-lib/transformers/typed-transformer';
+/**
+ * A transformer that converts a Duration to an ISO string and back.
+ */
+export declare class DurationTransformer extends TypedTransformer<moment.Duration, string> {
+    /**
+     * An id of the transformer.
+     *
+     * @returns The id of the transformer.
+     */
+    get id(): string;
+    /**
+     * Checks if the value is a Duration.
+     *
+     * @param value - The value to check.
+     * @returns `true` if the value is a Duration, `false` otherwise.
+     */
+    canTransform(value: unknown): value is moment.Duration;
+    /**
+     * Restores the value from a string.
+     *
+     * @param transformedValue - The string to restore the value from.
+     * @returns The restored value.
+     */
+    restoreValue(transformedValue: string): moment.Duration;
+    /**
+     * Transforms the value to a string.
+     *
+     * @param value - The value to transform.
+     * @returns The transformed value.
+     */
+    transformValue(value: moment.Duration): string;
+}

package/dist/lib/esm/transformers/duration-transformer.mjs

@@ -0,0 +1,85 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { TypedTransformer } from "@mnaoumov/typescript-lib/transformers/typed-transformer";
+import { moment } from "obsidian";
+class DurationTransformer extends TypedTransformer {
+  /**
+   * An id of the transformer.
+   *
+   * @returns The id of the transformer.
+   */
+  get id() {
+    return "duration";
+  }
+  /**
+   * Checks if the value is a Duration.
+   *
+   * @param value - The value to check.
+   * @returns `true` if the value is a Duration, `false` otherwise.
+   */
+  canTransform(value) {
+    const maybeDuration = value ?? {};
+    return !!maybeDuration.asHours && !!maybeDuration.asMinutes && !!maybeDuration.asSeconds && !!maybeDuration.asMilliseconds;
+  }
+  /**
+   * Restores the value from a string.
+   *
+   * @param transformedValue - The string to restore the value from.
+   * @returns The restored value.
+   */
+  restoreValue(transformedValue) {
+    return moment.duration(transformedValue);
+  }
+  /**
+   * Transforms the value to a string.
+   *
+   * @param value - The value to transform.
+   * @returns The transformed value.
+   */
+  transformValue(value) {
+    return value.toISOString();
+  }
+}
+export {
+  DurationTransformer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3RyYW5zZm9ybWVycy9kdXJhdGlvbi10cmFuc2Zvcm1lci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEEgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIER1cmF0aW9uIHRvIGFuIElTTyBzdHJpbmcgYW5kIGJhY2suXG4gKi9cblxuaW1wb3J0IHsgVHlwZWRUcmFuc2Zvcm1lciB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi90cmFuc2Zvcm1lcnMvdHlwZWQtdHJhbnNmb3JtZXInO1xuaW1wb3J0IHsgbW9tZW50IH0gZnJvbSAnb2JzaWRpYW4nO1xuXG4vKipcbiAqIEEgdHJhbnNmb3JtZXIgdGhhdCBjb252ZXJ0cyBhIER1cmF0aW9uIHRvIGFuIElTTyBzdHJpbmcgYW5kIGJhY2suXG4gKi9cbmV4cG9ydCBjbGFzcyBEdXJhdGlvblRyYW5zZm9ybWVyIGV4dGVuZHMgVHlwZWRUcmFuc2Zvcm1lcjxtb21lbnQuRHVyYXRpb24sIHN0cmluZz4ge1xuICAvKipcbiAgICogQW4gaWQgb2YgdGhlIHRyYW5zZm9ybWVyLlxuICAgKlxuICAgKiBAcmV0dXJucyBUaGUgaWQgb2YgdGhlIHRyYW5zZm9ybWVyLlxuICAgKi9cbiAgcHVibGljIG92ZXJyaWRlIGdldCBpZCgpOiBzdHJpbmcge1xuICAgIHJldHVybiAnZHVyYXRpb24nO1xuICB9XG5cbiAgLyoqXG4gICAqIENoZWNrcyBpZiB0aGUgdmFsdWUgaXMgYSBEdXJhdGlvbi5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrLlxuICAgKiBAcmV0dXJucyBgdHJ1ZWAgaWYgdGhlIHZhbHVlIGlzIGEgRHVyYXRpb24sIGBmYWxzZWAgb3RoZXJ3aXNlLlxuICAgKi9cbiAgcHVibGljIG92ZXJyaWRlIGNhblRyYW5zZm9ybSh2YWx1ZTogdW5rbm93bik6IHZhbHVlIGlzIG1vbWVudC5EdXJhdGlvbiB7XG4gICAgY29uc3QgbWF5YmVEdXJhdGlvbiA9ICh2YWx1ZSA/PyB7fSkgYXMgUGFydGlhbDxtb21lbnQuRHVyYXRpb24+O1xuICAgIHJldHVybiAhIW1heWJlRHVyYXRpb24uYXNIb3VycyAmJiAhIW1heWJlRHVyYXRpb24uYXNNaW51dGVzICYmICEhbWF5YmVEdXJhdGlvbi5hc1NlY29uZHMgJiYgISFtYXliZUR1cmF0aW9uLmFzTWlsbGlzZWNvbmRzO1xuICB9XG5cbiAgLyoqXG4gICAqIFJlc3RvcmVzIHRoZSB2YWx1ZSBmcm9tIGEgc3RyaW5nLlxuICAgKlxuICAgKiBAcGFyYW0gdHJhbnNmb3JtZWRWYWx1ZSAtIFRoZSBzdHJpbmcgdG8gcmVzdG9yZSB0aGUgdmFsdWUgZnJvbS5cbiAgICogQHJldHVybnMgVGhlIHJlc3RvcmVkIHZhbHVlLlxuICAgKi9cbiAgcHVibGljIG92ZXJyaWRlIHJlc3RvcmVWYWx1ZSh0cmFuc2Zvcm1lZFZhbHVlOiBzdHJpbmcpOiBtb21lbnQuRHVyYXRpb24ge1xuICAgIHJldHVybiBtb21lbnQuZHVyYXRpb24odHJhbnNmb3JtZWRWYWx1ZSk7XG4gIH1cblxuICAvKipcbiAgICogVHJhbnNmb3JtcyB0aGUgdmFsdWUgdG8gYSBzdHJpbmcuXG4gICAqXG4gICAqIEBwYXJhbSB2YWx1ZSAtIFRoZSB2YWx1ZSB0byB0cmFuc2Zvcm0uXG4gICAqIEByZXR1cm5zIFRoZSB0cmFuc2Zvcm1lZCB2YWx1ZS5cbiAgICovXG4gIHB1YmxpYyBvdmVycmlkZSB0cmFuc2Zvcm1WYWx1ZSh2YWx1ZTogbW9tZW50LkR1cmF0aW9uKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdmFsdWUudG9JU09TdHJpbmcoKTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFNQSxTQUFTLHdCQUF3QjtBQUNqQyxTQUFTLGNBQWM7QUFLaEIsTUFBTSw0QkFBNEIsaUJBQTBDO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBTWpGLElBQW9CLEtBQWE7QUFDL0IsV0FBTztBQUFBLEVBQ1Q7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVFnQixhQUFhLE9BQTBDO0FBQ3JFLFVBQU0sZ0JBQWlCLFNBQVMsQ0FBQztBQUNqQyxXQUFPLENBQUMsQ0FBQyxjQUFjLFdBQVcsQ0FBQyxDQUFDLGNBQWMsYUFBYSxDQUFDLENBQUMsY0FBYyxhQUFhLENBQUMsQ0FBQyxjQUFjO0FBQUEsRUFDOUc7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVFnQixhQUFhLGtCQUEyQztBQUN0RSxXQUFPLE9BQU8sU0FBUyxnQkFBZ0I7QUFBQSxFQUN6QztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBUWdCLGVBQWUsT0FBZ0M7QUFDN0QsV0FBTyxNQUFNLFlBQVk7QUFBQSxFQUMzQjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/transformers/index.d.mts

@@ -0,0 +1,2 @@
+/// <reference path="../library.d.mts" />
+export * as 'duration-transformer' from './duration-transformer.mjs';

package/dist/lib/esm/transformers/index.mjs

@@ -0,0 +1,46 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import * as duration_transformer from "./duration-transformer.mjs";
+export {
+  duration_transformer as "duration-transformer"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3RyYW5zZm9ybWVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdkdXJhdGlvbi10cmFuc2Zvcm1lcicgZnJvbSAnLi9kdXJhdGlvbi10cmFuc2Zvcm1lci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLFlBQVlBLDBCQUE0QjsiLAogICJuYW1lcyI6IFsiZHVyYXRpb24tdHJhbnNmb3JtZXIiXQp9Cg==

package/dist/lib/esm/trusted-input.d.mts

@@ -0,0 +1,131 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Trusted input helpers that work on **either platform** — the documented entry point for keystrokes,
+ * pointer moves and clicks that Obsidian actually believes.
+ *
+ * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,
+ * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises
+ * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets
+ * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection
+ * round-tripped through the harness's host channel on mobile.
+ *
+ * This module **internalizes that split**, as every public-facing API here must: it stays
+ * cross-platform-loadable — no platform-only module is on its import graph — and each helper defers to a
+ * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes
+ * `await clickElement({ element })` once and never a platform check.
+ *
+ * The arms remain importable directly, for a caller making a deliberate platform commitment:
+ * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and
+ * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.
+ *
+ * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's
+ * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has
+ * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane
+ * does not have to be rewritten.
+ *
+ * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on
+ * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw
+ * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.
+ * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.
+ *
+ * **Every Obsidian window is its own target.** A popout is a separate Electron web contents, so input sent
+ * to the main window never reaches it. {@link pressKey}, {@link clickMouse} and {@link moveMouse} take an
+ * optional `window` (the main window by default); the element and editor helpers use the window that owns
+ * their element or editor. Mobile has no popouts, so any window but the main one throws there.
+ */
+import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
+export type { ClickElementParams, ClickMouseParams, HoverElementParams, MouseButton, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
+/**
+ * Clicks the center of an element using **trusted** input — Electron's `sendInputEvent` on desktop, a CDP
+ * touch tap in the WebView on mobile.
+ *
+ * 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.
+ *
+ * @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 viewport coordinates using **trusted** input, so the renderer synthesizes a real
+ * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.
+ *
+ * The low-level primitive: one click at one point, with no waiting for any effect — callers poll their own
+ * readiness signal. Prefer {@link clickElement} for element-relative clicks.
+ *
+ * A real context menu actually opens, so a suite driving a right click must close it (or remove the
+ * leftover `.menu` element) before the next test.
+ *
+ * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the
+ * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and
+ * `'middle'` throws.
+ *
+ * @param params - The viewport 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 pointer to the center of an element using **trusted** pointer input, then polls until the
+ * element actually matches `:hover`.
+ *
+ * **Desktop only** — it throws on mobile, where `:hover` has no touch equivalent.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that resolves once the element matches `:hover`.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Moves the pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules
+ * genuinely apply.
+ *
+ * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer
+ * {@link hoverElement} / {@link unhoverElement} for element-relative moves.
+ *
+ * **Desktop only** — it throws on mobile, which has no persistent pointer to move.
+ *
+ * @param params - The viewport 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** keyboard input, firing the full real
+ * key pipeline — `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
+ *
+ * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then
+ * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the
+ * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable
+ * characters — anything else throws rather than pressing nothing.
+ *
+ * @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 editor using **trusted** keyboard input.
+ *
+ * Focuses the editor (caret to the end) and presses every code point of the text — the same trusted
+ * sequence a real user produces — so the text reaches the document **only if the editor genuinely holds
+ * focus**. Then 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 pointer to a point just outside an element's bounding box using a **trusted** 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.
+ *
+ * **Desktop only** — it throws on mobile, for the same reason {@link hoverElement} does.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;

package/dist/lib/esm/trusted-input.mjs

@@ -0,0 +1,83 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { Platform } from "obsidian";
+async function clickElement(params) {
+  const arm = await loadArm();
+  await arm.clickElement(params);
+}
+async function clickMouse(params) {
+  const arm = await loadArm();
+  await arm.clickMouse(params);
+}
+async function hoverElement(params) {
+  const arm = await loadArm();
+  await arm.hoverElement(params);
+}
+async function moveMouse(params) {
+  const arm = await loadArm();
+  await arm.moveMouse(params);
+}
+async function pressKey(params) {
+  const arm = await loadArm();
+  await arm.pressKey(params);
+}
+async function typeIntoEditor(params) {
+  const arm = await loadArm();
+  await arm.typeIntoEditor(params);
+}
+async function unhoverElement(params) {
+  const arm = await loadArm();
+  await arm.unhoverElement(params);
+}
+async function loadArm() {
+  return Platform.isDesktopApp ? await import("./desktop-trusted-input.mjs") : await import("./mobile-trusted-input.mjs");
+}
+export {
+  clickElement,
+  clickMouse,
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Trusted input helpers that work on **either platform** \u2014 the documented entry point for keystrokes,\n * pointer moves and clicks that Obsidian actually believes.\n *\n * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,\n * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises\n * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets\n * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection\n * round-tripped through the harness's host channel on mobile.\n *\n * This module **internalizes that split**, as every public-facing API here must: it stays\n * cross-platform-loadable \u2014 no platform-only module is on its import graph \u2014 and each helper defers to a\n * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes\n * `await clickElement({ element })` once and never a platform check.\n *\n * The arms remain importable directly, for a caller making a deliberate platform commitment:\n * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and\n * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.\n *\n * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's\n * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has\n * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane\n * does not have to be rewritten.\n *\n * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on\n * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw\n * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.\n * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.\n *\n * **Every Obsidian window is its own target.** A popout is a separate Electron web contents, so input sent\n * to the main window never reaches it. {@link pressKey}, {@link clickMouse} and {@link moveMouse} take an\n * optional `window` (the main window by default); the element and editor helpers use the window that owns\n * their element or editor. Mobile has no popouts, so any window but the main one throws there.\n */\n\nimport { Platform } from 'obsidian';\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n} from './desktop-trusted-input.ts';\n\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MouseButton,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n} from './desktop-trusted-input.ts';\n\n// The seven helpers both arms export, with identical signatures. Typed off the mobile arm because it\n// exports nothing else; the desktop arm additionally exports the parameter contracts both share.\ntype TrustedInputArm = typeof import('./mobile-trusted-input.ts');\n\n/**\n * Clicks the center of an element using **trusted** input \u2014 Electron's `sendInputEvent` on desktop, a CDP\n * touch tap in the WebView on mobile.\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 * @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 arm = await loadArm();\n  await arm.clickElement(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** input, so the renderer synthesizes a real\n * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * The low-level primitive: one click at one point, with no waiting for any effect \u2014 callers poll their own\n * readiness signal. Prefer {@link clickElement} for element-relative clicks.\n *\n * A real context menu actually opens, so a suite driving a right click must close it (or remove the\n * leftover `.menu` element) before the next test.\n *\n * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the\n * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and\n * `'middle'` throws.\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  const arm = await loadArm();\n  await arm.clickMouse(params);\n}\n\n/**\n * Moves the pointer to the center of an element using **trusted** pointer input, then polls until the\n * element actually matches `:hover`.\n *\n * **Desktop only** \u2014 it throws on mobile, where `:hover` has no touch equivalent.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that resolves once the element matches `:hover`.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.hoverElement(params);\n}\n\n/**\n * Moves the pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules\n * genuinely apply.\n *\n * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer\n * {@link hoverElement} / {@link unhoverElement} for element-relative moves.\n *\n * **Desktop only** \u2014 it throws on mobile, which has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that resolves once the move has been injected.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.moveMouse(params);\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** keyboard input, firing the full real\n * key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then\n * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the\n * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable\n * characters \u2014 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  const arm = await loadArm();\n  await arm.pressKey(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input.\n *\n * Focuses the editor (caret to the end) and presses every code point of the text \u2014 the same trusted\n * sequence a real user produces \u2014 so the text reaches the document **only if the editor genuinely holds\n * focus**. Then it polls until the document reflects the input, or a bounded timeout elapses (the expected\n * 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 arm = await loadArm();\n  await arm.typeIntoEditor(params);\n}\n\n/**\n * Moves the pointer to a point just outside an element's bounding box using a **trusted** pointer move,\n * 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\n * is reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * **Desktop only** \u2014 it throws on mobile, for the same reason {@link hoverElement} does.\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 */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.unhoverElement(params);\n}\n\nasync function loadArm(): Promise<TrustedInputArm> {\n  // Conditional import of the platform-only arm, at call time: neither arm is on the other platform's\n  // load path, and the specifiers stay literal so esbuild bundles both.\n  return Platform.isDesktopApp ? await import('./desktop-trusted-input.ts') : await import('./mobile-trusted-input.ts');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAS,gBAAgB;AAuCzB,eAAsB,aAAa,QAA2C;AAC5E,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,aAAa,MAAM;AAC/B;AAmBA,eAAsB,WAAW,QAAyC;AACxE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,WAAW,MAAM;AAC7B;AAWA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,aAAa,MAAM;AAC/B;AAcA,eAAsB,UAAU,QAAwC;AACtE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,UAAU,MAAM;AAC5B;AAcA,eAAsB,SAAS,QAAuC;AACpE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,SAAS,MAAM;AAC3B;AAaA,eAAsB,eAAe,QAA6C;AAChF,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,eAAe,MAAM;AACjC;AAcA,eAAsB,eAAe,QAA6C;AAChF,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,eAAe,MAAM;AACjC;AAEA,eAAe,UAAoC;AAGjD,SAAO,SAAS,eAAe,MAAM,OAAO,4BAA4B,IAAI,MAAM,OAAO,2BAA2B;AACtH;",
  "names": []
}


package/dist/lib/esm/validation.d.mts

@@ -0,0 +1,87 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Validation utilities.
+ */
+/**
+ * Holds a validation message.
+ */
+export interface ValidationMessageHolder {
+    /**
+     * A validation message.
+     */
+    validationMessage: string;
+}
+/**
+ * Type guard to check if a value is a validation message holder.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a validation message holder, `false` otherwise.
+ */
+export declare function isValidationMessageHolder(value: unknown): value is ValidationMessageHolder;
+/**
+ * Matches characters that are not safe to use in file names within Obsidian.
+ */
+export declare const OBSIDIAN_UNSAFE_FILENAME_CHARS: RegExp;
+/**
+ * Windows-specific unsafe file name path characters.
+ */
+export declare const WINDOWS_UNSAFE_PATH_CHARS: RegExp;
+/**
+ * Unix-specific unsafe file name path characters.
+ */
+export declare const UNIX_UNSAFE_PATH_CHARS: RegExp;
+/**
+ * Returns a regexp matching all unsafe characters in file names/paths.
+ *
+ * Includes both OS-specific restrictions and Obsidian-specific ones.
+ *
+ * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.
+ * @returns A regexp matching all unsafe characters in file names/paths.
+ */
+export declare function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+/**
+ * Returns a regexp matching characters that are not safe to use in file names/paths at the OS level.
+ *
+ * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.
+ * @returns A regexp matching characters that are not safe to use in file names/paths at the OS level.
+ */
+export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+/**
+ * Checks whether a name ends with the dots or spaces Windows refuses.
+ *
+ * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are
+ * not necessarily those of the machine asking.
+ *
+ * @param name - The name to check. A single path segment, not a path.
+ * @returns `true` if the name ends with a dot or a space, `false` otherwise.
+ */
+export declare function hasWindowsTrailingChars(name: string): boolean;
+/**
+ * Checks whether a name is one of the MS-DOS device names Windows refuses.
+ *
+ * Two steps the caller would otherwise have to know about happen here: trailing dots and spaces are
+ * trimmed BEFORE the test, because Windows strips them before deciding and `CON ` is therefore as
+ * reserved as `CON`; and the extension is dropped, because `CON.md` is reserved too.
+ *
+ * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately NOT reserved: they are accepted
+ * by every Windows version that runs Obsidian, and matching them would rename files that work.
+ *
+ * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are
+ * not necessarily those of the machine asking.
+ *
+ * @param name - The name to check. A single path segment, with or without its extension.
+ * @returns `true` if the name is reserved, `false` otherwise.
+ */
+export declare function isWindowsReservedName(name: string): boolean;
+/**
+ * Removes the trailing dots and spaces Windows refuses from the end of a name.
+ *
+ * Trim before testing for a reserved name, never after: trimming afterwards turns an accepted `CON ` into
+ * a rejected `CON`. {@link isWindowsReservedName} already does this internally.
+ *
+ * @param name - The name to trim. A single path segment, not a path.
+ * @returns The name without its trailing dots and spaces, which may be empty.
+ */
+export declare function trimWindowsTrailingChars(name: string): string;

package/dist/lib/esm/validation.mjs

@@ -0,0 +1,87 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  basename,
+  extname
+} from "@mnaoumov/typescript-lib/path";
+import { oneOf } from "@mnaoumov/typescript-lib/reg-exp";
+import { Platform } from "obsidian";
+function isValidationMessageHolder(value) {
+  return value.validationMessage !== void 0;
+}
+const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\]|]/g;
+const WINDOWS_UNSAFE_PATH_CHARS = /[*\\/<>:|?"]/g;
+const UNIX_UNSAFE_PATH_CHARS = /[\0/]/g;
+const WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;
+const WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;
+function getOsAndObsidianUnsafePathCharsRegExp(isWindows) {
+  return oneOf([
+    getOsUnsafePathCharsRegExp(isWindows),
+    OBSIDIAN_UNSAFE_FILENAME_CHARS
+  ]);
+}
+function getOsUnsafePathCharsRegExp(isWindows) {
+  isWindows ??= Platform.isWin;
+  return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
+}
+function hasWindowsTrailingChars(name) {
+  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);
+}
+function isWindowsReservedName(name) {
+  const trimmedName = trimWindowsTrailingChars(name);
+  return WINDOWS_RESERVED_NAME_REG_EXP.test(basename(trimmedName, extname(trimmedName)));
+}
+function trimWindowsTrailingChars(name) {
+  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, "");
+}
+export {
+  OBSIDIAN_UNSAFE_FILENAME_CHARS,
+  UNIX_UNSAFE_PATH_CHARS,
+  WINDOWS_UNSAFE_PATH_CHARS,
+  getOsAndObsidianUnsafePathCharsRegExp,
+  getOsUnsafePathCharsRegExp,
+  hasWindowsTrailingChars,
+  isValidationMessageHolder,
+  isWindowsReservedName,
+  trimWindowsTrailingChars
+};
+//# sourceMappingURL=data:application/json;base64,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