@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/desktop-demo-vault-opener.mjs

@@ -0,0 +1,266 @@
+/*
+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();
+})();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { extractZipArchive } from "@mnaoumov/typescript-lib/desktop-zip-extractor";
+import { join } from "@mnaoumov/typescript-lib/path";
+import { compareVersions } from "compare-versions";
+import { Buffer as Buffer2 } from "node:buffer";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { requestUrl } from "obsidian";
+import {
+  getCommunityPluginRepo,
+  getLatestReleaseVersion
+} from "./community-plugins.mjs";
+import { PluginNoticeMode } from "./components/plugin-notice-component.mjs";
+import {
+  getDemoVaultArchiveFileName,
+  getDemoVaultFolderName
+} from "./demo-vault-naming.mjs";
+import { selectOption } from "./modals/select-option.mjs";
+const DEMO_VAULTS_CACHE_FOLDER = "obsidian-demo-vaults";
+const ARCHIVES_SUBFOLDER = "archives";
+const EXTRACTED_VAULTS_SUBFOLDER = "extracted";
+const HTTP_STATUS_OK = 200;
+const ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 864e5;
+async function openDemoVault(params) {
+  var _stack = [];
+  try {
+    const {
+      app,
+      pluginId,
+      pluginName,
+      pluginNoticeComponent,
+      pluginVersion
+    } = params;
+    const progressNotice = __using(_stack, pluginNoticeComponent.showNoticeAfterDelay({
+      content: `Opening demo vault for ${pluginName}\u2026`,
+      delayInMilliseconds: 0,
+      mode: PluginNoticeMode.Separate
+    }));
+    const repo = await getCommunityPluginRepo(pluginId);
+    if (!repo) {
+      pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);
+      return;
+    }
+    const currentVersion = pluginVersion;
+    const latestVersion = await getLatestReleaseVersion(repo);
+    let versionToOpen;
+    if (compareVersions(currentVersion, latestVersion) >= 0) {
+      versionToOpen = currentVersion;
+    } else {
+      const chosenVersion = await selectOption({
+        app,
+        message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,
+        options: [
+          {
+            isCta: true,
+            text: `Open demo vault for latest version (v${latestVersion})`,
+            value: latestVersion
+          },
+          {
+            text: `Open demo vault for current version (v${currentVersion})`,
+            value: currentVersion
+          },
+          {
+            text: "Cancel",
+            value: null
+          }
+        ],
+        title: pluginName
+      });
+      if (chosenVersion === null) {
+        return;
+      }
+      versionToOpen = chosenVersion;
+    }
+    const archive = await resolveDemoVaultArchive({
+      pluginId,
+      pluginName,
+      pluginNoticeComponent,
+      progressNotice,
+      repo,
+      version: versionToOpen
+    });
+    if (!archive) {
+      return;
+    }
+    progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);
+    cleanupOrphanedExtractedVaults();
+    const vaultDirectory = extractDemoVaultToFreshFolder({
+      archive,
+      pluginId,
+      version: versionToOpen
+    });
+    window.electron.ipcRenderer.sendSync("vault-open", vaultDirectory, false);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function cleanupOrphanedExtractedVaults() {
+  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);
+  if (!existsSync(extractedVaultsRoot)) {
+    return;
+  }
+  const now = Date.now();
+  for (const entryName of readdirSync(extractedVaultsRoot)) {
+    const entryPath = join(extractedVaultsRoot, entryName);
+    try {
+      const stats = statSync(entryPath);
+      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {
+        continue;
+      }
+      rmSync(entryPath, { force: true, recursive: true });
+    } catch {
+    }
+  }
+}
+function extractDemoVaultArchive(archive, targetDirectory) {
+  const originalFs = window.require('node:original-fs');
+  extractZipArchive({
+    archive,
+    fileSystem: originalFs,
+    targetDirectory
+  });
+}
+function extractDemoVaultToFreshFolder(params) {
+  const { archive, pluginId, version } = params;
+  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);
+  mkdirSync(extractedVaultsRoot, { recursive: true });
+  const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));
+  extractDemoVaultArchive(archive, uniqueParentDirectory);
+  return join(
+    uniqueParentDirectory,
+    getDemoVaultFolderName({
+      pluginId,
+      version
+    })
+  );
+}
+async function resolveDemoVaultArchive(params) {
+  const {
+    pluginId,
+    pluginName,
+    pluginNoticeComponent,
+    progressNotice,
+    repo,
+    version
+  } = params;
+  const archivesDirectory = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);
+  const archivePath = join(archivesDirectory, `${pluginId}-${version}.zip`);
+  if (existsSync(archivePath)) {
+    return readFileSync(archivePath);
+  }
+  progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);
+  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${getDemoVaultArchiveFileName(pluginId)}`;
+  const response = await requestUrl({
+    throw: false,
+    url: assetUrl
+  });
+  if (response.status !== HTTP_STATUS_OK) {
+    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);
+    return null;
+  }
+  const archive = Buffer2.from(response.arrayBuffer);
+  mkdirSync(archivesDirectory, { recursive: true });
+  writeFileSync(archivePath, archive);
+  return archive;
+}
+export {
+  openDemoVault
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `<plugin-id>-demo-vault.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`; every name shared with it comes from\n * `demo-vault-naming.ts`). This resolves the plugin's repository from Obsidian's community registry,\n * downloads the archive for the chosen version, and opens it as a vault in a new window. When the\n * installed plugin version is behind the latest release, the user is offered a choice between the two\n * versions.\n *\n * A progress notice is shown immediately (download + extraction can take a while, so the user must see\n * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp\n * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a\n * previous session's edits never leak into a new one. The vault folder is the archive's own single\n * top-level folder, `<plugin-id>-demo-vault-<version>`, which reads nicely in Obsidian's vault switcher\n * and is the same name a hand-unzipped archive produces. Orphaned extracted folders left over from\n * earlier sessions are cleaned up (best-effort) on each open.\n *\n * **Nothing here may touch a platform-only API while the module INITIALIZES.** The `node:` imports below\n * are safe to merely evaluate on mobile \u2014 `require` hands back `undefined` there and nothing reads it at\n * load time \u2014 and because the generated barrels re-export this module, that is a load-bearing property of\n * the whole library rather than a detail of this file. It was learned the hard way: this module once\n * imported `adm-zip`, whose zip-crypto method opens with a top-level\n * `const { randomFillSync } = require('crypto')`, and a static `import AdmZip from 'adm-zip'` therefore\n * killed the library's load on Android (see the mobile-load check in\n * `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on exactly that). Extraction\n * now goes through `desktop-zip-extractor.ts`, which needs no dependency at all \u2014 but any future\n * dependency that initializes against a platform-only API still has to be deferred behind a call-time\n * `import()`.\n */\n\nimport type { App } from 'obsidian';\n\nimport { extractZipArchive } from '@mnaoumov/typescript-lib/desktop-zip-extractor';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { compareVersions } from 'compare-versions';\nimport { Buffer } from 'node:buffer';\nimport {\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  rmSync,\n  statSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { PluginNoticeMode } from './components/plugin-notice-component.ts';\nimport {\n  getDemoVaultArchiveFileName,\n  getDemoVaultFolderName\n} from './demo-vault-naming.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The plugin id, used to locate the GitHub repository, to name the archive asset, and to name the\n   * cached archive and the extracted vault folder.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin display name, used to label the notices and the version-choice dialog.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The notice component used to report progress and problems (plugin not in the registry, missing\n   * archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The currently installed plugin version, offered as one of the version choices.\n   */\n  readonly pluginVersion: string;\n}\n\ninterface ExtractDemoVaultToFreshFolderParams {\n  readonly archive: Buffer;\n  readonly pluginId: string;\n  readonly version: string;\n}\n\ninterface ResolveDemoVaultArchiveParams {\n  readonly pluginId: string;\n  readonly pluginName: string;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly progressNotice: PluginNoticeComponentDelayedNotice;\n  readonly repo: string;\n  readonly version: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst ARCHIVES_SUBFOLDER = 'archives';\nconst EXTRACTED_VAULTS_SUBFOLDER = 'extracted';\nconst HTTP_STATUS_OK = 200;\n// One day in milliseconds (24 * 60 * 60 * 1000).\nconst ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 86_400_000;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. A progress notice is shown\n * immediately. The chosen version's archive is downloaded once (then reused from the archive cache),\n * but a fresh copy is extracted into its own temporary folder on every open \u2014 the vault is never reused\n * across sessions.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    pluginVersion\n  } = params;\n\n  // Shown immediately (`delayInMilliseconds: 0`): resolving the release, downloading and extracting can\n  // each take a while, so the user must see progress the moment the command is invoked.\n  //\n  // Kept out of the shared slot (`Separate`), because this very function raises ordinary notices while\n  // the operation is still running \u2014 \"not in the registry\", \"no demo vault for this version\" \u2014 and a\n  // slot notice would hide the progress notice rather than appear beside it.\n  using progressNotice = pluginNoticeComponent.showNoticeAfterDelay({\n    content: `Opening demo vault for ${pluginName}\u2026`,\n    delayInMilliseconds: 0,\n    mode: PluginNoticeMode.Separate\n  });\n\n  const repo = await getCommunityPluginRepo(pluginId);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = pluginVersion;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: pluginName\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const archive = await resolveDemoVaultArchive({\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version: versionToOpen\n  });\n  if (!archive) {\n    return;\n  }\n\n  progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);\n  cleanupOrphanedExtractedVaults();\n  const vaultDirectory = extractDemoVaultToFreshFolder({\n    archive,\n    pluginId,\n    version: versionToOpen\n  });\n\n  window.electron.ipcRenderer.sendSync('vault-open', vaultDirectory, false);\n}\n\n/**\n * Removes extracted demo-vault folders left over from earlier sessions (best-effort).\n *\n * Every open extracts a fresh copy into its own folder and never deletes it afterwards (the vault stays\n * open in its window), so these accumulate. This drops folders older than\n * {@link ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS}. A folder whose vault is still open in another\n * window is locked on Windows and cannot be removed \u2014 the removal is wrapped so such a folder is simply\n * skipped and retried on a later open.\n */\nfunction cleanupOrphanedExtractedVaults(): void {\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  if (!existsSync(extractedVaultsRoot)) {\n    return;\n  }\n\n  const now = Date.now();\n  for (const entryName of readdirSync(extractedVaultsRoot)) {\n    const entryPath = join(extractedVaultsRoot, entryName);\n    try {\n      const stats = statSync(entryPath);\n      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {\n        continue;\n      }\n      rmSync(entryPath, { force: true, recursive: true });\n    } catch {\n      // Best-effort cleanup: an orphan whose vault is still open (locked on Windows) cannot be removed; skip it and retry on a later open.\n    }\n  }\n}\n\n/**\n * Extracts a downloaded demo-vault archive to disk.\n *\n * Extraction is written with Electron's `original-fs` \u2014 the real `fs` with asar interception disabled \u2014\n * rather than with `node:fs`. A demo vault may ship a file that merely LOOKS like an Electron archive\n * (e.g. `_assets/CodeScriptToolkit/module.asar` demonstrating the ASAR require feature), and Electron's\n * asar layer intercepts `fs` operations on any path containing `.asar`, treating it as an archive root\n * rather than a plain file. That already cost one production bug when the extractor `chmod`-ed such a\n * file and got `ENOENT`; nothing `chmod`s any more, but writing those bytes through the copy that has no\n * asar layer costs nothing and keeps the whole class of failure off this path. `original-fs` is a desktop-only\n * Electron module with no bundled types, so it is loaded via `window.require` and typed as `node:fs`'s\n * shape.\n *\n * @param archive - The raw zip archive bytes.\n * @param targetDirectory - The directory to extract into.\n */\nfunction extractDemoVaultArchive(archive: Buffer, targetDirectory: string): void {\n  const originalFs = window.require('node:original-fs') as typeof import('node:fs');\n  extractZipArchive({\n    archive,\n    fileSystem: originalFs,\n    targetDirectory\n  });\n}\n\n/**\n * Extracts the archive into a fresh, uniquely-named temporary folder and returns the vault path.\n *\n * A unique parent folder (`mkdtempSync`) guarantees a brand-new extraction every time \u2014 the demo vault\n * is never reused across opens, so a previous session's edits never leak in. The archive is extracted\n * into that parent and the vault is the single `<plugin-id>-demo-vault-<version>` folder it contains, so\n * Obsidian's vault switcher shows a friendly name (its basename) rather than the random temp id.\n *\n * That folder is not searched for: {@link getDemoVaultFolderName} names it on both sides, so the path is\n * known before a byte is written. Which keeps the extractor free of any read \u2014 deliberate, because\n * Electron's asar layer intercepts `fs` reads on any path containing `.asar`, and a demo vault may\n * legitimately ship such a file.\n *\n * @param params - The {@link ExtractDemoVaultToFreshFolderParams}.\n * @returns The absolute path of the freshly extracted vault folder.\n */\nfunction extractDemoVaultToFreshFolder(params: ExtractDemoVaultToFreshFolderParams): string {\n  const { archive, pluginId, version } = params;\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  mkdirSync(extractedVaultsRoot, { recursive: true });\n  const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));\n  extractDemoVaultArchive(archive, uniqueParentDirectory);\n  return join(\n    uniqueParentDirectory,\n    getDemoVaultFolderName({\n      pluginId,\n      version\n    })\n  );\n}\n\n/**\n * Resolves the demo-vault archive bytes for a version, downloading and caching them on first use.\n *\n * Only the archive is cached (keyed by plugin id + version); the extracted vault is not. A cache hit is\n * returned without any network request; a miss downloads the release asset, writes it to the archive\n * cache, and returns the freshly downloaded bytes.\n *\n * @param params - The {@link ResolveDemoVaultArchiveParams}.\n * @returns A {@link Promise} resolving to the archive bytes, or `null` when no archive is available for\n * the version (a notice has been shown).\n */\nasync function resolveDemoVaultArchive(params: ResolveDemoVaultArchiveParams): Promise<Buffer | null> {\n  const {\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version\n  } = params;\n\n  const archivesDirectory = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);\n  const archivePath = join(archivesDirectory, `${pluginId}-${version}.zip`);\n  if (existsSync(archivePath)) {\n    return readFileSync(archivePath);\n  }\n\n  progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${getDemoVaultArchiveFileName(pluginId)}`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);\n    return null;\n  }\n\n  const archive = Buffer.from(response.arrayBuffer);\n  mkdirSync(archivesDirectory, { recursive: true });\n  writeFileSync(archivePath, archive);\n  return archive;\n}\n"],
  "mappings": "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",
  "names": ["Buffer", "Buffer"]
}


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

@@ -0,0 +1,288 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @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';
+/**
+ * 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 {};