obsidian-integration-testing 9.2.2 → 10.0.0

package/dist/lib/esm/electron-compatibility.d.mts

@@ -23,31 +23,30 @@
  * is warned.
  */
 import type { ObsidianVersionMetadata } from './obsidian-metadata.mjs';
-/**
- * Parameters for {@link checkElectronCompatibility}.
- */
-export interface CheckElectronCompatibilityParams {
-    /** The Electron version the instance is actually running, or `undefined` when unreadable. */
-    readonly actualElectronVersion: string | undefined;
-    /** The resolved Obsidian app (asar) version that is running. */
-    readonly appVersion: string;
-    /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */
-    readonly metadata: ObsidianVersionMetadata | undefined;
-}
 /**
  * The runtime Electron compatibility verdict for a booted owned instance, carried
  * as data on the transport / connection result so consumers can assert on it.
  */
 export interface ElectronCompatibility {
-    /** The Electron version the instance is actually running, or `null` when unreadable. */
+    /**
+    The Electron version the instance is actually running, or `null` when unreadable.
+     */
     readonly actualElectronVersion: null | string;
-    /** The resolved Obsidian app (asar) version that is running. */
+    /**
+    The resolved Obsidian app (asar) version that is running.
+     */
     readonly appVersion: string;
-    /** A human-readable explanation, present for the `'nagged'` tier. */
+    /**
+    A human-readable explanation, present for the `'nagged'` tier.
+     */
     readonly message?: string;
-    /** The app's recommended-minimum Electron version, when the table carries one. */
+    /**
+    The app's recommended-minimum Electron version, when the table carries one.
+     */
     readonly minRecommendedElectronVersion?: string;
-    /** The resolved compatibility tier. */
+    /**
+    The resolved compatibility tier.
+     */
     readonly tier: ElectronCompatibilityTier;
 }
 /**
@@ -60,6 +59,23 @@ export interface ElectronCompatibility {
  *   app version carries no recommended Electron version in the table).
  */
 export type ElectronCompatibilityTier = 'nagged' | 'ok' | 'unknown';
+/**
+ * Parameters for {@link resolveElectronCompatibility}.
+ */
+export interface ResolveElectronCompatibilityParams {
+    /**
+    The Electron version the instance is actually running, or `undefined` when unreadable.
+     */
+    readonly actualElectronVersion: string | undefined;
+    /**
+    The resolved Obsidian app (asar) version that is running.
+     */
+    readonly appVersion: string;
+    /**
+    The `metadata.json` entry for {@link appVersion}, or `undefined` when absent.
+     */
+    readonly metadata: ObsidianVersionMetadata | undefined;
+}
 /**
  * Computes the runtime Electron compatibility verdict for a booted owned instance.
  *
@@ -71,4 +87,4 @@ export type ElectronCompatibilityTier = 'nagged' | 'ok' | 'unknown';
  *   version's metadata entry.
  * @returns The compatibility verdict.
  */
-export declare function checkElectronCompatibility(params: CheckElectronCompatibilityParams): ElectronCompatibility;
+export declare function resolveElectronCompatibility(params: ResolveElectronCompatibilityParams): ElectronCompatibility;

package/dist/lib/esm/electron-compatibility.mjs

@@ -1,5 +1,5 @@
 import { compareVersions } from "./obsidian-version.mjs";
-function checkElectronCompatibility(params) {
+function resolveElectronCompatibility(params) {
   const { actualElectronVersion, appVersion, metadata } = params;
   const minRecommendedElectronVersion = metadata?.minRecommendedElectronVersion;
   if (actualElectronVersion === void 0 || minRecommendedElectronVersion === void 0) {
@@ -17,6 +17,6 @@ function checkElectronCompatibility(params) {
   return { actualElectronVersion, appVersion, minRecommendedElectronVersion, tier: "ok" };
 }
 export {
-  checkElectronCompatibility
+  resolveElectronCompatibility
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/{cjs/emulator-args.d.cts → esm/emulator-arguments.d.mts}

@@ -4,10 +4,12 @@
  * Builds the argument list for spawning the Android emulator.
  */
 /**
- * Parameters for {@link buildEmulatorArgs}.
+ * Parameters for {@link buildEmulatorArguments}.
  */
-export interface BuildEmulatorArgsParams {
-    /** The Android Virtual Device name. */
+export interface BuildEmulatorArgumentsParams {
+    /**
+    The Android Virtual Device name.
+     */
     readonly avdName: string;
     /**
      * Whether to run the emulator headless (`-no-window`), so it never steals
@@ -21,4 +23,4 @@ export interface BuildEmulatorArgsParams {
  * @param params - The emulator argument parameters.
  * @returns The argument array to pass to the emulator binary.
  */
-export declare function buildEmulatorArgs(params: BuildEmulatorArgsParams): string[];
+export declare function buildEmulatorArguments(params: BuildEmulatorArgumentsParams): string[];

package/dist/lib/esm/emulator-arguments.mjs

@@ -0,0 +1,12 @@
+const DNS_SERVER = "8.8.8.8";
+function buildEmulatorArguments(params) {
+  const emulatorArguments = ["-avd", params.avdName, "-no-snapshot-save", "-dns-server", DNS_SERVER];
+  if (params.isHidden) {
+    emulatorArguments.push("-no-window");
+  }
+  return emulatorArguments;
+}
+export {
+  buildEmulatorArguments
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3VtZW50cy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEJ1aWxkcyB0aGUgYXJndW1lbnQgbGlzdCBmb3Igc3Bhd25pbmcgdGhlIEFuZHJvaWQgZW11bGF0b3IuXG4gKi9cblxuY29uc3QgRE5TX1NFUlZFUiA9ICc4LjguOC44JztcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRFbXVsYXRvckFyZ3VtZW50c30uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQnVpbGRFbXVsYXRvckFyZ3VtZW50c1BhcmFtcyB7XG4gIC8qKlxuICBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgYXZkTmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIHJ1biB0aGUgZW11bGF0b3IgaGVhZGxlc3MgKGAtbm8td2luZG93YCksIHNvIGl0IG5ldmVyIHN0ZWFsc1xuICAgKiBmb2N1cy4gUmVzb2x2ZWQgZnJvbSB0aGUgYGlzRW11bGF0b3JWaXNpYmxlYCB0cmFuc3BvcnQgb3B0aW9uLlxuICAgKi9cbiAgcmVhZG9ubHkgaXNIaWRkZW46IGJvb2xlYW47XG59XG5cbi8qKlxuICogQnVpbGRzIHRoZSBhcmd1bWVudCBsaXN0IGZvciBzcGF3bmluZyB0aGUgQW5kcm9pZCBlbXVsYXRvci5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIGVtdWxhdG9yIGFyZ3VtZW50IHBhcmFtZXRlcnMuXG4gKiBAcmV0dXJucyBUaGUgYXJndW1lbnQgYXJyYXkgdG8gcGFzcyB0byB0aGUgZW11bGF0b3IgYmluYXJ5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRFbXVsYXRvckFyZ3VtZW50cyhwYXJhbXM6IEJ1aWxkRW11bGF0b3JBcmd1bWVudHNQYXJhbXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IGVtdWxhdG9yQXJndW1lbnRzID0gWyctYXZkJywgcGFyYW1zLmF2ZE5hbWUsICctbm8tc25hcHNob3Qtc2F2ZScsICctZG5zLXNlcnZlcicsIEROU19TRVJWRVJdO1xuICBpZiAocGFyYW1zLmlzSGlkZGVuKSB7XG4gICAgZW11bGF0b3JBcmd1bWVudHMucHVzaCgnLW5vLXdpbmRvdycpO1xuICB9XG4gIHJldHVybiBlbXVsYXRvckFyZ3VtZW50cztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQU1BLE1BQU0sYUFBYTtBQXdCWixTQUFTLHVCQUF1QixRQUFnRDtBQUNyRixRQUFNLG9CQUFvQixDQUFDLFFBQVEsT0FBTyxTQUFTLHFCQUFxQixlQUFlLFVBQVU7QUFDakcsTUFBSSxPQUFPLFVBQVU7QUFDbkIsc0JBQWtCLEtBQUssWUFBWTtBQUFBLEVBQ3JDO0FBQ0EsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/enable-plugin.d.mts

@@ -4,7 +4,7 @@
  * Shared helper for enabling an Obsidian plugin with error capture.
  * Used by both the global setup and integration tests.
  */
-import type { CommonArgs } from './eval-in-obsidian.mjs';
+import type { CommonArguments } from './eval-in-obsidian.mjs';
 /**
  * Parameters for {@link enablePluginWithErrorCapture}.
  */
@@ -51,14 +51,14 @@ export interface EnablePluginResult {
  * Obsidian's `enablePlugin` try-catch swallows them. The original method
  * is always restored in a `finally` block.
  *
- * Designed to be passed as the `fn` argument to {@link evalInObsidian}.
+ * Designed to be passed as the `callback` argument to {@link evalInObsidian}.
  *
- * @param args - The common args plus the plugin ID.
- * @param args.app - The Obsidian app instance.
- * @param args.pluginId - The ID of the plugin to enable.
+ * @param input - The common input plus the plugin ID.
+ * @param input.app - The Obsidian app instance.
+ * @param input.pluginId - The ID of the plugin to enable.
  * @returns The enable result with error message and enabled status.
  */
-export declare function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult>;
+export declare function enablePluginWithErrorCapture({ app, pluginId }: CommonArguments & EnablePluginParams): Promise<EnablePluginResult>;
 /**
  * The generic last-resort message shown when a plugin is in the enabled set but
  * not loaded and no real error could be captured (neither the `loadPlugin`

package/dist/lib/esm/enable-plugin.mjs

@@ -2,7 +2,7 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
   if (!app.plugins.isEnabled()) {
     await app.plugins.setEnable(true);
   }
-  if (app.plugins.enabledPlugins.has(pluginId) && !(pluginId in app.plugins.plugins)) {
+  if (app.plugins.enabledPlugins.has(pluginId) && !Object.hasOwn(app.plugins.plugins, pluginId)) {
     await app.plugins.disablePluginAndSave(pluginId);
   }
   let errorMessage;
@@ -13,61 +13,61 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
       errorMessage = void 0;
       return result;
     } catch (error) {
-      const holder = window;
+      const holder = globalThis;
       errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);
       throw error;
     }
   };
   const capturedConsole = [];
-  const formatHolder = window;
-  function formatArg(arg) {
-    if (arg instanceof Error) {
-      return formatHolder.__obsidianIntegrationTesting?.errorToString(arg) ?? String(arg);
+  const formatHolder = globalThis;
+  function formatArgument(argument) {
+    if (argument instanceof Error) {
+      return formatHolder.__obsidianIntegrationTesting?.errorToString(argument) ?? String(argument);
     }
-    if (typeof arg === "string") {
-      return arg;
+    if (typeof argument === "string") {
+      return argument;
     }
-    if (arg === void 0 || arg === null) {
-      return String(arg);
+    if (argument === void 0 || argument === null) {
+      return String(argument);
     }
-    const json = JSON.stringify(arg);
-    return json ?? Object.prototype.toString.call(arg);
+    const json = JSON.stringify(argument);
+    return json ?? Object.prototype.toString.call(argument);
   }
-  function recordConsole(...args) {
-    capturedConsole.push(args.map(formatArg).join(" "));
+  function recordConsole(...input) {
+    capturedConsole.push(input.map((argument) => formatArgument(argument)).join(" "));
   }
   const origConsoleError = console.error;
   const origConsoleWarn = console.warn;
-  console.error = (...args) => {
-    recordConsole(...args);
-    origConsoleError.apply(console, args);
+  console.error = (...input) => {
+    recordConsole(...input);
+    origConsoleError.apply(console, input);
   };
-  console.warn = (...args) => {
-    recordConsole(...args);
-    origConsoleWarn.apply(console, args);
+  console.warn = (...input) => {
+    recordConsole(...input);
+    origConsoleWarn.apply(console, input);
   };
   function onWindowError(event) {
-    capturedConsole.push(event.error instanceof Error ? formatArg(event.error) : event.message);
+    capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);
   }
   function onUnhandledRejection(event) {
-    capturedConsole.push(formatArg(event.reason));
+    capturedConsole.push(formatArgument(event.reason));
   }
-  window.addEventListener("error", onWindowError);
-  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  globalThis.addEventListener("error", onWindowError);
+  globalThis.addEventListener("unhandledrejection", onUnhandledRejection);
   try {
     await app.plugins.enablePluginAndSave(pluginId);
   } finally {
     app.plugins.loadPlugin = origLoadPlugin;
     console.error = origConsoleError;
     console.warn = origConsoleWarn;
-    window.removeEventListener("error", onWindowError);
-    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+    globalThis.removeEventListener("error", onWindowError);
+    globalThis.removeEventListener("unhandledrejection", onUnhandledRejection);
   }
-  const isLoaded = pluginId in app.plugins.plugins;
+  const isLoaded = Object.hasOwn(app.plugins.plugins, pluginId);
   let rendererConsoleErrors;
   if (!errorMessage && !isLoaded) {
     const joined = capturedConsole.join("\n").trim();
-    rendererConsoleErrors = joined ? joined : void 0;
+    rendererConsoleErrors = joined || void 0;
   }
   return {
     errorMessage,
@@ -83,4 +83,4 @@ export {
   enablePluginWithErrorCapture,
   getGenericPluginLoadFailureMessage
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/enable-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helper for enabling an Obsidian plugin with error capture.\n * Used by both the global setup and integration tests.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Plugin } from 'obsidian';\n\nimport type { CommonArgs } from './eval-in-obsidian.mjs';\n\n/**\n * Parameters for {@link enablePluginWithErrorCapture}.\n */\nexport interface EnablePluginParams {\n  /**\n   * The ID of the plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Result of enabling a plugin with error capture.\n */\nexport interface EnablePluginResult {\n  /**\n   * The error message captured by the `loadPlugin` monkey-patch, or `undefined`\n   * when the patch saw no throw. When Obsidian swallows the error *before* the\n   * patch (leaving this empty) but the plugin still failed to load, the real\n   * cause \u2014 if it reached the renderer console \u2014 is in {@link EnablePluginResult.rendererConsoleErrors}.\n   */\n  readonly errorMessage: string | undefined;\n\n  /**\n   * Whether the plugin is in the enabled set after the enable attempt.\n   * A plugin can be \"enabled\" (configured) but not \"loaded\" (failed to initialize).\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Whether the plugin instance actually exists in `app.plugins.plugins`.\n   * This is the definitive check \u2014 a plugin that is enabled but not loaded has failed.\n   */\n  readonly isLoaded: boolean;\n\n  /**\n   * Console/error output captured in the renderer during the enable window \u2014\n   * populated **only** when the plugin failed to load and the monkey-patch saw\n   * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would\n   * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.\n   * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).\n   */\n  readonly rendererConsoleErrors: string | undefined;\n}\n\ninterface IntegrationTestingErrorToString {\n  errorToString(error: unknown): string;\n}\n\ninterface IntegrationTestingHolder {\n  __obsidianIntegrationTesting: IntegrationTestingErrorToString;\n}\n\n/**\n * Enables a plugin inside Obsidian and captures any load error.\n *\n * Monkey-patches `app.plugins.loadPlugin` to intercept errors before\n * Obsidian's `enablePlugin` try-catch swallows them. The original method\n * is always restored in a `finally` block.\n *\n * Designed to be passed as the `fn` argument to {@link evalInObsidian}.\n *\n * @param args - The common args plus the plugin ID.\n * @param args.app - The Obsidian app instance.\n * @param args.pluginId - The ID of the plugin to enable.\n * @returns The enable result with error message and enabled status.\n */\nexport async function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult> {\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n\n  /*\n   * Force a genuine reload when retrying. If a prior attempt left the plugin in\n   * the enabled set but not loaded (the cold-boot race), a plain re-enable can\n   * short-circuit on some Obsidian versions without re-attempting the load.\n   * Fully reset the enabled state first so the `enablePluginAndSave` below is a\n   * real fresh enable + load. No-op on the first attempt (not yet enabled).\n   */\n  if (app.plugins.enabledPlugins.has(pluginId) && !(pluginId in app.plugins.plugins)) {\n    await app.plugins.disablePluginAndSave(pluginId);\n  }\n\n  let errorMessage: string | undefined;\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Intentional monkey-patch; restored in finally.\n  const origLoadPlugin = app.plugins.loadPlugin;\n  app.plugins.loadPlugin = async function loadPlugin(id: string, isUserEnabled?: boolean): Promise<Plugin> {\n    try {\n      const result = await origLoadPlugin.call(this, id, isUserEnabled);\n      errorMessage = undefined;\n      return result;\n    } catch (error) {\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n      const holder = window as unknown as Partial<IntegrationTestingHolder>;\n      errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);\n      throw error;\n    }\n  };\n\n  /*\n   * Layer 1 \u2014 capture the renderer console + uncaught errors for the duration of\n   * the enable. If Obsidian swallows the load error before the monkey-patch above\n   * sees it (leaving `errorMessage` empty), the real cause is typically still\n   * `console.error`'d, so capturing it here surfaces it in place of the generic\n   * fallback. Works on desktop and Android alike since this whole function is\n   * serialized and injected into the renderer.\n   */\n  const capturedConsole: string[] = [];\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast, same rationale as above.\n  const formatHolder = window as unknown as Partial<IntegrationTestingHolder>;\n  function formatArg(arg: unknown): string {\n    if (arg instanceof Error) {\n      return formatHolder.__obsidianIntegrationTesting?.errorToString(arg) ?? String(arg);\n    }\n    if (typeof arg === 'string') {\n      return arg;\n    }\n    if (arg === undefined || arg === null) {\n      return String(arg);\n    }\n    const json = JSON.stringify(arg);\n    return json ?? Object.prototype.toString.call(arg);\n  }\n  function recordConsole(...args: unknown[]): void {\n    capturedConsole.push(args.map(formatArg).join(' '));\n  }\n  const origConsoleError = console.error;\n  const origConsoleWarn = console.warn;\n  console.error = (...args: unknown[]): void => {\n    recordConsole(...args);\n    origConsoleError.apply(console, args);\n  };\n  console.warn = (...args: unknown[]): void => {\n    recordConsole(...args);\n    origConsoleWarn.apply(console, args);\n  };\n  function onWindowError(event: ErrorEvent): void {\n    capturedConsole.push(event.error instanceof Error ? formatArg(event.error) : event.message);\n  }\n  function onUnhandledRejection(event: PromiseRejectionEvent): void {\n    capturedConsole.push(formatArg(event.reason));\n  }\n  window.addEventListener('error', onWindowError);\n  window.addEventListener('unhandledrejection', onUnhandledRejection);\n\n  try {\n    await app.plugins.enablePluginAndSave(pluginId);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Intentional restore of monkey-patch.\n    app.plugins.loadPlugin = origLoadPlugin;\n    console.error = origConsoleError;\n    console.warn = origConsoleWarn;\n    window.removeEventListener('error', onWindowError);\n    window.removeEventListener('unhandledrejection', onUnhandledRejection);\n  }\n\n  const isLoaded = pluginId in app.plugins.plugins;\n\n  let rendererConsoleErrors: string | undefined;\n  if (!errorMessage && !isLoaded) {\n    const joined = capturedConsole.join('\\n').trim();\n    rendererConsoleErrors = joined ? joined : undefined;\n  }\n\n  return {\n    errorMessage,\n    isEnabled: app.plugins.enabledPlugins.has(pluginId),\n    isLoaded,\n    rendererConsoleErrors\n  };\n}\n\n/**\n * The generic last-resort message shown when a plugin is in the enabled set but\n * not loaded and no real error could be captured (neither the `loadPlugin`\n * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a\n * cause).\n *\n * Host-side helper \u2014 used by the setup orchestration to compose the final\n * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}\n * stays self-contained.\n *\n * @param pluginId - The ID of the plugin that failed to load.\n * @returns The generic failure message.\n */\nexport function getGenericPluginLoadFailureMessage(pluginId: string): string {\n  return `Plugin \"${pluginId}\" is in the enabled set but not loaded. `\n    + 'Obsidian may have caught the error before the monkey-patch. '\n    + 'Check the Obsidian console for details.';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA+EA,eAAsB,6BAA6B,EAAE,KAAK,SAAS,GAAiE;AAClI,MAAI,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5B,UAAM,IAAI,QAAQ,UAAU,IAAI;AAAA,EAClC;AASA,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,KAAK,EAAE,YAAY,IAAI,QAAQ,UAAU;AAClF,UAAM,IAAI,QAAQ,qBAAqB,QAAQ;AAAA,EACjD;AAEA,MAAI;AAEJ,QAAM,iBAAiB,IAAI,QAAQ;AACnC,MAAI,QAAQ,aAAa,eAAe,WAAW,IAAY,eAA0C;AACvG,QAAI;AACF,YAAM,SAAS,MAAM,eAAe,KAAK,MAAM,IAAI,aAAa;AAChE,qBAAe;AACf,aAAO;AAAA,IACT,SAAS,OAAO;AAEd,YAAM,SAAS;AACf,qBAAe,OAAO,8BAA8B,cAAc,KAAK,KAAK,OAAO,KAAK;AACxF,YAAM;AAAA,IACR;AAAA,EACF;AAUA,QAAM,kBAA4B,CAAC;AAEnC,QAAM,eAAe;AACrB,WAAS,UAAU,KAAsB;AACvC,QAAI,eAAe,OAAO;AACxB,aAAO,aAAa,8BAA8B,cAAc,GAAG,KAAK,OAAO,GAAG;AAAA,IACpF;AACA,QAAI,OAAO,QAAQ,UAAU;AAC3B,aAAO;AAAA,IACT;AACA,QAAI,QAAQ,UAAa,QAAQ,MAAM;AACrC,aAAO,OAAO,GAAG;AAAA,IACnB;AACA,UAAM,OAAO,KAAK,UAAU,GAAG;AAC/B,WAAO,QAAQ,OAAO,UAAU,SAAS,KAAK,GAAG;AAAA,EACnD;AACA,WAAS,iBAAiB,MAAuB;AAC/C,oBAAgB,KAAK,KAAK,IAAI,SAAS,EAAE,KAAK,GAAG,CAAC;AAAA,EACpD;AACA,QAAM,mBAAmB,QAAQ;AACjC,QAAM,kBAAkB,QAAQ;AAChC,UAAQ,QAAQ,IAAI,SAA0B;AAC5C,kBAAc,GAAG,IAAI;AACrB,qBAAiB,MAAM,SAAS,IAAI;AAAA,EACtC;AACA,UAAQ,OAAO,IAAI,SAA0B;AAC3C,kBAAc,GAAG,IAAI;AACrB,oBAAgB,MAAM,SAAS,IAAI;AAAA,EACrC;AACA,WAAS,cAAc,OAAyB;AAC9C,oBAAgB,KAAK,MAAM,iBAAiB,QAAQ,UAAU,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EAC5F;AACA,WAAS,qBAAqB,OAAoC;AAChE,oBAAgB,KAAK,UAAU,MAAM,MAAM,CAAC;AAAA,EAC9C;AACA,SAAO,iBAAiB,SAAS,aAAa;AAC9C,SAAO,iBAAiB,sBAAsB,oBAAoB;AAElE,MAAI;AACF,UAAM,IAAI,QAAQ,oBAAoB,QAAQ;AAAA,EAChD,UAAE;AAEA,QAAI,QAAQ,aAAa;AACzB,YAAQ,QAAQ;AAChB,YAAQ,OAAO;AACf,WAAO,oBAAoB,SAAS,aAAa;AACjD,WAAO,oBAAoB,sBAAsB,oBAAoB;AAAA,EACvE;AAEA,QAAM,WAAW,YAAY,IAAI,QAAQ;AAEzC,MAAI;AACJ,MAAI,CAAC,gBAAgB,CAAC,UAAU;AAC9B,UAAM,SAAS,gBAAgB,KAAK,IAAI,EAAE,KAAK;AAC/C,4BAAwB,SAAS,SAAS;AAAA,EAC5C;AAEA,SAAO;AAAA,IACL;AAAA,IACA,WAAW,IAAI,QAAQ,eAAe,IAAI,QAAQ;AAAA,IAClD;AAAA,IACA;AAAA,EACF;AACF;AAeO,SAAS,mCAAmC,UAA0B;AAC3E,SAAO,WAAW,QAAQ;AAG5B;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/enable-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helper for enabling an Obsidian plugin with error capture.\n * Used by both the global setup and integration tests.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Plugin } from 'obsidian';\n\nimport type { CommonArguments } from './eval-in-obsidian.mjs';\n\n/**\n * Parameters for {@link enablePluginWithErrorCapture}.\n */\nexport interface EnablePluginParams {\n  /**\n   * The ID of the plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Result of enabling a plugin with error capture.\n */\nexport interface EnablePluginResult {\n  /**\n   * The error message captured by the `loadPlugin` monkey-patch, or `undefined`\n   * when the patch saw no throw. When Obsidian swallows the error *before* the\n   * patch (leaving this empty) but the plugin still failed to load, the real\n   * cause \u2014 if it reached the renderer console \u2014 is in {@link EnablePluginResult.rendererConsoleErrors}.\n   */\n  readonly errorMessage: string | undefined;\n\n  /**\n   * Whether the plugin is in the enabled set after the enable attempt.\n   * A plugin can be \"enabled\" (configured) but not \"loaded\" (failed to initialize).\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Whether the plugin instance actually exists in `app.plugins.plugins`.\n   * This is the definitive check \u2014 a plugin that is enabled but not loaded has failed.\n   */\n  readonly isLoaded: boolean;\n\n  /**\n   * Console/error output captured in the renderer during the enable window \u2014\n   * populated **only** when the plugin failed to load and the monkey-patch saw\n   * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would\n   * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.\n   * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).\n   */\n  readonly rendererConsoleErrors: string | undefined;\n}\n\ninterface IntegrationTestingErrorToString {\n  errorToString(error: unknown): string;\n}\n\ninterface IntegrationTestingHolder {\n  __obsidianIntegrationTesting: IntegrationTestingErrorToString;\n}\n\n/**\n * Enables a plugin inside Obsidian and captures any load error.\n *\n * Monkey-patches `app.plugins.loadPlugin` to intercept errors before\n * Obsidian's `enablePlugin` try-catch swallows them. The original method\n * is always restored in a `finally` block.\n *\n * Designed to be passed as the `callback` argument to {@link evalInObsidian}.\n *\n * @param input - The common input plus the plugin ID.\n * @param input.app - The Obsidian app instance.\n * @param input.pluginId - The ID of the plugin to enable.\n * @returns The enable result with error message and enabled status.\n */\nexport async function enablePluginWithErrorCapture({ app, pluginId }: CommonArguments & EnablePluginParams): Promise<EnablePluginResult> {\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n\n  /*\n   * Force a genuine reload when retrying. If a prior attempt left the plugin in\n   * the enabled set but not loaded (the cold-boot race), a plain re-enable can\n   * short-circuit on some Obsidian versions without re-attempting the load.\n   * Fully reset the enabled state first so the `enablePluginAndSave` below is a\n   * real fresh enable + load. No-op on the first attempt (not yet enabled).\n   */\n  if (app.plugins.enabledPlugins.has(pluginId) && !Object.hasOwn(app.plugins.plugins, pluginId)) {\n    await app.plugins.disablePluginAndSave(pluginId);\n  }\n\n  let errorMessage: string | undefined;\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Intentional monkey-patch; restored in finally.\n  const origLoadPlugin = app.plugins.loadPlugin;\n  app.plugins.loadPlugin = async function loadPlugin(id: string, isUserEnabled?: boolean): Promise<Plugin> {\n    try {\n      const result = await origLoadPlugin.call(this, id, isUserEnabled);\n      errorMessage = undefined;\n      return result;\n    } catch (error) {\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n      const holder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n      errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);\n      throw error;\n    }\n  };\n\n  /*\n   * Layer 1 \u2014 capture the renderer console + uncaught errors for the duration of\n   * the enable. If Obsidian swallows the load error before the monkey-patch above\n   * sees it (leaving `errorMessage` empty), the real cause is typically still\n   * `console.error`'d, so capturing it here surfaces it in place of the generic\n   * fallback. Works on desktop and Android alike since this whole function is\n   * serialized and injected into the renderer.\n   */\n  const capturedConsole: string[] = [];\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast, same rationale as above.\n  const formatHolder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n  function formatArgument(argument: unknown): string {\n    if (argument instanceof Error) {\n      return formatHolder.__obsidianIntegrationTesting?.errorToString(argument) ?? String(argument);\n    }\n    if (typeof argument === 'string') {\n      return argument;\n    }\n    if (argument === undefined || argument === null) {\n      return String(argument);\n    }\n    const json = JSON.stringify(argument);\n    return json ?? Object.prototype.toString.call(argument);\n  }\n  function recordConsole(...input: unknown[]): void {\n    capturedConsole.push(input.map((argument) => formatArgument(argument)).join(' '));\n  }\n  const origConsoleError = console.error;\n  const origConsoleWarn = console.warn;\n  console.error = (...input: unknown[]): void => {\n    recordConsole(...input);\n    origConsoleError.apply(console, input);\n  };\n  console.warn = (...input: unknown[]): void => {\n    recordConsole(...input);\n    origConsoleWarn.apply(console, input);\n  };\n  function onWindowError(event: ErrorEvent): void {\n    capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);\n  }\n  function onUnhandledRejection(event: PromiseRejectionEvent): void {\n    capturedConsole.push(formatArgument(event.reason));\n  }\n  globalThis.addEventListener('error', onWindowError);\n  globalThis.addEventListener('unhandledrejection', onUnhandledRejection);\n\n  try {\n    await app.plugins.enablePluginAndSave(pluginId);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Intentional restore of monkey-patch.\n    app.plugins.loadPlugin = origLoadPlugin;\n    console.error = origConsoleError;\n    console.warn = origConsoleWarn;\n    globalThis.removeEventListener('error', onWindowError);\n    globalThis.removeEventListener('unhandledrejection', onUnhandledRejection);\n  }\n\n  const isLoaded = Object.hasOwn(app.plugins.plugins, pluginId);\n\n  let rendererConsoleErrors: string | undefined;\n  if (!errorMessage && !isLoaded) {\n    const joined = capturedConsole.join('\\n').trim();\n    rendererConsoleErrors = joined || undefined;\n  }\n\n  return {\n    errorMessage,\n    isEnabled: app.plugins.enabledPlugins.has(pluginId),\n    isLoaded,\n    rendererConsoleErrors\n  };\n}\n\n/**\n * The generic last-resort message shown when a plugin is in the enabled set but\n * not loaded and no real error could be captured (neither the `loadPlugin`\n * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a\n * cause).\n *\n * Host-side helper \u2014 used by the setup orchestration to compose the final\n * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}\n * stays self-contained.\n *\n * @param pluginId - The ID of the plugin that failed to load.\n * @returns The generic failure message.\n */\nexport function getGenericPluginLoadFailureMessage(pluginId: string): string {\n  return `Plugin \"${pluginId}\" is in the enabled set but not loaded. `\n    + 'Obsidian may have caught the error before the monkey-patch. '\n    + 'Check the Obsidian console for details.';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA+EA,eAAsB,6BAA6B,EAAE,KAAK,SAAS,GAAsE;AACvI,MAAI,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5B,UAAM,IAAI,QAAQ,UAAU,IAAI;AAAA,EAClC;AASA,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,KAAK,CAAC,OAAO,OAAO,IAAI,QAAQ,SAAS,QAAQ,GAAG;AAC7F,UAAM,IAAI,QAAQ,qBAAqB,QAAQ;AAAA,EACjD;AAEA,MAAI;AAEJ,QAAM,iBAAiB,IAAI,QAAQ;AACnC,MAAI,QAAQ,aAAa,eAAe,WAAW,IAAY,eAA0C;AACvG,QAAI;AACF,YAAM,SAAS,MAAM,eAAe,KAAK,MAAM,IAAI,aAAa;AAChE,qBAAe;AACf,aAAO;AAAA,IACT,SAAS,OAAO;AAEd,YAAM,SAAS;AACf,qBAAe,OAAO,8BAA8B,cAAc,KAAK,KAAK,OAAO,KAAK;AACxF,YAAM;AAAA,IACR;AAAA,EACF;AAUA,QAAM,kBAA4B,CAAC;AAEnC,QAAM,eAAe;AACrB,WAAS,eAAe,UAA2B;AACjD,QAAI,oBAAoB,OAAO;AAC7B,aAAO,aAAa,8BAA8B,cAAc,QAAQ,KAAK,OAAO,QAAQ;AAAA,IAC9F;AACA,QAAI,OAAO,aAAa,UAAU;AAChC,aAAO;AAAA,IACT;AACA,QAAI,aAAa,UAAa,aAAa,MAAM;AAC/C,aAAO,OAAO,QAAQ;AAAA,IACxB;AACA,UAAM,OAAO,KAAK,UAAU,QAAQ;AACpC,WAAO,QAAQ,OAAO,UAAU,SAAS,KAAK,QAAQ;AAAA,EACxD;AACA,WAAS,iBAAiB,OAAwB;AAChD,oBAAgB,KAAK,MAAM,IAAI,CAAC,aAAa,eAAe,QAAQ,CAAC,EAAE,KAAK,GAAG,CAAC;AAAA,EAClF;AACA,QAAM,mBAAmB,QAAQ;AACjC,QAAM,kBAAkB,QAAQ;AAChC,UAAQ,QAAQ,IAAI,UAA2B;AAC7C,kBAAc,GAAG,KAAK;AACtB,qBAAiB,MAAM,SAAS,KAAK;AAAA,EACvC;AACA,UAAQ,OAAO,IAAI,UAA2B;AAC5C,kBAAc,GAAG,KAAK;AACtB,oBAAgB,MAAM,SAAS,KAAK;AAAA,EACtC;AACA,WAAS,cAAc,OAAyB;AAC9C,oBAAgB,KAAK,MAAM,iBAAiB,QAAQ,eAAe,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACjG;AACA,WAAS,qBAAqB,OAAoC;AAChE,oBAAgB,KAAK,eAAe,MAAM,MAAM,CAAC;AAAA,EACnD;AACA,aAAW,iBAAiB,SAAS,aAAa;AAClD,aAAW,iBAAiB,sBAAsB,oBAAoB;AAEtE,MAAI;AACF,UAAM,IAAI,QAAQ,oBAAoB,QAAQ;AAAA,EAChD,UAAE;AAEA,QAAI,QAAQ,aAAa;AACzB,YAAQ,QAAQ;AAChB,YAAQ,OAAO;AACf,eAAW,oBAAoB,SAAS,aAAa;AACrD,eAAW,oBAAoB,sBAAsB,oBAAoB;AAAA,EAC3E;AAEA,QAAM,WAAW,OAAO,OAAO,IAAI,QAAQ,SAAS,QAAQ;AAE5D,MAAI;AACJ,MAAI,CAAC,gBAAgB,CAAC,UAAU;AAC9B,UAAM,SAAS,gBAAgB,KAAK,IAAI,EAAE,KAAK;AAC/C,4BAAwB,UAAU;AAAA,EACpC;AAEA,SAAO;AAAA,IACL;AAAA,IACA,WAAW,IAAI,QAAQ,eAAe,IAAI,QAAQ;AAAA,IAClD;AAAA,IACA;AAAA,EACF;AACF;AAeO,SAAS,mCAAmC,UAA0B;AAC3E,SAAO,WAAW,QAAQ;AAG5B;",
  "names": []
}


package/dist/lib/esm/eval-in-obsidian.d.mts

@@ -6,12 +6,12 @@
 import type { App, Editor, Modifier, TFile } from 'obsidian';
 import type * as obsidian from 'obsidian';
 import type { Promisable } from 'type-fest';
-import type { ContextArgs, ContextId } from './context-id.mjs';
+import type { ContextArguments, ContextId } from './context-id.mjs';
 import type { ObsidianTransport } from './transport.mjs';
 /**
  * Common arguments automatically provided to every {@link evalInObsidian} callback.
  */
-export interface CommonArgs {
+export interface CommonArguments {
     /**
      * The Obsidian {@link App} instance.
      */
@@ -34,7 +34,7 @@ export interface CommonArgs {
     obsidianModule: typeof obsidian;
 }
 /**
- * Parameters for {@link CommonArgs.createNote}.
+ * Parameters for {@link CommonArguments.createNote}.
  */
 export interface CreateNoteParams {
     /**
@@ -50,12 +50,11 @@ export interface CreateNoteParams {
 /**
  * Parameters for {@link evalInObsidian}.
  */
-export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
+export interface EvalInObsidianParams<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
     /**
-     * Additional arguments to pass to the function. Values may include functions —
-     * they are serialized via `toString()`.
+     * The function to evaluate in the Obsidian context.
      */
-    readonly args?: Args;
+    callback(input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<Result>;
     /**
      * A {@link ContextId} linking this call to a persistent store on `window`
      * in the Obsidian process. The callback receives a typed `context` object
@@ -65,9 +64,10 @@ export interface EvalInObsidianParams<Args extends GenericObject, Result, TConte
      */
     readonly contextId?: TContextId;
     /**
-     * The function to evaluate in the Obsidian context.
+     * Additional arguments to pass to the function. Values may include functions —
+     * they are serialized via `toString()`.
      */
-    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
+    readonly input?: Input;
     /**
      * Skips pre-flight checks (vault registration, CLI availability).
      * Used internally by vault registration functions.
@@ -90,7 +90,7 @@ export interface EvalInObsidianParams<Args extends GenericObject, Result, TConte
  */
 export type GenericObject = Record<string, unknown>;
 /**
- * Parameters for {@link CommonArgs.hoverElement}.
+ * Parameters for {@link CommonArguments.hoverElement}.
  */
 export interface HoverElementParams {
     /**
@@ -102,7 +102,7 @@ export interface HoverElementParams {
 }
 /**
  * The shared library bag injected into every {@link evalInObsidian} callback as
- * {@link CommonArgs.lib}.
+ * {@link CommonArguments.lib}.
  *
  * Two layers compose into this one bag. The **base** — the harness-provided
  * renderer-driving helpers declared below (the trusted-input primitives and
@@ -281,7 +281,7 @@ export interface Lib {
     waitUntil(this: void, params: WaitUntilParams): Promise<void>;
 }
 /**
- * Parameters for {@link CommonArgs.moveMouse}.
+ * Parameters for {@link CommonArguments.moveMouse}.
  */
 export interface MoveMouseParams {
     /**
@@ -294,7 +294,7 @@ export interface MoveMouseParams {
     readonly y: number;
 }
 /**
- * Parameters for {@link CommonArgs.pressKey}.
+ * Parameters for {@link CommonArguments.pressKey}.
  */
 export interface PressKeyParams {
     /**
@@ -303,7 +303,7 @@ export interface PressKeyParams {
      * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character
      * (`'a'`, `'1'`). The produced character (when the key inserts text) is the
      * literal `key` value; case-correct text belongs to
-     * {@link CommonArgs.typeIntoEditor}, not a key-press primitive.
+     * {@link CommonArguments.typeIntoEditor}, not a key-press primitive.
      */
     readonly key: string;
     /**
@@ -317,7 +317,7 @@ export interface PressKeyParams {
     readonly modifiers?: readonly Modifier[];
 }
 /**
- * Parameters for {@link CommonArgs.typeIntoEditor}.
+ * Parameters for {@link CommonArguments.typeIntoEditor}.
  */
 export interface TypeIntoEditorParams {
     /**
@@ -326,13 +326,13 @@ export interface TypeIntoEditorParams {
      */
     readonly editor: Editor;
     /**
-     * The text to type. Each code point is pressed via {@link CommonArgs.pressKey}
+     * The text to type. Each code point is pressed via {@link CommonArguments.pressKey}
      * (a trusted `keyDown` → `char` → `keyUp`), exactly as a real user typing.
      */
     readonly text: string;
 }
 /**
- * Parameters for {@link CommonArgs.unhoverElement}.
+ * Parameters for {@link CommonArguments.unhoverElement}.
  */
 export interface UnhoverElementParams {
     /**
@@ -344,7 +344,7 @@ export interface UnhoverElementParams {
     readonly element: HTMLElement;
 }
 /**
- * Parameters for {@link CommonArgs.waitUntil}.
+ * Parameters for {@link CommonArguments.waitUntil}.
  */
 export interface WaitUntilParams {
     /**
@@ -377,15 +377,15 @@ export interface WaitUntilParams {
  * Evaluates a function inside the running Obsidian instance
  * via the active transport and returns the parsed result.
  *
- * The function receives an args object that includes `app`, `obsidianModule`,
- * `context`, and any additional `args` passed by the caller.
+ * The function receives an input object that includes `app`, `obsidianModule`,
+ * `context`, and any additional `input` passed by the caller.
  * It is serialized via `toString()` and invoked as an IIFE.
  * The function must be self-contained — closures over local variables will not work.
- * Pass any needed values as `args` — they are JSON-serialized and deserialized on the Obsidian side.
+ * Pass any needed values as `input` — they are JSON-serialized and deserialized on the Obsidian side.
  *
  * The result is `JSON.stringify`'d on the Obsidian side and parsed back.
  *
  * @param params - The parameters for the function to evaluate.
- * @returns A {@link Promise} that resolves to the return value of `fn`.
+ * @returns A {@link Promise} that resolves to the return value of `callback`.
  */
-export declare function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: EvalInObsidianParams<Args, Result, TContextId>): Promise<Result>;
+export declare function evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: EvalInObsidianParams<Input, Result, TContextId>): Promise<Result>;