peachsim 0.1.527

package/dist-lib/bridge-contract-input.cjs

@@ -0,0 +1,451 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"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);
+
+// src/bridge-contract-input.ts
+var bridge_contract_input_exports = {};
+__export(bridge_contract_input_exports, {
+  BridgeInputError: () => BridgeInputError,
+  SEMANTIC_WAIT_MAX_TIMEOUT_MS: () => SEMANTIC_WAIT_MAX_TIMEOUT_MS,
+  findUnbalancedTouchDown: () => findUnbalancedTouchDown,
+  parsePerformStep: () => parsePerformStep,
+  parseResetOptions: () => parseResetOptions,
+  parseScreenshotOptions: () => parseScreenshotOptions,
+  parseSemanticQuery: () => parseSemanticQuery,
+  parseSemanticResolveSelector: () => parseSemanticResolveSelector,
+  parseSemanticWaitOptions: () => parseSemanticWaitOptions,
+  parseStateOptions: () => parseStateOptions,
+  parseTapTarget: () => parseTapTarget
+});
+module.exports = __toCommonJS(bridge_contract_input_exports);
+
+// src/bridge-contract.ts
+var SIM_LONG_PRESS_MAX_MS = 5e3;
+
+// src/bridge-contract-input.ts
+var BridgeInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BridgeInputError";
+  }
+};
+var SEMANTIC_WAIT_MAX_TIMEOUT_MS = 3e4;
+function validationFailure(path, expectation) {
+  throw new BridgeInputError(`${path} ${expectation}`);
+}
+function isRecordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function recordValue(value, path) {
+  if (!isRecordValue(value)) {
+    validationFailure(path, "must be an object");
+  }
+  return value;
+}
+function stringValue(value, path) {
+  if (typeof value !== "string") validationFailure(path, "must be a string");
+  return value;
+}
+function numberValue(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    validationFailure(path, "must be a finite number");
+  }
+  return value;
+}
+function booleanValue(value, path) {
+  if (typeof value !== "boolean") validationFailure(path, "must be a boolean");
+  return value;
+}
+function optionalNumber(record, key, path) {
+  return record[key] === void 0 ? void 0 : numberValue(record[key], `${path}.${key}`);
+}
+function optionalBoolean(record, key, path) {
+  return record[key] === void 0 ? void 0 : booleanValue(record[key], `${path}.${key}`);
+}
+function semanticWaitTimeout(record, path) {
+  const timeoutMs = optionalNumber(record, "timeoutMs", path);
+  if (timeoutMs !== void 0 && timeoutMs > SEMANTIC_WAIT_MAX_TIMEOUT_MS) {
+    validationFailure(
+      `${path}.timeoutMs`,
+      `must be at most ${SEMANTIC_WAIT_MAX_TIMEOUT_MS}`
+    );
+  }
+  return timeoutMs;
+}
+function parsePerformStep(value, index) {
+  const path = `perform.steps[${index}]`;
+  const step = recordValue(value, path);
+  const type = stringValue(step.type, `${path}.type`);
+  switch (type) {
+    case "touchDown":
+    case "touchMove":
+    case "touchUp": {
+      const pointerId = optionalNumber(step, "pointerId", path);
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...pointerId === void 0 ? {} : { pointerId }
+      };
+    }
+    case "touchCancel": {
+      const pointerId = optionalNumber(step, "pointerId", path);
+      return { type, ...pointerId === void 0 ? {} : { pointerId } };
+    }
+    case "tap":
+      return {
+        type,
+        target: parseTapTarget(step.target),
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`)
+      };
+    case "tapId":
+      return { type, id: stringValue(step.id, `${path}.id`) };
+    case "tapText":
+      return { type, text: stringValue(step.text, `${path}.text`) };
+    case "doubleTap": {
+      const gapMs = optionalNumber(step, "gapMs", path);
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...gapMs === void 0 ? {} : { gapMs }
+      };
+    }
+    case "longPress": {
+      const durationMs = optionalNumber(step, "durationMs", path);
+      if (durationMs !== void 0 && (!Number.isInteger(durationMs) || durationMs < 1 || durationMs > SIM_LONG_PRESS_MAX_MS)) {
+        validationFailure(
+          `${path}.durationMs`,
+          `must be an integer between 1 and ${SIM_LONG_PRESS_MAX_MS}`
+        );
+      }
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...durationMs === void 0 ? {} : { durationMs }
+      };
+    }
+    case "drag": {
+      const steps = optionalNumber(step, "steps", path);
+      const stepMs = optionalNumber(step, "stepMs", path);
+      return {
+        type,
+        fromX: numberValue(step.fromX, `${path}.fromX`),
+        fromY: numberValue(step.fromY, `${path}.fromY`),
+        toX: numberValue(step.toX, `${path}.toX`),
+        toY: numberValue(step.toY, `${path}.toY`),
+        ...steps === void 0 ? {} : { steps },
+        ...stepMs === void 0 ? {} : { stepMs }
+      };
+    }
+    case "pinch": {
+      const steps = optionalNumber(step, "steps", path);
+      const stepMs = optionalNumber(step, "stepMs", path);
+      return {
+        type,
+        fromX1: numberValue(step.fromX1, `${path}.fromX1`),
+        fromY1: numberValue(step.fromY1, `${path}.fromY1`),
+        fromX2: numberValue(step.fromX2, `${path}.fromX2`),
+        fromY2: numberValue(step.fromY2, `${path}.fromY2`),
+        toX1: numberValue(step.toX1, `${path}.toX1`),
+        toY1: numberValue(step.toY1, `${path}.toY1`),
+        toX2: numberValue(step.toX2, `${path}.toX2`),
+        toY2: numberValue(step.toY2, `${path}.toY2`),
+        ...steps === void 0 ? {} : { steps },
+        ...stepMs === void 0 ? {} : { stepMs }
+      };
+    }
+    case "scroll": {
+      const x = optionalNumber(step, "x", path);
+      const y = optionalNumber(step, "y", path);
+      const animated = optionalBoolean(step, "animated", path);
+      return {
+        type,
+        id: stringValue(step.id, `${path}.id`),
+        ...x === void 0 ? {} : { x },
+        ...y === void 0 ? {} : { y },
+        ...animated === void 0 ? {} : { animated }
+      };
+    }
+    case "type":
+      return { type, text: stringValue(step.text, `${path}.text`) };
+    case "key":
+      return { type, key: stringValue(step.key, `${path}.key`) };
+    case "dismissKeyboard":
+      return { type };
+    case "setElementValue": {
+      const submit = optionalBoolean(step, "submit", path);
+      return {
+        type,
+        id: stringValue(step.id, `${path}.id`),
+        text: stringValue(step.text, `${path}.text`),
+        ...submit === void 0 ? {} : { submit }
+      };
+    }
+    case "toggleKeyboard":
+      return { type };
+    case "openUrl": {
+      const url = stringValue(step.url, `${path}.url`);
+      if (url.length === 0) validationFailure(`${path}.url`, "must be non-empty");
+      return { type, url };
+    }
+    case "keyDown":
+    case "keyUp":
+      return { type, key: stringValue(step.key, `${path}.key`) };
+    case "setOrientation": {
+      const orientation = stringValue(step.orientation, `${path}.orientation`);
+      if (orientation !== "portrait" && orientation !== "landscape") {
+        validationFailure(`${path}.orientation`, "must be portrait or landscape");
+      }
+      return { type, orientation };
+    }
+    case "deviceInfo":
+      return { type };
+    case "buttonDown":
+    case "buttonUp": {
+      const button = step.button === void 0 ? void 0 : stringValue(step.button, `${path}.button`);
+      return { type, ...button === void 0 ? {} : { button } };
+    }
+    case "incrementElement":
+    case "decrementElement":
+      return { type, id: stringValue(step.id, `${path}.id`) };
+    case "discoverStoreKitConfig":
+    case "clearStoreKitConfig":
+      return { type };
+    case "wait":
+      return { type, ms: numberValue(step.ms, `${path}.ms`) };
+    case "waitFor": {
+      const timeoutMs = semanticWaitTimeout(step, path);
+      const condition = step.condition === void 0 ? void 0 : stringValue(step.condition, `${path}.condition`);
+      if (condition !== void 0 && condition !== "present" && condition !== "mounted" && condition !== "absent") {
+        return validationFailure(
+          `${path}.condition`,
+          "must be present, mounted, or absent"
+        );
+      }
+      const selector = step.testID === void 0 ? { id: stringValue(step.id, `${path}.id`) } : { testID: stringValue(step.testID, `${path}.testID`) };
+      return {
+        type,
+        ...selector,
+        ...condition === void 0 ? {} : { condition },
+        ...timeoutMs === void 0 ? {} : { timeoutMs }
+      };
+    }
+    default:
+      return validationFailure(`${path}.type`, "is not a supported perform step");
+  }
+}
+function findUnbalancedTouchDown(steps) {
+  const open = /* @__PURE__ */ new Map();
+  const pointerIdOf = (step) => {
+    if (step.type !== "touchDown" && step.type !== "touchMove" && step.type !== "touchUp" && step.type !== "touchCancel") {
+      return null;
+    }
+    const pointerId = step.pointerId ?? 999;
+    return Number.isSafeInteger(pointerId) ? pointerId : null;
+  };
+  for (const [index, step] of steps.entries()) {
+    if (step.type === "touchDown") {
+      const pointerId = pointerIdOf(step) ?? 999;
+      if (!open.has(pointerId)) open.set(pointerId, index);
+    } else if (step.type === "touchUp" || step.type === "touchCancel") {
+      const pointerId = pointerIdOf(step);
+      if (pointerId !== null) open.delete(pointerId);
+    }
+  }
+  const next = open.entries().next();
+  if (next.done) return null;
+  return { index: next.value[1], pointerId: next.value[0] };
+}
+function parseStateOptions(value) {
+  const input = recordValue(value, "state");
+  const route = optionalBoolean(input, "route", "state");
+  const errors = optionalBoolean(input, "errors", "state");
+  const logs = optionalBoolean(input, "logs", "state");
+  const depth = optionalNumber(input, "depth", "state");
+  const errorLimit = optionalNumber(input, "errorLimit", "state");
+  const logLimit = optionalNumber(input, "logLimit", "state");
+  const layers = input.layers === void 0 ? void 0 : stringValue(input.layers, "state.layers");
+  if (layers !== void 0 && layers !== "full" && layers !== "tenant" && layers !== "shell") {
+    return validationFailure("state.layers", "must be full, tenant, or shell");
+  }
+  return {
+    screenshot: optionalBoolean(input, "screenshot", "state") ?? true,
+    tree: optionalBoolean(input, "tree", "state") ?? true,
+    ...route === void 0 ? {} : { route },
+    ...errors === void 0 ? {} : { errors },
+    ...logs === void 0 ? {} : { logs },
+    ...depth === void 0 ? {} : { depth },
+    ...layers === void 0 ? {} : { layers },
+    ...errorLimit === void 0 ? {} : { errorLimit },
+    ...logLimit === void 0 ? {} : { logLimit }
+  };
+}
+function parseSemanticSelector(value, path) {
+  const selector = recordValue(value, path);
+  if (selector.testID !== void 0) {
+    return { testID: stringValue(selector.testID, `${path}.testID`) };
+  }
+  if (selector.text !== void 0) {
+    return { text: stringValue(selector.text, `${path}.text`) };
+  }
+  if (selector.role !== void 0) {
+    return { role: stringValue(selector.role, `${path}.role`) };
+  }
+  if (selector.type !== void 0) {
+    return { type: stringValue(selector.type, `${path}.type`) };
+  }
+  if (selector.pressable !== void 0) {
+    if (booleanValue(selector.pressable, `${path}.pressable`) !== true) {
+      return validationFailure(`${path}.pressable`, "must be true");
+    }
+    return { pressable: true };
+  }
+  if (selector.visible !== void 0) {
+    if (booleanValue(selector.visible, `${path}.visible`) !== true) {
+      return validationFailure(`${path}.visible`, "must be true");
+    }
+    return { visible: true };
+  }
+  return validationFailure(
+    path,
+    "must select testID, text, role, type, pressable, or visible"
+  );
+}
+function parseSemanticQuery(value) {
+  const query = recordValue(value, "query");
+  const kind = stringValue(query.kind, "query.kind");
+  if (kind === "count") return { kind };
+  if (kind === "tree") {
+    const depth = optionalNumber(query, "depth", "query");
+    return { kind, ...depth === void 0 ? {} : { depth } };
+  }
+  if (kind === "find") {
+    return { kind, selector: parseSemanticSelector(query.selector, "query.selector") };
+  }
+  return validationFailure("query.kind", "must be tree, find, or count");
+}
+function semanticResolveSelector(value, path) {
+  const selector = recordValue(value, path);
+  if (selector.testID !== void 0) {
+    return { testID: stringValue(selector.testID, `${path}.testID`) };
+  }
+  if (selector.text !== void 0) {
+    return { text: stringValue(selector.text, `${path}.text`) };
+  }
+  return validationFailure(path, "must select testID or text");
+}
+function parseSemanticResolveSelector(value) {
+  return semanticResolveSelector(value, "selector");
+}
+function parseSemanticWaitOptions(value) {
+  const input = recordValue(value, "waitFor");
+  const condition = recordValue(input.condition, "waitFor.condition");
+  const type = stringValue(condition.type, "waitFor.condition.type");
+  const timeoutMs = semanticWaitTimeout(input, "waitFor");
+  if (type === "ready") {
+    return {
+      condition: { type },
+      ...timeoutMs === void 0 ? {} : { timeoutMs }
+    };
+  }
+  if (type !== "present" && type !== "mounted" && type !== "absent") {
+    return validationFailure(
+      "waitFor.condition.type",
+      "must be ready, present, mounted, or absent"
+    );
+  }
+  return {
+    condition: {
+      type,
+      selector: semanticResolveSelector(condition.selector, "waitFor.condition.selector")
+    },
+    ...timeoutMs === void 0 ? {} : { timeoutMs }
+  };
+}
+function parseResetOptions(value) {
+  const input = recordValue(value, "reset");
+  const strategy = input.strategy === void 0 ? "data" : stringValue(input.strategy, "reset.strategy");
+  if (strategy !== "data" && strategy !== "full") {
+    return validationFailure("reset.strategy", "must be data or full");
+  }
+  const from = input.from;
+  if (from !== void 0 && (typeof from !== "string" || from.length === 0 || from.length > 64)) {
+    return validationFailure("reset.from", "must name a simulator");
+  }
+  return {
+    strategy,
+    relaunch: optionalBoolean(input, "relaunch", "reset") ?? true,
+    ...from === void 0 ? {} : { from }
+  };
+}
+function parseScreenshotOptions(value) {
+  const input = recordValue(value, "screenshot");
+  const layers = input.layers === void 0 ? void 0 : stringValue(input.layers, "screenshot.layers");
+  if (layers !== void 0 && layers !== "full" && layers !== "tenant" && layers !== "shell") {
+    return validationFailure("screenshot.layers", "must be full, tenant, or shell");
+  }
+  const crop = input.crop === void 0 ? void 0 : recordValue(input.crop, "screenshot.crop");
+  return {
+    ...layers === void 0 ? {} : { layers },
+    ...crop === void 0 ? {} : {
+      crop: {
+        x: numberValue(crop.x, "screenshot.crop.x"),
+        y: numberValue(crop.y, "screenshot.crop.y"),
+        w: numberValue(crop.w, "screenshot.crop.w"),
+        h: numberValue(crop.h, "screenshot.crop.h")
+      }
+    }
+  };
+}
+function parseTapTarget(value) {
+  if (value === void 0) return void 0;
+  const input = recordValue(value, "tap.target");
+  const target = {};
+  if (input.nodeId !== void 0 && input.nodeId !== null) {
+    const nodeId = numberValue(input.nodeId, "tap.target.nodeId");
+    if (!Number.isSafeInteger(nodeId))
+      validationFailure("tap.target.nodeId", "must be an integer");
+    target.nodeId = nodeId;
+  }
+  for (const key of ["id", "testID", "text", "type"]) {
+    if (input[key] !== void 0 && input[key] !== null)
+      target[key] = stringValue(input[key], `tap.target.${key}`);
+  }
+  if (target.nodeId === void 0 && !target.testID && !target.id)
+    validationFailure("tap.target", "requires nodeId, testID or id");
+  return target;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BridgeInputError,
+  SEMANTIC_WAIT_MAX_TIMEOUT_MS,
+  findUnbalancedTouchDown,
+  parsePerformStep,
+  parseResetOptions,
+  parseScreenshotOptions,
+  parseSemanticQuery,
+  parseSemanticResolveSelector,
+  parseSemanticWaitOptions,
+  parseStateOptions,
+  parseTapTarget
+});