obsidian-integration-testing 10.4.0 → 12.0.0

package/dist/lib/cjs/mobile-input.cjs

@@ -0,0 +1,161 @@
+"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 mobile_input_exports = {};
+__export(mobile_input_exports, {
+  MOBILE_INPUT_BINDING_NAME: () => MOBILE_INPUT_BINDING_NAME,
+  MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS: () => MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS,
+  buildResolveInputExpression: () => buildResolveInputExpression,
+  codePointOf: () => codePointOf,
+  toCdpInputCommands: () => toCdpInputCommands,
+  toCdpModifiers: () => toCdpModifiers
+});
+module.exports = __toCommonJS(mobile_input_exports);
+const MOBILE_INPUT_BINDING_NAME = "__obsidianIntegrationTestingInput";
+const MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS = 15e3;
+const LONG_PRESS_DWELL_IN_MILLISECONDS = 600;
+const NO_MODIFIERS = 0;
+const MODIFIER_BIT_ALT = 1;
+const MODIFIER_BIT_CONTROL = 2;
+const MODIFIER_BIT_META = 4;
+const MODIFIER_BIT_SHIFT = 8;
+const CDP_MODIFIER_BIT_BY_NAME = /* @__PURE__ */ new Map([
+  ["alt", MODIFIER_BIT_ALT],
+  ["control", MODIFIER_BIT_CONTROL],
+  ["meta", MODIFIER_BIT_META],
+  ["shift", MODIFIER_BIT_SHIFT]
+]);
+const KEY_CODE_BACKSPACE = 8;
+const KEY_CODE_TAB = 9;
+const KEY_CODE_ENTER = 13;
+const KEY_CODE_ESCAPE = 27;
+const KEY_CODE_ARROW_LEFT = 37;
+const KEY_CODE_ARROW_UP = 38;
+const KEY_CODE_ARROW_RIGHT = 39;
+const KEY_CODE_ARROW_DOWN = 40;
+const KEY_CODE_DELETE = 46;
+const NAMED_KEYS = /* @__PURE__ */ new Map([
+  ["ArrowDown", { code: "ArrowDown", windowsVirtualKeyCode: KEY_CODE_ARROW_DOWN }],
+  ["ArrowLeft", { code: "ArrowLeft", windowsVirtualKeyCode: KEY_CODE_ARROW_LEFT }],
+  ["ArrowRight", { code: "ArrowRight", windowsVirtualKeyCode: KEY_CODE_ARROW_RIGHT }],
+  ["ArrowUp", { code: "ArrowUp", windowsVirtualKeyCode: KEY_CODE_ARROW_UP }],
+  ["Backspace", { code: "Backspace", windowsVirtualKeyCode: KEY_CODE_BACKSPACE }],
+  ["Delete", { code: "Delete", windowsVirtualKeyCode: KEY_CODE_DELETE }],
+  ["Enter", { code: "Enter", text: "\r", windowsVirtualKeyCode: KEY_CODE_ENTER }],
+  ["Escape", { code: "Escape", windowsVirtualKeyCode: KEY_CODE_ESCAPE }],
+  ["Tab", { code: "Tab", text: "	", windowsVirtualKeyCode: KEY_CODE_TAB }]
+]);
+const FIRST_CODE_POINT_INDEX = 0;
+const DIGIT_ZERO_CODE_POINT = codePointOf("0");
+const DIGIT_NINE_CODE_POINT = codePointOf("9");
+const UPPERCASE_A_CODE_POINT = codePointOf("A");
+const UPPERCASE_Z_CODE_POINT = codePointOf("Z");
+function buildResolveInputExpression(id, errorMessage) {
+  return `window.__obsidianIntegrationTesting?.resolveInput?.(${JSON.stringify(id)}, ${JSON.stringify(errorMessage ?? null)})`;
+}
+function codePointOf(text) {
+  const codePoint = text.codePointAt(FIRST_CODE_POINT_INDEX);
+  if (codePoint === void 0) {
+    throw new Error("codePointOf received an empty string.");
+  }
+  return codePoint;
+}
+function toCdpInputCommands(request) {
+  if (request.kind === "key") {
+    return toKeyCommands(request);
+  }
+  return toPointerCommands(request);
+}
+function toCdpModifiers(modifiers) {
+  const bits = /* @__PURE__ */ new Set();
+  for (const modifier of modifiers) {
+    const bit = CDP_MODIFIER_BIT_BY_NAME.get(modifier);
+    if (bit !== void 0) {
+      bits.add(bit);
+    }
+  }
+  let bitmask = NO_MODIFIERS;
+  for (const bit of bits) {
+    bitmask += bit;
+  }
+  return bitmask;
+}
+function resolveKey(key) {
+  const namedKey = NAMED_KEYS.get(key);
+  if (namedKey) {
+    return namedKey;
+  }
+  const codePoint = key.codePointAt(FIRST_CODE_POINT_INDEX);
+  if (codePoint === void 0 || String.fromCodePoint(codePoint) !== key) {
+    throw new Error(
+      `pressKey received an unknown key name on mobile: ${JSON.stringify(key)}. Pass a single character or one of: ${[...NAMED_KEYS.keys()].join(", ")}.`
+    );
+  }
+  const upperCasedCodePoint = codePointOf(key.toUpperCase());
+  return {
+    code: resolveKeyCode(upperCasedCodePoint),
+    text: key,
+    windowsVirtualKeyCode: upperCasedCodePoint
+  };
+}
+function resolveKeyCode(upperCasedCodePoint) {
+  if (upperCasedCodePoint >= UPPERCASE_A_CODE_POINT && upperCasedCodePoint <= UPPERCASE_Z_CODE_POINT) {
+    return `Key${String.fromCodePoint(upperCasedCodePoint)}`;
+  }
+  if (upperCasedCodePoint >= DIGIT_ZERO_CODE_POINT && upperCasedCodePoint <= DIGIT_NINE_CODE_POINT) {
+    return `Digit${String.fromCodePoint(upperCasedCodePoint)}`;
+  }
+  return "";
+}
+function toKeyCommands(request) {
+  const { code, text, windowsVirtualKeyCode } = resolveKey(request.key);
+  const modifiers = toCdpModifiers(request.modifiers);
+  const base = { code, key: request.key, modifiers, windowsVirtualKeyCode };
+  const commands = [
+    { method: "Input.dispatchKeyEvent", params: { ...base, type: "rawKeyDown" } }
+  ];
+  if (text !== void 0) {
+    commands.push({ method: "Input.dispatchKeyEvent", params: { ...base, text, type: "char" } });
+  }
+  commands.push({ method: "Input.dispatchKeyEvent", params: { ...base, type: "keyUp" } });
+  return commands;
+}
+function toPointerCommands(request) {
+  const modifiers = toCdpModifiers(request.modifiers);
+  return [
+    {
+      method: "Input.dispatchTouchEvent",
+      params: { modifiers, touchPoints: [{ x: request.x, y: request.y }], type: "touchStart" }
+    },
+    {
+      ...request.kind === "longPress" && { delayBeforeInMilliseconds: LONG_PRESS_DWELL_IN_MILLISECONDS },
+      method: "Input.dispatchTouchEvent",
+      params: { modifiers, touchPoints: [], type: "touchEnd" }
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MOBILE_INPUT_BINDING_NAME,
+  MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS,
+  buildResolveInputExpression,
+  codePointOf,
+  toCdpInputCommands,
+  toCdpModifiers
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/mobile-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Translates a mobile trusted-input request into the ordered Chrome DevTools Protocol `Input.*` commands\n * that realize it (see **L39**).\n *\n * Pure and synchronous by design: the WebView connection ({@link WebViewCdpConnection}) sends whatever this\n * returns, so every decision that is worth a test \u2014 the touch pair a tap expands into, the dwell a\n * long-press adds, the `rawKeyDown` \u2192 `char` \u2192 `keyUp` shape a key press mirrors from the desktop twin, the\n * modifier bitmask \u2014 lives here rather than inside the transport's I/O path.\n *\n * The request travels renderer \u2192 host as JSON (the renderer computes the coordinates, because only it can\n * see the DOM), so both the request and the command shapes are deliberately plain data.\n */\n\n/**\n * The name of the `Runtime.addBinding` function the host exposes on the page so the renderer can hand it an\n * input request mid-closure.\n *\n * It is passed *into* the serialized bootstrap closure as data rather than referenced from it, because that\n * closure may not read outer scope (**L15**) \u2014 so this stays the single definition.\n */\nexport const MOBILE_INPUT_BINDING_NAME = '__obsidianIntegrationTestingInput';\n\n/**\n * How long the renderer waits for the host to service one input request before giving up.\n *\n * Generous relative to the work (a tap is two CDP commands; a long-press adds a 600ms dwell): the point is\n * to fail with a legible error rather than hang the closure until the whole run times out. Passed into the\n * bootstrap closure as data, for the same reason as {@link MOBILE_INPUT_BINDING_NAME}.\n */\nexport const MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS = 15_000;\n\n/**\n * A single Chrome DevTools Protocol command, plus how long to wait before sending it.\n *\n * The delay is carried here rather than applied by the producer so that the whole sequence stays pure\n * data \u2014 a test asserts the dwell without waiting for it.\n */\nexport interface CdpInputCommand {\n  /**\n   * Milliseconds to wait before sending this command. Absent means \"send immediately\".\n   *\n   * Used only by the long-press dwell.\n   */\n  readonly delayBeforeInMilliseconds?: number;\n\n  /**\n   * The CDP method name, e.g. `Input.dispatchTouchEvent`.\n   */\n  readonly method: string;\n\n  /**\n   * The CDP method parameters.\n   */\n  readonly params: Record<string, unknown>;\n}\n\n/**\n * What the renderer hands to the host binding: one request, plus the id to answer it on.\n *\n * The renderer builds this literal inside the serialized bootstrap closure, which cannot import (**L15**),\n * so the shape is declared here and mirrored there. They are one wire format; change them together.\n */\nexport interface MobileInputEnvelope {\n  /**\n   * The request id the renderer is waiting on.\n   */\n  readonly id: string;\n\n  /**\n   * What to inject.\n   */\n  readonly request: MobileInputRequest;\n}\n\n/**\n * Anything the renderer can ask the host to inject.\n */\nexport type MobileInputRequest = MobileKeyInputRequest | MobilePointerInputRequest;\n\n/**\n * A trusted key press to inject on mobile.\n */\nexport interface MobileKeyInputRequest {\n  /**\n   * The key to press, in the same spelling the desktop twin takes: either a named key\n   * (`Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, an arrow) or a single printable character.\n   */\n  readonly key: string;\n\n  /**\n   * Discriminant.\n   */\n  readonly kind: 'key';\n\n  /**\n   * Modifiers already resolved to their platform-independent lowercase names by the renderer's\n   * `toElectronModifiers` \u2014 the one mapping a key press and a click share, so `'Mod'` cannot mean two\n   * different things (**L17**).\n   */\n  readonly modifiers: readonly string[];\n}\n\n/**\n * A trusted pointer gesture to inject on mobile, in CSS pixels within the WebView's own viewport.\n *\n * No device-pixel conversion is involved: CDP takes page coordinates, so `devicePixelRatio` and the\n * WebView's offset under the status bar never enter the picture (they would for native injection).\n */\nexport interface MobilePointerInputRequest {\n  /**\n   * `tap` is the touch analog of a left click; `longPress` is the mobile context-menu gesture, i.e. what a\n   * desktop right click means here.\n   */\n  readonly kind: 'longPress' | 'tap';\n\n  /**\n   * See {@link MobileKeyInputRequest.modifiers}.\n   */\n  readonly modifiers: readonly string[];\n\n  /**\n   * The viewport x coordinate, in CSS pixels.\n   */\n  readonly x: number;\n\n  /**\n   * The viewport y coordinate, in CSS pixels.\n   */\n  readonly y: number;\n}\n\n/**\n * How long a long-press holds the touch down before releasing it.\n *\n * Obsidian Mobile implements long-press in JavaScript (a timer started on `touchstart`) rather than\n * relying on a native gesture, so this has to clear *its* threshold, not Android's. 600ms is the\n * conventional Android long-press threshold and clears Obsidian's comfortably.\n */\nconst LONG_PRESS_DWELL_IN_MILLISECONDS = 600;\n\nconst NO_MODIFIERS = 0;\nconst MODIFIER_BIT_ALT = 1;\nconst MODIFIER_BIT_CONTROL = 2;\nconst MODIFIER_BIT_META = 4;\nconst MODIFIER_BIT_SHIFT = 8;\n\n/**\n * CDP's modifier bitmask, which is not the same spelling as Electron's string list.\n *\n * @see {@link https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchKeyEvent}\n */\nconst CDP_MODIFIER_BIT_BY_NAME = new Map<string, number>([\n  ['alt', MODIFIER_BIT_ALT],\n  ['control', MODIFIER_BIT_CONTROL],\n  ['meta', MODIFIER_BIT_META],\n  ['shift', MODIFIER_BIT_SHIFT]\n]);\n\nconst KEY_CODE_BACKSPACE = 8;\nconst KEY_CODE_TAB = 9;\nconst KEY_CODE_ENTER = 13;\nconst KEY_CODE_ESCAPE = 27;\nconst KEY_CODE_ARROW_LEFT = 37;\nconst KEY_CODE_ARROW_UP = 38;\nconst KEY_CODE_ARROW_RIGHT = 39;\nconst KEY_CODE_ARROW_DOWN = 40;\nconst KEY_CODE_DELETE = 46;\n\n/**\n * Named keys, with the `text` a real key press would produce (absent when it produces none).\n *\n * Only keys the fleet actually presses are listed, plus the editing keys a caller would reasonably reach\n * for next. An unknown multi-character key is a caller error, not a silent no-op \u2014 see\n * {@link toKeyCommands}.\n */\nconst NAMED_KEYS = new Map<string, NamedKey>([\n  ['ArrowDown', { code: 'ArrowDown', windowsVirtualKeyCode: KEY_CODE_ARROW_DOWN }],\n  ['ArrowLeft', { code: 'ArrowLeft', windowsVirtualKeyCode: KEY_CODE_ARROW_LEFT }],\n  ['ArrowRight', { code: 'ArrowRight', windowsVirtualKeyCode: KEY_CODE_ARROW_RIGHT }],\n  ['ArrowUp', { code: 'ArrowUp', windowsVirtualKeyCode: KEY_CODE_ARROW_UP }],\n  ['Backspace', { code: 'Backspace', windowsVirtualKeyCode: KEY_CODE_BACKSPACE }],\n  ['Delete', { code: 'Delete', windowsVirtualKeyCode: KEY_CODE_DELETE }],\n  ['Enter', { code: 'Enter', text: '\\r', windowsVirtualKeyCode: KEY_CODE_ENTER }],\n  ['Escape', { code: 'Escape', windowsVirtualKeyCode: KEY_CODE_ESCAPE }],\n  ['Tab', { code: 'Tab', text: '\\t', windowsVirtualKeyCode: KEY_CODE_TAB }]\n]);\n\nconst FIRST_CODE_POINT_INDEX = 0;\nconst DIGIT_ZERO_CODE_POINT = codePointOf('0');\nconst DIGIT_NINE_CODE_POINT = codePointOf('9');\nconst UPPERCASE_A_CODE_POINT = codePointOf('A');\nconst UPPERCASE_Z_CODE_POINT = codePointOf('Z');\n\n/**\n * The CDP spelling of one named key.\n */\ninterface NamedKey {\n  readonly code: string;\n  readonly text?: string;\n  readonly windowsVirtualKeyCode: number;\n}\n\n/**\n * Builds the expression the host evaluates to answer one input request.\n *\n * Optional chaining throughout: by the time the host answers, the page may have navigated and dropped the\n * namespace, and a `TypeError` inside this evaluate would be reported as an injection failure that already\n * succeeded.\n *\n * @param id - The request id the renderer is waiting on.\n * @param errorMessage - Why the injection failed, when it did. Omit on success.\n * @returns A self-contained expression to pass to `Runtime.evaluate`.\n */\nexport function buildResolveInputExpression(id: string, errorMessage?: string): string {\n  return `window.__obsidianIntegrationTesting?.resolveInput?.(${JSON.stringify(id)}, ${JSON.stringify(errorMessage ?? null)})`;\n}\n\n/**\n * The first code point of a non-empty string.\n *\n * `String.prototype.codePointAt` is typed `number | undefined`, so every call site would otherwise carry a\n * `?? fallback` that no input can ever reach \u2014 a dead branch under the 100% coverage gate. Throwing here\n * keeps that impossible case in ONE place, where a unit test can reach it directly, instead of spreading\n * unreachable fallbacks (or coverage suppressions) across the module.\n *\n * @param text - A non-empty string.\n * @returns Its first code point.\n * @throws When `text` is empty.\n */\nexport function codePointOf(text: string): number {\n  const codePoint = text.codePointAt(FIRST_CODE_POINT_INDEX);\n  if (codePoint === undefined) {\n    throw new Error('codePointOf received an empty string.');\n  }\n\n  return codePoint;\n}\n\n/**\n * Translates a mobile input request into the ordered CDP commands that realize it.\n *\n * @param request - What the renderer asked the host to inject.\n * @returns The commands to send, in order.\n */\nexport function toCdpInputCommands(request: MobileInputRequest): CdpInputCommand[] {\n  if (request.kind === 'key') {\n    return toKeyCommands(request);\n  }\n\n  return toPointerCommands(request);\n}\n\n/**\n * Folds resolved modifier names into CDP's bitmask.\n *\n * Unknown names are ignored rather than throwing: the renderer's `toElectronModifiers` is exhaustive over\n * Obsidian's `Modifier` union, so an unknown name here would mean the two copies have already drifted, and\n * failing the whole gesture is a worse outcome than pressing it unmodified.\n *\n * @param modifiers - Resolved lowercase modifier names.\n * @returns The CDP modifier bitmask.\n */\nexport function toCdpModifiers(modifiers: readonly string[]): number {\n  // Summing DISTINCT bits equals OR-ing them, and the `Set` is what makes that hold even when a caller\n  // Passes the same modifier twice \u2014 so the mask is built without a bitwise operator.\n  const bits = new Set<number>();\n  for (const modifier of modifiers) {\n    const bit = CDP_MODIFIER_BIT_BY_NAME.get(modifier);\n    if (bit !== undefined) {\n      bits.add(bit);\n    }\n  }\n\n  let bitmask = NO_MODIFIERS;\n  for (const bit of bits) {\n    bitmask += bit;\n  }\n\n  return bitmask;\n}\n\n/**\n * Resolves a key name to its CDP spelling.\n *\n * @param key - A named key or a single printable character.\n * @returns The CDP spelling.\n */\nfunction resolveKey(key: string): NamedKey {\n  const namedKey = NAMED_KEYS.get(key);\n  if (namedKey) {\n    return namedKey;\n  }\n\n  // \"Exactly one code point\", tested without splitting the string: `fromCodePoint` round-trips only when\n  // `key` is that single code point, so an astral-plane character counts as one and `'Ctrl+K'` does not.\n  const codePoint = key.codePointAt(FIRST_CODE_POINT_INDEX);\n  if (codePoint === undefined || String.fromCodePoint(codePoint) !== key) {\n    throw new Error(\n      `pressKey received an unknown key name on mobile: ${JSON.stringify(key)}. `\n        + `Pass a single character or one of: ${[...NAMED_KEYS.keys()].join(', ')}.`\n    );\n  }\n\n  const upperCasedCodePoint = codePointOf(key.toUpperCase());\n  return {\n    code: resolveKeyCode(upperCasedCodePoint),\n    text: key,\n    windowsVirtualKeyCode: upperCasedCodePoint\n  };\n}\n\n/**\n * Resolves the physical `code` for a printable character.\n *\n * Characters outside the ASCII letter/digit rows have no stable physical key, so they get an empty\n * `code` \u2014 the `text` still carries them, which is what an editor reads.\n *\n * @param upperCasedCodePoint - The character's upper-cased code point.\n * @returns The CDP `code`, or an empty string when there is no stable one.\n */\nfunction resolveKeyCode(upperCasedCodePoint: number): string {\n  if (upperCasedCodePoint >= UPPERCASE_A_CODE_POINT && upperCasedCodePoint <= UPPERCASE_Z_CODE_POINT) {\n    return `Key${String.fromCodePoint(upperCasedCodePoint)}`;\n  }\n\n  if (upperCasedCodePoint >= DIGIT_ZERO_CODE_POINT && upperCasedCodePoint <= DIGIT_NINE_CODE_POINT) {\n    return `Digit${String.fromCodePoint(upperCasedCodePoint)}`;\n  }\n\n  return '';\n}\n\n/**\n * Builds the command sequence for a key press.\n *\n * Mirrors the desktop twin's trusted `keyDown` \u2192 `char` \u2192 `keyUp` in CDP's spelling: `rawKeyDown` fires\n * `keydown` alone, `char` fires `keypress` / `beforeinput` / `input`, `keyUp` fires `keyup`. A key that\n * produces no text (`Escape`) skips the `char`, exactly as a real one does.\n *\n * @param request - The key request.\n * @returns The commands to send, in order.\n */\nfunction toKeyCommands(request: MobileKeyInputRequest): CdpInputCommand[] {\n  const { code, text, windowsVirtualKeyCode } = resolveKey(request.key);\n  const modifiers = toCdpModifiers(request.modifiers);\n  const base = { code, key: request.key, modifiers, windowsVirtualKeyCode };\n\n  const commands: CdpInputCommand[] = [\n    { method: 'Input.dispatchKeyEvent', params: { ...base, type: 'rawKeyDown' } }\n  ];\n\n  if (text !== undefined) {\n    commands.push({ method: 'Input.dispatchKeyEvent', params: { ...base, text, type: 'char' } });\n  }\n\n  commands.push({ method: 'Input.dispatchKeyEvent', params: { ...base, type: 'keyUp' } });\n\n  return commands;\n}\n\n/**\n * Builds the command sequence for a tap or a long-press.\n *\n * A trusted touch pair is all Chromium needs \u2014 it synthesizes `pointerdown` / `touchstart` /\n * `pointerup` / `touchend` / `click` from it, every one `isTrusted`. The release carries an empty\n * `touchPoints` list, which is CDP's spelling for \"all fingers lifted\".\n *\n * @param request - The pointer request.\n * @returns The commands to send, in order.\n */\nfunction toPointerCommands(request: MobilePointerInputRequest): CdpInputCommand[] {\n  const modifiers = toCdpModifiers(request.modifiers);\n\n  return [\n    {\n      method: 'Input.dispatchTouchEvent',\n      params: { modifiers, touchPoints: [{ x: request.x, y: request.y }], type: 'touchStart' }\n    },\n    {\n      ...(request.kind === 'longPress' && { delayBeforeInMilliseconds: LONG_PRESS_DWELL_IN_MILLISECONDS }),\n      method: 'Input.dispatchTouchEvent',\n      params: { modifiers, touchPoints: [], type: 'touchEnd' }\n    }\n  ];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,MAAM,4BAA4B;AASlC,MAAM,uCAAuC;AA6GpD,MAAM,mCAAmC;AAEzC,MAAM,eAAe;AACrB,MAAM,mBAAmB;AACzB,MAAM,uBAAuB;AAC7B,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;AAO3B,MAAM,2BAA2B,oBAAI,IAAoB;AAAA,EACvD,CAAC,OAAO,gBAAgB;AAAA,EACxB,CAAC,WAAW,oBAAoB;AAAA,EAChC,CAAC,QAAQ,iBAAiB;AAAA,EAC1B,CAAC,SAAS,kBAAkB;AAC9B,CAAC;AAED,MAAM,qBAAqB;AAC3B,MAAM,eAAe;AACrB,MAAM,iBAAiB;AACvB,MAAM,kBAAkB;AACxB,MAAM,sBAAsB;AAC5B,MAAM,oBAAoB;AAC1B,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB;AAC5B,MAAM,kBAAkB;AASxB,MAAM,aAAa,oBAAI,IAAsB;AAAA,EAC3C,CAAC,aAAa,EAAE,MAAM,aAAa,uBAAuB,oBAAoB,CAAC;AAAA,EAC/E,CAAC,aAAa,EAAE,MAAM,aAAa,uBAAuB,oBAAoB,CAAC;AAAA,EAC/E,CAAC,cAAc,EAAE,MAAM,cAAc,uBAAuB,qBAAqB,CAAC;AAAA,EAClF,CAAC,WAAW,EAAE,MAAM,WAAW,uBAAuB,kBAAkB,CAAC;AAAA,EACzE,CAAC,aAAa,EAAE,MAAM,aAAa,uBAAuB,mBAAmB,CAAC;AAAA,EAC9E,CAAC,UAAU,EAAE,MAAM,UAAU,uBAAuB,gBAAgB,CAAC;AAAA,EACrE,CAAC,SAAS,EAAE,MAAM,SAAS,MAAM,MAAM,uBAAuB,eAAe,CAAC;AAAA,EAC9E,CAAC,UAAU,EAAE,MAAM,UAAU,uBAAuB,gBAAgB,CAAC;AAAA,EACrE,CAAC,OAAO,EAAE,MAAM,OAAO,MAAM,KAAM,uBAAuB,aAAa,CAAC;AAC1E,CAAC;AAED,MAAM,yBAAyB;AAC/B,MAAM,wBAAwB,YAAY,GAAG;AAC7C,MAAM,wBAAwB,YAAY,GAAG;AAC7C,MAAM,yBAAyB,YAAY,GAAG;AAC9C,MAAM,yBAAyB,YAAY,GAAG;AAsBvC,SAAS,4BAA4B,IAAY,cAA+B;AACrF,SAAO,uDAAuD,KAAK,UAAU,EAAE,CAAC,KAAK,KAAK,UAAU,gBAAgB,IAAI,CAAC;AAC3H;AAcO,SAAS,YAAY,MAAsB;AAChD,QAAM,YAAY,KAAK,YAAY,sBAAsB;AACzD,MAAI,cAAc,QAAW;AAC3B,UAAM,IAAI,MAAM,uCAAuC;AAAA,EACzD;AAEA,SAAO;AACT;AAQO,SAAS,mBAAmB,SAAgD;AACjF,MAAI,QAAQ,SAAS,OAAO;AAC1B,WAAO,cAAc,OAAO;AAAA,EAC9B;AAEA,SAAO,kBAAkB,OAAO;AAClC;AAYO,SAAS,eAAe,WAAsC;AAGnE,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,YAAY,WAAW;AAChC,UAAM,MAAM,yBAAyB,IAAI,QAAQ;AACjD,QAAI,QAAQ,QAAW;AACrB,WAAK,IAAI,GAAG;AAAA,IACd;AAAA,EACF;AAEA,MAAI,UAAU;AACd,aAAW,OAAO,MAAM;AACtB,eAAW;AAAA,EACb;AAEA,SAAO;AACT;AAQA,SAAS,WAAW,KAAuB;AACzC,QAAM,WAAW,WAAW,IAAI,GAAG;AACnC,MAAI,UAAU;AACZ,WAAO;AAAA,EACT;AAIA,QAAM,YAAY,IAAI,YAAY,sBAAsB;AACxD,MAAI,cAAc,UAAa,OAAO,cAAc,SAAS,MAAM,KAAK;AACtE,UAAM,IAAI;AAAA,MACR,oDAAoD,KAAK,UAAU,GAAG,CAAC,wCAC7B,CAAC,GAAG,WAAW,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IAC7E;AAAA,EACF;AAEA,QAAM,sBAAsB,YAAY,IAAI,YAAY,CAAC;AACzD,SAAO;AAAA,IACL,MAAM,eAAe,mBAAmB;AAAA,IACxC,MAAM;AAAA,IACN,uBAAuB;AAAA,EACzB;AACF;AAWA,SAAS,eAAe,qBAAqC;AAC3D,MAAI,uBAAuB,0BAA0B,uBAAuB,wBAAwB;AAClG,WAAO,MAAM,OAAO,cAAc,mBAAmB,CAAC;AAAA,EACxD;AAEA,MAAI,uBAAuB,yBAAyB,uBAAuB,uBAAuB;AAChG,WAAO,QAAQ,OAAO,cAAc,mBAAmB,CAAC;AAAA,EAC1D;AAEA,SAAO;AACT;AAYA,SAAS,cAAc,SAAmD;AACxE,QAAM,EAAE,MAAM,MAAM,sBAAsB,IAAI,WAAW,QAAQ,GAAG;AACpE,QAAM,YAAY,eAAe,QAAQ,SAAS;AAClD,QAAM,OAAO,EAAE,MAAM,KAAK,QAAQ,KAAK,WAAW,sBAAsB;AAExE,QAAM,WAA8B;AAAA,IAClC,EAAE,QAAQ,0BAA0B,QAAQ,EAAE,GAAG,MAAM,MAAM,aAAa,EAAE;AAAA,EAC9E;AAEA,MAAI,SAAS,QAAW;AACtB,aAAS,KAAK,EAAE,QAAQ,0BAA0B,QAAQ,EAAE,GAAG,MAAM,MAAM,MAAM,OAAO,EAAE,CAAC;AAAA,EAC7F;AAEA,WAAS,KAAK,EAAE,QAAQ,0BAA0B,QAAQ,EAAE,GAAG,MAAM,MAAM,QAAQ,EAAE,CAAC;AAEtF,SAAO;AACT;AAYA,SAAS,kBAAkB,SAAuD;AAChF,QAAM,YAAY,eAAe,QAAQ,SAAS;AAElD,SAAO;AAAA,IACL;AAAA,MACE,QAAQ;AAAA,MACR,QAAQ,EAAE,WAAW,aAAa,CAAC,EAAE,GAAG,QAAQ,GAAG,GAAG,QAAQ,EAAE,CAAC,GAAG,MAAM,aAAa;AAAA,IACzF;AAAA,IACA;AAAA,MACE,GAAI,QAAQ,SAAS,eAAe,EAAE,2BAA2B,iCAAiC;AAAA,MAClG,QAAQ;AAAA,MACR,QAAQ,EAAE,WAAW,aAAa,CAAC,GAAG,MAAM,WAAW;AAAA,IACzD;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/cjs/mobile-input.d.cts

@@ -0,0 +1,160 @@
+/**
+ * @file
+ *
+ * Translates a mobile trusted-input request into the ordered Chrome DevTools Protocol `Input.*` commands
+ * that realize it (see **L39**).
+ *
+ * Pure and synchronous by design: the WebView connection ({@link WebViewCdpConnection}) sends whatever this
+ * returns, so every decision that is worth a test — the touch pair a tap expands into, the dwell a
+ * long-press adds, the `rawKeyDown` → `char` → `keyUp` shape a key press mirrors from the desktop twin, the
+ * modifier bitmask — lives here rather than inside the transport's I/O path.
+ *
+ * The request travels renderer → host as JSON (the renderer computes the coordinates, because only it can
+ * see the DOM), so both the request and the command shapes are deliberately plain data.
+ */
+/**
+ * The name of the `Runtime.addBinding` function the host exposes on the page so the renderer can hand it an
+ * input request mid-closure.
+ *
+ * It is passed *into* the serialized bootstrap closure as data rather than referenced from it, because that
+ * closure may not read outer scope (**L15**) — so this stays the single definition.
+ */
+export declare const MOBILE_INPUT_BINDING_NAME = "__obsidianIntegrationTestingInput";
+/**
+ * How long the renderer waits for the host to service one input request before giving up.
+ *
+ * Generous relative to the work (a tap is two CDP commands; a long-press adds a 600ms dwell): the point is
+ * to fail with a legible error rather than hang the closure until the whole run times out. Passed into the
+ * bootstrap closure as data, for the same reason as {@link MOBILE_INPUT_BINDING_NAME}.
+ */
+export declare const MOBILE_INPUT_TIMEOUT_IN_MILLISECONDS = 15000;
+/**
+ * A single Chrome DevTools Protocol command, plus how long to wait before sending it.
+ *
+ * The delay is carried here rather than applied by the producer so that the whole sequence stays pure
+ * data — a test asserts the dwell without waiting for it.
+ */
+export interface CdpInputCommand {
+    /**
+     * Milliseconds to wait before sending this command. Absent means "send immediately".
+     *
+     * Used only by the long-press dwell.
+     */
+    readonly delayBeforeInMilliseconds?: number;
+    /**
+     * The CDP method name, e.g. `Input.dispatchTouchEvent`.
+     */
+    readonly method: string;
+    /**
+     * The CDP method parameters.
+     */
+    readonly params: Record<string, unknown>;
+}
+/**
+ * What the renderer hands to the host binding: one request, plus the id to answer it on.
+ *
+ * The renderer builds this literal inside the serialized bootstrap closure, which cannot import (**L15**),
+ * so the shape is declared here and mirrored there. They are one wire format; change them together.
+ */
+export interface MobileInputEnvelope {
+    /**
+     * The request id the renderer is waiting on.
+     */
+    readonly id: string;
+    /**
+     * What to inject.
+     */
+    readonly request: MobileInputRequest;
+}
+/**
+ * Anything the renderer can ask the host to inject.
+ */
+export type MobileInputRequest = MobileKeyInputRequest | MobilePointerInputRequest;
+/**
+ * A trusted key press to inject on mobile.
+ */
+export interface MobileKeyInputRequest {
+    /**
+     * The key to press, in the same spelling the desktop twin takes: either a named key
+     * (`Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, an arrow) or a single printable character.
+     */
+    readonly key: string;
+    /**
+     * Discriminant.
+     */
+    readonly kind: 'key';
+    /**
+     * Modifiers already resolved to their platform-independent lowercase names by the renderer's
+     * `toElectronModifiers` — the one mapping a key press and a click share, so `'Mod'` cannot mean two
+     * different things (**L17**).
+     */
+    readonly modifiers: readonly string[];
+}
+/**
+ * A trusted pointer gesture to inject on mobile, in CSS pixels within the WebView's own viewport.
+ *
+ * No device-pixel conversion is involved: CDP takes page coordinates, so `devicePixelRatio` and the
+ * WebView's offset under the status bar never enter the picture (they would for native injection).
+ */
+export interface MobilePointerInputRequest {
+    /**
+     * `tap` is the touch analog of a left click; `longPress` is the mobile context-menu gesture, i.e. what a
+     * desktop right click means here.
+     */
+    readonly kind: 'longPress' | 'tap';
+    /**
+     * See {@link MobileKeyInputRequest.modifiers}.
+     */
+    readonly modifiers: readonly string[];
+    /**
+     * The viewport x coordinate, in CSS pixels.
+     */
+    readonly x: number;
+    /**
+     * The viewport y coordinate, in CSS pixels.
+     */
+    readonly y: number;
+}
+/**
+ * Builds the expression the host evaluates to answer one input request.
+ *
+ * Optional chaining throughout: by the time the host answers, the page may have navigated and dropped the
+ * namespace, and a `TypeError` inside this evaluate would be reported as an injection failure that already
+ * succeeded.
+ *
+ * @param id - The request id the renderer is waiting on.
+ * @param errorMessage - Why the injection failed, when it did. Omit on success.
+ * @returns A self-contained expression to pass to `Runtime.evaluate`.
+ */
+export declare function buildResolveInputExpression(id: string, errorMessage?: string): string;
+/**
+ * The first code point of a non-empty string.
+ *
+ * `String.prototype.codePointAt` is typed `number | undefined`, so every call site would otherwise carry a
+ * `?? fallback` that no input can ever reach — a dead branch under the 100% coverage gate. Throwing here
+ * keeps that impossible case in ONE place, where a unit test can reach it directly, instead of spreading
+ * unreachable fallbacks (or coverage suppressions) across the module.
+ *
+ * @param text - A non-empty string.
+ * @returns Its first code point.
+ * @throws When `text` is empty.
+ */
+export declare function codePointOf(text: string): number;
+/**
+ * Translates a mobile input request into the ordered CDP commands that realize it.
+ *
+ * @param request - What the renderer asked the host to inject.
+ * @returns The commands to send, in order.
+ */
+export declare function toCdpInputCommands(request: MobileInputRequest): CdpInputCommand[];
+/**
+ * Folds resolved modifier names into CDP's bitmask.
+ *
+ * Unknown names are ignored rather than throwing: the renderer's `toElectronModifiers` is exhaustive over
+ * Obsidian's `Modifier` union, so an unknown name here would mean the two copies have already drifted, and
+ * failing the whole gesture is a worse outcome than pressing it unmodified.
+ *
+ * @param modifiers - Resolved lowercase modifier names.
+ * @returns The CDP modifier bitmask.
+ */
+export declare function toCdpModifiers(modifiers: readonly string[]): number;