obsidian-integration-testing 12.1.0 → 12.1.2

package/dist/lib/cjs/adb.cjs

@@ -0,0 +1,61 @@
+"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 adb_exports = {};
+__export(adb_exports, {
+  runAdbBinary: () => runAdbBinary,
+  runAdbText: () => runAdbText,
+  runAdbTextWithoutDevice: () => runAdbTextWithoutDevice
+});
+module.exports = __toCommonJS(adb_exports);
+var import_node_child_process = require("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) => {
+    (0, import_node_child_process.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) => {
+    (0, import_node_child_process.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());
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runAdbBinary,
+  runAdbText,
+  runAdbTextWithoutDevice
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -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/cjs/device-screenshot.cjs

@@ -0,0 +1,42 @@
+"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 device_screenshot_exports = {};
+__export(device_screenshot_exports, {
+  captureDeviceScreenshot: () => captureDeviceScreenshot
+});
+module.exports = __toCommonJS(device_screenshot_exports);
+var import_adb = require("./adb.cjs");
+var import_capture_screenshot = require("./capture-screenshot.cjs");
+async function captureDeviceScreenshot(params) {
+  const bytes = await (0, import_adb.runAdbBinary)({
+    commandArguments: ["exec-out", "screencap", "-p"],
+    deviceId: params.deviceId
+  });
+  if (!(0, import_capture_screenshot.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureDeviceScreenshot
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -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/cjs/device-setting-restore.cjs

@@ -0,0 +1,45 @@
+"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 device_setting_restore_exports = {};
+__export(device_setting_restore_exports, {
+  DeviceSettingRestoreKind: () => DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore: () => resolveDeviceSettingRestore
+});
+module.exports = __toCommonJS(device_setting_restore_exports);
+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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/device-setting-restore.d.cts

@@ -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/cjs/device-settings-command.cjs

@@ -0,0 +1,49 @@
+"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 device_settings_command_exports = {};
+__export(device_settings_command_exports, {
+  DeviceSettingNamespace: () => DeviceSettingNamespace,
+  DeviceSettingVerb: () => DeviceSettingVerb,
+  buildDeviceSettingsCommandArguments: () => buildDeviceSettingsCommandArguments
+});
+module.exports = __toCommonJS(device_settings_command_exports);
+var DeviceSettingNamespace = /* @__PURE__ */ ((DeviceSettingNamespace2) => {
+  DeviceSettingNamespace2["Global"] = "global";
+  DeviceSettingNamespace2["Secure"] = "secure";
+  DeviceSettingNamespace2["System"] = "system";
+  return DeviceSettingNamespace2;
+})(DeviceSettingNamespace || {});
+var DeviceSettingVerb = /* @__PURE__ */ ((DeviceSettingVerb2) => {
+  DeviceSettingVerb2["Delete"] = "delete";
+  DeviceSettingVerb2["Get"] = "get";
+  DeviceSettingVerb2["Put"] = "put";
+  return DeviceSettingVerb2;
+})(DeviceSettingVerb || {});
+function buildDeviceSettingsCommandArguments(params) {
+  const namespace = params.namespace ?? "secure" /* Secure */;
+  const value = params.verb === "put" /* Put */ && params.value !== void 0 ? [params.value] : [];
+  return ["shell", "settings", params.verb, namespace, params.name, ...value];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeviceSettingNamespace,
+  DeviceSettingVerb,
+  buildDeviceSettingsCommandArguments
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Builds the `adb shell settings …` argument list.
+ *
+ * Split out of {@link ./device-settings.ts} for the same reason
+ * {@link ./adb-device-list.ts} is split out of the transport factory: the
+ * argument list is pure and worth unit-testing, while the call that runs it is
+ * integration-time code that a unit test cannot reach. Keeping them in one file
+ * would put the namespace default inside a coverage-ignored block, where nothing
+ * checks that it is what the documentation claims.
+ */
+/**
+ * The `settings` namespaces this helper addresses.
+ */
+export declare enum DeviceSettingNamespace {
+    /**
+     * Device-wide settings, e.g. `hide_error_dialogs`.
+     */
+    Global = "global",
+    /**
+     * Per-user settings the system reads, e.g. `show_ime_with_hard_keyboard`.
+     */
+    Secure = "secure",
+    /**
+     * Per-user settings apps may read, e.g. `screen_brightness`.
+     */
+    System = "system"
+}
+/**
+ * The `settings` sub-commands this helper issues.
+ */
+export declare enum DeviceSettingVerb {
+    /**
+     * Removes the setting, returning it to never-having-been-written.
+     */
+    Delete = "delete",
+    /**
+     * Reads the setting, printing `null` when it has never been written.
+     */
+    Get = "get",
+    /**
+     * Writes the setting.
+     */
+    Put = "put"
+}
+/**
+ * Parameters for {@link buildDeviceSettingsCommandArguments}.
+ */
+export interface BuildDeviceSettingsCommandArgumentsParams {
+    /**
+     * 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;
+    /**
+     * The value to write. Meaningful only for {@link DeviceSettingVerb.Put}.
+     */
+    readonly value?: string;
+    /**
+     * The sub-command to issue.
+     */
+    readonly verb: DeviceSettingVerb;
+}
+/**
+ * Builds the arguments for `adb shell settings <verb> <namespace> <name> [value]`.
+ *
+ * @param params - The sub-command, the setting, its namespace and — for a write — its value.
+ * @returns The arguments to hand to `runAdbText`, `shell` included.
+ */
+export declare function buildDeviceSettingsCommandArguments(params: BuildDeviceSettingsCommandArgumentsParams): string[];

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

@@ -0,0 +1,88 @@
+"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 device_settings_exports = {};
+__export(device_settings_exports, {
+  deleteDeviceSetting: () => deleteDeviceSetting,
+  readDeviceSetting: () => readDeviceSetting,
+  withSoftKeyboardEnabled: () => withSoftKeyboardEnabled,
+  writeDeviceSetting: () => writeDeviceSetting
+});
+module.exports = __toCommonJS(device_settings_exports);
+var import_adb = require("./adb.cjs");
+var import_device_setting_restore = require("./device-setting-restore.cjs");
+var import_device_settings_command = require("./device-settings-command.cjs");
+const SOFT_KEYBOARD_SETTING_NAME = "show_ime_with_hard_keyboard";
+const SOFT_KEYBOARD_SETTING_ON = "1";
+async function deleteDeviceSetting(params) {
+  await (0, import_adb.runAdbText)({
+    commandArguments: (0, import_device_settings_command.buildDeviceSettingsCommandArguments)({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      verb: import_device_settings_command.DeviceSettingVerb.Delete
+    }),
+    deviceId: params.deviceId
+  });
+}
+async function readDeviceSetting(params) {
+  return await (0, import_adb.runAdbText)({
+    commandArguments: (0, import_device_settings_command.buildDeviceSettingsCommandArguments)({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      verb: import_device_settings_command.DeviceSettingVerb.Get
+    }),
+    deviceId: params.deviceId
+  });
+}
+async function withSoftKeyboardEnabled(params) {
+  const settingParams = {
+    deviceId: params.deviceId,
+    name: SOFT_KEYBOARD_SETTING_NAME
+  };
+  const previousValue = await readDeviceSetting(settingParams);
+  await writeDeviceSetting({ ...settingParams, value: SOFT_KEYBOARD_SETTING_ON });
+  try {
+    return await params.callback();
+  } finally {
+    const restore = (0, import_device_setting_restore.resolveDeviceSettingRestore)(previousValue);
+    if (restore.kind === import_device_setting_restore.DeviceSettingRestoreKind.Delete) {
+      await deleteDeviceSetting(settingParams);
+    } else {
+      await writeDeviceSetting({ ...settingParams, value: restore.value });
+    }
+  }
+}
+async function writeDeviceSetting(params) {
+  await (0, import_adb.runAdbText)({
+    commandArguments: (0, import_device_settings_command.buildDeviceSettingsCommandArguments)({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      value: params.value,
+      verb: import_device_settings_command.DeviceSettingVerb.Put
+    }),
+    deviceId: params.deviceId
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteDeviceSetting,
+  readDeviceSetting,
+  withSoftKeyboardEnabled,
+  writeDeviceSetting
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/device-settings.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and writes Android device settings \u2014 and wraps the one setting a\n * screenshot suite has to change.\n *\n * The screenshot AVDs are built `hw.keyboard=yes`, so Android suppresses the\n * on-screen keyboard even where the page asks for one. `show_ime_with_hard_keyboard`\n * is what turns it back on. {@link withSoftKeyboardEnabled} flips it, runs the\n * work, and puts the device back exactly as it found it \u2014 including restoring a\n * setting that had never been written, which takes a delete rather than a write\n * (see `device-setting-restore`).\n *\n * Every function here shells out, so the whole module is integration-time code;\n * the restore decision and the argument list it depends on are unit-tested in\n * their own modules.\n */\n\n/* v8 ignore start -- Integration-time code (shells out to a real device) covered by integration tests, not unit tests. */\n\nimport type { DeviceSettingNamespace } from './device-settings-command.cjs';\n\nimport { runAdbText } from './adb.cjs';\nimport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nimport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\n\n/**\n * Parameters for {@link deleteDeviceSetting} and {@link readDeviceSetting}.\n */\nexport interface DeviceSettingParams {\n  /**\n   * The device to address.\n   */\n  readonly deviceId: string;\n\n  /**\n   * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.\n   */\n  readonly name: string;\n\n  /**\n   * The settings namespace the name lives in.\n   *\n   * @default {@link DeviceSettingNamespace.Secure}\n   */\n  readonly namespace?: DeviceSettingNamespace;\n}\n\n/**\n * Parameters for {@link withSoftKeyboardEnabled}.\n *\n * @typeParam T - What the wrapped work returns.\n */\nexport interface WithSoftKeyboardEnabledParams<T> {\n  /**\n   * The work to run while the on-screen keyboard is permitted.\n   */\n  readonly callback: (this: void) => Promise<T>;\n\n  /**\n   * The device to address.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * Parameters for {@link writeDeviceSetting}.\n */\nexport interface WriteDeviceSettingParams extends DeviceSettingParams {\n  /**\n   * The value to write.\n   */\n  readonly value: string;\n}\n\n/**\n * The setting deciding whether Android draws a keyboard while a hardware one is attached.\n */\nconst SOFT_KEYBOARD_SETTING_NAME = 'show_ime_with_hard_keyboard';\n\nconst SOFT_KEYBOARD_SETTING_ON = '1';\n\n/**\n * Clears a device setting, returning it to never-having-been-written.\n *\n * @param params - The device, the setting and its namespace.\n * @returns A {@link Promise} that resolves once the setting is gone.\n */\nexport async function deleteDeviceSetting(params: DeviceSettingParams): Promise<void> {\n  await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      verb: DeviceSettingVerb.Delete\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Reads a device setting.\n *\n * @param params - The device, the setting and its namespace.\n * @returns A {@link Promise} that resolves to the setting's value, or the literal `null` when it has never\n *   been written.\n */\nexport async function readDeviceSetting(params: DeviceSettingParams): Promise<string> {\n  return await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      verb: DeviceSettingVerb.Get\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Permits the on-screen keyboard for the duration of a callback, then restores the device exactly.\n *\n * The restore runs whether the callback succeeded or threw \u2014 a suite that dies mid-capture must not leave\n * the device configured differently than it found it.\n *\n * @typeParam T - What the wrapped work returns.\n * @param params - The device and the work to run.\n * @returns A {@link Promise} that resolves to whatever the callback returned.\n */\nexport async function withSoftKeyboardEnabled<T>(params: WithSoftKeyboardEnabledParams<T>): Promise<T> {\n  const settingParams: DeviceSettingParams = {\n    deviceId: params.deviceId,\n    name: SOFT_KEYBOARD_SETTING_NAME\n  };\n\n  const previousValue = await readDeviceSetting(settingParams);\n  await writeDeviceSetting({ ...settingParams, value: SOFT_KEYBOARD_SETTING_ON });\n\n  try {\n    return await params.callback();\n  } finally {\n    const restore = resolveDeviceSettingRestore(previousValue);\n    if (restore.kind === DeviceSettingRestoreKind.Delete) {\n      await deleteDeviceSetting(settingParams);\n    } else {\n      await writeDeviceSetting({ ...settingParams, value: restore.value });\n    }\n  }\n}\n\n/**\n * Writes a device setting.\n *\n * @param params - The device, the setting, its namespace and the value to write.\n * @returns A {@link Promise} that resolves once the setting is written.\n */\nexport async function writeDeviceSetting(params: WriteDeviceSettingParams): Promise<void> {\n  await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      value: params.value,\n      verb: DeviceSettingVerb.Put\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,iBAA2B;AAC3B,oCAGO;AACP,qCAGO;AAsDP,MAAM,6BAA6B;AAEnC,MAAM,2BAA2B;AAQjC,eAAsB,oBAAoB,QAA4C;AACpF,YAAM,uBAAW;AAAA,IACf,sBAAkB,oEAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,MAAM,iDAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AASA,eAAsB,kBAAkB,QAA8C;AACpF,SAAO,UAAM,uBAAW;AAAA,IACtB,sBAAkB,oEAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,MAAM,iDAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AAYA,eAAsB,wBAA2B,QAAsD;AACrG,QAAM,gBAAqC;AAAA,IACzC,UAAU,OAAO;AAAA,IACjB,MAAM;AAAA,EACR;AAEA,QAAM,gBAAgB,MAAM,kBAAkB,aAAa;AAC3D,QAAM,mBAAmB,EAAE,GAAG,eAAe,OAAO,yBAAyB,CAAC;AAE9E,MAAI;AACF,WAAO,MAAM,OAAO,SAAS;AAAA,EAC/B,UAAE;AACA,UAAM,cAAU,2DAA4B,aAAa;AACzD,QAAI,QAAQ,SAAS,uDAAyB,QAAQ;AACpD,YAAM,oBAAoB,aAAa;AAAA,IACzC,OAAO;AACL,YAAM,mBAAmB,EAAE,GAAG,eAAe,OAAO,QAAQ,MAAM,CAAC;AAAA,IACrE;AAAA,EACF;AACF;AAQA,eAAsB,mBAAmB,QAAiD;AACxF,YAAM,uBAAW;AAAA,IACf,sBAAkB,oEAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,OAAO,OAAO;AAAA,MACd,MAAM,iDAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;",
  "names": []
}
