obsidian-dev-utils 97.0.0 → 98.0.0

package/dist/lib/esm/obsidian/demo-vault-naming.d.mts

@@ -0,0 +1,54 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * The names a plugin's demo-vault release artifact carries — the one contract between the release-time
+ * packaging step and the runtime opener.
+ *
+ * The two live far apart: `script-utils/demo-vault.ts` runs under Node at release time and WRITES the
+ * archive, while `desktop-demo-vault-opener.ts` runs inside Obsidian and DOWNLOADS it by name. They used
+ * to agree by a comment on each side saying the other must be changed too, which is exactly the sort of
+ * pairing that survives until the day it does not. Both now derive every shared name from here.
+ *
+ * Kept free of `obsidian` and `node:` imports on purpose: the packaging step runs under Node, where the
+ * `obsidian` module does not exist, and the opener sits in the generated barrels, which must stay safe to
+ * evaluate on mobile.
+ */
+/**
+ * Parameters for {@link getDemoVaultFolderName}.
+ */
+export interface GetDemoVaultFolderNameParams {
+    /**
+     * The plugin id the vault demonstrates, from that plugin's `manifest.json`.
+     */
+    readonly pluginId: string;
+    /**
+     * The plugin version the vault ships with.
+     */
+    readonly version: string;
+}
+/**
+ * The file name of the demo-vault archive attached to a plugin's GitHub release.
+ *
+ * Carries the plugin id so several plugins' demo vaults never collide, and deliberately NOT the version:
+ * a release asset is already namespaced by its release tag (`…/releases/download/<version>/…`), so the
+ * version bought no disambiguation while making the asset name change on every release — which is what
+ * broke the Community directory's finding overrides, whose fingerprint includes the name. The version
+ * lives inside the archive instead, as {@link getDemoVaultFolderName} and on the README's heading.
+ *
+ * @param pluginId - The plugin id the vault demonstrates.
+ * @returns The archive file name, e.g. `my-plugin-demo-vault.zip`.
+ */
+export declare function getDemoVaultArchiveFileName(pluginId: string): string;
+/**
+ * The name of the demo vault's own folder — the archive's single top-level entry, and the folder the
+ * opener extracts it to.
+ *
+ * One name serves both because they are the same folder seen twice: a user who unzips the archive by hand
+ * gets a self-describing, version-distinct folder rather than an anonymous one, and a user who runs the
+ * `Open demo vault` command sees that same name in Obsidian's vault switcher.
+ *
+ * @param params - The {@link GetDemoVaultFolderNameParams}.
+ * @returns The folder name, e.g. `my-plugin-demo-vault-1.2.3`.
+ */
+export declare function getDemoVaultFolderName(params: GetDemoVaultFolderNameParams): string;

package/dist/lib/esm/obsidian/demo-vault-naming.mjs

@@ -0,0 +1,61 @@
+/*
+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 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 initEsm() {
+  ensureBrowserProcess();
+})();
+})();
+
+function getDemoVaultArchiveFileName(pluginId) {
+  return `${getDemoVaultBaseName(pluginId)}.zip`;
+}
+function getDemoVaultFolderName(params) {
+  const {
+    pluginId,
+    version
+  } = params;
+  return `${getDemoVaultBaseName(pluginId)}-${version}`;
+}
+function getDemoVaultBaseName(pluginId) {
+  return `${pluginId}-demo-vault`;
+}
+export {
+  getDemoVaultArchiveFileName,
+  getDemoVaultFolderName
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/desktop-demo-vault-opener.d.mts

@@ -4,18 +4,20 @@
  *
  * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).
  *
- * A plugin can attach a `<plugin-id>-demo-vault-<version>.zip` archive to each GitHub release (see
- * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository
- * from Obsidian's community registry, downloads the archive for the chosen version, and opens it as a
- * vault in a new window. When the installed plugin version is behind the latest release, the user is
- * offered a choice between the two versions.
+ * A plugin can attach a `<plugin-id>-demo-vault.zip` archive to each GitHub release (see
+ * `archivePluginDemoVault` in `script-utils/demo-vault.ts`; every name shared with it comes from
+ * `demo-vault-naming.ts`). This resolves the plugin's repository from Obsidian's community registry,
+ * downloads the archive for the chosen version, and opens it as a vault in a new window. When the
+ * installed plugin version is behind the latest release, the user is offered a choice between the two
+ * versions.
  *
  * A progress notice is shown immediately (download + extraction can take a while, so the user must see
  * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp
  * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a
- * previous session's edits never leak into a new one. The extracted vault folder is named
- * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned
- * extracted folders left over from earlier sessions are cleaned up (best-effort) on each open.
+ * previous session's edits never leak into a new one. The vault folder is the archive's own single
+ * top-level folder, `<plugin-id>-demo-vault-<version>`, which reads nicely in Obsidian's vault switcher
+ * and is the same name a hand-unzipped archive produces. Orphaned extracted folders left over from
+ * earlier sessions are cleaned up (best-effort) on each open.
  *
  * **Nothing here may touch a platform-only API while the module INITIALIZES.** The `node:` imports below
  * are safe to merely evaluate on mobile — `require` hands back `undefined` there and nothing reads it at

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

@@ -107,6 +107,10 @@ import {
   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";
@@ -220,9 +224,14 @@ function extractDemoVaultToFreshFolder(params) {
   const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);
   mkdirSync(extractedVaultsRoot, { recursive: true });
   const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));
-  const vaultDirectory = join(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);
-  extractDemoVaultArchive(archive, vaultDirectory);
-  return vaultDirectory;
+  extractDemoVaultArchive(archive, uniqueParentDirectory);
+  return join(
+    uniqueParentDirectory,
+    getDemoVaultFolderName({
+      pluginId,
+      version
+    })
+  );
 }
 async function resolveDemoVaultArchive(params) {
   const {
@@ -239,7 +248,7 @@ async function resolveDemoVaultArchive(params) {
     return readFileSync(archivePath);
   }
   progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);
-  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${pluginId}-demo-vault-${version}.zip`;
+  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${getDemoVaultArchiveFileName(pluginId)}`;
   const response = await requestUrl({
     throw: false,
     url: assetUrl
@@ -256,4 +265,4 @@ async function resolveDemoVaultArchive(params) {
 export {
   openDemoVault
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/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-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, and opens it as a\n * vault in a new window. When the installed plugin version is behind the latest release, the user is\n * offered a choice between the two 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 extracted vault folder is named\n * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned\n * extracted folders left over from 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 { compareVersions } from 'compare-versions';\n/* eslint-disable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\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';\n/* eslint-enable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport { extractZipArchive } from '../desktop-zip-extractor.ts';\nimport { join } from '../path.ts';\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { PluginNoticeMode } from './components/plugin-notice-component.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. Inside it, the vault folder\n * is named `<plugin-id>-<version>.demo-vault` so Obsidian's vault switcher shows a friendly name (its\n * basename) rather than the random temp id.\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  const vaultDirectory = join(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);\n  extractDemoVaultArchive(archive, vaultDirectory);\n  return vaultDirectory;\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}/${pluginId}-demo-vault-${version}.zip`;\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"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/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 { compareVersions } from 'compare-versions';\n/* eslint-disable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\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';\n/* eslint-enable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport { extractZipArchive } from '../desktop-zip-extractor.ts';\nimport { join } from '../path.ts';\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/obsidian/desktop-trusted-input.d.mts

@@ -10,6 +10,10 @@
  * 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';
 /**
@@ -140,9 +144,15 @@ interface PointerCoordinates {
  * 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): void;
+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`.
@@ -158,10 +168,13 @@ export declare function clickElement(params: ClickElementParams): void;
  * 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): void;
+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`.
@@ -182,9 +195,12 @@ export declare function hoverElement(params: HoverElementParams): Promise<void>;
  * (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): void;
+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`.
@@ -194,9 +210,12 @@ export declare function moveMouse(params: MoveMouseParams): void;
  * 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): void;
+export declare function pressKey(params: PressKeyParams): Promise<void>;
 /**
  * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.
  *

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

@@ -47,17 +47,17 @@ const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;
 const INPUT_TIMEOUT_IN_MILLISECONDS = 5e3;
 const CENTER_DIVISOR = 2;
 const SINGLE_CLICK_COUNT = 1;
-function clickElement(params) {
+async function clickElement(params) {
   const { button = "left", element, modifiers = [] } = params;
   const rect = element.getBoundingClientRect();
-  clickMouse({
+  await clickMouse({
     button,
     modifiers,
     x: rect.left + rect.width / CENTER_DIVISOR,
     y: rect.top + rect.height / CENTER_DIVISOR
   });
 }
-function clickMouse(params) {
+async function clickMouse(params) {
   const { button = "left", modifiers = [], x, y } = params;
   const electronModifiers = toElectronModifiers(modifiers);
   const roundedX = Math.round(x);
@@ -84,16 +84,16 @@ function clickMouse(params) {
 async function hoverElement(params) {
   const { element } = params;
   const rect = element.getBoundingClientRect();
-  moveMouse({ x: rect.left + rect.width / CENTER_DIVISOR, y: rect.top + rect.height / CENTER_DIVISOR });
+  await moveMouse({ x: rect.left + rect.width / CENTER_DIVISOR, y: rect.top + rect.height / CENTER_DIVISOR });
   const startTime = Date.now();
   while (!element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
     await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
   }
 }
-function moveMouse(params) {
+async function moveMouse(params) {
   getWebContents().sendInputEvent({ type: "mouseMove", x: Math.round(params.x), y: Math.round(params.y) });
 }
-function pressKey(params) {
+async function pressKey(params) {
   const { key, modifiers = [] } = params;
   const electronModifiers = toElectronModifiers(modifiers);
   const webContents = getWebContents();
@@ -110,7 +110,7 @@ async function typeIntoEditor(params) {
   editor.setCursor(lastLine, editor.getLine(lastLine).length);
   await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);
   for (const char of text) {
-    pressKey({ key: char });
+    await pressKey({ key: char });
   }
   const startTime = Date.now();
   while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
@@ -123,7 +123,7 @@ async function unhoverElement(params) {
   const rect = element.getBoundingClientRect();
   const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;
   const y = rect.top + rect.height / CENTER_DIVISOR;
-  moveMouse({ x, y });
+  await moveMouse({ x, y });
   const startTime = Date.now();
   while (element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
     await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
@@ -166,4 +166,4 @@ export {
   typeIntoEditor,
   unhoverElement
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop-only trusted input helpers that drive the real Electron renderer via\n * `webContents.sendInputEvent`, so keystrokes, pointer moves and clicks flow through the same trusted\n * input pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror, the CSS\n * `:hover` engine and every `e.isTrusted` guard in Obsidian ignore).\n *\n * These are the importable-module twins of the base helpers the `obsidian-integration-testing` harness\n * seeds into the `lib` bag; the two copies are kept behaviorally in sync by hand (see the project\n * `CLAUDE.md`). Desktop-only: they depend on `window.electron`.\n */\n\nimport type {\n  Editor,\n  Modifier\n} from 'obsidian';\n\nimport { Platform } from 'obsidian';\n\nimport { assertNever } from '../type-guards.ts';\n\n/**\n * Parameters for {@link clickElement}.\n */\nexport interface ClickElementParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The element to click. The pointer is moved to its center.\n   */\n  readonly element: HTMLElement;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link clickMouse}.\n */\nexport interface ClickMouseParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n\n  /**\n   * The x coordinate (web-contents DIP) to click at.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to click at.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center.\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The mouse button a trusted click presses, in Electron's `sendInputEvent` spelling.\n */\nexport type MouseButton = NonNullable<ElectronMouseInputEvent['button']>;\n\n/**\n * Parameters for {@link moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g. `'Enter'`, `'Escape'`, `'Tab'`,\n   * an arrow key, or a printable character (`'a'`, `'1'`).\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (caret moved to the end of the document) before the keystrokes\n   * are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link pressKey}, exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point just outside its bounding\n   * box.\n   */\n  readonly element: HTMLElement;\n}\n\ntype CurrentWebContents = ReturnType<Window['electron']['remote']['getCurrentWebContents']>;\n\n// The Electron modifier-key names `sendInputEvent` accepts (e.g. 'meta', 'control', 'shift', 'alt').\n// The type is derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronModifier = NonNullable<Parameters<CurrentWebContents['sendInputEvent']>[0]['modifiers']>[number];\n\n// The pointer variant of the `sendInputEvent` union, picked out by the coordinates only it carries.\n// Derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronMouseInputEvent = Extract<Parameters<CurrentWebContents['sendInputEvent']>[0], PointerCoordinates>;\n\n// The shape that discriminates a pointer `sendInputEvent` payload from a keyboard one.\ninterface PointerCoordinates {\n  x: number;\n}\n\n/**\n * Interval (in ms) between polls while waiting for a trusted input event to take effect (the editor\n * document updates, or an element's `:hover` state flips).\n */\nconst INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;\n\n/**\n * Maximum time (in ms) to wait for a trusted input event to take effect before giving up (the expected\n * outcome when the input is rejected \u2014 e.g. a read-only editor).\n */\nconst INPUT_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/**\n * Divisor used to find the center of an element's bounding box.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * The `clickCount` a single (non-double) trusted click carries.\n */\nconst SINGLE_CLICK_COUNT = 1;\n\n/**\n * Clicks the center of an element using **trusted** Electron pointer input.\n *\n * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /\n * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the\n * element's center \u2014 the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside\n * `.cm-sizer`, so no element's center lands on it.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n */\nexport function clickElement(params: ClickElementParams): void {\n  const { button = 'left', element, modifiers = [] } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n  const rect = element.getBoundingClientRect();\n  clickMouse({\n    button,\n    modifiers,\n    x: rect.left + rect.width / CENTER_DIVISOR,\n    y: rect.top + rect.height / CENTER_DIVISOR\n  });\n}\n\n/**\n * Clicks at the given web-contents coordinates using **trusted** Electron pointer input, so Chromium\n * synthesizes a real `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do: Obsidian and CodeMirror gate\n * on `isTrusted`, so a dispatched event silently exercises nothing while the test still passes. Obsidian\n * 1.13.7's markdown viewport (margin) menu, for example, opens from\n * `cm.scrollDOM.addEventListener('contextmenu', (e) => { if (!e.defaultPrevented && e.isTrusted && \u2026) })`\n * \u2014 a dispatched `contextmenu` never gets past that check.\n *\n * It is the low-level primitive: a single trusted `mouseMove` \u2192 `mouseDown` \u2192 `mouseUp` at one point,\n * with no waiting for any effect (callers poll their own readiness signal). The leading move is what puts\n * the pointer over the hit-test target before the button goes down. Prefer {@link clickElement} for\n * element-relative clicks.\n *\n * @param params - The web-contents DIP coordinates to click at, the button to press and any modifiers to\n * hold.\n */\nexport function clickMouse(params: ClickMouseParams): void {\n  const { button = 'left', modifiers = [], x, y } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const roundedX = Math.round(x);\n  const roundedY = Math.round(y);\n  const webContents = getWebContents();\n\n  webContents.sendInputEvent({ modifiers: electronModifiers, type: 'mouseMove', x: roundedX, y: roundedY });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseDown',\n    x: roundedX,\n    y: roundedY\n  });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseUp',\n    x: roundedX,\n    y: roundedY\n  });\n}\n\n/**\n * Moves the mouse pointer to the center of an element using **trusted** Electron pointer input, then polls\n * until the element actually matches `:hover`.\n *\n * Because the move is trusted, the real `:hover` state takes effect in the CSS engine \u2014 unlike\n * `dispatchEvent(new MouseEvent('mouseover'))`, which is untrusted and never sets `:hover`. It targets the\n * single window's **global** pointer, so only one element is hovered at a time.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that resolves once the element matches `:hover`.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  const { element } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n  const rect = element.getBoundingClientRect();\n  moveMouse({ x: rect.left + rect.width / CENTER_DIVISOR, y: rect.top + rect.height / CENTER_DIVISOR });\n\n  // Poll until the real `:hover` state has actually taken, instead of a fixed settle.\n  const startTime = Date.now();\n  while (!element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to the given web-contents coordinates using a **trusted** Electron pointer move.\n *\n * A trusted move updates the real pointer state in the CSS engine, so `:hover` rules genuinely apply. This\n * is the low-level primitive: it performs a single move and does **not** wait for any state to settle\n * (callers poll their own readiness signal). Prefer {@link hoverElement} / {@link unhoverElement} for\n * element-relative moves.\n *\n * @param params - The web-contents DIP coordinates to move to.\n */\nexport function moveMouse(params: MoveMouseParams): void {\n  getWebContents().sendInputEvent({ type: 'mouseMove', x: Math.round(params.x), y: Math.round(params.y) });\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** Electron keyboard input, firing the\n * full real key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It injects a trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence, delivered to the window's DOM-focused\n * element \u2014 unlike `dispatchEvent(new KeyboardEvent(...))`, which is untrusted and ignored by CodeMirror.\n * Use it for special keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations. It does\n * **not** poll for any effect; the caller focuses the target first, then awaits the expected effect.\n *\n * @param params - The key to press and any modifiers to hold.\n */\nexport function pressKey(params: PressKeyParams): void {\n  const { key, modifiers = [] } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const webContents = getWebContents();\n\n  // A trusted key press is keyDown -> char -> keyUp: the full real key pipeline.\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyDown' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'char' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyUp' });\n}\n\n/**\n * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.\n *\n * This focuses the editor (caret to end) and presses every code point of `text` via {@link pressKey} \u2014 the\n * same trusted sequence a real user produces \u2014 so the text reaches the document **only if the editor\n * genuinely holds focus**. After injecting the keystrokes it polls until the document reflects the input,\n * or a bounded timeout elapses (the expected outcome when the editor is read-only or focus was stolen).\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;\n\n  const { editor, text } = params;\n  const valueBeforeTyping = editor.getValue();\n\n  // Focus the editor and place the caret at the end of the document.\n  editor.focus();\n  const lastLine = editor.lastLine();\n  editor.setCursor(lastLine, editor.getLine(lastLine).length);\n\n  // Let any focus trap (a `setTimeout(0)` re-focus) fire before typing, so stolen focus is detected.\n  await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);\n\n  // Typing is pressing each character key in turn.\n  for (const char of text) {\n    pressKey({ key: char });\n  }\n\n  // Poll until the document reflects the input or the timeout elapses, instead of a fixed settle.\n  const startTime = Date.now();\n  while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to a point just outside an element's bounding box using a **trusted** Electron\n * pointer move, then polls until the element no longer matches `:hover`.\n *\n * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box is\n * reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const OUTSIDE_OFFSET_IN_PIXELS = 1;\n\n  const { element } = params;\n\n  // Move to a point just outside the element's box. When flush against the viewport's left edge, use just\n  // Past the right edge. A full-viewport-width element should use `moveMouse` directly instead.\n  const rect = element.getBoundingClientRect();\n  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;\n  const y = rect.top + rect.height / CENTER_DIVISOR;\n  moveMouse({ x, y });\n\n  // Poll until the real `:hover` state has actually cleared, instead of a fixed settle.\n  const startTime = Date.now();\n  while (element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\nfunction getWebContents(): CurrentWebContents {\n  return window.electron.remote.getCurrentWebContents();\n}\n\n// Maps Obsidian's `Modifier` names to Electron's lowercase `sendInputEvent` modifier names.\n// Shared by every trusted-input helper, so a key press and a click cannot disagree on `'Mod'`.\nfunction toElectronModifiers(modifiers: readonly Modifier[]): ElectronModifier[] {\n  // 'Mod' is Obsidian's platform-agnostic modifier: Cmd (meta) on macOS, Ctrl elsewhere.\n  const isMacOS = Platform.isMacOS;\n\n  return modifiers.map((modifier): ElectronModifier => {\n    switch (modifier) {\n      case 'Alt': {\n        return 'alt';\n      }\n      case 'Ctrl': {\n        return 'control';\n      }\n      case 'Meta': {\n        return 'meta';\n      }\n      case 'Mod': {\n        return isMacOS ? 'meta' : 'control';\n      }\n      case 'Shift': {\n        return 'shift';\n      }\n      default: {\n        return assertNever(modifier);\n      }\n    }\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAS,gBAAgB;AAEzB,SAAS,mBAAmB;AAwJ5B,MAAM,sCAAsC;AAM5C,MAAM,gCAAgC;AAKtC,MAAM,iBAAiB;AAKvB,MAAM,qBAAqB;AAYpB,SAAS,aAAa,QAAkC;AAC7D,QAAM,EAAE,SAAS,QAAQ,SAAS,YAAY,CAAC,EAAE,IAAI;AAGrD,QAAM,OAAO,QAAQ,sBAAsB;AAC3C,aAAW;AAAA,IACT;AAAA,IACA;AAAA,IACA,GAAG,KAAK,OAAO,KAAK,QAAQ;AAAA,IAC5B,GAAG,KAAK,MAAM,KAAK,SAAS;AAAA,EAC9B,CAAC;AACH;AAoBO,SAAS,WAAW,QAAgC;AACzD,QAAM,EAAE,SAAS,QAAQ,YAAY,CAAC,GAAG,GAAG,EAAE,IAAI;AAElD,QAAM,oBAAoB,oBAAoB,SAAS;AACvD,QAAM,WAAW,KAAK,MAAM,CAAC;AAC7B,QAAM,WAAW,KAAK,MAAM,CAAC;AAC7B,QAAM,cAAc,eAAe;AAEnC,cAAY,eAAe,EAAE,WAAW,mBAAmB,MAAM,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AACxG,cAAY,eAAe;AAAA,IACzB;AAAA,IACA,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,MAAM;AAAA,IACN,GAAG;AAAA,IACH,GAAG;AAAA,EACL,CAAC;AACD,cAAY,eAAe;AAAA,IACzB;AAAA,IACA,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,MAAM;AAAA,IACN,GAAG;AAAA,IACH,GAAG;AAAA,EACL,CAAC;AACH;AAaA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,EAAE,QAAQ,IAAI;AAGpB,QAAM,OAAO,QAAQ,sBAAsB;AAC3C,YAAU,EAAE,GAAG,KAAK,OAAO,KAAK,QAAQ,gBAAgB,GAAG,KAAK,MAAM,KAAK,SAAS,eAAe,CAAC;AAGpG,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,CAAC,QAAQ,QAAQ,QAAQ,KAAK,KAAK,IAAI,IAAI,YAAY,+BAA+B;AAC3F,UAAM,MAAM,mCAAmC;AAAA,EACjD;AACF;AAYO,SAAS,UAAU,QAA+B;AACvD,iBAAe,EAAE,eAAe,EAAE,MAAM,aAAa,GAAG,KAAK,MAAM,OAAO,CAAC,GAAG,GAAG,KAAK,MAAM,OAAO,CAAC,EAAE,CAAC;AACzG;AAaO,SAAS,SAAS,QAA8B;AACrD,QAAM,EAAE,KAAK,YAAY,CAAC,EAAE,IAAI;AAEhC,QAAM,oBAAoB,oBAAoB,SAAS;AACvD,QAAM,cAAc,eAAe;AAGnC,cAAY,eAAe,EAAE,SAAS,KAAK,WAAW,mBAAmB,MAAM,UAAU,CAAC;AAC1F,cAAY,eAAe,EAAE,SAAS,KAAK,WAAW,mBAAmB,MAAM,OAAO,CAAC;AACvF,cAAY,eAAe,EAAE,SAAS,KAAK,WAAW,mBAAmB,MAAM,QAAQ,CAAC;AAC1F;AAaA,eAAsB,eAAe,QAA6C;AAChF,QAAM,qCAAqC;AAE3C,QAAM,EAAE,QAAQ,KAAK,IAAI;AACzB,QAAM,oBAAoB,OAAO,SAAS;AAG1C,SAAO,MAAM;AACb,QAAM,WAAW,OAAO,SAAS;AACjC,SAAO,UAAU,UAAU,OAAO,QAAQ,QAAQ,EAAE,MAAM;AAG1D,QAAM,MAAM,kCAAkC;AAG9C,aAAW,QAAQ,MAAM;AACvB,aAAS,EAAE,KAAK,KAAK,CAAC;AAAA,EACxB;AAGA,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,OAAO,SAAS,MAAM,qBAAqB,KAAK,IAAI,IAAI,YAAY,+BAA+B;AACxG,UAAM,MAAM,mCAAmC;AAAA,EACjD;AACF;AAYA,eAAsB,eAAe,QAA6C;AAChF,QAAM,2BAA2B;AAEjC,QAAM,EAAE,QAAQ,IAAI;AAIpB,QAAM,OAAO,QAAQ,sBAAsB;AAC3C,QAAM,IAAI,KAAK,QAAQ,2BAA2B,KAAK,OAAO,2BAA2B,KAAK,QAAQ;AACtG,QAAM,IAAI,KAAK,MAAM,KAAK,SAAS;AACnC,YAAU,EAAE,GAAG,EAAE,CAAC;AAGlB,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,QAAQ,QAAQ,QAAQ,KAAK,KAAK,IAAI,IAAI,YAAY,+BAA+B;AAC1F,UAAM,MAAM,mCAAmC;AAAA,EACjD;AACF;AAEA,SAAS,iBAAqC;AAC5C,SAAO,OAAO,SAAS,OAAO,sBAAsB;AACtD;AAIA,SAAS,oBAAoB,WAAoD;AAE/E,QAAM,UAAU,SAAS;AAEzB,SAAO,UAAU,IAAI,CAAC,aAA+B;AACnD,YAAQ,UAAU;AAAA,MAChB,KAAK,OAAO;AACV,eAAO;AAAA,MACT;AAAA,MACA,KAAK,QAAQ;AACX,eAAO;AAAA,MACT;AAAA,MACA,KAAK,QAAQ;AACX,eAAO;AAAA,MACT;AAAA,MACA,KAAK,OAAO;AACV,eAAO,UAAU,SAAS;AAAA,MAC5B;AAAA,MACA,KAAK,SAAS;AACZ,eAAO;AAAA,MACT;AAAA,MACA,SAAS;AACP,eAAO,YAAY,QAAQ;AAAA,MAC7B;AAAA,IACF;AAAA,EACF,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop-only trusted input helpers that drive the real Electron renderer via\n * `webContents.sendInputEvent`, so keystrokes, pointer moves and clicks flow through the same trusted\n * input pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror, the CSS\n * `:hover` engine and every `e.isTrusted` guard in Obsidian ignore).\n *\n * These are the importable-module twins of the base helpers the `obsidian-integration-testing` harness\n * seeds into the `lib` bag; the two copies are kept behaviorally in sync by hand (see the project\n * `CLAUDE.md`). Desktop-only: they depend on `window.electron`.\n *\n * This is the **desktop arm**. Import it directly only as a deliberate platform commitment; the\n * cross-platform entry point is the {@link ./trusted-input.ts | trusted-input} facade, which dispatches\n * to this module or to {@link ./mobile-trusted-input.ts | mobile-trusted-input} per call.\n */\n\nimport type {\n  Editor,\n  Modifier\n} from 'obsidian';\n\nimport { Platform } from 'obsidian';\n\nimport { assertNever } from '../type-guards.ts';\n\n/**\n * Parameters for {@link clickElement}.\n */\nexport interface ClickElementParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The element to click. The pointer is moved to its center.\n   */\n  readonly element: HTMLElement;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link clickMouse}.\n */\nexport interface ClickMouseParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n\n  /**\n   * The x coordinate (web-contents DIP) to click at.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to click at.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center.\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The mouse button a trusted click presses, in Electron's `sendInputEvent` spelling.\n */\nexport type MouseButton = NonNullable<ElectronMouseInputEvent['button']>;\n\n/**\n * Parameters for {@link moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g. `'Enter'`, `'Escape'`, `'Tab'`,\n   * an arrow key, or a printable character (`'a'`, `'1'`).\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (caret moved to the end of the document) before the keystrokes\n   * are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link pressKey}, exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point just outside its bounding\n   * box.\n   */\n  readonly element: HTMLElement;\n}\n\ntype CurrentWebContents = ReturnType<Window['electron']['remote']['getCurrentWebContents']>;\n\n// The Electron modifier-key names `sendInputEvent` accepts (e.g. 'meta', 'control', 'shift', 'alt').\n// The type is derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronModifier = NonNullable<Parameters<CurrentWebContents['sendInputEvent']>[0]['modifiers']>[number];\n\n// The pointer variant of the `sendInputEvent` union, picked out by the coordinates only it carries.\n// Derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronMouseInputEvent = Extract<Parameters<CurrentWebContents['sendInputEvent']>[0], PointerCoordinates>;\n\n// The shape that discriminates a pointer `sendInputEvent` payload from a keyboard one.\ninterface PointerCoordinates {\n  x: number;\n}\n\n/**\n * Interval (in ms) between polls while waiting for a trusted input event to take effect (the editor\n * document updates, or an element's `:hover` state flips).\n */\nconst INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;\n\n/**\n * Maximum time (in ms) to wait for a trusted input event to take effect before giving up (the expected\n * outcome when the input is rejected \u2014 e.g. a read-only editor).\n */\nconst INPUT_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/**\n * Divisor used to find the center of an element's bounding box.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * The `clickCount` a single (non-double) trusted click carries.\n */\nconst SINGLE_CLICK_COUNT = 1;\n\n/**\n * Clicks the center of an element using **trusted** Electron pointer input.\n *\n * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /\n * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the\n * element's center \u2014 the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside\n * `.cm-sizer`, so no element's center lands on it.\n *\n * **Must be awaited.** Nothing here needs to wait, but the cross-platform twins do \u2014 on mobile the\n * injection is a round-trip to the host, because the renderer cannot produce a trusted event itself \u2014 so\n * the signature is the same on both platforms and a caller never rewrites its `await`s when it grows a\n * mobile lane.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  const { button = 'left', element, modifiers = [] } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n  const rect = element.getBoundingClientRect();\n  await clickMouse({\n    button,\n    modifiers,\n    x: rect.left + rect.width / CENTER_DIVISOR,\n    y: rect.top + rect.height / CENTER_DIVISOR\n  });\n}\n\n/**\n * Clicks at the given web-contents coordinates using **trusted** Electron pointer input, so Chromium\n * synthesizes a real `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do: Obsidian and CodeMirror gate\n * on `isTrusted`, so a dispatched event silently exercises nothing while the test still passes. Obsidian\n * 1.13.7's markdown viewport (margin) menu, for example, opens from\n * `cm.scrollDOM.addEventListener('contextmenu', (e) => { if (!e.defaultPrevented && e.isTrusted && \u2026) })`\n * \u2014 a dispatched `contextmenu` never gets past that check.\n *\n * It is the low-level primitive: a single trusted `mouseMove` \u2192 `mouseDown` \u2192 `mouseUp` at one point,\n * with no waiting for any effect (callers poll their own readiness signal). The leading move is what puts\n * the pointer over the hit-test target before the button goes down. Prefer {@link clickElement} for\n * element-relative clicks.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The web-contents DIP coordinates to click at, the button to press and any modifiers to\n * hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  const { button = 'left', modifiers = [], x, y } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const roundedX = Math.round(x);\n  const roundedY = Math.round(y);\n  const webContents = getWebContents();\n\n  webContents.sendInputEvent({ modifiers: electronModifiers, type: 'mouseMove', x: roundedX, y: roundedY });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseDown',\n    x: roundedX,\n    y: roundedY\n  });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseUp',\n    x: roundedX,\n    y: roundedY\n  });\n}\n\n/**\n * Moves the mouse pointer to the center of an element using **trusted** Electron pointer input, then polls\n * until the element actually matches `:hover`.\n *\n * Because the move is trusted, the real `:hover` state takes effect in the CSS engine \u2014 unlike\n * `dispatchEvent(new MouseEvent('mouseover'))`, which is untrusted and never sets `:hover`. It targets the\n * single window's **global** pointer, so only one element is hovered at a time.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that resolves once the element matches `:hover`.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  const { element } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n  const rect = element.getBoundingClientRect();\n  await moveMouse({ x: rect.left + rect.width / CENTER_DIVISOR, y: rect.top + rect.height / CENTER_DIVISOR });\n\n  // Poll until the real `:hover` state has actually taken, instead of a fixed settle.\n  const startTime = Date.now();\n  while (!element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to the given web-contents coordinates using a **trusted** Electron pointer move.\n *\n * A trusted move updates the real pointer state in the CSS engine, so `:hover` rules genuinely apply. This\n * is the low-level primitive: it performs a single move and does **not** wait for any state to settle\n * (callers poll their own readiness signal). Prefer {@link hoverElement} / {@link unhoverElement} for\n * element-relative moves.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The web-contents DIP coordinates to move to.\n * @returns A {@link Promise} that resolves once the move has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  getWebContents().sendInputEvent({ type: 'mouseMove', x: Math.round(params.x), y: Math.round(params.y) });\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** Electron keyboard input, firing the\n * full real key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It injects a trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence, delivered to the window's DOM-focused\n * element \u2014 unlike `dispatchEvent(new KeyboardEvent(...))`, which is untrusted and ignored by CodeMirror.\n * Use it for special keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations. It does\n * **not** poll for any effect; the caller focuses the target first, then awaits the expected effect.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  const { key, modifiers = [] } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const webContents = getWebContents();\n\n  // A trusted key press is keyDown -> char -> keyUp: the full real key pipeline.\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyDown' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'char' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyUp' });\n}\n\n/**\n * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.\n *\n * This focuses the editor (caret to end) and presses every code point of `text` via {@link pressKey} \u2014 the\n * same trusted sequence a real user produces \u2014 so the text reaches the document **only if the editor\n * genuinely holds focus**. After injecting the keystrokes it polls until the document reflects the input,\n * or a bounded timeout elapses (the expected outcome when the editor is read-only or focus was stolen).\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;\n\n  const { editor, text } = params;\n  const valueBeforeTyping = editor.getValue();\n\n  // Focus the editor and place the caret at the end of the document.\n  editor.focus();\n  const lastLine = editor.lastLine();\n  editor.setCursor(lastLine, editor.getLine(lastLine).length);\n\n  // Let any focus trap (a `setTimeout(0)` re-focus) fire before typing, so stolen focus is detected.\n  await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);\n\n  // Typing is pressing each character key in turn.\n  for (const char of text) {\n    await pressKey({ key: char });\n  }\n\n  // Poll until the document reflects the input or the timeout elapses, instead of a fixed settle.\n  const startTime = Date.now();\n  while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to a point just outside an element's bounding box using a **trusted** Electron\n * pointer move, then polls until the element no longer matches `:hover`.\n *\n * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box is\n * reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const OUTSIDE_OFFSET_IN_PIXELS = 1;\n\n  const { element } = params;\n\n  // Move to a point just outside the element's box. When flush against the viewport's left edge, use just\n  // Past the right edge. A full-viewport-width element should use `moveMouse` directly instead.\n  const rect = element.getBoundingClientRect();\n  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;\n  const y = rect.top + rect.height / CENTER_DIVISOR;\n  await moveMouse({ x, y });\n\n  // Poll until the real `:hover` state has actually cleared, instead of a fixed settle.\n  const startTime = Date.now();\n  while (element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\nfunction getWebContents(): CurrentWebContents {\n  return window.electron.remote.getCurrentWebContents();\n}\n\n// Maps Obsidian's `Modifier` names to Electron's lowercase `sendInputEvent` modifier names.\n// Shared by every trusted-input helper, so a key press and a click cannot disagree on `'Mod'`.\nfunction toElectronModifiers(modifiers: readonly Modifier[]): ElectronModifier[] {\n  // 'Mod' is Obsidian's platform-agnostic modifier: Cmd (meta) on macOS, Ctrl elsewhere.\n  const isMacOS = Platform.isMacOS;\n\n  return modifiers.map((modifier): ElectronModifier => {\n    switch (modifier) {\n      case 'Alt': {\n        return 'alt';\n      }\n      case 'Ctrl': {\n        return 'control';\n      }\n      case 'Meta': {\n        return 'meta';\n      }\n      case 'Mod': {\n        return isMacOS ? 'meta' : 'control';\n      }\n      case 'Shift': {\n        return 'shift';\n      }\n      default: {\n        return assertNever(modifier);\n      }\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -22,6 +22,7 @@ export * as 'dataview-link' from './dataview-link.mjs';
 export * as 'dataview' from './dataview.mjs';
 export * as 'demo-vault-helper-settings' from './demo-vault-helper-settings.mjs';
 export * as 'demo-vault-helper' from './demo-vault-helper.mjs';
+export * as 'demo-vault-naming' from './demo-vault-naming.mjs';
 export * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.mjs';
 export * as 'desktop-trusted-input' from './desktop-trusted-input.mjs';
 export * as 'editor-extension-registrar' from './editor-extension-registrar.mjs';
@@ -50,6 +51,7 @@ export * as 'markdown-view' from './markdown-view.mjs';
 export * as 'markdown' from './markdown.mjs';
 export * as 'menu-event-registrar' from './menu-event-registrar.mjs';
 export * as 'metadata-cache' from './metadata-cache.mjs';
+export * as 'mobile-trusted-input' from './mobile-trusted-input.mjs';
 export * as 'modals' from './modals/index.mjs';
 export * as 'note-priority' from './note-priority.mjs';
 export * as 'notebook-navigator' from './notebook-navigator.mjs';
@@ -72,6 +74,7 @@ export * as 'setting-ex' from './setting-ex.mjs';
 export * as 'setting-group-ex' from './setting-group-ex.mjs';
 export * as 'status-bar-item-registrar' from './status-bar-item-registrar.mjs';
 export * as 'templater' from './templater.mjs';
+export * as 'trusted-input' from './trusted-input.mjs';
 export * as 'validation' from './validation.mjs';
 export * as 'vault-delete' from './vault-delete.mjs';
 export * as 'vault-transaction' from './vault-transaction.mjs';