ff-automationv2 2.2.28 → 2.2.29

package/dist/utils/DomExtraction/jsForAttributeInjection.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAnnotatedDOM = getAnnotatedDOM;
+exports.getReactAnnotatedDOM = getReactAnnotatedDOM;
+exports.getAngularAnnotatedDOM = getAngularAnnotatedDOM;
 exports.getAnnotatedDOMForMobile = getAnnotatedDOMForMobile;
+const xmldom_1 = require("@xmldom/xmldom");
 const logData_js_1 = require("../../utils/logger/logData.js");
+const frameWorkDetector_js_1 = require("../frameWorkDetector/frameWorkDetector.js");
 async function getAnnotatedDOM(browser) {
+    const isAngular = await frameWorkDetector_js_1.frameWorkDetector.isAngular(browser);
+    if (isAngular) {
+        return getAngularAnnotatedDOM(browser);
+    }
+    return getReactAnnotatedDOM(browser);
+}
+async function getReactAnnotatedDOM(browser) {
     return await browser.execute(() => {
         let nodeIndex = 0;
         // const xpaths: Record<string, string> = {};
@@ -221,7 +232,211 @@ async function getAnnotatedDOM(browser) {
         };
     });
 }
-const xmldom_1 = require("@xmldom/xmldom");
+const INJECT_AND_SERIALIZE_DOM_JS = `
+return (function () {
+  let nodeIndex = 0;
+function getCoverageStatus(el) {
+    if (!el || !el.getBoundingClientRect) return "unknown";
+    const s = getComputedStyle(el);
+    if (s.pointerEvents === "none") return "false";
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return "false";
+    // Off-screen element — check if something is blocking the viewport
+    const isOffScreen =
+        rect.bottom < 0 ||
+        rect.right < 0 ||
+        rect.top > window.innerHeight ||
+        rect.left > window.innerWidth;
+    if (isOffScreen) {
+        const centerEl = document.elementFromPoint(
+            window.innerWidth / 2,
+            window.innerHeight / 2
+        );
+        if (centerEl && centerEl !== document.body && centerEl !== document.documentElement) {
+            // Something is at center of viewport — check if el and centerEl
+            // share the same scrollable container
+            const elScrollParent = getScrollParent(el);
+            const centerScrollParent = getScrollParent(centerEl);
+            if (elScrollParent !== centerScrollParent) return "true";
+        }
+        return "false";
+    }
+    // On-screen element — use elementFromPoint
+    const testPoints = [
+        [rect.left + 5, rect.top + 5],
+        [rect.right - 5, rect.top + 5],
+        [rect.left + 5, rect.bottom - 5],
+        [rect.right - 5, rect.bottom - 5],
+        [rect.left + rect.width / 2, rect.top + rect.height / 2]
+    ];
+    for (const [x, y] of testPoints) {
+        if (x < 0 || y < 0 || x > window.innerWidth || y > window.innerHeight) continue;
+        const topEl = document.elementFromPoint(x, y);
+        if (!topEl) continue;
+        if (topEl === el || el.contains(topEl)) continue;
+        if (topEl.contains(el)) continue; // topEl is ancestor, not a cover
+        return "true";
+    }
+    return "false";
+}
+function getScrollParent(node) {
+    if (!node || node === document.body) return document.body;
+    const s = getComputedStyle(node);
+    if (
+        s.overflow === "auto" || s.overflow === "scroll" ||
+        s.overflowY === "auto" || s.overflowY === "scroll"
+    ) return node;
+    return getScrollParent(node.parentElement);
+}
+function isUsable(node) {
+    const s = getComputedStyle(node);
+    if (s.display === "none" || s.visibility === "hidden" || s.opacity === "0") return false;
+    const rect = node.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    return true;
+}
+
+function isSelectRelated(node) {
+    return (
+        node.matches?.("select, option") ||
+        node.closest?.("select, [role='listbox'], [role='combobox']")
+    );
+}
+  function annotate(node) {
+    const s = getComputedStyle(node);
+    node.setAttribute("element-visibility", s.visibility || "");
+    node.setAttribute("element-pointer-events", s.pointerEvents || "");
+    node.setAttribute("element-zindex", s.zIndex || "");
+     if (isSelectRelated(node)) {
+        node.setAttribute("element-covered", "false");
+        return;
+    }
+
+    if (!isUsable(node)) {
+        node.setAttribute("element-covered", "true");
+        return;
+    }
+     try {
+        node.setAttribute("element-covered", getCoverageStatus(node));
+        
+    } catch {
+        node.setAttribute("element-covered", "unknown");
+    }
+  }
+  function getXPath(node) {
+    if (!node || node.nodeType !== 1) return "";
+    let segments = [];
+    let current = node;
+    while (current && current.nodeType === 1) {
+        const parent = current.parentNode;
+        if (parent instanceof ShadowRoot) {
+            const host = parent.host;
+            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
+            const index = siblings.indexOf(current) + 1;
+            segments.unshift("shadow/" + current.tagName.toLowerCase() + "[" + index + "]");
+            current = host;
+            continue;
+        }
+        let index = 1;
+        if (parent && parent.children) {
+            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
+            index = siblings.indexOf(current) + 1;
+        }
+        segments.unshift(current.tagName.toLowerCase() + "[" + index + "]");
+        if (!parent || parent.nodeType !== 1) break;
+        current = parent;
+    }
+    let path = "/" + segments.join("/");
+    if (node.ownerDocument !== document) {
+        const frameEl = node.ownerDocument.defaultView && node.ownerDocument.defaultView.frameElement;
+        if (frameEl) {
+            let framePath = frameEl.getAttribute("ff-xpath");
+            if (!framePath) framePath = getXPath(frameEl);
+            path = framePath + path;
+        }
+    }
+    return path;
+  }
+  function walk(root) {
+     const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
+    let node = walker.currentNode;
+    while (node) {
+        if (node.nodeType === 1 
+            && typeof node.setAttribute === 'function'
+            && !["META", "STYLE", "SCRIPT"].includes(node.tagName)) {
+            node.setAttribute("ff-inspect", "Fire-Flink-" + nodeIndex++);
+            node.setAttribute("ff-xpath", getXPath(node));
+            annotate(node);
+        }
+        if (node.shadowRoot) walk(node.shadowRoot);
+        if (node.tagName === "IFRAME") {
+            try {
+                const doc = node.contentDocument;
+                if (doc && doc.documentElement) walk(doc.documentElement);
+            } catch {
+                node.setAttribute("ff-cross-origin", "true");
+            }
+        }
+        node = walker.nextNode();
+    }
+  }
+function cleanup(root) {
+    const startNode = (root.nodeType === 1) ? root : null;
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
+    let node = walker.currentNode;
+    while (node) {
+     if (node.nodeType === 1 && typeof node.removeAttribute === 'function') {
+        node.removeAttribute("ff-inspect");
+        node.removeAttribute("ff-xpath");
+        node.removeAttribute("element-visibility");
+        node.removeAttribute("element-pointer-events");
+        node.removeAttribute("element-zindex");
+        node.removeAttribute("element-covered");
+        node.removeAttribute("ff-cross-origin");
+}
+        if (node.shadowRoot) cleanup(node.shadowRoot);
+        node = walker.nextNode();
+    }
+}
+cleanup(document.documentElement);
+// Force browser to settle DOM after cleanup
+void document.documentElement.offsetHeight;
+walk(document.documentElement);
+  function serializeNode(node) {
+    if (node.nodeType === Node.TEXT_NODE) return node.textContent;
+    if (node.nodeType !== Node.ELEMENT_NODE) return "";
+    const tag = node.tagName.toLowerCase();
+    let html = "<" + tag;
+    for (const attr of node.attributes) {
+        if (attr.name === "srcdoc") continue;
+        html += " " + attr.name + "=\\"" + attr.value.replace(/"/g, "&quot;") + "\\"";
+    }
+    html += ">";
+    if (node.shadowRoot) {
+        html += "<!--#shadow-root-->";
+        node.shadowRoot.childNodes.forEach(child => { html += serializeNode(child); });
+        html += "<!--#/shadow-root-->";
+    }
+    if (tag === "iframe" && node.getAttribute("ff-cross-origin") !== "true") {
+        try {
+            const doc = node.contentDocument;
+            if (doc) html += serializeNode(doc.documentElement);
+        } catch {}
+    }
+    node.childNodes.forEach(child => { html += serializeNode(child); });
+    html += "</" + tag + ">";
+    return html;
+  }
+  return "<!DOCTYPE html>\\n" + serializeNode(document.documentElement);
+})();
+`;
+async function getAngularAnnotatedDOM(browser) {
+    const fn = new Function(INJECT_AND_SERIALIZE_DOM_JS);
+    const result = await browser.execute(fn);
+    return {
+        dom: result
+    };
+}
 async function getAnnotatedDOMForMobile(driver, existingDom) {
     try {
         let pageSource = "";
@@ -230,9 +445,7 @@ async function getAnnotatedDOMForMobile(driver, existingDom) {
         }
         else {
             await driver.pause(1000);
-            const startTime = Date.now();
             pageSource = await driver.getPageSource();
-            logData_js_1.logger.info(`Page source captured in ${Date.now() - startTime}ms`);
         }
         if (!pageSource) {
             throw new Error("Unable to capture DOM");
@@ -249,12 +462,11 @@ async function getAnnotatedDOMForMobile(driver, existingDom) {
         const serializer = new xmldom_1.XMLSerializer();
         let annotatedXML = serializer.serializeToString(xmlDoc);
         // Preserve XML declaration if present
-        if (pageSource.trim().startsWith("<?xml")) {
+        if (pageSource.trim().startsWith("<?xml") &&
+            !annotatedXML.trim().startsWith("<?xml")) {
             const declarationEnd = pageSource.indexOf("?>");
-            if (declarationEnd !== -1) {
-                const declaration = pageSource.substring(0, declarationEnd + 2).trim();
-                annotatedXML = `${declaration}\n${annotatedXML}`;
-            }
+            const declaration = pageSource.substring(0, declarationEnd + 2).trim();
+            annotatedXML = `${declaration}\n${annotatedXML}`;
         }
         return {
             dom: annotatedXML

package/dist/utils/InstancesDetails/getInstancesInfo.d.ts

@@ -1 +1,26 @@
-export declare function getAiInstanceInfo(responseObject: any): Record<string, string>;
+export interface GoogleServiceAccount {
+    type: string;
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+    universe_domain: string;
+}
+export interface AIInstanceInfo {
+    serviceProvider: string;
+    apiKey: string;
+    apiUrl: string;
+    visionApiKey: string;
+    model: string;
+    resource: string;
+    accountType: string;
+    enterpriseConfigFile: GoogleServiceAccount;
+    projectId: string;
+    region: string;
+}
+export declare function getAiInstanceInfo(responseObject: any): AIInstanceInfo;

package/dist/utils/InstancesDetails/getInstancesInfo.js

@@ -4,10 +4,16 @@ exports.getAiInstanceInfo = getAiInstanceInfo;
 function getAiInstanceInfo(responseObject) {
     return {
         serviceProvider: responseObject.serviceProvider,
-        apiKey: responseObject.instanceDetails.apiKey,
-        apiUrl: responseObject.instanceDetails.apiUrl,
-        visionApiKey: responseObject?.instanceDetails?.visionApiKey,
-        model: responseObject.model,
-        resource: responseObject.resource ?? null,
+        apiKey: responseObject.instanceDetails?.apiKey,
+        apiUrl: responseObject.instanceDetails?.apiUrl,
+        visionApiKey: responseObject?.visionKey,
+        model: responseObject.serviceProvider === "DefaultFireFlink"
+            ? "openai/gpt-oss-20b"
+            : responseObject.model,
+        resource: responseObject.resourceName ?? null,
+        accountType: responseObject.accountType ?? null,
+        enterpriseConfigFile: responseObject.enterpriseConfigFile ?? null,
+        projectId: responseObject.enterpriseConfigFile?.project_id ?? null,
+        region: responseObject.region ?? null,
     };
 }

package/dist/utils/browserCap/capability.d.ts

@@ -1,22 +1,22 @@
 import { BrowserId } from "../../core/types/browserType.js";
-export declare function getCapabilities(browserName: BrowserId): {
-    'goog:chromeOptions'?: {
-        args: string[];
-    } | undefined;
+export declare function getCapabilities(browserName: BrowserId, path?: string, profile?: string): {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;
-} | {
-    'moz:firefoxOptions'?: {
+    "goog:chromeOptions": {
         args: string[];
-    } | undefined;
+    };
+} | {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;
-} | {
-    'ms:edgeOptions'?: {
+    "moz:firefoxOptions": {
         args: string[];
-    } | undefined;
+    };
+} | {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;
+    "ms:edgeOptions": {
+        args: string[];
+    };
 } | {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;

package/dist/utils/browserCap/capability.js

@@ -1,35 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCapabilities = getCapabilities;
-function getCapabilities(browserName) {
+function getCapabilities(browserName, path, profile) {
     const isLinux = process.platform === 'linux';
     const browserCapabilities = {
         chrome: {
             browserName: 'chrome',
             "wdio:enforceWebDriverClassic": true,
-            ...(isLinux && {
-                'goog:chromeOptions': {
-                    args: ['--ozone-platform=x11']
-                },
-            })
+            "goog:chromeOptions": {
+                args: [
+                    ...(path ? [`--user-data-dir=${path}`] : []),
+                    ...(profile ? [`--profile-directory=${profile}`] : []),
+                    ...(isLinux ? ['--ozone-platform=x11'] : []),
+                ],
+            },
         },
         firefox: {
             browserName: 'firefox',
             "wdio:enforceWebDriverClassic": true,
-            ...(isLinux && {
-                'moz:firefoxOptions': {
-                    args: ['--ozone-platform=x11']
-                }
-            })
+            "moz:firefoxOptions": {
+                args: [
+                    ...(path ? ['-profile', path] : []),
+                    ...(isLinux ? ['--ozone-platform=x11'] : []),
+                ],
+            },
         },
         edge: {
             browserName: 'MicrosoftEdge',
             "wdio:enforceWebDriverClassic": true,
-            ...(isLinux && {
-                'ms:edgeOptions': {
-                    args: ['--ozone-platform=x11']
-                }
-            })
+            "ms:edgeOptions": {
+                args: [
+                    ...(path ? [`--user-data-dir=${path}`] : []),
+                    ...(profile ? [`--profile-directory=${profile}`] : []),
+                    ...(isLinux ? ['--ozone-platform=x11'] : []),
+                ],
+            },
         },
         safari: {
             browserName: 'safari',

package/dist/utils/frameWorkDetector/frameWorkDetector.d.ts

@@ -0,0 +1,6 @@
+import { frameWorkDetectorInterface } from "./frameWorkDetectorInterface.js";
+export declare class frameWorkDetector {
+    static detectFramework(driver: any): Promise<frameWorkDetectorInterface>;
+    static isAngular(driver: any): Promise<boolean>;
+    static isReact(driver: any): Promise<boolean>;
+}

package/dist/utils/frameWorkDetector/frameWorkDetector.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameWorkDetector = void 0;
+const logData_1 = require("../logger/logData");
+class frameWorkDetector {
+    // private static cachedFramework: frameWorkDetectorInterface | null = null;
+    static async detectFramework(driver) {
+        // if (this.cachedFramework) {
+        //     return this.cachedFramework;
+        // }
+        try {
+            const framework = await driver.execute(() => {
+                const isReact = !!(window.__REACT_DEVTOOLS_GLOBAL_HOOK__ ||
+                    [...document.querySelectorAll('*')].some(el => Object.keys(el).some(key => key.startsWith('__reactFiber$') ||
+                        key.startsWith('__reactProps$'))));
+                if (isReact)
+                    return { framework: "react", detected: true };
+                const isAngular = !!(window.ng ||
+                    document.querySelector('[ng-version], [ng-app]') ||
+                    [...document.querySelectorAll('*')].some(el => el.getAttributeNames().some(attr => attr.startsWith('_ngcontent') ||
+                        attr.startsWith('_nghost'))));
+                if (isAngular)
+                    return { framework: "angular", detected: true };
+                return { framework: "react", detected: false };
+            });
+            // this.cachedFramework = framework;
+            return framework;
+        }
+        catch (error) {
+            logData_1.logger.error(error.message);
+            return { framework: "react", detected: false };
+        }
+    }
+    static async isAngular(driver) {
+        const framework = await this.detectFramework(driver);
+        return framework.framework === "angular";
+    }
+    static async isReact(driver) {
+        const framework = await this.detectFramework(driver);
+        return framework.framework === "react";
+    }
+}
+exports.frameWorkDetector = frameWorkDetector;

package/dist/utils/frameWorkDetector/frameWorkDetectorInterface.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface Window {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown;
+        ng?: unknown;
+    }
+}
+export interface frameWorkDetectorInterface {
+    framework: string;
+    detected: boolean;
+}

package/dist/utils/frameWorkDetector/frameWorkDetectorInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/helpers/enterActionHelper.d.ts

@@ -3,6 +3,7 @@ interface EnterActionResult {
     xpathPath: string;
 }
 interface EnterActionResultMob {
+    ffNumber: number;
     xpathPath: string;
 }
 export declare const enterActionHelper: (pageDOM: string, ffNumber: string) => EnterActionResult;

package/dist/utils/helpers/enterActionHelper.js

@@ -87,7 +87,7 @@ function enterActionHelperMob(annotatedDom, num) {
         if (element) {
             const elementClass = (element.getAttribute("class") || "").toLowerCase();
             if (elementClass.includes("edittext") ||
-                elementClass.includes("autocompletetextview")) {
+                elementClass.includes("autocompletetextview") || elementClass.includes("XCUIElementTypeTextField")) {
                 const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(annotatedDom, num);
                 xpathPath = result.xpathPath;
             }
@@ -119,6 +119,7 @@ function enterActionHelperMob(annotatedDom, num) {
             logData_js_1.logger.info(`No element found for ffNumber: ${numericFF} in MOB_Enter action`);
         }
         return {
+            ffNumber: numericFF,
             xpathPath
         };
     }

package/dist/utils/helpers/platformContext.d.ts

@@ -0,0 +1,3 @@
+import { platform } from "../../core/types/scriptTypesType.js";
+export declare function setPlatform(value: platform): void;
+export declare function getPlatform(): platform;

package/dist/utils/helpers/platformContext.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPlatform = setPlatform;
+exports.getPlatform = getPlatform;
+let currentPlatform;
+function setPlatform(value) {
+    currentPlatform = value;
+}
+function getPlatform() {
+    return currentPlatform;
+}

package/dist/utils/helpers/platformSyntax.d.ts

@@ -0,0 +1 @@
+export declare function getPlatformSyntax(platform: string): "Android" | "iOS" | "Web";

package/dist/utils/helpers/platformSyntax.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformSyntax = getPlatformSyntax;
+function getPlatformSyntax(platform) {
+    if (platform === "web") {
+        return "Web";
+    }
+    else if (platform === "android") {
+        return "Android";
+    }
+    else if (platform === "ios") {
+        return "iOS";
+    }
+    else {
+        return "Web";
+    }
+}

package/dist/utils/helpers/sameActionsHelper.js

@@ -24,7 +24,8 @@ exports.sameActionHelper = {
     MOB_GetTagName: "GetTagName",
     MOB_GetScreenshotOfElement: "GetScreenshotAs",
     MOB_GetX: "GetXLocationOfWebElement",
-    MOB_GetLocation: "GetLocation",
+    MOB_GetListOfElementsFromLocatorTypeLocatorValue: "GetListOfElementsFromLocatorTypeLocatorValue",
+    MOB_GetLocationOfElement: "GetLocation",
     MOB_GetY: "GetYLocationOfWebElement",
     MOB_GetRect: "GetRect",
     MOB_GetText: "GetText",
@@ -51,5 +52,9 @@ exports.sameActionHelper = {
     MOB_PressAnyKey: "PressAnyKey",
     MOB_WaitTillElementHasText: "WaitTillElementHasText",
     MOB_WaitTillElementContainsText: "WaitTillElementContainsText",
-    MOB_PressEnterKey: "PressEnterKey"
+    MOB_PressEnterKey: "PressEnterKey",
+    MOB_VerifyElementIsNotDisplayed: "VerifyElementIsNotDisplayed",
+    MOB_VerifyElementIsDisplayedInSpecifiedTime: "VerifyElementIsDisplayedInSpecifiedTime",
+    MOB_VerifyElementIsEnabledInSpecifiedTime: "VerifyElementIsEnabledInSpecifiedTime",
+    MOB_VerifyElementIsSelectedInSpecifiedTime: "VerifyElementIsSelectedInSpecifiedTime"
 };

package/dist/utils/helpers/xpathcreation.d.ts

@@ -2,5 +2,9 @@ interface FFResult {
     xpathPath: string;
     ffInspector?: string;
 }
-export declare function getFFIndexAndXPath(annotatedDom: string, fireflinkIndex: string): FFResult;
+export interface IWebXPathResult {
+    xpathPath: string;
+}
+export declare function getWebXPathByFFIndex(annotatedDom: string, fireflinkIndex: string): IWebXPathResult;
+export declare function getFFIndexAndXPath(annotatedDom: string, fireflinkIndex: string, platform?: string): FFResult;
 export {};

package/dist/utils/helpers/xpathcreation.js

@@ -3,19 +3,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebXPathByFFIndex = getWebXPathByFFIndex;
 exports.getFFIndexAndXPath = getFFIndexAndXPath;
 const xmldom_1 = require("@xmldom/xmldom");
 const xpath_1 = __importDefault(require("xpath"));
-function getFFIndexAndXPath(annotatedDom, fireflinkIndex) {
+const logData_js_1 = require("../logger/logData.js");
+function getWebXPathByFFIndex(annotatedDom, fireflinkIndex) {
+    try {
+        const escaped = fireflinkIndex.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        // Find the tag containing the required ff-inspect
+        const tagRegex = new RegExp(`<[^>]+\\bff-inspect\\s*=\\s*["']${escaped}["'][^>]*>`, "i");
+        const tag = annotatedDom.match(tagRegex)?.[0];
+        if (!tag) {
+            return { xpathPath: "" };
+        }
+        // Extract ff-xpath irrespective of attribute order
+        const attrs = [...tag.matchAll(/([\w-]+)\s*=\s*["']([^"']*)["']/g)];
+        const ffXpath = attrs.find(([_, name]) => name.toLowerCase() === "ff-xpath");
+        return {
+            xpathPath: ffXpath?.[2] ?? "",
+        };
+    }
+    catch (error) {
+        throw new Error("Error while resolving ff-xpath", {
+            cause: error,
+        });
+    }
+}
+function getFFIndexAndXPath(annotatedDom, fireflinkIndex, platform) {
     try {
         const parser = new xmldom_1.DOMParser();
         const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
         let xpathQuery = "";
         let isBounds = false;
-        // 🔥 Detect input type
         if (fireflinkIndex.startsWith("[")) {
             isBounds = true;
-            xpathQuery = `//*[@bounds='${fireflinkIndex}' and @clickable='true']`;
+            if (platform === "android") {
+                xpathQuery = `//*[@bounds='${fireflinkIndex}' and @clickable='true']`;
+            }
+            else {
+                const match = fireflinkIndex.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+                if (!match) {
+                    throw new Error(`Invalid bounds format: ${fireflinkIndex}`);
+                }
+                const [, x1, y1, x2, y2] = match.map(Number);
+                const x = x1;
+                const y = y1;
+                const width = x2 - x1;
+                const height = y2 - y1;
+                logData_js_1.logger.info(`Parsed bounds - x: ${x}, y: ${y}, width: ${width}, height: ${height}`);
+                xpathQuery = `//*[@x='${x}' and @y='${y}' and @width='${width}' and @height='${height}' and @enabled='true']`;
+            }
         }
         else {
             xpathQuery = `//*[@FF-inspecter='${fireflinkIndex}']`;
@@ -45,7 +83,8 @@ function getFFIndexAndXPath(annotatedDom, fireflinkIndex) {
             }
             return "/" + parts.join("/");
         }
-        const xpathPath = buildXPath(element);
+        let xpathPath = buildXPath(element);
+        xpathPath = xpathPath.replace("/AppiumAUT[1]", "");
         if (isBounds) {
             return {
                 xpathPath,