obsidian-integration-testing 12.1.0 → 12.1.2

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

@@ -0,0 +1,156 @@
+/**
+ * @file
+ *
+ * Decides whether the Android soft keyboard is up, and where to touch to raise
+ * it — from geometry alone.
+ *
+ * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`
+ * and the modal container all stay at their full height with the keyboard shown
+ * and `dumpsys input_method` reporting `mInputShown=true` — Obsidian Mobile keeps
+ * a full-screen container and lifts its contents inside it. The only signal is
+ * the field's own offset from the bottom, which is why the detection here is
+ * geometric rather than an API call. Two runs failed on that before a framebuffer
+ * dump said so, which is also why the diagnostic below exists.
+ *
+ * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.
+ */
+/**
+ * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.
+ */
+export interface BuildSoftKeyboardDiagnosticMessageParams {
+    /**
+     * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.
+     */
+    readonly inputMethodState: string;
+    /**
+     * Where the device framebuffer was written, so the reader can look at what the device was showing.
+     */
+    readonly screenshotPath: string;
+    /**
+     * The geometry read after the last touch.
+     */
+    readonly snapshot: SoftKeyboardViewportSnapshot;
+}
+/**
+ * Parameters for {@link checkIsSoftKeyboardUp}.
+ */
+export interface CheckIsSoftKeyboardUpParams {
+    /**
+     * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.
+     *
+     * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}
+     */
+    readonly minimumKeyboardHeightInPixels?: number;
+    /**
+     * The geometry to judge.
+     */
+    readonly snapshot: SoftKeyboardViewportSnapshot;
+}
+/**
+ * A rectangle as the renderer reports it, in CSS pixels.
+ */
+export interface ElementRect {
+    /**
+     * The rectangle's height.
+     */
+    readonly height: number;
+    /**
+     * The distance from the viewport's left edge.
+     */
+    readonly left: number;
+    /**
+     * The distance from the viewport's top edge.
+     */
+    readonly top: number;
+    /**
+     * The rectangle's width.
+     */
+    readonly width: number;
+}
+/**
+ * Parameters for {@link resolveSoftKeyboardTapPoints}.
+ */
+export interface ResolveSoftKeyboardTapPointsParams {
+    /**
+     * The geometry the tap is aimed from.
+     */
+    readonly snapshot: SoftKeyboardViewportSnapshot;
+}
+/**
+ * A point on the device's screen, in device pixels.
+ */
+export interface SoftKeyboardTapPoint {
+    /**
+     * The distance from the screen's left edge.
+     */
+    readonly xInPixels: number;
+    /**
+     * The distance from the screen's top edge.
+     */
+    readonly yInPixels: number;
+}
+/**
+ * What the renderer knows about its own geometry.
+ */
+export interface SoftKeyboardViewportSnapshot {
+    /**
+     * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.
+     */
+    readonly devicePixelRatio: number;
+    /**
+     * The viewport's height in CSS pixels.
+     *
+     * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.
+     */
+    readonly innerHeight: number;
+    /**
+     * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.
+     */
+    readonly inputRect: ElementRect | null;
+    /**
+     * The window's offset from the top of the screen, as the page understands it.
+     */
+    readonly screenY: number;
+}
+/**
+ * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.
+ *
+ * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,
+ * and a suite tightening it wants to say so relative to this rather than in the abstract.
+ */
+export declare const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
+/**
+ * Builds the message a failed raise reports.
+ *
+ * A bare "the keyboard did not come up" is unreadable — what the reader needs is what the page saw and what
+ * the device thought, side by side, because the two disagreeing is the whole diagnosis.
+ *
+ * @param params - The evidence gathered after the last touch.
+ * @returns The message, ready to throw.
+ */
+export declare function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string;
+/**
+ * Decides whether the IME is up, from the page's own geometry.
+ *
+ * @param params - The geometry to judge, and how far the field must have lifted.
+ * @returns Whether the field has stopped short of the bottom to make room for a keyboard.
+ */
+export declare function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean;
+/**
+ * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.
+ *
+ * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.
+ * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.
+ */
+export declare function parseInputMethodState(dumpsysOutput: string): string;
+/**
+ * Works out where to touch, in the device pixels `adb shell input tap` speaks.
+ *
+ * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot
+ * tell which. Both land inside the field — it is taller than the offset — so a wrong guess costs one touch
+ * rather than a mis-tap on whatever sits below.
+ *
+ * @param params - The geometry the tap is aimed from.
+ * @returns The points to try, in order, or an empty array when the field is not on screen.
+ */
+export declare function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[];

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

@@ -0,0 +1,118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var soft_keyboard_exports = {};
+__export(soft_keyboard_exports, {
+  raiseSoftKeyboard: () => raiseSoftKeyboard,
+  tapDevice: () => tapDevice
+});
+module.exports = __toCommonJS(soft_keyboard_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_promises = require("node:timers/promises");
+var import_adb = require("./adb.cjs");
+var import_device_screenshot = require("./device-screenshot.cjs");
+var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_soft_keyboard_geometry = require("./soft-keyboard-geometry.cjs");
+const DEFAULT_DIAGNOSTICS_DIRECTORY = (0, import_node_path.join)(import_node_process.default.cwd(), "dist", "screenshots");
+const KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;
+async function raiseSoftKeyboard(params) {
+  let snapshot = await readSoftKeyboardViewport(params);
+  if (!snapshot.inputRect) {
+    throw new Error(`raiseSoftKeyboard: nothing matches "${params.inputSelector}", so there is no field to touch.`);
+  }
+  for (const point of (0, import_soft_keyboard_geometry.resolveSoftKeyboardTapPoints)({ snapshot })) {
+    if (checkIsUp(snapshot)) {
+      break;
+    }
+    await tapDevice({ deviceId: params.deviceId, point });
+    await (0, import_promises.setTimeout)(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);
+    snapshot = await readSoftKeyboardViewport(params);
+  }
+  if (!checkIsUp(snapshot)) {
+    throw new Error(await buildFailureMessage(params, snapshot));
+  }
+  return snapshot;
+  function checkIsUp(current) {
+    return (0, import_soft_keyboard_geometry.checkIsSoftKeyboardUp)({
+      ...params.minimumKeyboardHeightInPixels !== void 0 && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels },
+      snapshot: current
+    });
+  }
+}
+async function tapDevice(params) {
+  await (0, import_adb.runAdbText)({
+    commandArguments: ["shell", "input", "tap", String(params.point.xInPixels), String(params.point.yInPixels)],
+    deviceId: params.deviceId
+  });
+}
+async function buildFailureMessage(params, snapshot) {
+  const diagnosticsDirectory = params.diagnosticsDirectory ?? DEFAULT_DIAGNOSTICS_DIRECTORY;
+  (0, import_node_fs.mkdirSync)(diagnosticsDirectory, { recursive: true });
+  const screenshotPath = (0, import_node_path.join)(diagnosticsDirectory, "keyboard-not-raised.png");
+  (0, import_node_fs.writeFileSync)(screenshotPath, await (0, import_device_screenshot.captureDeviceScreenshot)({ deviceId: params.deviceId }));
+  const dumpsysOutput = await (0, import_adb.runAdbText)({
+    commandArguments: ["shell", "dumpsys", "input_method"],
+    deviceId: params.deviceId
+  });
+  return (0, import_soft_keyboard_geometry.buildSoftKeyboardDiagnosticMessage)({
+    inputMethodState: (0, import_soft_keyboard_geometry.parseInputMethodState)(dumpsysOutput),
+    screenshotPath,
+    snapshot
+  });
+}
+async function readSoftKeyboardViewport(params) {
+  return await (0, import_eval_in_obsidian.evalInObsidian)({
+    callback({ inputSelector }) {
+      const inputEl = document.querySelector(inputSelector);
+      function toRect(rect) {
+        return {
+          height: rect.height,
+          left: rect.left,
+          top: rect.top,
+          width: rect.width
+        };
+      }
+      return {
+        devicePixelRatio: window.devicePixelRatio,
+        innerHeight: window.innerHeight,
+        inputRect: inputEl ? toRect(inputEl.getBoundingClientRect()) : null,
+        screenY: window.screenY
+      };
+    },
+    input: { inputSelector: params.inputSelector },
+    ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  raiseSoftKeyboard,
+  tapDevice
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Raises the Android soft keyboard for a screenshot, and proves it came up.\n *\n * Two things have to be true, and the second is the one that is easy to miss:\n *\n * 1. The device must be allowed to draw a keyboard at all. The screenshot AVDs\n *    are built `hw.keyboard=yes`, so Android suppresses the on-screen one \u2014\n *    `withSoftKeyboardEnabled` in `device-settings` is what lifts that.\n * 2. The IME must be *asked* for by a gesture. A field that takes focus\n *    programmatically does not get one: an Android WebView raises the IME on a\n *    real touch, and a run with the setting flipped and no touch comes back with\n *    exactly the empty band it had before. `adb shell input tap` is that gesture.\n *\n * The geometry that decides whether it worked is unit-tested in\n * `soft-keyboard-geometry`; everything here drives a real device, so the whole\n * module is integration-time code.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian on a real device) covered by integration tests, not unit tests. */\n\nimport {\n  mkdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type {\n  ElementRect,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\n\nimport { runAdbText } from './adb.cjs';\nimport { captureDeviceScreenshot } from './device-screenshot.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\n\n/**\n * Parameters for {@link raiseSoftKeyboard}.\n */\nexport interface RaiseSoftKeyboardParams {\n  /**\n   * The device to touch.\n   */\n  readonly deviceId: string;\n\n  /**\n   * Where a failed attempt writes the device framebuffer.\n   *\n   * When omitted, it is `dist/screenshots` under the working directory \u2014 resolved at load, so there is no\n   * literal default to state here.\n   */\n  readonly diagnosticsDirectory?: string;\n\n  /**\n   * The CSS selector of the field to touch, e.g. `.prompt-input`.\n   */\n  readonly inputSelector: string;\n\n  /**\n   * The least a raised keyboard lifts the field by.\n   *\n   * When omitted, `DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS` from `soft-keyboard-geometry` applies.\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The vault to read the geometry from. When omitted, the current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link tapDevice}.\n */\nexport interface TapDeviceParams {\n  /**\n   * The device to touch.\n   */\n  readonly deviceId: string;\n\n  /**\n   * Where to touch it.\n   */\n  readonly point: SoftKeyboardTapPoint;\n}\n\n/**\n * Where a failed attempt leaves its evidence \u2014 gitignored across the fleet, like the capture scratch files.\n */\nconst DEFAULT_DIAGNOSTICS_DIRECTORY = join(process.cwd(), 'dist', 'screenshots');\n\n/**\n * How long the IME takes to finish animating in, after which the layout has settled.\n */\nconst KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;\n\n/**\n * Raises the on-screen keyboard with a real touch on a field, and confirms it came up.\n *\n * Call it inside `withSoftKeyboardEnabled` \u2014 the device setting alone does not raise the keyboard, and this\n * touch alone cannot while the setting suppresses it.\n *\n * @param params - The device, the field to touch, and how far it must lift.\n * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.\n * @throws Error if the keyboard never came up, after writing the device framebuffer and the device's own\n *   `input_method` state to the diagnostics directory.\n */\nexport async function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  let snapshot = await readSoftKeyboardViewport(params);\n\n  if (!snapshot.inputRect) {\n    throw new Error(`raiseSoftKeyboard: nothing matches \"${params.inputSelector}\", so there is no field to touch.`);\n  }\n\n  for (const point of resolveSoftKeyboardTapPoints({ snapshot })) {\n    if (checkIsUp(snapshot)) {\n      break;\n    }\n\n    await tapDevice({ deviceId: params.deviceId, point });\n    await sleep(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);\n    snapshot = await readSoftKeyboardViewport(params);\n  }\n\n  if (!checkIsUp(snapshot)) {\n    throw new Error(await buildFailureMessage(params, snapshot));\n  }\n\n  return snapshot;\n\n  function checkIsUp(current: SoftKeyboardViewportSnapshot): boolean {\n    return checkIsSoftKeyboardUp({\n      ...(params.minimumKeyboardHeightInPixels !== undefined && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels }),\n      snapshot: current\n    });\n  }\n}\n\n/**\n * Touches the device at a point, the way a thumb would.\n *\n * @param params - The device and where to touch it.\n * @returns A {@link Promise} that resolves once the touch has been dispatched.\n */\nexport async function tapDevice(params: TapDeviceParams): Promise<void> {\n  await runAdbText({\n    commandArguments: ['shell', 'input', 'tap', String(params.point.xInPixels), String(params.point.yInPixels)],\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Writes the device framebuffer and reads the device's `input_method` state, then composes the failure.\n *\n * @param params - The device and the diagnostics directory.\n * @param snapshot - The geometry read after the last touch.\n * @returns A {@link Promise} that resolves to the message to throw.\n */\nasync function buildFailureMessage(params: RaiseSoftKeyboardParams, snapshot: SoftKeyboardViewportSnapshot): Promise<string> {\n  const diagnosticsDirectory = params.diagnosticsDirectory ?? DEFAULT_DIAGNOSTICS_DIRECTORY;\n  mkdirSync(diagnosticsDirectory, { recursive: true });\n\n  const screenshotPath = join(diagnosticsDirectory, 'keyboard-not-raised.png');\n  writeFileSync(screenshotPath, await captureDeviceScreenshot({ deviceId: params.deviceId }));\n\n  const dumpsysOutput = await runAdbText({\n    commandArguments: ['shell', 'dumpsys', 'input_method'],\n    deviceId: params.deviceId\n  });\n\n  return buildSoftKeyboardDiagnosticMessage({\n    inputMethodState: parseInputMethodState(dumpsysOutput),\n    screenshotPath,\n    snapshot\n  });\n}\n\n/**\n * Reads what the renderer knows about its own geometry.\n *\n * @param params - The field to measure and the vault to read it from.\n * @returns A {@link Promise} that resolves to the viewport and the field's rect, in CSS pixels.\n */\nasync function readSoftKeyboardViewport(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  return await evalInObsidian({\n    callback({ inputSelector }): SoftKeyboardViewportSnapshot {\n      const inputEl = document.querySelector(inputSelector);\n\n      // eslint-disable-next-line unicorn/consistent-function-scoping -- This closure is serialized and evaluated in the renderer, so a helper hoisted to module scope would not exist there.\n      function toRect(rect: DOMRect): ElementRect {\n        return {\n          height: rect.height,\n          left: rect.left,\n          top: rect.top,\n          width: rect.width\n        };\n      }\n\n      return {\n        devicePixelRatio: window.devicePixelRatio,\n        innerHeight: window.innerHeight,\n        inputRect: inputEl ? toRect(inputEl.getBoundingClientRect()) : null,\n        screenY: window.screenY\n      };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,qBAGO;AACP,uBAAqB;AACrB,0BAAoB;AACpB,sBAAoC;AAQpC,iBAA2B;AAC3B,+BAAwC;AACxC,8BAA+B;AAC/B,oCAKO;AAuDP,MAAM,oCAAgC,uBAAK,oBAAAA,QAAQ,IAAI,GAAG,QAAQ,aAAa;AAK/E,MAAM,wCAAwC;AAa9C,eAAsB,kBAAkB,QAAwE;AAC9G,MAAI,WAAW,MAAM,yBAAyB,MAAM;AAEpD,MAAI,CAAC,SAAS,WAAW;AACvB,UAAM,IAAI,MAAM,uCAAuC,OAAO,aAAa,mCAAmC;AAAA,EAChH;AAEA,aAAW,aAAS,4DAA6B,EAAE,SAAS,CAAC,GAAG;AAC9D,QAAI,UAAU,QAAQ,GAAG;AACvB;AAAA,IACF;AAEA,UAAM,UAAU,EAAE,UAAU,OAAO,UAAU,MAAM,CAAC;AACpD,cAAM,gBAAAC,YAAM,qCAAqC;AACjD,eAAW,MAAM,yBAAyB,MAAM;AAAA,EAClD;AAEA,MAAI,CAAC,UAAU,QAAQ,GAAG;AACxB,UAAM,IAAI,MAAM,MAAM,oBAAoB,QAAQ,QAAQ,CAAC;AAAA,EAC7D;AAEA,SAAO;AAEP,WAAS,UAAU,SAAgD;AACjE,eAAO,qDAAsB;AAAA,MAC3B,GAAI,OAAO,kCAAkC,UAAa,EAAE,+BAA+B,OAAO,8BAA8B;AAAA,MAChI,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACF;AAQA,eAAsB,UAAU,QAAwC;AACtE,YAAM,uBAAW;AAAA,IACf,kBAAkB,CAAC,SAAS,SAAS,OAAO,OAAO,OAAO,MAAM,SAAS,GAAG,OAAO,OAAO,MAAM,SAAS,CAAC;AAAA,IAC1G,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AASA,eAAe,oBAAoB,QAAiC,UAAyD;AAC3H,QAAM,uBAAuB,OAAO,wBAAwB;AAC5D,gCAAU,sBAAsB,EAAE,WAAW,KAAK,CAAC;AAEnD,QAAM,qBAAiB,uBAAK,sBAAsB,yBAAyB;AAC3E,oCAAc,gBAAgB,UAAM,kDAAwB,EAAE,UAAU,OAAO,SAAS,CAAC,CAAC;AAE1F,QAAM,gBAAgB,UAAM,uBAAW;AAAA,IACrC,kBAAkB,CAAC,SAAS,WAAW,cAAc;AAAA,IACrD,UAAU,OAAO;AAAA,EACnB,CAAC;AAED,aAAO,kEAAmC;AAAA,IACxC,sBAAkB,qDAAsB,aAAa;AAAA,IACrD;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAQA,eAAe,yBAAyB,QAAwE;AAC9G,SAAO,UAAM,wCAAe;AAAA,IAC1B,SAAS,EAAE,cAAc,GAAiC;AACxD,YAAM,UAAU,SAAS,cAAc,aAAa;AAGpD,eAAS,OAAO,MAA4B;AAC1C,eAAO;AAAA,UACL,QAAQ,KAAK;AAAA,UACb,MAAM,KAAK;AAAA,UACX,KAAK,KAAK;AAAA,UACV,OAAO,KAAK;AAAA,QACd;AAAA,MACF;AAEA,aAAO;AAAA,QACL,kBAAkB,OAAO;AAAA,QACzB,aAAa,OAAO;AAAA,QACpB,WAAW,UAAU,OAAO,QAAQ,sBAAsB,CAAC,IAAI;AAAA,QAC/D,SAAS,OAAO;AAAA,MAClB;AAAA,IACF;AAAA,IACA,OAAO,EAAE,eAAe,OAAO,cAAc;AAAA,IAC7C,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,EACtE,CAAC;AACH;",
  "names": ["process", "sleep"]
}


package/dist/lib/cjs/soft-keyboard.d.cts

@@ -0,0 +1,82 @@
+/**
+ * @file
+ *
+ * Raises the Android soft keyboard for a screenshot, and proves it came up.
+ *
+ * Two things have to be true, and the second is the one that is easy to miss:
+ *
+ * 1. The device must be allowed to draw a keyboard at all. The screenshot AVDs
+ *    are built `hw.keyboard=yes`, so Android suppresses the on-screen one —
+ *    `withSoftKeyboardEnabled` in `device-settings` is what lifts that.
+ * 2. The IME must be *asked* for by a gesture. A field that takes focus
+ *    programmatically does not get one: an Android WebView raises the IME on a
+ *    real touch, and a run with the setting flipped and no touch comes back with
+ *    exactly the empty band it had before. `adb shell input tap` is that gesture.
+ *
+ * The geometry that decides whether it worked is unit-tested in
+ * `soft-keyboard-geometry`; everything here drives a real device, so the whole
+ * module is integration-time code.
+ */
+import type { SoftKeyboardTapPoint, SoftKeyboardViewportSnapshot } from './soft-keyboard-geometry.cjs';
+/**
+ * Parameters for {@link raiseSoftKeyboard}.
+ */
+export interface RaiseSoftKeyboardParams {
+    /**
+     * The device to touch.
+     */
+    readonly deviceId: string;
+    /**
+     * Where a failed attempt writes the device framebuffer.
+     *
+     * When omitted, it is `dist/screenshots` under the working directory — resolved at load, so there is no
+     * literal default to state here.
+     */
+    readonly diagnosticsDirectory?: string;
+    /**
+     * The CSS selector of the field to touch, e.g. `.prompt-input`.
+     */
+    readonly inputSelector: string;
+    /**
+     * The least a raised keyboard lifts the field by.
+     *
+     * When omitted, `DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS` from `soft-keyboard-geometry` applies.
+     */
+    readonly minimumKeyboardHeightInPixels?: number;
+    /**
+     * The vault to read the geometry from. When omitted, the current test context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Parameters for {@link tapDevice}.
+ */
+export interface TapDeviceParams {
+    /**
+     * The device to touch.
+     */
+    readonly deviceId: string;
+    /**
+     * Where to touch it.
+     */
+    readonly point: SoftKeyboardTapPoint;
+}
+/**
+ * Raises the on-screen keyboard with a real touch on a field, and confirms it came up.
+ *
+ * Call it inside `withSoftKeyboardEnabled` — the device setting alone does not raise the keyboard, and this
+ * touch alone cannot while the setting suppresses it.
+ *
+ * @param params - The device, the field to touch, and how far it must lift.
+ * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.
+ * @throws Error if the keyboard never came up, after writing the device framebuffer and the device's own
+ *   `input_method` state to the diagnostics directory.
+ */
+export declare function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot>;
+/**
+ * Touches the device at a point, the way a thumb would.
+ *
+ * @param params - The device and where to touch it.
+ * @returns A {@link Promise} that resolves once the touch has been dispatched.
+ */
+export declare function tapDevice(params: TapDeviceParams): Promise<void>;