obsidian-integration-testing 12.1.0 → 12.1.1

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>;

package/dist/lib/esm/adb.d.mts

@@ -0,0 +1,61 @@
+/**
+ * @file
+ *
+ * Runs `adb` and hands back what it printed — as text, or as raw bytes.
+ *
+ * The harness already shells out to `adb` in half a dozen places inside
+ * `transport-factory` / `transport-appium`, but always through `exec`, which
+ * decodes stdout as UTF-8. That is fine for `devices` and `settings get` and
+ * fatally wrong for `exec-out screencap -p`, whose stdout is a PNG: decoding it
+ * as text corrupts every byte above 0x7F. Hence the two runners here — the same
+ * command shape, differing only in whether the output is decoded.
+ *
+ * These are the process layer for the device-facing helpers a capture suite
+ * uses (`device-screenshot`, `device-settings`, `soft-keyboard`); they are not a
+ * general-purpose adb wrapper and deliberately do not try to become one.
+ *
+ * Every function here shells out, so the whole module is integration-time code.
+ * That is also why the parsing and geometry these helpers depend on live in
+ * their own modules — the same split `adb-device-list` already has from the
+ * transport factory, so a sort rule can never move a unit-tested function
+ * inside a coverage-ignored block.
+ */
+/**
+ * Parameters for {@link runAdbBinary} and {@link runAdbText}.
+ */
+export interface RunAdbParams {
+    /**
+     * The arguments to pass after `-s <deviceId>`, e.g. `['shell', 'input', 'tap', '10', '20']`.
+     */
+    readonly commandArguments: readonly string[];
+    /**
+     * The device to address, as `adb devices` lists it.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Runs `adb -s <deviceId> <commandArguments>` and returns stdout **undecoded**.
+ *
+ * @param params - The device and the arguments to run.
+ * @returns A {@link Promise} that resolves to the raw stdout bytes.
+ * @throws Error if adb could not be run, or exited non-zero.
+ */
+export declare function runAdbBinary(params: RunAdbParams): Promise<Uint8Array>;
+/**
+ * Runs `adb -s <deviceId> <commandArguments>` and returns stdout as trimmed text.
+ *
+ * @param params - The device and the arguments to run.
+ * @returns A {@link Promise} that resolves to stdout, with surrounding whitespace removed.
+ * @throws Error if adb could not be run, or exited non-zero.
+ */
+export declare function runAdbText(params: RunAdbParams): Promise<string>;
+/**
+ * Runs `adb <commandArguments>` with no device selected.
+ *
+ * Only `devices` needs this — every other call in this family addresses one device.
+ *
+ * @param commandArguments - The arguments to run.
+ * @returns A {@link Promise} that resolves to stdout, with surrounding whitespace removed.
+ * @throws Error if adb could not be run, or exited non-zero.
+ */
+export declare function runAdbTextWithoutDevice(commandArguments: readonly string[]): Promise<string>;

package/dist/lib/esm/adb.mjs

@@ -0,0 +1,35 @@
+import { execFile } from "node:child_process";
+const OUTPUT_MAX_BUFFER_IN_BYTES = 67108864;
+async function runAdbBinary(params) {
+  const commandArguments = ["-s", params.deviceId, ...params.commandArguments];
+  return await new Promise((resolve, reject) => {
+    execFile("adb", commandArguments, { encoding: "buffer", maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES }, (error, stdout) => {
+      if (error) {
+        reject(new Error(`Failed to run 'adb ${commandArguments.join(" ")}': ${error.message}. Is ADB installed and in PATH?`));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+async function runAdbText(params) {
+  const stdout = await runAdbBinary(params);
+  return new TextDecoder().decode(stdout).trim();
+}
+async function runAdbTextWithoutDevice(commandArguments) {
+  return await new Promise((resolve, reject) => {
+    execFile("adb", [...commandArguments], { encoding: "utf-8", maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES }, (error, stdout) => {
+      if (error) {
+        reject(new Error(`Failed to run 'adb ${commandArguments.join(" ")}': ${error.message}. Is ADB installed and in PATH?`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+export {
+  runAdbBinary,
+  runAdbText,
+  runAdbTextWithoutDevice
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/device-screenshot.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @file
+ *
+ * Photographs the DEVICE, not the web page.
+ *
+ * `captureObsidianScreenshot` goes through Appium in the WebView context, so on
+ * Android it captures the page: no status bar, and — the reason this exists —
+ * no soft keyboard, because the IME is a system window and not part of the
+ * page. A frame that is meant to show what a phone looks like therefore cannot
+ * be taken that way.
+ *
+ * `adb exec-out screencap -p` reads the framebuffer instead, which is the same
+ * route the trusted-input passes already use. The trade is deliberate and worth
+ * writing down at every call site: a device capture carries the status-bar clock
+ * and battery, so it is **not byte-reproducible** the way a page capture is.
+ * Reach for this only for the shots that need the keyboard; leave the rest on
+ * `captureObsidianScreenshot`.
+ */
+/**
+ * Parameters for {@link captureDeviceScreenshot}.
+ */
+export interface CaptureDeviceScreenshotParams {
+    /**
+     * The device to photograph.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Captures the device's framebuffer as a PNG.
+ *
+ * @param params - The device to photograph.
+ * @returns A {@link Promise} that resolves to the raw PNG bytes.
+ * @throws Error if what came back is not a PNG — which is what a truncated or text-decoded capture looks
+ *   like, and is far cheaper to catch here than in an image diff.
+ */
+export declare function captureDeviceScreenshot(params: CaptureDeviceScreenshotParams): Promise<Uint8Array>;

package/dist/lib/esm/device-screenshot.mjs

@@ -0,0 +1,18 @@
+import { runAdbBinary } from "./adb.mjs";
+import { isPng } from "./capture-screenshot.mjs";
+async function captureDeviceScreenshot(params) {
+  const bytes = await runAdbBinary({
+    commandArguments: ["exec-out", "screencap", "-p"],
+    deviceId: params.deviceId
+  });
+  if (!isPng(bytes)) {
+    throw new Error(
+      `captureDeviceScreenshot: ${params.deviceId} returned ${String(bytes.length)} bytes that are not a PNG. A device that is still booting, or an adb transport that decoded the stream as text, both look like this.`
+    );
+  }
+  return bytes;
+}
+export {
+  captureDeviceScreenshot
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/device-setting-restore.d.mts

@@ -0,0 +1,60 @@
+/**
+ * @file
+ *
+ * Decides how a device setting that was changed for a capture gets put back.
+ *
+ * A suite that flips a setting owes the device its original value back —
+ * including the case where it never had one. `settings get` prints the literal
+ * `null` for a setting that has never been written, and `settings put … null`
+ * does **not** reproduce that state: it writes the four-character string
+ * `null`. Restoring an unset setting takes `settings delete`, which is why this
+ * is a decision rather than a straight write-back.
+ *
+ * Pure and unit-tested; the calls that carry it out live in `device-settings`.
+ */
+/**
+ * How a setting is restored.
+ */
+export declare enum DeviceSettingRestoreKind {
+    /**
+     * The setting had never been written, so restoring it means removing it again.
+     */
+    Delete = "delete",
+    /**
+     * The setting held a value, which is written back verbatim.
+     */
+    Write = "write"
+}
+/**
+ * What restoring a setting requires: putting a value back, or removing it again.
+ */
+export type DeviceSettingRestore = DeviceSettingRestoreDelete | DeviceSettingRestoreWrite;
+/**
+ * Restoring a setting by removing it, because it had never been written.
+ */
+export interface DeviceSettingRestoreDelete {
+    /**
+     * Discriminates the union.
+     */
+    readonly kind: DeviceSettingRestoreKind.Delete;
+}
+/**
+ * Restoring a setting by writing its previous value back.
+ */
+export interface DeviceSettingRestoreWrite {
+    /**
+     * Discriminates the union.
+     */
+    readonly kind: DeviceSettingRestoreKind.Write;
+    /**
+     * The value to write back, exactly as it was read.
+     */
+    readonly value: string;
+}
+/**
+ * Decides how a setting read before a change is put back afterwards.
+ *
+ * @param previousValue - Exactly what `readDeviceSetting` returned before the change.
+ * @returns Whether to write the value back or to remove the setting again.
+ */
+export declare function resolveDeviceSettingRestore(previousValue: string): DeviceSettingRestore;

package/dist/lib/esm/device-setting-restore.mjs

@@ -0,0 +1,20 @@
+var DeviceSettingRestoreKind = /* @__PURE__ */ ((DeviceSettingRestoreKind2) => {
+  DeviceSettingRestoreKind2["Delete"] = "delete";
+  DeviceSettingRestoreKind2["Write"] = "write";
+  return DeviceSettingRestoreKind2;
+})(DeviceSettingRestoreKind || {});
+const UNSET_SETTING_VALUE = "null";
+function resolveDeviceSettingRestore(previousValue) {
+  if (previousValue === UNSET_SETTING_VALUE) {
+    return { kind: "delete" /* Delete */ };
+  }
+  return {
+    kind: "write" /* Write */,
+    value: previousValue
+  };
+}
+export {
+  DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore
+};
+//# sourceMappingURL=data:application/json;base64,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