@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/metadata-cache.d.cts

@@ -0,0 +1,359 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This module provides utility functions for working with the metadata cache in Obsidian.
+ */
+import type { RetryOptions } from '@mnaoumov/typescript-lib/async' with { 'resolution-mode': 'import' };
+import type { CustomArrayDict } from '@obsidian-typings/obsidian-public-latest' with { 'resolution-mode': 'import' };
+import type { App, CachedMetadata, Reference, TAbstractFile } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PathOrFile } from './file-system.cjs';
+import type { CombinedFrontmatter } from './frontmatter.cjs';
+import type { ParseLinkFrontmatterReference, ParseLinkFrontmatterReferenceWithOffsets, ParseLinkReference } from './parse-link.cjs';
+/**
+ * A parsing feature that was applied when computing a {@link CachedMetadataEx}.
+ */
+export declare enum CachedMetadataExFeature {
+    /**
+     * The external links parsed from the note content body.
+     */
+    ExternalLinks = "ExternalLinks",
+    /**
+     * The external links parsed from single-link note frontmatter values.
+     */
+    FrontmatterExternalLinks = "FrontmatterExternalLinks",
+    /**
+     * The external links parsed from multi-link note frontmatter values.
+     */
+    MultiValueFrontmatterExternalLinks = "MultiValueFrontmatterExternalLinks",
+    /**
+     * The internal links parsed from multi-link note frontmatter values, which Obsidian does not natively cache.
+     */
+    MultiValueFrontmatterLinks = "MultiValueFrontmatterLinks",
+    /**
+     * Obsidian's native metadata parsing (internal links, embeds, frontmatter links).
+     */
+    Native = "Native"
+}
+/**
+ * An extended {@link CachedMetadata} that records which parsing {@link CachedMetadataExFeature}s were
+ * applied (via {@link CachedMetadataEx.features}) and carries the resulting external links. Each links
+ * array is populated only when its corresponding feature is present in {@link CachedMetadataEx.features}.
+ */
+export interface CachedMetadataEx extends CachedMetadata {
+    /**
+     * The external links parsed from the note content body. Populated only when
+     * {@link CachedMetadataExFeature.ExternalLinks} is applied.
+     */
+    externalLinks?: ParseLinkReference[];
+    /**
+     * The parsing features that were applied when computing this cache.
+     */
+    readonly features: CachedMetadataExFeature[];
+    /**
+     * The external links parsed from single-link (single-value) note frontmatter values. Populated only
+     * when {@link CachedMetadataExFeature.FrontmatterExternalLinks} is applied.
+     */
+    frontmatterExternalLinks?: ParseLinkFrontmatterReference[];
+    /**
+     * The external links parsed from multi-link (multi-value) note frontmatter values. Populated only when
+     * {@link CachedMetadataExFeature.MultiValueFrontmatterExternalLinks} is applied.
+     */
+    multiValueFrontmatterExternalLinks?: ParseLinkFrontmatterReferenceWithOffsets[];
+    /**
+     * The internal links parsed from multi-link (multi-value) note frontmatter values. Populated only when
+     * {@link CachedMetadataExFeature.MultiValueFrontmatterLinks} is applied.
+     */
+    multiValueFrontmatterLinks?: ParseLinkFrontmatterReferenceWithOffsets[];
+}
+/**
+ * Options for {@link getBacklinksForFileSafe}.
+ */
+export interface GetBacklinksForFileSafeOptions extends RetryOptions {
+    /**
+     * Whether to show a timeout notice.
+     *
+     * @default `true`
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+}
+/**
+ * Parameters for {@link getBacklinksForFileSafe}.
+ */
+export interface GetBacklinksForFileSafeParams extends GetBacklinksForFileSafeOptions {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The path or file object.
+     */
+    readonly pathOrFile: PathOrFile;
+}
+/**
+ * Wrapper for the getBacklinksForFile method that provides a safe overload.
+ */
+export interface GetBacklinksForFileSafeWrapper {
+    /**
+     * Retrieves the backlinks for a file safely.
+     *
+     * @param pathOrFile - The path or file object.
+     * @returns A {@link Promise} that resolves to an array dictionary of backlinks.
+     */
+    safe: (pathOrFile: PathOrFile) => Promise<CustomArrayDict<Reference>>;
+}
+/**
+ * Options for {@link getCacheSafe}.
+ */
+export type GetCacheSafeOptions = ParseCacheOptions;
+/**
+ * Params for {@link getLinks}.
+ */
+export interface GetLinksParams {
+    /**
+     * The cached metadata to retrieve the links from.
+     */
+    readonly cache: CachedMetadata;
+    /**
+     * Whether to include the embeds (`cache.embeds`).
+     *
+     * @default `true`
+     */
+    readonly shouldIncludeEmbeds?: boolean;
+    /**
+     * Whether to include the external links parsed from the note body. Requires the cache to be a
+     * {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeExternalLinks?: boolean;
+    /**
+     * Whether to include the external links parsed from single-link (single-value) note frontmatter
+     * values. Requires the cache to be a {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to include the frontmatter links (`cache.frontmatterLinks`).
+     *
+     * @default `true`
+     */
+    readonly shouldIncludeFrontmatterLinks?: boolean;
+    /**
+     * Whether to include the external links parsed from multi-link (multi-value) note frontmatter values,
+     * i.e. the offset-carrying frontmatter external links (narrowed via
+     * {@link isFrontmatterLinkCacheWithOffsets}). Requires the cache to be a {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeMultiValueFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to include the internal links parsed from multi-link (multi-value) note frontmatter values.
+     * Requires the cache to be a {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeMultiValueFrontmatterLinks?: boolean;
+    /**
+     * Whether to include the reference links (`cache.links`).
+     *
+     * @default `true`
+     */
+    readonly shouldIncludeReferences?: boolean;
+}
+/**
+ * Options for the parsing performed by {@link getCacheSafe} and {@link parseMetadata} beyond Obsidian's
+ * native metadata parsing. Each option is opt-in; enabling it adds the corresponding
+ * {@link CachedMetadataExFeature} and populates the matching links array.
+ */
+export interface ParseCacheOptions {
+    /**
+     * Whether to parse the external links from the note content body.
+     *
+     * @default `false`
+     */
+    readonly shouldParseExternalLinks?: boolean;
+    /**
+     * Whether to parse the external links from single-link (single-value) note frontmatter values.
+     *
+     * @default `false`
+     */
+    readonly shouldParseFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to parse the external links from multi-link (multi-value) note frontmatter values.
+     *
+     * @default `false`
+     */
+    readonly shouldParseMultiValueFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to parse the internal links from multi-link (multi-value) note frontmatter values.
+     *
+     * @default `false`
+     */
+    readonly shouldParseMultiValueFrontmatterLinks?: boolean;
+}
+/**
+ * Options for {@link parseMetadata}.
+ */
+export type ParseMetadataOptions = ParseCacheOptions;
+/**
+ * Parameters for {@link registerFileCacheForNonExistingFile}.
+ */
+export interface RegisterFileCacheForNonExistingFileParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The file cache to register.
+     */
+    readonly cache: CachedMetadata;
+    /**
+     * The path or file to register the file cache for.
+     */
+    readonly pathOrFile: PathOrFile;
+}
+/**
+ * The plugin id of the Advanced Metadata Cache plugin, the successor to Backlink Cache.
+ *
+ * Used by {@link hasBacklinkCachePlugin}. Note that {@link getBacklinksForFileSafe} does NOT need this id: it detects the cache by the {@link GetBacklinksForFileSafeWrapper.safe} overload grafted onto `MetadataCache.getBacklinksForFile`, which both plugins install and which names no plugin.
+ */
+export declare const ADVANCED_METADATA_CACHE_PLUGIN_ID = "advanced-metadata-cache";
+/**
+ * The plugin id of the retired Backlink Cache plugin, superseded by {@link ADVANCED_METADATA_CACHE_PLUGIN_ID}.
+ *
+ * Still recognized by {@link hasBacklinkCachePlugin}, deliberately. Removing a plugin from the community registry blocks new installs; it uninstalls nothing, so every existing user keeps it until they migrate by hand.
+ *
+ * It may be dropped when all three of the following hold, and not before: Advanced Metadata Cache is listed in the community registry, so migrating is possible at all; the final Backlink Cache handover release has been out for at least twelve months; and this library is cutting a major release anyway, because dropping the id silently un-gates canvas link handling for anyone who has not migrated. There is no cost pressure to drop it earlier - recognizing a dead id is one string comparison on a path that already reads a plugin registry.
+ */
+export declare const BACKLINK_CACHE_PLUGIN_ID = "backlink-cache";
+/**
+ * Ensures that the metadata cache is ready for all files.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns A {@link Promise} that resolves when the metadata cache is ready.
+ */
+export declare function ensureMetadataCacheReady(app: App): Promise<void>;
+/**
+ * Retrieves the backlinks for a file or path.
+ * NOTE: The file may be non-existent.
+ *
+ * When a backlink-cache plugin has grafted its {@link GetBacklinksForFileSafeWrapper.safe} overload onto
+ * `MetadataCache.getBacklinksForFile`, that patched method answers. Otherwise the answer comes from a backlink
+ * index whose cost is proportional to the candidate notes rather than to every reference in the vault, and which
+ * gives the same references Obsidian's own `getBacklinksForFile` gives.
+ *
+ * @param app - The Obsidian application instance.
+ * @param pathOrFile - The path or file object.
+ * @returns The backlinks for the file.
+ */
+export declare function getBacklinksForFileOrPath(app: App, pathOrFile: PathOrFile): CustomArrayDict<Reference>;
+/**
+ * Retrieves the backlinks for a file safely.
+ *
+ * This is NOT a pure read. When no backlink-cache plugin supplies the `safe` overload, it verifies
+ * each backlink against the note's current text, and to do that it calls {@link saveNote} on every
+ * note that links to the file, which saves any open editor view of those notes that has unsaved
+ * changes. Call it from an explicit user action. Do not call it from an automatic trigger (a vault or
+ * metadata event, a save or render patch) that only decides whether to act. There, a forced save can
+ * race another plugin's in-flight editor change.
+ *
+ * @param params - The parameters for retrieving the backlinks.
+ * @returns A {@link Promise} that resolves to an array dictionary of backlinks.
+ */
+export declare function getBacklinksForFileSafe(params: GetBacklinksForFileSafeParams): Promise<CustomArrayDict<Reference>>;
+/**
+ * Retrieves the cached metadata for a given file or path.
+ *
+ * This is NOT a pure read: before it reads the cache, it calls {@link saveNote}, which saves any
+ * open editor view of the note that has unsaved changes. That save is why the cache matches what the
+ * user sees, and why a command that rewrites the note can use this safely without its rewrite being
+ * clobbered. It is also a write on the note. So do not call this from an automatic trigger (a vault
+ * or metadata event, a save or render patch, a layout hook) that only decides whether to act: a
+ * forced save one tick after another plugin has dispatched a change into the editor can leave
+ * Obsidian's editor rendering stale state. A read-only probe on the note's current text should use
+ * {@link parseMetadata} on that text instead. It needs no view, no cache and no save.
+ *
+ * @param app - The Obsidian app instance.
+ * @param fileOrPath - The file or path to retrieve the metadata for.
+ * @param options - The parse options controlling which additional links to parse.
+ * @returns The cached metadata for the file, or `null` if it doesn't exist.
+ */
+export declare function getCacheSafe(app: App, fileOrPath: PathOrFile, options?: GetCacheSafeOptions): Promise<CachedMetadataEx | null>;
+/**
+ * Retrieves the front matter from the metadata cache safely.
+ *
+ * It reads through {@link getCacheSafe}, so it saves any open editor view of the note that has
+ * unsaved changes. See {@link getCacheSafe} for when that save matters and what to use instead.
+ *
+ * @typeParam CustomFrontmatter - The type of custom front matter.
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file to retrieve the front matter from.
+ * @returns The combined front matter.
+ */
+export declare function getFrontmatterSafe<CustomFrontmatter = unknown>(app: App, pathOrFile: PathOrFile): Promise<CombinedFrontmatter<CustomFrontmatter>>;
+/**
+ * Retrieves the selected links from the provided cache.
+ *
+ * @param params - The parameters for retrieving the links.
+ * @returns An array of references representing the selected links.
+ */
+export declare function getLinks(params: GetLinksParams): Reference[];
+/**
+ * Determines whether a backlink cache plugin is currently loaded - either Advanced Metadata Cache ({@link ADVANCED_METADATA_CACHE_PLUGIN_ID}) or its retired predecessor Backlink Cache ({@link BACKLINK_CACHE_PLUGIN_ID}).
+ *
+ * Such a plugin grafts a drain-on-read backlink index onto the metadata cache and indexes canvas metadata, so a caller that compensates for Obsidian's own gaps can stand down while one is present. Both ids are recognized; {@link BACKLINK_CACHE_PLUGIN_ID} records when the retired one may be dropped.
+ *
+ * This reads the LOADED plugin instance rather than `app.plugins.enabledPlugins`, deliberately: the question is whether the plugin's patches are in place right now, and they are not until it has loaded. Plugins load in an unspecified order, so call this from a user-driven path rather than from plugin load - see rule L25 in `AGENTS.md`.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns `true` if a backlink cache plugin is loaded, otherwise `false`.
+ */
+export declare function hasBacklinkCachePlugin(app: App): boolean;
+/**
+ * Determines whether a cache is a {@link CachedMetadataEx} (i.e. it was computed with external-link
+ * parsing enabled).
+ *
+ * @param cache - The cache to check.
+ * @returns `true` if the cache is a {@link CachedMetadataEx}, otherwise `false`.
+ */
+export declare function isCachedMetadataEx(cache: CachedMetadata): cache is CachedMetadataEx;
+/**
+ * Parses the metadata for a given string.
+ *
+ * @param app - The Obsidian app instance.
+ * @param $string - The string to parse the metadata for.
+ * @param options - The parse options controlling which additional links to parse.
+ * @returns The parsed metadata.
+ */
+export declare function parseMetadata(app: App, $string: string, options?: ParseMetadataOptions): Promise<CachedMetadataEx>;
+/**
+ * Registers the file cache for a non-existing file.
+ *
+ * @param params - The parameters for registering the file cache.
+ * @returns A {@link Disposable} that unregisters the file cache when disposed, for use with `using`.
+ */
+export declare function registerFileCacheForNonExistingFile(params: RegisterFileCacheForNonExistingFileParams): Disposable;
+/**
+ * Registers files in the Obsidian app.
+ *
+ * @param app - The Obsidian app instance.
+ * @param files - The files to register.
+ * @returns A {@link Disposable} that unregisters the files when disposed, for use with `using`.
+ */
+export declare function registerFiles(app: App, files: TAbstractFile[]): Disposable;
+/**
+ * Unregisters the file cache for a non-existing file.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file to unregister the file cache for.
+ */
+export declare function unregisterFileCacheForNonExistingFile(app: App, pathOrFile: PathOrFile): void;
+/**
+ * Unregisters files from the Obsidian app.
+ *
+ * @param app - The Obsidian app instance.
+ * @param files - The files to unregister.
+ */
+export declare function unregisterFiles(app: App, files: TAbstractFile[]): void;

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

@@ -0,0 +1,185 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_trusted_input_exports = {};
+__export(mobile_trusted_input_exports, {
+  clickElement: () => clickElement,
+  clickMouse: () => clickMouse,
+  hoverElement: () => hoverElement,
+  moveMouse: () => moveMouse,
+  pressKey: () => pressKey,
+  typeIntoEditor: () => typeIntoEditor,
+  unhoverElement: () => unhoverElement
+});
+module.exports = __toCommonJS(mobile_trusted_input_exports);
+async function clickElement(params) {
+  await getSeamFunction("clickElement")(params);
+}
+async function clickMouse(params) {
+  await getSeamFunction("clickMouse")(params);
+}
+async function hoverElement(params) {
+  await getSeamFunction("hoverElement")(params);
+}
+async function moveMouse(params) {
+  await getSeamFunction("moveMouse")(params);
+}
+async function pressKey(params) {
+  await getSeamFunction("pressKey")(params);
+}
+async function typeIntoEditor(params) {
+  await getSeamFunction("typeIntoEditor")(params);
+}
+async function unhoverElement(params) {
+  await getSeamFunction("unhoverElement")(params);
+}
+function getSeamFunction(name) {
+  const holder = globalThis;
+  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];
+  if (!seamFunction) {
+    throw new Error(
+      `Trusted input is unavailable on mobile: \`window.__obsidianIntegrationTesting.trustedInput.${name}\` is not installed. A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the \`obsidian-integration-testing\` Appium transport's channel \u2014 which means these helpers only work inside an app that harness bootstrapped.`
+    );
+  }
+  return seamFunction;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clickElement,
+  clickMouse,
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/mobile-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone \u2014\n * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted \u2014 so the injection\n * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's\n * binding channel, and the host injects it into the WebView over CDP \u2014 as `Input.dispatchTouchEvent` for\n * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past\n * Android's gesture recognizer and so is classified as a tap at any dwell.\n *\n * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the\n * harness rather than reimplementing the wire format: they call\n * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness\n * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics \u2014\n * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws\n * for the `:hover` helpers \u2014 identical to the harness's own copy for free, instead of a second\n * implementation to hand-sync.\n *\n * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in\n * either direction, at runtime or in types.\n *\n * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.\n * Outside one they throw a message saying so, rather than silently doing nothing \u2014 a no-op would recreate\n * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct\n * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.\n *\n * The params are forwarded untouched, `window` included, so the harness's own refusal of any window but\n * the main one applies here too: Obsidian Mobile has no popout windows to send input to.\n */\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n  // The parameter contracts live with the desktop twin and are shared verbatim, so the two platforms\n  // cannot drift apart on what a caller passes. A type-only import loads nothing at runtime, so this\n  // import leaves the module mobile-safe.\n} from './desktop-trusted-input.ts';\n\n/**\n * The global the harness bootstraps its namespace onto.\n */\ninterface ObsidianIntegrationTestingHolder {\n  __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;\n}\n\n/**\n * The part of the harness namespace this module reads. Everything else on it is none of this module's\n * business.\n */\ninterface ObsidianIntegrationTestingNamespace {\n  trustedInput?: Partial<TrustedInputSeam>;\n}\n\n/**\n * The trusted-input seam the `obsidian-integration-testing` harness publishes on its namespace.\n *\n * Declared here rather than imported: the harness is not a dependency of this library. It mirrors\n * `namespace-bootstrap.ts`'s `trustedInput` object, and the mirroring is by hand \u2014 the same\n * behavioral-sync obligation the desktop twin carries.\n */\ninterface TrustedInputSeam {\n  clickElement: (params: ClickElementParams) => Promise<void>;\n  clickMouse: (params: ClickMouseParams) => Promise<void>;\n  hoverElement: (params: HoverElementParams) => Promise<void>;\n  moveMouse: (params: MoveMouseParams) => Promise<void>;\n  pressKey: (params: PressKeyParams) => Promise<void>;\n  typeIntoEditor: (params: TypeIntoEditorParams) => Promise<void>;\n  unhoverElement: (params: UnhoverElementParams) => Promise<void>;\n}\n\n/**\n * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host\n * over CDP.\n *\n * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens\n * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing\n * one would be worse than saying so.\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  await getSeamFunction('clickElement')(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.\n *\n * The coordinates are CSS pixels in the WebView's own viewport \u2014 which is what CDP takes \u2014 so\n * `devicePixelRatio` never enters the picture.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  await getSeamFunction('clickMouse')(params);\n}\n\n/**\n * Always throws: `:hover` has no touch equivalent.\n *\n * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm\n * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with\n * {@link clickElement}.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  await getSeamFunction('hoverElement')(params);\n}\n\n/**\n * Always throws: a touch screen has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  await getSeamFunction('moveMouse')(params);\n}\n\n/**\n * Presses a single key using **trusted** keyboard input, injected by the host over CDP.\n *\n * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable\n * characters are supported; anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  await getSeamFunction('pressKey')(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.\n *\n * Focuses the editor (caret to the end), presses every code point of the text, then polls until the\n * document reflects the input or a bounded timeout elapses.\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  await getSeamFunction('typeIntoEditor')(params);\n}\n\n/**\n * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  await getSeamFunction('unhoverElement')(params);\n}\n\nfunction getSeamFunction<Key extends keyof TrustedInputSeam>(name: Key): TrustedInputSeam[Key] {\n  // eslint-disable-next-line obsidianmd/no-global-this -- The harness installs its namespace on the realm global; there is nowhere else to read it from.\n  const holder = globalThis as Partial<ObsidianIntegrationTestingHolder>;\n  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];\n  if (!seamFunction) {\n    throw new Error(\n      `Trusted input is unavailable on mobile: \\`window.__obsidianIntegrationTesting.trustedInput.${name}\\` is not installed. `\n        + 'A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the '\n        + '`obsidian-integration-testing` Appium transport\\'s channel \u2014 which means these helpers only work inside an app that '\n        + 'harness bootstrapped.'\n    );\n  }\n\n  return seamFunction;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsFA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAWA,eAAsB,WAAW,QAAyC;AACxE,QAAM,gBAAgB,YAAY,EAAE,MAAM;AAC5C;AAYA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAQA,eAAsB,UAAU,QAAwC;AACtE,QAAM,gBAAgB,WAAW,EAAE,MAAM;AAC3C;AAWA,eAAsB,SAAS,QAAuC;AACpE,QAAM,gBAAgB,UAAU,EAAE,MAAM;AAC1C;AAWA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAQA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAEA,SAAS,gBAAoD,MAAkC;AAE7F,QAAM,SAAS;AACf,QAAM,eAAe,OAAO,8BAA8B,eAAe,IAAI;AAC7E,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR,8FAA8F,IAAI;AAAA,IAIpG;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


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

@@ -0,0 +1,98 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone —
+ * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted — so the injection
+ * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's
+ * binding channel, and the host injects it into the WebView over CDP — as `Input.dispatchTouchEvent` for
+ * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past
+ * Android's gesture recognizer and so is classified as a tap at any dwell.
+ *
+ * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the
+ * harness rather than reimplementing the wire format: they call
+ * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness
+ * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics —
+ * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws
+ * for the `:hover` helpers — identical to the harness's own copy for free, instead of a second
+ * implementation to hand-sync.
+ *
+ * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in
+ * either direction, at runtime or in types.
+ *
+ * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.
+ * Outside one they throw a message saying so, rather than silently doing nothing — a no-op would recreate
+ * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct
+ * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.
+ *
+ * The params are forwarded untouched, `window` included, so the harness's own refusal of any window but
+ * the main one applies here too: Obsidian Mobile has no popout windows to send input to.
+ */
+import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.cjs';
+/**
+ * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host
+ * over CDP.
+ *
+ * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens
+ * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing
+ * one would be worse than saying so.
+ *
+ * @param params - The element to click, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickElement(params: ClickElementParams): Promise<void>;
+/**
+ * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.
+ *
+ * The coordinates are CSS pixels in the WebView's own viewport — which is what CDP takes — so
+ * `devicePixelRatio` never enters the picture.
+ *
+ * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickMouse(params: ClickMouseParams): Promise<void>;
+/**
+ * Always throws: `:hover` has no touch equivalent.
+ *
+ * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm
+ * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with
+ * {@link clickElement}.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that never resolves — the call throws.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Always throws: a touch screen has no persistent pointer to move.
+ *
+ * @param params - The viewport coordinates to move to.
+ * @returns A {@link Promise} that never resolves — the call throws.
+ */
+export declare function moveMouse(params: MoveMouseParams): Promise<void>;
+/**
+ * Presses a single key using **trusted** keyboard input, injected by the host over CDP.
+ *
+ * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable
+ * characters are supported; anything else throws rather than pressing nothing.
+ *
+ * @param params - The key to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the key press has been injected.
+ */
+export declare function pressKey(params: PressKeyParams): Promise<void>;
+/**
+ * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.
+ *
+ * Focuses the editor (caret to the end), presses every code point of the text, then polls until the
+ * document reflects the input or a bounded timeout elapses.
+ *
+ * @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>;
+/**
+ * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that never resolves — the call throws.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;