npm - ff-automationv2 - Versions diffs - 2.1.3 → 2.2.0 - Mend

ff-automationv2 2.1.3 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (362) hide show

package/src/utils/DomExtraction/jsForAttributeInjection.ts CHANGED Viewed

@@ -1,18 +1,17 @@
-import type { Browser } from "webdriverio";
+import { logger } from "../../utils/logger/logData.js"
 export interface AnnotatedDOMResult {
     dom: string;
-    selectors: Record<string, string>;
+    // selectors: Record<string, string>;
 }
 export async function getAnnotatedDOM(
-    browser: Browser
+    browser: WebdriverIO.Browser
 ): Promise<AnnotatedDOMResult> {
     return await browser.execute<AnnotatedDOMResult, []>(() => {
         let nodeIndex = 0;
-        const xpaths: Record<string, string> = {};
+        // const xpaths: Record<string, string> = {};
         // ==========================================================
         // COVERAGE CHECK
@@ -32,9 +31,9 @@ export async function getAnnotatedDOM(
                 [rect.left + rect.width / 2, rect.top + rect.height / 2]
             ];
-            for (let [x, y] of testPoints) {
+            for (const [x, y] of testPoints) {
-                let topEl = document.elementFromPoint(x, y);
+                const topEl = document.elementFromPoint(x, y);
                 if (!topEl) continue;
                 if (topEl === el || el.contains(topEl)) continue;
@@ -115,7 +114,7 @@ export async function getAnnotatedDOM(
             if (!node || node.nodeType !== 1) return "";
-            let segments: string[] = [];
+            const segments: string[] = [];
             let current: Element | null = node;
             while (current && current.nodeType === 1) {
@@ -214,7 +213,7 @@ export async function getAnnotatedDOM(
                     node.setAttribute("ff-inspect", fireId);
                     node.setAttribute("ff-xpath", xpath);
-                    xpaths[fireId] = xpath;
+                    // xpaths[fireId] = xpath;
                     annotate(node);
                 }
@@ -300,7 +299,10 @@ export async function getAnnotatedDOM(
                             doc.documentElement
                         );
                     }
-                } catch { }
+                } catch (error) {
+                    logger.error("Attribute injection failed", error)
+                }
             }
             el.childNodes.forEach(child => {
@@ -314,9 +316,63 @@ export async function getAnnotatedDOM(
         return {
             dom:
                 "<!DOCTYPE html>\n" +
-                serializeNode(document.documentElement),
-            selectors: xpaths
+                serializeNode(document.documentElement)
+            // selectors: xpaths
         };
     });
 }
+import { DOMParser, XMLSerializer } from "@xmldom/xmldom";
+export async function getAnnotatedDOMForMobile(
+    driver: WebdriverIO.Browser
+): Promise<AnnotatedDOMResult> {
+    try {
+        // Wait like Python sleep(2)
+        await driver.pause(2000);
+        const pageSource = await driver.getPageSource();
+        if (!pageSource) {
+            throw new Error("Unable to capture DOM");
+        }
+        // Parse XML DOM
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(pageSource, "text/xml");
+        const allElements = xmlDoc.getElementsByTagName("*");
+        let index = 1;
+        for (const element of Array.from(allElements)) {
+            element.setAttribute("FF-inspecter", `Fire-Flink-${index}`);
+            index++;
+        }
+        // Convert DOM back to string
+        const serializer = new XMLSerializer();
+        let annotatedXML = serializer.serializeToString(xmlDoc);
+        // Preserve XML declaration if present
+        if (pageSource.trim().startsWith("<?xml")) {
+            const declarationEnd = pageSource.indexOf("?>");
+            if (declarationEnd !== -1) {
+                const declaration = pageSource.substring(0, declarationEnd + 2).trim();
+                annotatedXML = `${declaration}\n${annotatedXML}`;
+            }
+        }
+        return {
+            dom: annotatedXML
+        };
+    } catch (error: any) {
+            throw new Error(`Unable to annotate DOM: ${error.message}`, { cause: error });
+        }
+}

package/src/utils/InstancesDetails/getInstancesInfo.ts ADDED Viewed

@@ -0,0 +1,12 @@
+export function getAiInstanceInfo(
+    responseObject: any
+): Record<string, string> {
+    return {
+        serviceProvider: responseObject.serviceProvider,
+        apiKey: responseObject.instanceDetails.apiKey,
+        apiUrl: responseObject.instanceDetails.apiUrl,
+        visionApiKey: responseObject.instanceDetails.visionApiKey ?? "c2stcHJvai1zODVFenVfWkdnVUxoT1dNVVhRTmxuUW9ELUpnS3dEMGpvSmJZcDE0YWd4ZEZ3MWM5Mlh5NnlLUFJpYk1XckUtTTRTV1dzcHc0MFQzQmxia0ZKekVkWXRMTm1rWWlJQVRYTUwyTWhhTU5NR3FUWjhZekJYZHdkTHc0MHRVT084d0t6N19wRENYSERSX0NsSVRtTVpjR3VsY3ZlNEE=",
+        model: responseObject.model,
+    };
+}

package/src/utils/alertPopup/isAlertPresent.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { IAlertChecker } from "./isAlertPresentInterface";
+export const isAlertPresent: IAlertChecker = async (
+    driver,
+    timeout: number = 0
+): Promise<boolean> => {
+    try {
+        if (!driver) return false;
+        await driver.waitUntil(
+            async () => await driver.isAlertOpen(),
+            { timeout }
+        );
+        return true;
+    } catch {
+        return false;
+    }
+};

package/src/utils/alertPopup/isAlertPresentInterface.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export interface IAlertChecker {
+    (
+        driver: WebdriverIO.Browser,
+        timeout?: number
+    ): Promise<boolean>;
+}

package/src/utils/helpers/enterActionHelper.ts CHANGED Viewed

@@ -1,9 +1,17 @@
 import { JSDOM } from "jsdom";
+import { DOMParser } from "@xmldom/xmldom";
+import { getFFIndexAndXPath } from "./xpathcreation.js";
+import { logger } from "../logger/logData.js";
+import xpath from "xpath";
-export interface EnterActionResult {
+interface EnterActionResult {
     ffNumber: number;
     xpathPath: string;
 }
+interface EnterActionResultMob {
+    xpathPath: string;
+}
 export const enterActionHelper = (
     pageDOM: string,
@@ -32,7 +40,7 @@ export const enterActionHelper = (
         return el?.getAttribute("ff-xpath") || "";
     };
-    let element = doc.querySelector(
+    const element = doc.querySelector(
         `[ff-inspect="Fire-Flink-${numericFF}"]`
     );
@@ -92,3 +100,81 @@ export const enterActionHelper = (
         xpathPath
     };
 };
+export function enterActionHelperMob(
+  annotatedDom: string,
+  num: string,
+): EnterActionResultMob {
+    const parser = new DOMParser();
+    const match = num.match(/\d+$/);
+    const numericFF = match ? parseInt(match[0], 10) : 0;
+    const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
+    const xpathQuery = `//*[@FF-inspecter='${num}']`;
+    const nodes = xpath.select(xpathQuery, xmlDoc) as Node[];
+    const element = nodes.length ? (nodes[0] as Element) : null;
+    let xpathPath = "";
+    if (element) {
+      const elementClass = (element.getAttribute("class") || "").toLowerCase();
+        if (
+          elementClass.includes("edittext") ||
+          elementClass.includes("autocompletetextview")
+        ) {
+          xpathPath = getFFIndexAndXPath(annotatedDom, num);
+        } else {
+          // check immediate children
+          const children = Array.from(element.children);
+          let editableChild: Element | null = null;
+          for (const child of children) {
+            const childClass = (child.getAttribute("class") || "").toLowerCase();
+            if (
+              childClass.includes("edittext") ||
+              childClass.includes("autocompletetextview")
+            ) {
+              editableChild = child;
+              break;
+            }
+          }
+          if (editableChild) {
+            const childNum =
+              editableChild.getAttribute("FF-inspecter")?.split("-").pop();
+            if (childNum) {
+              xpathPath = getFFIndexAndXPath(annotatedDom, `Fire-Flink-${childNum}`);
+            }
+          } else {
+            xpathPath = getFFIndexAndXPath(annotatedDom, num);
+          }
+        }
+    } else {
+      logger.info(`No element found for ffNumber: ${numericFF} in MOB_Enter action`);
+    }
+     return {
+        xpathPath
+    };
+}

package/src/utils/helpers/imageUtils.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Ensures that a base64 string or Buffer has the correct data URI prefix for PNG images.
+ * @param image The base64 string or Buffer.
+ * @returns The base64 string with the `data:image/png;base64,` prefix.
+ */
+export function formatImageBase64(image: string | Buffer): string {
+    if (!image) return "";
+    const base64 = Buffer.isBuffer(image) ? image.toString("base64") : image;
+    return base64.startsWith("data:") ? base64 : `data:image/png;base64,${base64}`;
+}

package/src/utils/helpers/sameActionsHelper.ts ADDED Viewed

@@ -0,0 +1,52 @@
+export const sameActionHelper: Record<string, string> = {
+    MOB_Tap: "Click",
+    MOB_Enter: "SendKeys",
+    MOB_VerifyElementIsDisplayed: "VerifyElementIsDisplayed",
+    MOB_VerifyElementIsEnabled: "VerifyElementIsEnabled",
+    MOB_VerifyXLocationOfAndroidElement: "VerifyXLocationOfElement",
+    MOB_VerifyElementIsSelected: "VerifyElementIsSelected",
+    MOB_VerifyYLocationOfAndroidElement: "VerifyYLocationOfElement",
+    MOB_VerifyWidthOfElement: "VerifyWidthOfElement",
+    MOB_WaitAndClick: "WaitAndClick",
+    MOB_GetScreenshot: "GetScreenshot",
+    MOB_VerifyText: "VerifyText",
+    MOB_VerifyElementNotContainsText: "VerifyElementNotContainsText",
+    MOB_VerifyIfXAndYCoordinateOfElement: "VerifyIfXAndYCoordinateOfElement",
+    MOB_VerifyPartialAttributeValue: "VerifyPartialAttributeValue",
+    MOB_VerifyElementIsClickable: "VerifyElementIsClickable",
+    MOB_VerifyElementIsDisabled: "VerifyElementIsDisabled",
+    MOB_GetImplicitTimeOut: "GetImplicitTimeOut",
+    MOB_GetDriverInstance: "GetDriverInstance",
+    MOB_GetCurrentWindowHandle: "GetCurrentWindowHandle",
+    MOB_GetTagName: "GetTagName",
+    MOB_GetScreenshotAs: "GetScreenshotAs",
+    MOB_GetX: "GetXLocationOfWebElement",
+    MOB_GetLocation: "GetLocation",
+    MOB_GetY: "GetYLocationOfWebElement",
+    MOB_GetRect: "GetRect",
+    MOB_GetText: "GetText",
+    MOB_GetSize: "GetSize",
+    MOB_GetAttribute: "GetAttribute",
+    MOB_Clear: "Clear",
+    MOB_DoubleTap: "DoubleClick",
+    MOB_TapNTimes: "ClickNTimes",
+    MOB_VerifyPartialText: "VerifyPartialText",
+    MOB_VerifyAttributeValue: "VerifyAttributeValue",
+    MOB_ClearThenEnterInput: "ClearThenEnterInput",
+    MOB_EnterDataAndPressKey: "EnterDataAndPressKey",
+    MOB_WaitAndSendKeys: "WaitAndSendKeys",
+    MOB_VerifyHeightOfElement: "VerifyHeightOfWebElement",
+    MOB_WaitTillPresenceOfElement: "WaitTillPresenceOfElement",
+    MOB_WaitTillPresenceOfAllElements: "WaitTillPresenceOfAllElements",
+    MOB_WaitTillAttributeOfElementIsString: "WaitTillAttributeOfElementIsString",
+    MOB_EnterUrl: "EnterUrl",
+    MOB_SetClipBoardText: "SetClipBoardText",
+    MOB_PressAnyKeyNTimes: "PressAnyKeyNTimes",
+    MOB_FindElements: "FindElements",
+    MOB_WaitTillElementIsClickable: "WaitTillElementIsClickable",
+    MOB_CheckIfElementIsDisplayed: "CheckIfElementIsDisplayed",
+    MOB_PressAnyKey: "PressAnyKey",
+    MOB_WaitTillElementHasText: "WaitTillElementHasText",
+    MOB_WaitTillElementContainsText: "WaitTillElementContainsText",
+    MOB_PressEnterKey: "PressEnterKey"
+};

package/src/utils/helpers/xpathcreation.ts ADDED Viewed

@@ -0,0 +1,59 @@
+import { DOMParser } from "@xmldom/xmldom";
+import xpath from "xpath";
+// import { logger } from "../logger/logData.js";
+export function getFFIndexAndXPath(
+  annotatedDom: string,
+  fireflinkIndex: string
+): string  {
+  try{
+ const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
+  const xpathQuery = `//*[@FF-inspecter='${fireflinkIndex}']`;
+  const nodes = xpath.select(xpathQuery, xmlDoc) as Node[];
+  const element = nodes.length ? (nodes[0] as Element) : null;
+  function buildXPath(node: Node): string {
+    if (node.nodeType !== 1) return "";
+    const parts: string[] = [];
+    while (node && node.nodeType === 1) {
+      let index = 1;
+      let sibling = node.previousSibling;
+      while (sibling) {
+        if (
+          sibling.nodeType === 1 &&
+          (sibling as Element).tagName === (node as Element).tagName
+        ) {
+          index++;
+        }
+        sibling = sibling.previousSibling;
+      }
+      parts.unshift(`${(node as Element).tagName}[${index}]`);
+      node = node.parentNode!;
+    }
+    return "/" + parts.join("/");
+  }
+  let xpathPath = "";
+  if (element) {
+    xpathPath = buildXPath(element);
+  }
+  return xpathPath;
+}
+  catch(error:any){
+    throw new Error( "Error in getFFIndexAndXPath",{cause : error} );
+  }
+}

package/src/utils/iframesExtraction/findElementUsingFF.ts ADDED Viewed

@@ -0,0 +1,45 @@
+import { IFindElementUsingFF } from "./iframeInterface.js";
+import { switchToIframeByMeta } from "./switchToIframeByMeta.js";
+export const findElementUsingFF: (args: IFindElementUsingFF) => Promise<void> =
+    async (args) => {
+        await args.driver.switchToFrame(null);
+        const usedElementNames: string[] = [];
+        for (const frameMeta of args.frames) {
+            const xpathUsed = await switchToIframeByMeta(args.driver, frameMeta);
+            if (xpathUsed) {
+                let finalElementName = args.elementName;
+                if (finalElementName) {
+                    const baseName = finalElementName;
+                    let newName = baseName;
+                    let count = 0;
+                    while (usedElementNames.includes(newName)) {
+                        count++;
+                        newName = `${baseName}_${count}`;
+                    }
+                    finalElementName = newName;
+                    usedElementNames.push(finalElementName);
+                }
+                args.scriptDataAppender.add(async () => ({
+                    nlpName: 'SwitchToFrameByFrameElement',
+                    stepInputs: [],
+                    elementsData: [{
+                        name: finalElementName,
+                        type: args.elementType,
+                        locators: [{ name: "xpath", value: xpathUsed }],
+                        platform: args.platform
+                    }]
+                }));
+            }
+        }
+    };

package/src/utils/iframesExtraction/iframeInterface.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import { ScriptDataAppender } from "../../fireflinkData/fireflinkScript/scriptGenrationData";
+export interface FrameMeta {
+    id?: string;
+    name?: string;
+    title?: string;
+    aria?: string;
+    src?: string;
+}
+export interface IFindElementUsingFF {
+    driver: WebdriverIO.Browser,
+    selector: string,
+    frames: FrameMeta[],
+    scriptDataAppender: ScriptDataAppender,
+    elementName: string,
+    elementType: string,
+    platform: string
+}

package/src/utils/iframesExtraction/switchToIframeByMeta.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import { FrameMeta } from "./iframeInterface.js";
+export async function switchToIframeByMeta(driver: WebdriverIO.Browser, frameMeta: FrameMeta): Promise<string | null> {
+    const selectors = [
+        frameMeta.id && `//*[@id='${frameMeta.id}']`,
+        frameMeta.name && `//*[@name='${frameMeta.name}']`,
+        frameMeta.title && `//iframe[@title='${frameMeta.title}']`,
+        frameMeta.aria && `//iframe[@aria-label='${frameMeta.aria}']`,
+        frameMeta.src && `//iframe[contains(@src,'${frameMeta.src}')]`,
+    ].filter(Boolean) as string[];
+    for (const selector of selectors) {
+        try {
+            const iframe = await driver.$(selector);
+            if (await iframe.isExisting()) {
+                await driver.switchToFrame(iframe);
+                return selector;
+            }
+        } catch { continue; }
+    }
+    return null;
+}

package/src/utils/javascript/jsFindElement.ts CHANGED Viewed

@@ -9,10 +9,10 @@ export const Find_element_by_ff_js_script = `
   // ---------------- FINDER ----------------
   function findByFfInspect(root) {
       const visited = new Set();
-      const stack = [{ node: root, frames: [] }];
+      const stack = [{ node: root, frames: [], currentDoc: root }];
       while (stack.length > 0) {
-          const { node, frames } = stack.pop();
+          const { node, frames, currentDoc } = stack.pop();
           if (!node) continue;
           if (
@@ -26,36 +26,43 @@ export const Find_element_by_ff_js_script = `
           if (node.nodeType === Node.ELEMENT_NODE) {
               if (node.getAttribute && node.getAttribute("ff-inspect") === target) {
-                  return { node, frames };
+                  return { node, frames, iframe_dom: currentDoc };
               }
+              // Shadow DOM
               if (node.shadowRoot) {
-                  stack.push({ node: node.shadowRoot, frames });
+                  stack.push({
+                      node: node.shadowRoot,
+                      frames,
+                      currentDoc
+                  });
               }
+              // Iframe traversal
               if (node.tagName === "IFRAME") {
-                try {
-                    const doc = node.contentDocument || node.contentWindow?.document;
-                    if (doc) {
-                        const meta = {
-                            id: node.id || null,
-                            name: node.getAttribute("name") || null,
-                            title: node.getAttribute("title") || null,
-                            aria: node.getAttribute("aria-label") || null,
-                            src: node.getAttribute("src") || null,
-                        };
-                        stack.push({
-                            node: doc,
-                            frames: [...frames, meta]
-                        });
-                    }
-                } catch (e) {}
+                  try {
+                      const doc = node.contentDocument || node.contentWindow?.document;
+                      if (doc) {
+                          const meta = {
+                              id: node.id || null,
+                              name: node.getAttribute("name") || null,
+                              title: node.getAttribute("title") || null,
+                              aria: node.getAttribute("aria-label") || null,
+                              src: node.getAttribute("src") || null,
+                          };
+                          stack.push({
+                              node: doc,
+                              frames: [...frames, meta],
+                              currentDoc: doc
+                          });
+                      }
+                  } catch (e) {}
               }
               const kids = node.children || node.childNodes;
               for (let i = kids.length - 1; i >= 0; i--) {
-                  stack.push({ node: kids[i], frames });
+                  stack.push({ node: kids[i], frames, currentDoc });
               }
           }
@@ -65,7 +72,7 @@ export const Find_element_by_ff_js_script = `
           ) {
               const kids = node.childNodes;
               for (let i = kids.length - 1; i >= 0; i--) {
-                  stack.push({ node: kids[i], frames });
+                  stack.push({ node: kids[i], frames, currentDoc });
               }
           }
       }
@@ -101,15 +108,15 @@ export const Find_element_by_ff_js_script = `
   function buildXPath(el) {
       if (!el) return null;
-      if (el.id) return \`//*[@id="\${el.id}"]\`;
+      if (el.id) return "//*[@id=\\"" + el.id + "\\"]";
       const name = el.getAttribute("name");
-      if (name) return \`//*[@name="\${name}"]\`;
+      if (name) return "//*[@name=\\"" + name + "\\"]";
       const text = el.textContent && el.textContent.trim();
       if (text && text.length < 50) {
-          const escaped = text.replace(/"/g, '\\\\"');
-          const xp = \`//*[text()="\${escaped}"]\`;
+          const escaped = text.replace(/"/g, '\\"');
+          const xp = "//*[text()=\\"" + escaped + "\\"]";
           try {
               const n = document.evaluate(xp, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
               if (n.singleNodeValue === el) return xp;
@@ -150,12 +157,13 @@ export const Find_element_by_ff_js_script = `
           if (inside) targetNode = inside;
       }
-      const xpath = buildXPath(targetNode);
+      const xpath_if = buildXPath(targetNode);
       return callback({
           success: true,
-          xpath,
-          frames: found.frames
+          xpath_if,
+          frames: found.frames,
+          iframe_dom_html: found.iframe_dom?.documentElement?.outerHTML || null
       });
   })();
-`;
+`;

package/src/utils/javascript/jsForShadowRoot.ts CHANGED Viewed

@@ -113,8 +113,8 @@ const path = arguments[0];
 function resolve(path) {
   function toCss(sel) {
-    return sel.replace(/(\\\\w+)\\\\[(\\\\d+)\\\\]/g,
-      (_, t, n) => \`\\\${t}:nth-of-type(\\\${n})\`);
+    return sel.replace(/(\\w+)\\[(\\d+)\\]/g,
+      (_, t, n) => \`\${t}:nth-of-type(\${n})\`);
   }
   const parts = path.split("/shadow/");
@@ -130,7 +130,7 @@ function resolve(path) {
   for (let i = 1; i < parts.length; i++) {
     if (!node || !node.shadowRoot) return null;
     node = node.shadowRoot.querySelector(
-      toCss(parts[i].replace(/\\\\//g, " > "))
+      toCss(parts[i].replace(/\\//g, " > "))
     );
   }
@@ -149,8 +149,8 @@ const text = arguments[1];
 function resolve(path) {
   function toCss(sel) {
-    return sel.replace(/(\\\\w+)\\\\[(\\\\d+)\\\\]/g,
-      (_, t, n) => \`\\\${t}:nth-of-type(\\\${n})\`);
+    return sel.replace(/(\\w+)\\[(\\d+)\\]/g,
+      (_, t, n) => \`\${t}:nth-of-type(\${n})\`);
   }
   const parts = path.split("/shadow/");
@@ -166,7 +166,7 @@ function resolve(path) {
   for (let i = 1; i < parts.length; i++) {
     if (!node || !node.shadowRoot) return null;
     node = node.shadowRoot.querySelector(
-      toCss(parts[i].replace(/\\\\//g, " > "))
+      toCss(parts[i].replace(/\\//g, " > "))
     );
   }
@@ -184,8 +184,8 @@ const expected = arguments[1];
 function resolve(path) {
   function toCss(sel) {
-    return sel.replace(/(\\\\w+)\\\\[(\\\\d+)\\\\]/g,
-      (_, t, n) => \`\\\${t}:nth-of-type(\\\${n})\`);
+    return sel.replace(/(\\w+)\\[(\\d+)\\]/g,
+      (_, t, n) => \`\${t}:nth-of-type(\${n})\`);
   }
   const parts = path.split("/shadow/");
@@ -201,7 +201,7 @@ function resolve(path) {
   for (let i = 1; i < parts.length; i++) {
     if (!node || !node.shadowRoot) return null;
     node = node.shadowRoot.querySelector(
-      toCss(parts[i].replace(/\\\\//g, " > "))
+      toCss(parts[i].replace(/\\//g, " > "))
     );
   }