obsidian-integration-testing 12.1.0 → 12.1.1

package/dist/lib/cjs/device-settings.d.cts

@@ -0,0 +1,94 @@
+/**
+ * @file
+ *
+ * Reads and writes Android device settings — and wraps the one setting a
+ * screenshot suite has to change.
+ *
+ * The screenshot AVDs are built `hw.keyboard=yes`, so Android suppresses the
+ * on-screen keyboard even where the page asks for one. `show_ime_with_hard_keyboard`
+ * is what turns it back on. {@link withSoftKeyboardEnabled} flips it, runs the
+ * work, and puts the device back exactly as it found it — including restoring a
+ * setting that had never been written, which takes a delete rather than a write
+ * (see `device-setting-restore`).
+ *
+ * Every function here shells out, so the whole module is integration-time code;
+ * the restore decision and the argument list it depends on are unit-tested in
+ * their own modules.
+ */
+import type { DeviceSettingNamespace } from './device-settings-command.cjs';
+/**
+ * Parameters for {@link deleteDeviceSetting} and {@link readDeviceSetting}.
+ */
+export interface DeviceSettingParams {
+    /**
+     * The device to address.
+     */
+    readonly deviceId: string;
+    /**
+     * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.
+     */
+    readonly name: string;
+    /**
+     * The settings namespace the name lives in.
+     *
+     * @default {@link DeviceSettingNamespace.Secure}
+     */
+    readonly namespace?: DeviceSettingNamespace;
+}
+/**
+ * Parameters for {@link withSoftKeyboardEnabled}.
+ *
+ * @typeParam T - What the wrapped work returns.
+ */
+export interface WithSoftKeyboardEnabledParams<T> {
+    /**
+     * The work to run while the on-screen keyboard is permitted.
+     */
+    readonly callback: (this: void) => Promise<T>;
+    /**
+     * The device to address.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link writeDeviceSetting}.
+ */
+export interface WriteDeviceSettingParams extends DeviceSettingParams {
+    /**
+     * The value to write.
+     */
+    readonly value: string;
+}
+/**
+ * Clears a device setting, returning it to never-having-been-written.
+ *
+ * @param params - The device, the setting and its namespace.
+ * @returns A {@link Promise} that resolves once the setting is gone.
+ */
+export declare function deleteDeviceSetting(params: DeviceSettingParams): Promise<void>;
+/**
+ * Reads a device setting.
+ *
+ * @param params - The device, the setting and its namespace.
+ * @returns A {@link Promise} that resolves to the setting's value, or the literal `null` when it has never
+ *   been written.
+ */
+export declare function readDeviceSetting(params: DeviceSettingParams): Promise<string>;
+/**
+ * Permits the on-screen keyboard for the duration of a callback, then restores the device exactly.
+ *
+ * The restore runs whether the callback succeeded or threw — a suite that dies mid-capture must not leave
+ * the device configured differently than it found it.
+ *
+ * @typeParam T - What the wrapped work returns.
+ * @param params - The device and the work to run.
+ * @returns A {@link Promise} that resolves to whatever the callback returned.
+ */
+export declare function withSoftKeyboardEnabled<T>(params: WithSoftKeyboardEnabledParams<T>): Promise<T>;
+/**
+ * Writes a device setting.
+ *
+ * @param params - The device, the setting, its namespace and the value to write.
+ * @returns A {@link Promise} that resolves once the setting is written.
+ */
+export declare function writeDeviceSetting(params: WriteDeviceSettingParams): Promise<void>;

package/dist/lib/cjs/emulator-device-id.cjs

@@ -0,0 +1,32 @@
+"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 emulator_device_id_exports = {};
+__export(emulator_device_id_exports, {
+  selectEmulatorDeviceId: () => selectEmulatorDeviceId
+});
+module.exports = __toCommonJS(emulator_device_id_exports);
+function selectEmulatorDeviceId(params) {
+  const match = params.candidates.find((candidate) => candidate.avdName === params.avdName);
+  return match ? match.deviceId : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectEmulatorDeviceId
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/emulator-device-id.d.cts

@@ -0,0 +1,49 @@
+/**
+ * @file
+ *
+ * Picks the running emulator that belongs to a named AVD.
+ *
+ * A capture suite must never take "the first device `adb devices` lists". Two
+ * things routinely make that the wrong device on this fleet: a physical phone is
+ * often plugged into the same machine, and the harness's own `obsidian_test` AVD
+ * runs at a different geometry than the `obsidian_screenshots` AVD sized to the
+ * store's frame. Picking by position silently photographs the wrong screen at
+ * the wrong size, and the dimension assertion that would have caught it fires
+ * several minutes later, after the run.
+ *
+ * Pure and unit-tested; the `adb` round-trips that gather the AVD names live in
+ * `resolve-emulator-device-id`.
+ */
+/**
+ * One running emulator, paired with the AVD it was started from.
+ */
+export interface EmulatorDeviceCandidate {
+    /**
+     * The AVD name the emulator reports, e.g. `obsidian_screenshots`.
+     */
+    readonly avdName: string;
+    /**
+     * The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link selectEmulatorDeviceId}.
+ */
+export interface SelectEmulatorDeviceIdParams {
+    /**
+     * The AVD name to match.
+     */
+    readonly avdName: string;
+    /**
+     * Every running emulator, with the AVD each was started from.
+     */
+    readonly candidates: readonly EmulatorDeviceCandidate[];
+}
+/**
+ * Picks the emulator started from a named AVD.
+ *
+ * @param params - The AVD to match and the running emulators to match against.
+ * @returns The matching device UDID, or `null` when no running emulator carries that AVD name.
+ */
+export declare function selectEmulatorDeviceId(params: SelectEmulatorDeviceIdParams): null | string;

package/dist/lib/cjs/index.cjs

@@ -23,9 +23,13 @@ __export(index_exports, {
   ConfigDirectoryFallbackError: () => import_config_directory_fallback_error.ConfigDirectoryFallbackError,
   ContextId: () => import_context_id.ContextId,
   DEFAULT_CONFIG_DIRECTORY: () => import_config_directory.DEFAULT_CONFIG_DIRECTORY,
+  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS: () => import_soft_keyboard_geometry.DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS: () => import_version_matrix.DEFAULT_OBSIDIAN_VERSION_SPECS,
   DesktopCdpTransport: () => import_transport_desktop_cdp.DesktopCdpTransport,
   DesktopOnlyPluginSkipError: () => import_desktop_only_plugin_skip_error.DesktopOnlyPluginSkipError,
+  DeviceSettingNamespace: () => import_device_settings_command.DeviceSettingNamespace,
+  DeviceSettingRestoreKind: () => import_device_setting_restore.DeviceSettingRestoreKind,
+  DeviceSettingVerb: () => import_device_settings_command.DeviceSettingVerb,
   IncompatibleInstallerVersionError: () => import_incompatible_installer_version_error.IncompatibleInstallerVersionError,
   IntegrationSetupFailedError: () => import_integration_setup_failed_error.IntegrationSetupFailedError,
   OwnedInstanceExitedError: () => import_owned_instance_exited_error.OwnedInstanceExitedError,
@@ -38,14 +42,19 @@ __export(index_exports, {
   buildDemoVaultPopulate: () => import_demo_vault_populate.buildDemoVaultPopulate,
   buildDemoVaultPopulateAsync: () => import_demo_vault_bootstrap.buildDemoVaultPopulateAsync,
   buildDeviceMetricsOverride: () => import_capture_screenshot.buildDeviceMetricsOverride,
+  buildDeviceSettingsCommandArguments: () => import_device_settings_command.buildDeviceSettingsCommandArguments,
   buildLabelSvg: () => import_label_screenshot.buildLabelSvg,
+  buildSoftKeyboardDiagnosticMessage: () => import_soft_keyboard_geometry.buildSoftKeyboardDiagnosticMessage,
+  captureDeviceScreenshot: () => import_device_screenshot.captureDeviceScreenshot,
   captureObsidianScreenshot: () => import_capture_obsidian_screenshot.captureObsidianScreenshot,
   checkIsMobileTransport: () => import_transport_options.checkIsMobileTransport,
+  checkIsSoftKeyboardUp: () => import_soft_keyboard_geometry.checkIsSoftKeyboardUp,
   computeFitToCanvas: () => import_fit_screenshot.computeFitToCanvas,
   computeLabelBand: () => import_label_screenshot.computeLabelBand,
   connectToCdp: () => import_connect_to_cdp.connectToCdp,
   createTransportFromOptions: () => import_transport_factory.createTransportFromOptions,
   decodeBase64Png: () => import_capture_screenshot.decodeBase64Png,
+  deleteDeviceSetting: () => import_device_settings.deleteDeviceSetting,
   escapeSvgText: () => import_label_screenshot.escapeSvgText,
   evalInObsidian: () => import_eval_in_obsidian.evalInObsidian,
   fitScreenshotToCanvas: () => import_fit_screenshot.fitScreenshotToCanvas,
@@ -53,22 +62,36 @@ __export(index_exports, {
   isPng: () => import_capture_screenshot.isPng,
   labelScreenshot: () => import_label_screenshot.labelScreenshot,
   openObsidianSettingsTab: () => import_open_obsidian_settings_tab.openObsidianSettingsTab,
+  parseInputMethodState: () => import_soft_keyboard_geometry.parseInputMethodState,
   pollInObsidian: () => import_poll_in_obsidian.pollInObsidian,
+  raiseSoftKeyboard: () => import_soft_keyboard.raiseSoftKeyboard,
   readDemoVaultTree: () => import_demo_vault_tree.readDemoVaultTree,
+  readDeviceSetting: () => import_device_settings.readDeviceSetting,
   readPngDimensions: () => import_capture_screenshot.readPngDimensions,
   registerLibResolver: () => import_lib_registry.registerLibResolver,
   registerVault: () => import_vault_registry.registerVault,
   resolveAsarFallback: () => import_asar_fallback_detection.resolveAsarFallback,
+  resolveDeviceSettingRestore: () => import_device_setting_restore.resolveDeviceSettingRestore,
   resolveElectronCompatibility: () => import_electron_compatibility.resolveElectronCompatibility,
+  resolveEmulatorDeviceId: () => import_resolve_emulator_device_id.resolveEmulatorDeviceId,
   resolveInstallerCompatibility: () => import_installer_compatibility.resolveInstallerCompatibility,
   resolveMissingInjectedPlugins: () => import_demo_vault_populate.resolveMissingInjectedPlugins,
+  resolveSoftKeyboardTapPoints: () => import_soft_keyboard_geometry.resolveSoftKeyboardTapPoints,
+  runAdbBinary: () => import_adb.runAdbBinary,
+  runAdbText: () => import_adb.runAdbText,
+  runAdbTextWithoutDevice: () => import_adb.runAdbTextWithoutDevice,
   runObsidianVersionMatrix: () => import_run_version_matrix.runObsidianVersionMatrix,
+  selectEmulatorDeviceId: () => import_emulator_device_id.selectEmulatorDeviceId,
   setSetupErrorResolver: () => import_context_provider.setSetupErrorResolver,
   setTransportOptionsResolver: () => import_context_provider.setTransportOptionsResolver,
   setVaultPathResolver: () => import_context_provider.setVaultPathResolver,
-  unregisterVault: () => import_vault_registry.unregisterVault
+  tapDevice: () => import_soft_keyboard.tapDevice,
+  unregisterVault: () => import_vault_registry.unregisterVault,
+  withSoftKeyboardEnabled: () => import_device_settings.withSoftKeyboardEnabled,
+  writeDeviceSetting: () => import_device_settings.writeDeviceSetting
 });
 module.exports = __toCommonJS(index_exports);
+var import_adb = require("./adb.cjs");
 var import_asar_fallback_detection = require("./asar-fallback-detection.cjs");
 var import_capture_obsidian_screenshot = require("./capture-obsidian-screenshot.cjs");
 var import_capture_screenshot = require("./capture-screenshot.cjs");
@@ -81,7 +104,12 @@ var import_demo_vault_bootstrap = require("./demo-vault-bootstrap.cjs");
 var import_demo_vault_populate = require("./demo-vault-populate.cjs");
 var import_demo_vault_tree = require("./demo-vault-tree.cjs");
 var import_desktop_only_plugin_skip_error = require("./desktop-only-plugin-skip-error.cjs");
+var import_device_screenshot = require("./device-screenshot.cjs");
+var import_device_setting_restore = require("./device-setting-restore.cjs");
+var import_device_settings_command = require("./device-settings-command.cjs");
+var import_device_settings = require("./device-settings.cjs");
 var import_electron_compatibility = require("./electron-compatibility.cjs");
+var import_emulator_device_id = require("./emulator-device-id.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_fit_screenshot = require("./fit-screenshot.cjs");
 var import_incompatible_installer_version_error = require("./incompatible-installer-version-error.cjs");
@@ -95,8 +123,11 @@ var import_open_obsidian_settings_tab = require("./open-obsidian-settings-tab.cj
 var import_owned_instance_exited_error = require("./owned-instance-exited-error.cjs");
 var import_poll_in_obsidian = require("./poll-in-obsidian.cjs");
 var import_renderer_failed_to_initialize_error = require("./renderer-failed-to-initialize-error.cjs");
+var import_resolve_emulator_device_id = require("./resolve-emulator-device-id.cjs");
 var import_run_version_matrix = require("./run-version-matrix.cjs");
 var import_silent_asar_fallback_error = require("./silent-asar-fallback-error.cjs");
+var import_soft_keyboard_geometry = require("./soft-keyboard-geometry.cjs");
+var import_soft_keyboard = require("./soft-keyboard.cjs");
 var import_temporary_vault = require("./temporary-vault.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
@@ -111,9 +142,13 @@ var import_version_matrix = require("./version-matrix.cjs");
   ConfigDirectoryFallbackError,
   ContextId,
   DEFAULT_CONFIG_DIRECTORY,
+  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
+  DeviceSettingNamespace,
+  DeviceSettingRestoreKind,
+  DeviceSettingVerb,
   IncompatibleInstallerVersionError,
   IntegrationSetupFailedError,
   OwnedInstanceExitedError,
@@ -126,14 +161,19 @@ var import_version_matrix = require("./version-matrix.cjs");
   buildDemoVaultPopulate,
   buildDemoVaultPopulateAsync,
   buildDeviceMetricsOverride,
+  buildDeviceSettingsCommandArguments,
   buildLabelSvg,
+  buildSoftKeyboardDiagnosticMessage,
+  captureDeviceScreenshot,
   captureObsidianScreenshot,
   checkIsMobileTransport,
+  checkIsSoftKeyboardUp,
   computeFitToCanvas,
   computeLabelBand,
   connectToCdp,
   createTransportFromOptions,
   decodeBase64Png,
+  deleteDeviceSetting,
   escapeSvgText,
   evalInObsidian,
   fitScreenshotToCanvas,
@@ -141,19 +181,32 @@ var import_version_matrix = require("./version-matrix.cjs");
   isPng,
   labelScreenshot,
   openObsidianSettingsTab,
+  parseInputMethodState,
   pollInObsidian,
+  raiseSoftKeyboard,
   readDemoVaultTree,
+  readDeviceSetting,
   readPngDimensions,
   registerLibResolver,
   registerVault,
   resolveAsarFallback,
+  resolveDeviceSettingRestore,
   resolveElectronCompatibility,
+  resolveEmulatorDeviceId,
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
+  resolveSoftKeyboardTapPoints,
+  runAdbBinary,
+  runAdbText,
+  runAdbTextWithoutDevice,
   runObsidianVersionMatrix,
+  selectEmulatorDeviceId,
   setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver,
-  unregisterVault
+  tapDevice,
+  unregisterVault,
+  withSoftKeyboardEnabled,
+  writeDeviceSetting
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelScreenshotOptions\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabOptions } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultOptions\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAMP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAM3C,oCAA6C;AAkB7C,8BAA+B;AAM/B,4BAGO;AAEP,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAM5C,8BAKO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAEzC,8BAA+B;AAC/B,iDAAgD;AAEhD,gCAAyC;AAEzC,wCAAwC;AAMxC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelScreenshotOptions\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabOptions } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultOptions\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,iBAIO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAMP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAkBvC,8BAA+B;AAM/B,4BAGO;AAEP,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAM5C,8BAKO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAEzC,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAMO;AAKP,2BAGO;AAMP,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}


package/dist/lib/cjs/index.d.cts

@@ -3,6 +3,8 @@
  *
  * Contains the entry point for the integration testing module.
  */
+export type { RunAdbParams } from './adb.cjs';
+export { runAdbBinary, runAdbText, runAdbTextWithoutDevice } from './adb.cjs';
 export type { AsarFallback, AsarFallbackTier, ResolveAsarFallbackParams } from './asar-fallback-detection.cjs';
 export { resolveAsarFallback } from './asar-fallback-detection.cjs';
 export type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';
@@ -25,8 +27,18 @@ export { buildDemoVaultPopulate, resolveMissingInjectedPlugins } from './demo-va
 export type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';
 export { readDemoVaultTree } from './demo-vault-tree.cjs';
 export { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';
+export type { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';
+export { captureDeviceScreenshot } from './device-screenshot.cjs';
+export type { DeviceSettingRestore, DeviceSettingRestoreDelete, DeviceSettingRestoreWrite } from './device-setting-restore.cjs';
+export { DeviceSettingRestoreKind, resolveDeviceSettingRestore } from './device-setting-restore.cjs';
+export type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';
+export { buildDeviceSettingsCommandArguments, DeviceSettingNamespace, DeviceSettingVerb } from './device-settings-command.cjs';
+export type { DeviceSettingParams, WithSoftKeyboardEnabledParams, WriteDeviceSettingParams } from './device-settings.cjs';
+export { deleteDeviceSetting, readDeviceSetting, withSoftKeyboardEnabled, writeDeviceSetting } from './device-settings.cjs';
 export type { ElectronCompatibility, ElectronCompatibilityTier, ResolveElectronCompatibilityParams } from './electron-compatibility.cjs';
 export { resolveElectronCompatibility } from './electron-compatibility.cjs';
+export type { EmulatorDeviceCandidate, SelectEmulatorDeviceIdParams } from './emulator-device-id.cjs';
+export { selectEmulatorDeviceId } from './emulator-device-id.cjs';
 export type { ClickElementParams, ClickMouseParams, CommonArguments, CreateNoteParams, EvalInObsidianParams, GenericObject, HoverElementParams, Lib, MouseButton, MoveMouseParams, OpenSettingsTabParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
 export { evalInObsidian } from './eval-in-obsidian.cjs';
 export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.cjs';
@@ -51,10 +63,16 @@ export { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';
 export type { PollInObsidianParams } from './poll-in-obsidian.cjs';
 export { pollInObsidian } from './poll-in-obsidian.cjs';
 export { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';
+export type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';
+export { resolveEmulatorDeviceId } from './resolve-emulator-device-id.cjs';
 export type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';
 export { runObsidianVersionMatrix } from './run-version-matrix.cjs';
 export type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';
 export { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';
+export type { BuildSoftKeyboardDiagnosticMessageParams, CheckIsSoftKeyboardUpParams, ElementRect, ResolveSoftKeyboardTapPointsParams, SoftKeyboardTapPoint, SoftKeyboardViewportSnapshot } from './soft-keyboard-geometry.cjs';
+export { buildSoftKeyboardDiagnosticMessage, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.cjs';
+export type { RaiseSoftKeyboardParams, TapDeviceParams } from './soft-keyboard.cjs';
+export { raiseSoftKeyboard, tapDevice } from './soft-keyboard.cjs';
 export type { PopulateFileContent, PopulateFilesParams, TemporaryVaultOptions } from './temporary-vault.cjs';
 export { TemporaryVault } from './temporary-vault.cjs';
 export type { AppiumSessionInfo, AppiumTransportConfig } from './transport-appium.cjs';

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "12.1.0";
+const LIBRARY_VERSION = false ? "dev" : "12.1.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION

package/dist/lib/cjs/resolve-emulator-device-id.cjs

@@ -0,0 +1,54 @@
+"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 resolve_emulator_device_id_exports = {};
+__export(resolve_emulator_device_id_exports, {
+  resolveEmulatorDeviceId: () => resolveEmulatorDeviceId
+});
+module.exports = __toCommonJS(resolve_emulator_device_id_exports);
+var import_adb_device_list = require("./adb-device-list.cjs");
+var import_adb = require("./adb.cjs");
+var import_emulator_device_id = require("./emulator-device-id.cjs");
+const EMULATOR_DEVICE_ID_PREFIX = "emulator-";
+async function resolveEmulatorDeviceId(params) {
+  const candidates = await listEmulatorDeviceCandidates();
+  const deviceId = (0, import_emulator_device_id.selectEmulatorDeviceId)({ avdName: params.avdName, candidates });
+  if (!deviceId) {
+    const listed = candidates.map((candidate) => `${candidate.deviceId} (${candidate.avdName})`).join(", ") || "none";
+    throw new Error(
+      `resolveEmulatorDeviceId: no running emulator for AVD "${params.avdName}". Running emulators: ${listed}. Start it, or run this project once to have the harness start it.`
+    );
+  }
+  return deviceId;
+}
+async function listEmulatorDeviceCandidates() {
+  const devicesOutput = await (0, import_adb.runAdbTextWithoutDevice)(["devices"]);
+  const deviceIds = (0, import_adb_device_list.listOnlineDeviceIds)(devicesOutput).filter((deviceId) => deviceId.startsWith(EMULATOR_DEVICE_ID_PREFIX));
+  const candidates = [];
+  for (const deviceId of deviceIds) {
+    const output = await (0, import_adb.runAdbText)({ commandArguments: ["emu", "avd", "name"], deviceId });
+    const avdName = output.split("\n", 1)[0]?.trim() ?? "";
+    candidates.push({ avdName, deviceId });
+  }
+  return candidates;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveEmulatorDeviceId
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/resolve-emulator-device-id.d.cts

@@ -0,0 +1,28 @@
+/**
+ * @file
+ *
+ * Asks the running emulators which AVD each was started from, and resolves one
+ * by name through {@link ./emulator-device-id.ts}'s selection.
+ *
+ * Every function here shells out, so the whole module is integration-time code
+ * — which is exactly why the selection it delegates to lives in its own module
+ * and stays unit-tested.
+ */
+/**
+ * Parameters for {@link resolveEmulatorDeviceId}.
+ */
+export interface ResolveEmulatorDeviceIdParams {
+    /**
+     * The AVD name to match, e.g. `obsidian_screenshots`.
+     */
+    readonly avdName: string;
+}
+/**
+ * Finds the running emulator whose AVD is the named one.
+ *
+ * @param params - The AVD to match.
+ * @returns A {@link Promise} that resolves to the device UDID to address it by.
+ * @throws Error if no running emulator was started from that AVD. The message lists what IS running, since
+ *   "the wrong emulator is up" and "no emulator is up" need different answers.
+ */
+export declare function resolveEmulatorDeviceId(params: ResolveEmulatorDeviceIdParams): Promise<string>;

package/dist/lib/cjs/soft-keyboard-geometry.cjs

@@ -0,0 +1,75 @@
+"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 soft_keyboard_geometry_exports = {};
+__export(soft_keyboard_geometry_exports, {
+  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS: () => DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
+  buildSoftKeyboardDiagnosticMessage: () => buildSoftKeyboardDiagnosticMessage,
+  checkIsSoftKeyboardUp: () => checkIsSoftKeyboardUp,
+  parseInputMethodState: () => parseInputMethodState,
+  resolveSoftKeyboardTapPoints: () => resolveSoftKeyboardTapPoints
+});
+module.exports = __toCommonJS(soft_keyboard_geometry_exports);
+const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
+const INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;
+const CENTER_DIVISOR = 2;
+function buildSoftKeyboardDiagnosticMessage(params) {
+  const { inputRect } = params.snapshot;
+  const inputBottom = inputRect ? inputRect.top + inputRect.height : null;
+  return [
+    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,
+    `page: innerHeight=${String(params.snapshot.innerHeight)} inputBottom=${inputBottom === null ? "(no input)" : String(inputBottom)}`,
+    `device: ${params.inputMethodState || "(no input_method state reported)"}`
+  ].join("\n");
+}
+function checkIsSoftKeyboardUp(params) {
+  const { inputRect } = params.snapshot;
+  if (!inputRect) {
+    return false;
+  }
+  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;
+  return params.snapshot.innerHeight - (inputRect.top + inputRect.height) > minimumKeyboardHeightInPixels;
+}
+function parseInputMethodState(dumpsysOutput) {
+  return dumpsysOutput.split("\n").filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line)).map((line) => line.trim()).join(" | ");
+}
+function resolveSoftKeyboardTapPoints(params) {
+  const { devicePixelRatio, inputRect, screenY } = params.snapshot;
+  if (!inputRect) {
+    return [];
+  }
+  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);
+  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);
+  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);
+  if (topOffsetInPixels === 0) {
+    return [{ xInPixels, yInPixels: centerYInPixels }];
+  }
+  return [
+    { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },
+    { xInPixels, yInPixels: centerYInPixels }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
+  buildSoftKeyboardDiagnosticMessage,
+  checkIsSoftKeyboardUp,
+  parseInputMethodState,
+  resolveSoftKeyboardTapPoints
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * the field's own offset from the bottom, which is why the detection here is\n * geometric rather than an API call. Two runs failed on that before a framebuffer\n * dump said so, which is also why the diagnostic below exists.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis.\n *\n * @param params - The evidence gathered after the last touch.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const { inputRect } = params.snapshot;\n  const inputBottom = inputRect ? inputRect.top + inputRect.height : null;\n\n  return [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} inputBottom=${inputBottom === null ? '(no input)' : String(inputBottom)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`\n  ].join('\\n');\n}\n\n/**\n * Decides whether the IME is up, from the page's own geometry.\n *\n * @param params - The geometry to judge, and how far the field must have lifted.\n * @returns Whether the field has stopped short of the bottom to make room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const { inputRect } = params.snapshot;\n  if (!inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return params.snapshot.innerHeight - (inputRect.top + inputRect.height) > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  if (topOffsetInPixels === 0) {\n    return [{ xInPixels, yInPixels: centerYInPixels }];\n  }\n\n  return [\n    { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n    { xInPixels, yInPixels: centerYInPixels }\n  ];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyIO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAKnC,MAAM,iBAAiB;AAWhB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,QAAM,cAAc,YAAY,UAAU,MAAM,UAAU,SAAS;AAEnE,SAAO;AAAA,IACL,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,gBAAgB,gBAAgB,OAAO,eAAe,OAAO,WAAW,CAAC;AAAA,IACjI,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,EAC1E,EAAE,KAAK,IAAI;AACb;AAQO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,OAAO,SAAS,eAAe,UAAU,MAAM,UAAU,UAAU;AAC5E;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,MAAI,sBAAsB,GAAG;AAC3B,WAAO,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC;AAAA,EACnD;AAEA,SAAO;AAAA,IACL,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACF;",
  "names": []
}
