@wdio/mcp 2.0.0 → 2.2.0

package/lib/snapshot.js

@@ -0,0 +1,1178 @@
+// src/scripts/get-browser-accessibility-tree.ts
+function flattenAccessibilityTree(node, result = []) {
+  if (!node) return result;
+  if (node.role !== "WebArea" || node.name) {
+    const entry = {
+      role: node.role || "",
+      name: node.name || "",
+      value: node.value ?? "",
+      description: node.description || "",
+      disabled: node.disabled ? "true" : "",
+      focused: node.focused ? "true" : "",
+      selected: node.selected ? "true" : "",
+      checked: node.checked === true ? "true" : node.checked === false ? "false" : node.checked === "mixed" ? "mixed" : "",
+      expanded: node.expanded === true ? "true" : node.expanded === false ? "false" : "",
+      pressed: node.pressed === true ? "true" : node.pressed === false ? "false" : node.pressed === "mixed" ? "mixed" : "",
+      readonly: node.readonly ? "true" : "",
+      required: node.required ? "true" : "",
+      level: node.level ?? "",
+      valuemin: node.valuemin ?? "",
+      valuemax: node.valuemax ?? "",
+      autocomplete: node.autocomplete || "",
+      haspopup: node.haspopup || "",
+      invalid: node.invalid ? "true" : "",
+      modal: node.modal ? "true" : "",
+      multiline: node.multiline ? "true" : "",
+      multiselectable: node.multiselectable ? "true" : "",
+      orientation: node.orientation || "",
+      keyshortcuts: node.keyshortcuts || "",
+      roledescription: node.roledescription || "",
+      valuetext: node.valuetext || ""
+    };
+    result.push(entry);
+  }
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      flattenAccessibilityTree(child, result);
+    }
+  }
+  return result;
+}
+async function getBrowserAccessibilityTree(browser) {
+  const puppeteer = await browser.getPuppeteer();
+  const pages = await puppeteer.pages();
+  if (pages.length === 0) {
+    return [];
+  }
+  const page = pages[0];
+  const snapshot = await page.accessibility.snapshot({
+    interestingOnly: true
+  });
+  if (!snapshot) {
+    return [];
+  }
+  return flattenAccessibilityTree(snapshot);
+}
+
+// src/scripts/get-interactable-browser-elements.ts
+var elementsScript = (elementType = "interactable") => (function() {
+  const interactableSelectors = [
+    "a[href]",
+    // Links with href
+    "button",
+    // Buttons
+    'input:not([type="hidden"])',
+    // Input fields (except hidden)
+    "select",
+    // Select dropdowns
+    "textarea",
+    // Text areas
+    '[role="button"]',
+    // Elements with button role
+    '[role="link"]',
+    // Elements with link role
+    '[role="checkbox"]',
+    // Elements with checkbox role
+    '[role="radio"]',
+    // Elements with radio role
+    '[role="tab"]',
+    // Elements with tab role
+    '[role="menuitem"]',
+    // Elements with menuitem role
+    '[role="combobox"]',
+    // Elements with combobox role
+    '[role="option"]',
+    // Elements with option role
+    '[role="switch"]',
+    // Elements with switch role
+    '[role="slider"]',
+    // Elements with slider role
+    '[role="textbox"]',
+    // Elements with textbox role
+    '[role="searchbox"]',
+    // Elements with searchbox role
+    '[contenteditable="true"]',
+    // Editable content
+    '[tabindex]:not([tabindex="-1"])'
+    // Elements with tabindex
+  ];
+  const visualSelectors = [
+    "img",
+    // Images
+    "picture",
+    // Picture elements
+    "svg",
+    // SVG graphics
+    "video",
+    // Video elements
+    "canvas",
+    // Canvas elements
+    '[style*="background-image"]'
+    // Elements with background images
+  ];
+  function isVisible(element) {
+    if (typeof element.checkVisibility === "function") {
+      return element.checkVisibility({
+        opacityProperty: true,
+        visibilityProperty: true,
+        contentVisibilityAuto: true
+      });
+    }
+    const style = window.getComputedStyle(element);
+    return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0" && element.offsetWidth > 0 && element.offsetHeight > 0;
+  }
+  function getCssSelector(element) {
+    if (element.id) {
+      return `#${CSS.escape(element.id)}`;
+    }
+    if (element.className && typeof element.className === "string") {
+      const classes = element.className.trim().split(/\s+/).filter(Boolean);
+      if (classes.length > 0) {
+        const classSelector = classes.slice(0, 2).map((c) => `.${CSS.escape(c)}`).join("");
+        const tagWithClass = `${element.tagName.toLowerCase()}${classSelector}`;
+        if (document.querySelectorAll(tagWithClass).length === 1) {
+          return tagWithClass;
+        }
+      }
+    }
+    let current = element;
+    const path = [];
+    while (current && current !== document.documentElement) {
+      let selector = current.tagName.toLowerCase();
+      if (current.id) {
+        selector = `#${CSS.escape(current.id)}`;
+        path.unshift(selector);
+        break;
+      }
+      const parent = current.parentElement;
+      if (parent) {
+        const siblings = Array.from(parent.children).filter(
+          (child) => child.tagName === current.tagName
+        );
+        if (siblings.length > 1) {
+          const index = siblings.indexOf(current) + 1;
+          selector += `:nth-child(${index})`;
+        }
+      }
+      path.unshift(selector);
+      current = current.parentElement;
+      if (path.length >= 4) {
+        break;
+      }
+    }
+    return path.join(" > ");
+  }
+  function getElements() {
+    const selectors = [];
+    if (elementType === "interactable" || elementType === "all") {
+      selectors.push(...interactableSelectors);
+    }
+    if (elementType === "visual" || elementType === "all") {
+      selectors.push(...visualSelectors);
+    }
+    const allElements = [];
+    selectors.forEach((selector) => {
+      const elements = document.querySelectorAll(selector);
+      elements.forEach((element) => {
+        if (!allElements.includes(element)) {
+          allElements.push(element);
+        }
+      });
+    });
+    const elementInfos = allElements.filter((element) => isVisible(element) && !element.disabled).map((element) => {
+      const el = element;
+      const inputEl = element;
+      const rect = el.getBoundingClientRect();
+      const isInViewport = rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
+      const info = {
+        tagName: el.tagName.toLowerCase(),
+        type: el.getAttribute("type") || "",
+        id: el.id || "",
+        className: (typeof el.className === "string" ? el.className : "") || "",
+        textContent: el.textContent?.trim() || "",
+        value: inputEl.value || "",
+        placeholder: inputEl.placeholder || "",
+        href: el.getAttribute("href") || "",
+        ariaLabel: el.getAttribute("aria-label") || "",
+        role: el.getAttribute("role") || "",
+        src: el.getAttribute("src") || "",
+        alt: el.getAttribute("alt") || "",
+        cssSelector: getCssSelector(el),
+        isInViewport
+      };
+      return info;
+    });
+    return elementInfos;
+  }
+  return getElements();
+})();
+async function getBrowserInteractableElements(browser, options = {}) {
+  const { elementType = "interactable" } = options;
+  return browser.execute(elementsScript, elementType);
+}
+
+// src/locators/constants.ts
+var ANDROID_INTERACTABLE_TAGS = [
+  // Input elements
+  "android.widget.EditText",
+  "android.widget.AutoCompleteTextView",
+  "android.widget.MultiAutoCompleteTextView",
+  "android.widget.SearchView",
+  // Button-like elements
+  "android.widget.Button",
+  "android.widget.ImageButton",
+  "android.widget.ToggleButton",
+  "android.widget.CompoundButton",
+  "android.widget.RadioButton",
+  "android.widget.CheckBox",
+  "android.widget.Switch",
+  "android.widget.FloatingActionButton",
+  "com.google.android.material.button.MaterialButton",
+  "com.google.android.material.floatingactionbutton.FloatingActionButton",
+  // Text elements (often tappable)
+  "android.widget.TextView",
+  "android.widget.CheckedTextView",
+  // Image elements (often tappable)
+  "android.widget.ImageView",
+  "android.widget.QuickContactBadge",
+  // Selection elements
+  "android.widget.Spinner",
+  "android.widget.SeekBar",
+  "android.widget.RatingBar",
+  "android.widget.ProgressBar",
+  "android.widget.DatePicker",
+  "android.widget.TimePicker",
+  "android.widget.NumberPicker",
+  // List/grid items
+  "android.widget.AdapterView"
+];
+var ANDROID_LAYOUT_CONTAINERS = [
+  // Core ViewGroup classes
+  "android.view.ViewGroup",
+  "android.view.View",
+  "android.widget.FrameLayout",
+  "android.widget.LinearLayout",
+  "android.widget.RelativeLayout",
+  "android.widget.GridLayout",
+  "android.widget.TableLayout",
+  "android.widget.TableRow",
+  "android.widget.AbsoluteLayout",
+  // AndroidX layout classes
+  "androidx.constraintlayout.widget.ConstraintLayout",
+  "androidx.coordinatorlayout.widget.CoordinatorLayout",
+  "androidx.appcompat.widget.LinearLayoutCompat",
+  "androidx.cardview.widget.CardView",
+  "androidx.appcompat.widget.ContentFrameLayout",
+  "androidx.appcompat.widget.FitWindowsFrameLayout",
+  // Scrolling containers
+  "android.widget.ScrollView",
+  "android.widget.HorizontalScrollView",
+  "android.widget.NestedScrollView",
+  "androidx.core.widget.NestedScrollView",
+  "androidx.recyclerview.widget.RecyclerView",
+  "android.widget.ListView",
+  "android.widget.GridView",
+  "android.widget.AbsListView",
+  // App chrome / system elements
+  "android.widget.ActionBarContainer",
+  "android.widget.ActionBarOverlayLayout",
+  "android.view.ViewStub",
+  "androidx.appcompat.widget.ActionBarContainer",
+  "androidx.appcompat.widget.ActionBarContextView",
+  "androidx.appcompat.widget.ActionBarOverlayLayout",
+  // Decor views
+  "com.android.internal.policy.DecorView",
+  "android.widget.DecorView"
+];
+var IOS_INTERACTABLE_TAGS = [
+  // Input elements
+  "XCUIElementTypeTextField",
+  "XCUIElementTypeSecureTextField",
+  "XCUIElementTypeTextView",
+  "XCUIElementTypeSearchField",
+  // Button-like elements
+  "XCUIElementTypeButton",
+  "XCUIElementTypeLink",
+  // Text elements (often tappable)
+  "XCUIElementTypeStaticText",
+  // Image elements
+  "XCUIElementTypeImage",
+  "XCUIElementTypeIcon",
+  // Selection elements
+  "XCUIElementTypeSwitch",
+  "XCUIElementTypeSlider",
+  "XCUIElementTypeStepper",
+  "XCUIElementTypeSegmentedControl",
+  "XCUIElementTypePicker",
+  "XCUIElementTypePickerWheel",
+  "XCUIElementTypeDatePicker",
+  "XCUIElementTypePageIndicator",
+  // Table/list items
+  "XCUIElementTypeCell",
+  "XCUIElementTypeMenuItem",
+  "XCUIElementTypeMenuBarItem",
+  // Toggle elements
+  "XCUIElementTypeCheckBox",
+  "XCUIElementTypeRadioButton",
+  "XCUIElementTypeToggle",
+  // Other interactive
+  "XCUIElementTypeKey",
+  "XCUIElementTypeKeyboard",
+  "XCUIElementTypeAlert",
+  "XCUIElementTypeSheet"
+];
+var IOS_LAYOUT_CONTAINERS = [
+  // Generic containers
+  "XCUIElementTypeOther",
+  "XCUIElementTypeGroup",
+  "XCUIElementTypeLayoutItem",
+  // Scroll containers
+  "XCUIElementTypeScrollView",
+  "XCUIElementTypeTable",
+  "XCUIElementTypeCollectionView",
+  "XCUIElementTypeScrollBar",
+  // Navigation chrome
+  "XCUIElementTypeNavigationBar",
+  "XCUIElementTypeTabBar",
+  "XCUIElementTypeToolbar",
+  "XCUIElementTypeStatusBar",
+  "XCUIElementTypeMenuBar",
+  // Windows and views
+  "XCUIElementTypeWindow",
+  "XCUIElementTypeSheet",
+  "XCUIElementTypeDrawer",
+  "XCUIElementTypeDialog",
+  "XCUIElementTypePopover",
+  "XCUIElementTypePopUpButton",
+  // Outline elements
+  "XCUIElementTypeOutline",
+  "XCUIElementTypeOutlineRow",
+  "XCUIElementTypeBrowser",
+  "XCUIElementTypeSplitGroup",
+  "XCUIElementTypeSplitter",
+  // Application root
+  "XCUIElementTypeApplication"
+];
+
+// src/locators/xml-parsing.ts
+import { DOMParser } from "@xmldom/xmldom";
+import xpath from "xpath";
+function childNodesOf(node) {
+  const children = [];
+  if (node.childNodes) {
+    for (let i = 0; i < node.childNodes.length; i++) {
+      const child = node.childNodes.item(i);
+      if (child?.nodeType === 1) {
+        children.push(child);
+      }
+    }
+  }
+  return children;
+}
+function translateRecursively(domNode, parentPath = "", index = null) {
+  const attributes = {};
+  const element = domNode;
+  if (element.attributes) {
+    for (let attrIdx = 0; attrIdx < element.attributes.length; attrIdx++) {
+      const attr = element.attributes.item(attrIdx);
+      if (attr) {
+        attributes[attr.name] = attr.value.replace(/(\n)/gm, "\\n");
+      }
+    }
+  }
+  const path = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
+  return {
+    children: childNodesOf(domNode).map(
+      (childNode, childIndex) => translateRecursively(childNode, path, childIndex)
+    ),
+    tagName: domNode.nodeName,
+    attributes,
+    path
+  };
+}
+function isSameElement(node1, node2) {
+  if (node1.nodeType !== 1 || node2.nodeType !== 1) return false;
+  const el1 = node1;
+  const el2 = node2;
+  if (el1.nodeName !== el2.nodeName) return false;
+  const bounds1 = el1.getAttribute("bounds");
+  const bounds2 = el2.getAttribute("bounds");
+  if (bounds1 && bounds2) {
+    return bounds1 === bounds2;
+  }
+  const x1 = el1.getAttribute("x");
+  const y1 = el1.getAttribute("y");
+  const x2 = el2.getAttribute("x");
+  const y2 = el2.getAttribute("y");
+  if (x1 && y1 && x2 && y2) {
+    return x1 === x2 && y1 === y2 && el1.getAttribute("width") === el2.getAttribute("width") && el1.getAttribute("height") === el2.getAttribute("height");
+  }
+  return false;
+}
+function xmlToJSON(sourceXML) {
+  try {
+    const parser = new DOMParser();
+    const sourceDoc = parser.parseFromString(sourceXML, "text/xml");
+    const parseErrors = sourceDoc.getElementsByTagName("parsererror");
+    if (parseErrors.length > 0) {
+      console.error("[xmlToJSON] XML parsing error:", parseErrors[0].textContent);
+      return null;
+    }
+    const children = childNodesOf(sourceDoc);
+    const firstChild = children[0] || (sourceDoc.documentElement ? childNodesOf(sourceDoc.documentElement)[0] : null);
+    return firstChild ? translateRecursively(firstChild) : { children: [], tagName: "", attributes: {}, path: "" };
+  } catch (e) {
+    console.error("[xmlToJSON] Failed to parse XML:", e);
+    return null;
+  }
+}
+function xmlToDOM(sourceXML) {
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(sourceXML, "text/xml");
+    const parseErrors = doc.getElementsByTagName("parsererror");
+    if (parseErrors.length > 0) {
+      console.error("[xmlToDOM] XML parsing error:", parseErrors[0].textContent);
+      return null;
+    }
+    return doc;
+  } catch (e) {
+    console.error("[xmlToDOM] Failed to parse XML:", e);
+    return null;
+  }
+}
+function evaluateXPath(doc, xpathExpr) {
+  try {
+    const nodes = xpath.select(xpathExpr, doc);
+    if (Array.isArray(nodes)) {
+      return nodes;
+    }
+    return [];
+  } catch (e) {
+    console.error(`[evaluateXPath] Failed to evaluate "${xpathExpr}":`, e);
+    return [];
+  }
+}
+function checkXPathUniqueness(doc, xpathExpr, targetNode) {
+  try {
+    const nodes = evaluateXPath(doc, xpathExpr);
+    const totalMatches = nodes.length;
+    if (totalMatches === 0) {
+      return { isUnique: false };
+    }
+    if (totalMatches === 1) {
+      return { isUnique: true };
+    }
+    if (targetNode) {
+      for (let i = 0; i < nodes.length; i++) {
+        if (nodes[i].isSameNode(targetNode) || isSameElement(nodes[i], targetNode)) {
+          return {
+            isUnique: false,
+            index: i + 1,
+            // 1-based index for XPath
+            totalMatches
+          };
+        }
+      }
+    }
+    return { isUnique: false, totalMatches };
+  } catch (e) {
+    console.error(`[checkXPathUniqueness] Error checking "${xpathExpr}":`, e);
+    return { isUnique: false };
+  }
+}
+function findDOMNodeByPath(doc, path) {
+  if (!path) return doc.documentElement;
+  const indices = path.split(".").map(Number);
+  let current = doc.documentElement;
+  for (const index of indices) {
+    if (!current) return null;
+    const children = [];
+    if (current.childNodes) {
+      for (let i = 0; i < current.childNodes.length; i++) {
+        const child = current.childNodes.item(i);
+        if (child?.nodeType === 1) {
+          children.push(child);
+        }
+      }
+    }
+    current = children[index] || null;
+  }
+  return current;
+}
+function parseAndroidBounds(bounds) {
+  const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+  if (!match) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  const x1 = parseInt(match[1], 10);
+  const y1 = parseInt(match[2], 10);
+  const x2 = parseInt(match[3], 10);
+  const y2 = parseInt(match[4], 10);
+  return {
+    x: x1,
+    y: y1,
+    width: x2 - x1,
+    height: y2 - y1
+  };
+}
+function parseIOSBounds(attributes) {
+  return {
+    x: parseInt(attributes.x || "0", 10),
+    y: parseInt(attributes.y || "0", 10),
+    width: parseInt(attributes.width || "0", 10),
+    height: parseInt(attributes.height || "0", 10)
+  };
+}
+function countAttributeOccurrences(sourceXML, attribute, value) {
+  const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`${attribute}=["']${escapedValue}["']`, "g");
+  const matches = sourceXML.match(pattern);
+  return matches ? matches.length : 0;
+}
+function isAttributeUnique(sourceXML, attribute, value) {
+  return countAttributeOccurrences(sourceXML, attribute, value) === 1;
+}
+
+// src/locators/element-filter.ts
+function matchesTagList(tagName, tagList) {
+  if (tagList.includes(tagName)) {
+    return true;
+  }
+  for (const tag of tagList) {
+    if (tagName.endsWith(tag) || tagName.includes(tag)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesTagFilters(element, includeTagNames, excludeTagNames) {
+  if (includeTagNames.length > 0 && !matchesTagList(element.tagName, includeTagNames)) {
+    return false;
+  }
+  if (matchesTagList(element.tagName, excludeTagNames)) {
+    return false;
+  }
+  return true;
+}
+function matchesAttributeFilters(element, requireAttributes, minAttributeCount) {
+  if (requireAttributes.length > 0) {
+    const hasRequiredAttr = requireAttributes.some((attr) => element.attributes?.[attr]);
+    if (!hasRequiredAttr) return false;
+  }
+  if (element.attributes && minAttributeCount > 0) {
+    const attrCount = Object.values(element.attributes).filter(
+      (v) => v !== void 0 && v !== null && v !== ""
+    ).length;
+    if (attrCount < minAttributeCount) {
+      return false;
+    }
+  }
+  return true;
+}
+function isInteractableElement(element, isNative, automationName) {
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const interactableTags = isAndroid ? ANDROID_INTERACTABLE_TAGS : IOS_INTERACTABLE_TAGS;
+  if (matchesTagList(element.tagName, interactableTags)) {
+    return true;
+  }
+  if (isAndroid) {
+    if (element.attributes?.clickable === "true" || element.attributes?.focusable === "true" || element.attributes?.checkable === "true" || element.attributes?.["long-clickable"] === "true") {
+      return true;
+    }
+  }
+  if (!isAndroid) {
+    if (element.attributes?.accessible === "true") {
+      return true;
+    }
+  }
+  return false;
+}
+function isLayoutContainer(element, platform) {
+  const containerList = platform === "android" ? ANDROID_LAYOUT_CONTAINERS : IOS_LAYOUT_CONTAINERS;
+  return matchesTagList(element.tagName, containerList);
+}
+function hasMeaningfulContent(element, platform) {
+  const attrs = element.attributes;
+  if (attrs.text && attrs.text.trim() !== "" && attrs.text !== "null") {
+    return true;
+  }
+  if (platform === "android") {
+    if (attrs["content-desc"] && attrs["content-desc"].trim() !== "" && attrs["content-desc"] !== "null") {
+      return true;
+    }
+  } else {
+    if (attrs.label && attrs.label.trim() !== "" && attrs.label !== "null") {
+      return true;
+    }
+    if (attrs.name && attrs.name.trim() !== "" && attrs.name !== "null") {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldIncludeElement(element, filters, isNative, automationName) {
+  const {
+    includeTagNames = [],
+    excludeTagNames = ["hierarchy"],
+    requireAttributes = [],
+    minAttributeCount = 0,
+    fetchableOnly = false,
+    clickableOnly = false,
+    visibleOnly = true
+  } = filters;
+  if (!matchesTagFilters(element, includeTagNames, excludeTagNames)) {
+    return false;
+  }
+  if (!matchesAttributeFilters(element, requireAttributes, minAttributeCount)) {
+    return false;
+  }
+  if (clickableOnly && element.attributes?.clickable !== "true") {
+    return false;
+  }
+  if (visibleOnly) {
+    const isAndroid = automationName.toLowerCase().includes("uiautomator");
+    if (isAndroid && element.attributes?.displayed === "false") {
+      return false;
+    }
+    if (!isAndroid && element.attributes?.visible === "false") {
+      return false;
+    }
+  }
+  if (fetchableOnly && !isInteractableElement(element, isNative, automationName)) {
+    return false;
+  }
+  return true;
+}
+function getDefaultFilters(platform, includeContainers = false) {
+  const layoutContainers = platform === "android" ? ANDROID_LAYOUT_CONTAINERS : IOS_LAYOUT_CONTAINERS;
+  return {
+    excludeTagNames: includeContainers ? ["hierarchy"] : ["hierarchy", ...layoutContainers],
+    fetchableOnly: !includeContainers,
+    visibleOnly: true,
+    clickableOnly: false
+  };
+}
+
+// src/locators/locator-generation.ts
+function isValidValue(value) {
+  return value !== void 0 && value !== null && value !== "null" && value.trim() !== "";
+}
+function escapeText(text) {
+  return text.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function escapeXPathValue(value) {
+  if (!value.includes("'")) {
+    return `'${value}'`;
+  }
+  if (!value.includes('"')) {
+    return `"${value}"`;
+  }
+  const parts = [];
+  let current = "";
+  for (const char of value) {
+    if (char === "'") {
+      if (current) parts.push(`'${current}'`);
+      parts.push(`"'"`);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current) parts.push(`'${current}'`);
+  return `concat(${parts.join(",")})`;
+}
+function generateIndexedXPath(baseXPath, index) {
+  return `(${baseXPath})[${index}]`;
+}
+function generateIndexedUiAutomator(baseSelector, index) {
+  return `${baseSelector}.instance(${index - 1})`;
+}
+function checkUniqueness(ctx, xpath2, targetNode) {
+  if (ctx.parsedDOM) {
+    return checkXPathUniqueness(ctx.parsedDOM, xpath2, targetNode);
+  }
+  const match = xpath2.match(/\/\/\*\[@([^=]+)="([^"]+)"\]/);
+  if (match) {
+    const [, attr, value] = match;
+    return { isUnique: isAttributeUnique(ctx.sourceXML, attr, value) };
+  }
+  return { isUnique: false };
+}
+function getSiblingIndex(element) {
+  const parent = element.parentNode;
+  if (!parent) return 1;
+  const tagName = element.nodeName;
+  let index = 0;
+  for (let i = 0; i < parent.childNodes.length; i++) {
+    const child = parent.childNodes.item(i);
+    if (child?.nodeType === 1 && child.nodeName === tagName) {
+      index++;
+      if (child === element) return index;
+    }
+  }
+  return 1;
+}
+function countSiblings(element) {
+  const parent = element.parentNode;
+  if (!parent) return 1;
+  const tagName = element.nodeName;
+  let count = 0;
+  for (let i = 0; i < parent.childNodes.length; i++) {
+    const child = parent.childNodes.item(i);
+    if (child?.nodeType === 1 && child.nodeName === tagName) {
+      count++;
+    }
+  }
+  return count;
+}
+function findUniqueAttribute(element, ctx) {
+  const attrs = ctx.isAndroid ? ["resource-id", "content-desc", "text"] : ["name", "label", "value"];
+  for (const attr of attrs) {
+    const value = element.getAttribute(attr);
+    if (value && value.trim()) {
+      const xpath2 = `//*[@${attr}=${escapeXPathValue(value)}]`;
+      const result = ctx.parsedDOM ? checkXPathUniqueness(ctx.parsedDOM, xpath2) : { isUnique: isAttributeUnique(ctx.sourceXML, attr, value) };
+      if (result.isUnique) {
+        return `@${attr}=${escapeXPathValue(value)}`;
+      }
+    }
+  }
+  return null;
+}
+function buildHierarchicalXPath(ctx, element, maxDepth = 3) {
+  if (!ctx.parsedDOM) return null;
+  const pathParts = [];
+  let current = element;
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const tagName = current.nodeName;
+    const uniqueAttr = findUniqueAttribute(current, ctx);
+    if (uniqueAttr) {
+      pathParts.unshift(`//${tagName}[${uniqueAttr}]`);
+      break;
+    } else {
+      const siblingIndex = getSiblingIndex(current);
+      const siblingCount = countSiblings(current);
+      if (siblingCount > 1) {
+        pathParts.unshift(`${tagName}[${siblingIndex}]`);
+      } else {
+        pathParts.unshift(tagName);
+      }
+    }
+    const parent = current.parentNode;
+    current = parent && parent.nodeType === 1 ? parent : null;
+    depth++;
+  }
+  if (pathParts.length === 0) return null;
+  let result = pathParts[0];
+  for (let i = 1; i < pathParts.length; i++) {
+    result += "/" + pathParts[i];
+  }
+  if (!result.startsWith("//")) {
+    result = "//" + result;
+  }
+  return result;
+}
+function addXPathLocator(results, xpath2, ctx, targetNode) {
+  const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+  if (uniqueness.isUnique) {
+    results.push(["xpath", xpath2]);
+  } else if (uniqueness.index) {
+    results.push(["xpath", generateIndexedXPath(xpath2, uniqueness.index)]);
+  } else {
+    if (targetNode && ctx.parsedDOM) {
+      const hierarchical = buildHierarchicalXPath(ctx, targetNode);
+      if (hierarchical) {
+        results.push(["xpath", hierarchical]);
+      }
+    }
+    results.push(["xpath", xpath2]);
+  }
+}
+function isInUiAutomatorScope(element, doc) {
+  if (!doc) return true;
+  const hierarchyNodes = evaluateXPath(doc, "/hierarchy/*");
+  if (hierarchyNodes.length === 0) return true;
+  const lastIndex = hierarchyNodes.length;
+  const pathParts = element.path.split(".");
+  if (pathParts.length === 0 || pathParts[0] === "") return true;
+  const firstIndex = parseInt(pathParts[0], 10);
+  return firstIndex === lastIndex - 1;
+}
+function buildUiAutomatorSelector(element) {
+  const attrs = element.attributes;
+  const parts = [];
+  if (isValidValue(attrs["resource-id"])) {
+    parts.push(`resourceId("${attrs["resource-id"]}")`);
+  }
+  if (isValidValue(attrs.text) && attrs.text.length < 100) {
+    parts.push(`text("${escapeText(attrs.text)}")`);
+  }
+  if (isValidValue(attrs["content-desc"])) {
+    parts.push(`description("${attrs["content-desc"]}")`);
+  }
+  if (isValidValue(attrs.class)) {
+    parts.push(`className("${attrs.class}")`);
+  }
+  if (parts.length === 0) return null;
+  return `android=new UiSelector().${parts.join(".")}`;
+}
+function buildPredicateString(element) {
+  const attrs = element.attributes;
+  const conditions = [];
+  if (isValidValue(attrs.name)) {
+    conditions.push(`name == "${escapeText(attrs.name)}"`);
+  }
+  if (isValidValue(attrs.label)) {
+    conditions.push(`label == "${escapeText(attrs.label)}"`);
+  }
+  if (isValidValue(attrs.value)) {
+    conditions.push(`value == "${escapeText(attrs.value)}"`);
+  }
+  if (attrs.visible === "true") {
+    conditions.push("visible == 1");
+  }
+  if (attrs.enabled === "true") {
+    conditions.push("enabled == 1");
+  }
+  if (conditions.length === 0) return null;
+  return `-ios predicate string:${conditions.join(" AND ")}`;
+}
+function buildClassChain(element) {
+  const attrs = element.attributes;
+  const tagName = element.tagName;
+  if (!tagName.startsWith("XCUI")) return null;
+  let selector = `**/${tagName}`;
+  if (isValidValue(attrs.label)) {
+    selector += `[\`label == "${escapeText(attrs.label)}"\`]`;
+  } else if (isValidValue(attrs.name)) {
+    selector += `[\`name == "${escapeText(attrs.name)}"\`]`;
+  }
+  return `-ios class chain:${selector}`;
+}
+function buildXPath(element, sourceXML, isAndroid) {
+  const attrs = element.attributes;
+  const tagName = element.tagName;
+  const conditions = [];
+  if (isAndroid) {
+    if (isValidValue(attrs["resource-id"])) {
+      conditions.push(`@resource-id="${attrs["resource-id"]}"`);
+    }
+    if (isValidValue(attrs["content-desc"])) {
+      conditions.push(`@content-desc="${attrs["content-desc"]}"`);
+    }
+    if (isValidValue(attrs.text) && attrs.text.length < 100) {
+      conditions.push(`@text="${escapeText(attrs.text)}"`);
+    }
+  } else {
+    if (isValidValue(attrs.name)) {
+      conditions.push(`@name="${attrs.name}"`);
+    }
+    if (isValidValue(attrs.label)) {
+      conditions.push(`@label="${attrs.label}"`);
+    }
+    if (isValidValue(attrs.value)) {
+      conditions.push(`@value="${attrs.value}"`);
+    }
+  }
+  if (conditions.length === 0) {
+    return `//${tagName}`;
+  }
+  return `//${tagName}[${conditions.join(" and ")}]`;
+}
+function getSimpleSuggestedLocators(element, ctx, automationName, targetNode) {
+  const results = [];
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const attrs = element.attributes;
+  const inUiAutomatorScope = isAndroid ? isInUiAutomatorScope(element, ctx.parsedDOM) : true;
+  if (isAndroid) {
+    const resourceId = attrs["resource-id"];
+    if (isValidValue(resourceId)) {
+      const xpath2 = `//*[@resource-id="${resourceId}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique && inUiAutomatorScope) {
+        results.push(["id", `android=new UiSelector().resourceId("${resourceId}")`]);
+      } else if (uniqueness.index && inUiAutomatorScope) {
+        const base = `android=new UiSelector().resourceId("${resourceId}")`;
+        results.push(["id", generateIndexedUiAutomator(base, uniqueness.index)]);
+      }
+    }
+    const contentDesc = attrs["content-desc"];
+    if (isValidValue(contentDesc)) {
+      const xpath2 = `//*[@content-desc="${contentDesc}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push(["accessibility-id", `~${contentDesc}`]);
+      }
+    }
+    const text = attrs.text;
+    if (isValidValue(text) && text.length < 100) {
+      const xpath2 = `//*[@text="${escapeText(text)}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique && inUiAutomatorScope) {
+        results.push(["text", `android=new UiSelector().text("${escapeText(text)}")`]);
+      } else if (uniqueness.index && inUiAutomatorScope) {
+        const base = `android=new UiSelector().text("${escapeText(text)}")`;
+        results.push(["text", generateIndexedUiAutomator(base, uniqueness.index)]);
+      }
+    }
+  } else {
+    const name = attrs.name;
+    if (isValidValue(name)) {
+      const xpath2 = `//*[@name="${name}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push(["accessibility-id", `~${name}`]);
+      }
+    }
+    const label = attrs.label;
+    if (isValidValue(label) && label !== attrs.name) {
+      const xpath2 = `//*[@label="${escapeText(label)}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push(["predicate-string", `-ios predicate string:label == "${escapeText(label)}"`]);
+      }
+    }
+    const value = attrs.value;
+    if (isValidValue(value)) {
+      const xpath2 = `//*[@value="${escapeText(value)}"]`;
+      const uniqueness = checkUniqueness(ctx, xpath2, targetNode);
+      if (uniqueness.isUnique) {
+        results.push(["predicate-string", `-ios predicate string:value == "${escapeText(value)}"`]);
+      }
+    }
+  }
+  return results;
+}
+function getComplexSuggestedLocators(element, ctx, automationName, targetNode) {
+  const results = [];
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const inUiAutomatorScope = isAndroid ? isInUiAutomatorScope(element, ctx.parsedDOM) : true;
+  if (isAndroid) {
+    if (inUiAutomatorScope) {
+      const uiAutomator = buildUiAutomatorSelector(element);
+      if (uiAutomator) {
+        results.push(["uiautomator", uiAutomator]);
+      }
+    }
+    const xpath2 = buildXPath(element, ctx.sourceXML, true);
+    if (xpath2) {
+      addXPathLocator(results, xpath2, ctx, targetNode);
+    }
+    if (inUiAutomatorScope && isValidValue(element.attributes.class)) {
+      results.push([
+        "class-name",
+        `android=new UiSelector().className("${element.attributes.class}")`
+      ]);
+    }
+  } else {
+    const predicate = buildPredicateString(element);
+    if (predicate) {
+      results.push(["predicate-string", predicate]);
+    }
+    const classChain = buildClassChain(element);
+    if (classChain) {
+      results.push(["class-chain", classChain]);
+    }
+    const xpath2 = buildXPath(element, ctx.sourceXML, false);
+    if (xpath2) {
+      addXPathLocator(results, xpath2, ctx, targetNode);
+    }
+    const type = element.tagName;
+    if (type.startsWith("XCUIElementType")) {
+      results.push(["class-name", `-ios class chain:**/${type}`]);
+    }
+  }
+  return results;
+}
+function getSuggestedLocators(element, sourceXML, automationName, ctx, targetNode) {
+  const locatorCtx = ctx ?? {
+    sourceXML,
+    parsedDOM: null,
+    isAndroid: automationName.toLowerCase().includes("uiautomator")
+  };
+  const simpleLocators = getSimpleSuggestedLocators(element, locatorCtx, automationName, targetNode);
+  const complexLocators = getComplexSuggestedLocators(element, locatorCtx, automationName, targetNode);
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const locator of [...simpleLocators, ...complexLocators]) {
+    if (!seen.has(locator[1])) {
+      seen.add(locator[1]);
+      results.push(locator);
+    }
+  }
+  return results;
+}
+function locatorsToObject(locators) {
+  const result = {};
+  for (const [strategy, value] of locators) {
+    if (!result[strategy]) {
+      result[strategy] = value;
+    }
+  }
+  return result;
+}
+
+// src/locators/index.ts
+function parseBounds(element, platform) {
+  return platform === "android" ? parseAndroidBounds(element.attributes.bounds || "") : parseIOSBounds(element.attributes);
+}
+function isWithinViewport(bounds, viewport) {
+  return bounds.x >= 0 && bounds.y >= 0 && bounds.width > 0 && bounds.height > 0 && bounds.x + bounds.width <= viewport.width && bounds.y + bounds.height <= viewport.height;
+}
+function transformElement(element, locators, ctx) {
+  const attrs = element.attributes;
+  const bounds = parseBounds(element, ctx.platform);
+  return {
+    tagName: element.tagName,
+    locators: locatorsToObject(locators),
+    text: attrs.text || attrs.label || "",
+    contentDesc: attrs["content-desc"] || "",
+    resourceId: attrs["resource-id"] || "",
+    accessibilityId: attrs.name || attrs["content-desc"] || "",
+    label: attrs.label || "",
+    value: attrs.value || "",
+    className: attrs.class || element.tagName,
+    clickable: attrs.clickable === "true" || attrs.accessible === "true" || attrs["long-clickable"] === "true",
+    enabled: attrs.enabled !== "false",
+    displayed: ctx.platform === "android" ? attrs.displayed !== "false" : attrs.visible !== "false",
+    bounds,
+    isInViewport: isWithinViewport(bounds, ctx.viewportSize)
+  };
+}
+function shouldProcess(element, ctx) {
+  if (shouldIncludeElement(element, ctx.filters, ctx.isNative, ctx.automationName)) {
+    return true;
+  }
+  return isLayoutContainer(element, ctx.platform) && hasMeaningfulContent(element, ctx.platform);
+}
+function processElement(element, ctx) {
+  if (!shouldProcess(element, ctx)) return;
+  try {
+    const targetNode = ctx.parsedDOM ? findDOMNodeByPath(ctx.parsedDOM, element.path) : void 0;
+    const locators = getSuggestedLocators(
+      element,
+      ctx.sourceXML,
+      ctx.automationName,
+      { sourceXML: ctx.sourceXML, parsedDOM: ctx.parsedDOM, isAndroid: ctx.platform === "android" },
+      targetNode || void 0
+    );
+    if (locators.length === 0) return;
+    const transformed = transformElement(element, locators, ctx);
+    if (Object.keys(transformed.locators).length === 0) return;
+    ctx.results.push(transformed);
+  } catch (error) {
+    console.error(`[processElement] Error at path ${element.path}:`, error);
+  }
+}
+function traverseTree(element, ctx) {
+  if (!element) return;
+  processElement(element, ctx);
+  for (const child of element.children || []) {
+    traverseTree(child, ctx);
+  }
+}
+function generateAllElementLocators(sourceXML, options) {
+  const sourceJSON = xmlToJSON(sourceXML);
+  if (!sourceJSON) {
+    console.error("[generateAllElementLocators] Failed to parse page source XML");
+    return [];
+  }
+  const parsedDOM = xmlToDOM(sourceXML);
+  const ctx = {
+    sourceXML,
+    platform: options.platform,
+    automationName: options.platform === "android" ? "uiautomator2" : "xcuitest",
+    isNative: options.isNative ?? true,
+    viewportSize: options.viewportSize ?? { width: 9999, height: 9999 },
+    filters: options.filters ?? {},
+    results: [],
+    parsedDOM
+  };
+  traverseTree(sourceJSON, ctx);
+  return ctx.results;
+}
+
+// src/scripts/get-visible-mobile-elements.ts
+var LOCATOR_PRIORITY = [
+  "accessibility-id",
+  // Most stable, cross-platform
+  "id",
+  // Android resource-id
+  "text",
+  // Text-based (can be fragile but readable)
+  "predicate-string",
+  // iOS predicate
+  "class-chain",
+  // iOS class chain
+  "uiautomator",
+  // Android UiAutomator compound
+  "xpath"
+  // XPath (last resort, brittle)
+  // 'class-name' intentionally excluded - too generic
+];
+function selectBestLocators(locators) {
+  const selected = [];
+  for (const strategy of LOCATOR_PRIORITY) {
+    if (locators[strategy]) {
+      selected.push(locators[strategy]);
+      break;
+    }
+  }
+  for (const strategy of LOCATOR_PRIORITY) {
+    if (locators[strategy] && !selected.includes(locators[strategy])) {
+      selected.push(locators[strategy]);
+      break;
+    }
+  }
+  return selected;
+}
+function toMobileElementInfo(element, includeBounds) {
+  const selectedLocators = selectBestLocators(element.locators);
+  const accessId = element.accessibilityId || element.contentDesc;
+  const info = {
+    selector: selectedLocators[0] || "",
+    tagName: element.tagName,
+    isInViewport: element.isInViewport,
+    text: element.text || "",
+    resourceId: element.resourceId || "",
+    accessibilityId: accessId || "",
+    isEnabled: element.enabled !== false,
+    altSelector: selectedLocators[1] || ""
+    // Single alternative (flattened for tabular)
+  };
+  if (includeBounds) {
+    info.bounds = element.bounds;
+  }
+  return info;
+}
+async function getViewportSize(browser) {
+  try {
+    const size = await browser.getWindowSize();
+    return { width: size.width, height: size.height };
+  } catch {
+    return { width: 9999, height: 9999 };
+  }
+}
+async function getMobileVisibleElements(browser, platform, options = {}) {
+  const { includeContainers = false, includeBounds = false, filterOptions } = options;
+  const viewportSize = await getViewportSize(browser);
+  const pageSource = await browser.getPageSource();
+  const filters = {
+    ...getDefaultFilters(platform, includeContainers),
+    ...filterOptions
+  };
+  const elements = generateAllElementLocators(pageSource, {
+    platform,
+    viewportSize,
+    filters
+  });
+  return elements.map((el) => toMobileElementInfo(el, includeBounds));
+}
+export {
+  getBrowserAccessibilityTree,
+  getBrowserInteractableElements,
+  getMobileVisibleElements
+};
+//# sourceMappingURL=snapshot.js.map