ff-automationv2 2.2.28 → 2.2.29

package/dist/fireflinkData/fireflinkLocators/parser/getElementsFromHTML.js

@@ -0,0 +1,557 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementsFromHTML = void 0;
+const xpath_js_1 = require("../utils/xpath.js");
+const cssSelector_js_1 = require("../utils/cssSelector.js");
+const jsdom_1 = require("jsdom");
+const xpathHelpers_js_1 = require("../utils/xpathHelpers.js");
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const getElementFromCssSelector = (docmt, selector) => {
+    try {
+        const found = docmt.querySelector(selector);
+        if (found)
+            return found;
+    }
+    catch (error) {
+        console.error("Invalid CSS selector:", selector, error);
+        return null;
+    }
+    return getElementFromShadowRoot(docmt.body, selector);
+};
+const isCssSelectorLocator = (locator) => {
+    return locator.name?.toLowerCase().includes("cssselector") ?? false;
+};
+const getElementFromShadowRoot = (el, selector) => {
+    const shadowRoot = el.shadowRoot;
+    if (shadowRoot && !selector.includes("dynamic")) {
+        return shadowRoot.querySelector(selector);
+    }
+    const elements = Array.from(el.querySelectorAll("*"));
+    try {
+        for (let i = 0; i < elements.length; i++) {
+            if (elements[i].shadowRoot) {
+                const { shadowRoot } = elements[i];
+                if (shadowRoot) {
+                    const nestedElement = getElementFromShadowRoot(shadowRoot, selector);
+                    if (nestedElement) {
+                        return nestedElement;
+                    }
+                    if (shadowRoot && !selector.includes("dynamic")) {
+                        return shadowRoot.querySelector(selector);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error(error);
+    }
+    return null;
+};
+const getId = (element) => {
+    return element?.id || null;
+};
+const getClassName = (element) => {
+    if (element instanceof element.ownerDocument.defaultView.SVGElement) {
+        const cls = element.className;
+        if (typeof cls === "string") {
+            return cls;
+        }
+        return cls?.baseVal || null;
+    }
+    return element.className || null;
+};
+const getVisibleText = (element) => {
+    return element.textContent?.trim() || null;
+};
+const getName = (element) => {
+    const elementEl = element;
+    if (elementEl.hasAttribute("name")) {
+        const attrValue = elementEl.getAttribute("name");
+        const name = `${attrValue}`;
+        return name || null;
+    }
+    return null;
+};
+const relations = [
+    "/preceding-sibling",
+    "/following-sibling",
+    "/parent",
+    "/descendant",
+    "/ancestor",
+    "/self",
+    "/ancestor-or-self",
+    "/child",
+    "/preceding",
+    "/following"
+];
+function getElementFromXPath(docmt, xpath, platform) {
+    if (platform !== "web") {
+        const ffMatch = xpath.match(/^\/\/\*\[@FF-inspecter="([^"]+)"\]$/);
+        if (ffMatch) {
+            return docmt.querySelector(`[FF-inspecter="${ffMatch[1]}"]`);
+        }
+    }
+    return (0, xpathHelpers_js_1.evaluateXPath)(xpath, docmt, "first").singleNodeValue;
+}
+function checkReferenceElementIsValid(locator, relation, docmt) {
+    if (locator.includes(relation)) {
+        const locatotSplitArray = locator.split(relation);
+        const sourceLoc = locatotSplitArray[0].trim();
+        const window = docmt.defaultView;
+        if (!window)
+            return null;
+        if (!locator.includes("dynamic")) {
+            const sourceElement = (0, xpathHelpers_js_1.evaluateXPath)(sourceLoc, docmt, "first").singleNodeValue;
+            if (sourceElement) {
+                const completeElement = (0, xpathHelpers_js_1.evaluateXPath)(locator, docmt, "first").singleNodeValue;
+                let relativeXpath;
+                if (completeElement) {
+                    relativeXpath = locator;
+                    return relativeXpath;
+                }
+                else {
+                    console.error("Complete Locator is Invalid:", locator);
+                    relativeXpath = locator;
+                    return relativeXpath;
+                }
+            }
+            else {
+                console.error("Source Locator Not Found:", sourceLoc);
+            }
+        }
+    }
+    return null;
+}
+const getElementsFromHTML = (record, htmlString, platform) => {
+    const virtualConsole = new jsdom_1.VirtualConsole();
+    let docmt;
+    if (platform === "web") {
+        try {
+            const dom = new jsdom_1.JSDOM(htmlString, {
+                resources: "usable",
+                runScripts: "outside-only",
+                pretendToBeVisual: true,
+                virtualConsole,
+                includeNodeLocations: true,
+            });
+            docmt = dom.window.document;
+        }
+        catch (e) {
+            logData_js_1.logger.error("Unable to parse XML : ", e.message);
+            return null;
+        }
+    }
+    else {
+        try {
+            const dom = new jsdom_1.JSDOM(htmlString, {
+                contentType: "text/xml",
+                virtualConsole,
+            });
+            docmt = dom.window.document;
+        }
+        catch (e) {
+            logData_js_1.logger.error("Unable to parse XML : ", e.message);
+            return null;
+        }
+    }
+    const elementsToRemove = docmt.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source");
+    if (elementsToRemove) {
+        elementsToRemove.forEach((tag) => {
+            tag.remove();
+        });
+    }
+    const finalLocatorsSet = new Set();
+    const finalLocators = [];
+    function createLocator(base, overrides = {}) {
+        const newLocator = {
+            name: overrides.name ?? base?.name,
+            type: overrides.type ?? base?.type,
+            value: overrides.value ?? base?.value,
+            reference: overrides.reference ?? base?.reference,
+            status: overrides.status ?? base?.status,
+            isRecorded: overrides.isRecorded ?? base?.isRecorded
+        };
+        newLocator.isSelfHealed = "Y";
+        pushUniqueLocator(newLocator);
+    }
+    function resolveElement(ctx, locator, selector) {
+        if (isCssSelectorLocator(locator)) {
+            return getElementFromCssSelector(ctx, selector);
+        }
+        else if (locator.name.includes("id") || selector.startsWith("#")) {
+            return ctx.querySelector("#" + (0, xpathHelpers_js_1.escapeAttrValue)(selector));
+        }
+        else if (locator.name.includes("className") || selector.startsWith(".")) {
+            return ctx.querySelector("." + selector);
+        }
+        else if (locator.name === "name") {
+            const safeName = (0, xpathHelpers_js_1.escapeAttrValue)(selector);
+            return ctx.querySelector(`[name="${safeName}"]`);
+        }
+        else if (locator.name === "tagName") {
+            return ctx.querySelector(selector);
+        }
+        else if (locator.name === "linkText") {
+            return (Array.from(ctx.querySelectorAll("a")).find((a) => a.textContent?.trim() === selector) || null);
+        }
+        else if (locator.name === "partialLinkText") {
+            return (Array.from(ctx.querySelectorAll("a")).find((a) => a.textContent?.includes(selector)) || null);
+        }
+        else if ((locator.name.includes("xpath") || selector.startsWith("//")) &&
+            !locator.type.match("dynamic")) {
+            const el = getElementFromXPath(ctx, selector, platform);
+            if (el) {
+                createLocator(locator, {
+                    value: selector,
+                    isRecorded: String(locator.isRecorded).includes("N") ? "N" : "Y"
+                });
+            }
+            return el;
+        }
+        else {
+            return ctx.querySelector(selector);
+        }
+    }
+    function findInIframes(docmt, locator, selector) {
+        const iframes = docmt.querySelectorAll("iframe");
+        for (const iframe of iframes) {
+            try {
+                const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
+                if (!iframeDoc)
+                    continue;
+                const el = resolveElement(iframeDoc, locator, selector);
+                if (el)
+                    return el;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    function pushUniqueLocator(obj) {
+        const key = `${obj.name}:${obj.value}`;
+        if (!finalLocatorsSet.has(key)) {
+            finalLocatorsSet.add(key);
+            finalLocators.push(obj);
+        }
+    }
+    /** Locator Value Cleaner (Handles Special Scenarios) **/
+    const cleanLocatorValue = (val, type, isRecorded) => {
+        if (!val)
+            return null;
+        if (val.toLowerCase().includes('ff-inspecter') || val.toLowerCase().includes('ff-inspect')) {
+            return null;
+        }
+        let cleaned = val.trim();
+        // Return null for empty or literal "null"
+        if (platform === "web") {
+            if (!cleaned || cleaned.toLowerCase() === "null")
+                return null;
+        }
+        else {
+            if (!cleaned || cleaned === "null")
+                return null;
+        }
+        // Unescape any escaped quotes
+        cleaned = cleaned.replace(/\\"/g, '"').replace(/\\'/g, "'");
+        // Remove surrounding single or double quotes
+        cleaned = cleaned.replace(/^['"](.+?)['"]$/, "$1");
+        // Replace double single quotes with a single quote inside XPath
+        cleaned = cleaned.replace(/''/g, "'");
+        // Normalize double quotes in XPath attribute selectors [@id="" -> [@id='']
+        cleaned = cleaned.replace(/\[@(id|name)=['"]{2}(.+?)['"]{2}\]/g, "[@$1='$2']");
+        // For DOM selectors (id or name), remove ALL quotes
+        if (type === "id" || type === "name") {
+            cleaned = cleaned.replace(/['"]/g, "").trim();
+        }
+        if (platform === "web" && type === "xpath" && isRecorded === "Y" && !val.startsWith("//"))
+            return null;
+        // Final check for empty strings
+        if (!cleaned || /^['"]{2}$/.test(cleaned))
+            return null;
+        return cleaned;
+    };
+    locators: for (const locator of record.locators) {
+        try {
+            const recordedNLocators = record.locators.filter((l) => l.isRecorded === "N");
+            if (recordedNLocators.length > 0) {
+                for (const locator of recordedNLocators) {
+                    createLocator(locator);
+                }
+            }
+            const isDynamic = String(locator.value || locator.type || "");
+            if (isDynamic.includes("dynamic") ||
+                isDynamic.match("dynamic") ||
+                isDynamic.includes("{") ||
+                isDynamic.includes("}")) {
+                createLocator(locator);
+                continue;
+            }
+            // if (record.isShared.includes("Y")) {
+            //   break locators;
+            // }
+            try {
+                let targetElement = null;
+                const selectors = locator.value.split(">>>");
+                for (const selector of selectors) {
+                    if (!docmt) {
+                        console.error("Element not found at:", selector);
+                        break;
+                    }
+                    const trimmedSelector = selector.trim();
+                    //normal DOM
+                    targetElement = resolveElement(docmt, locator, trimmedSelector);
+                    //iframe (if not found)
+                    if (!targetElement && platform === "web") {
+                        targetElement = findInIframes(docmt, locator, trimmedSelector);
+                    }
+                    //shadow DOM (if still not found)
+                    if (!targetElement && platform === "web") {
+                        targetElement = getElementFromShadowRoot(docmt.body, trimmedSelector);
+                    }
+                    if (!targetElement) {
+                        console.warn("Locator failed:", trimmedSelector);
+                        continue locators;
+                    }
+                }
+                const locatorExists = (name, value) => {
+                    const key = `${name}:${value}`;
+                    return finalLocatorsSet.has(key);
+                };
+                if (targetElement) {
+                    const excludedAttributes = [];
+                    const idValue = getId(targetElement);
+                    const ffXpath = targetElement.getAttribute("ff-xpath");
+                    if (idValue &&
+                        !locatorExists("id", idValue) &&
+                        !(0, xpathHelpers_js_1.isNumberExist)(idValue)) {
+                        const prevId = record.locators.find((l) => l.name === "id");
+                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "id", idValue, targetElement)) {
+                            excludedAttributes.push("id");
+                            createLocator(prevId, {
+                                name: "id",
+                                type: "static",
+                                isRecorded: "Y",
+                                value: idValue
+                            });
+                        }
+                    }
+                    const tagName = targetElement.tagName;
+                    if (tagName && !locatorExists("tagName", tagName)) {
+                        const prevTag = record.locators.find((l) => l.name === "tagName");
+                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "tagName", tagName, targetElement)) {
+                            excludedAttributes.push("tagName");
+                            createLocator(prevTag, {
+                                name: "tagName",
+                                type: "static",
+                                isRecorded: "Y",
+                                value: tagName
+                            });
+                        }
+                    }
+                    const textValue = getVisibleText(targetElement);
+                    if (targetElement.tagName.toLowerCase() === "a" &&
+                        textValue &&
+                        !(0, xpathHelpers_js_1.isNumberExist)(textValue)) {
+                        const prevLinkText = record.locators.find((l) => l.name === "linkText");
+                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "linkText", textValue, targetElement)) {
+                            excludedAttributes.push("linkText");
+                            createLocator(prevLinkText, {
+                                name: "linkText",
+                                type: "static",
+                                isRecorded: "Y",
+                                value: textValue
+                            });
+                        }
+                    }
+                    const nameLocator = getName(targetElement);
+                    if (nameLocator &&
+                        !locatorExists("name", nameLocator) &&
+                        !(0, xpathHelpers_js_1.isNumberExist)(nameLocator)) {
+                        const prevName = record.locators.find((l) => l.name === "name");
+                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "name", nameLocator, targetElement)) {
+                            excludedAttributes.push("name");
+                            createLocator(prevName, {
+                                name: "name",
+                                type: "static",
+                                isRecorded: "Y",
+                                value: nameLocator
+                            });
+                        }
+                    }
+                    const classValue = getClassName(targetElement);
+                    if (classValue &&
+                        classValue.trim() !== "" &&
+                        !classValue.includes(" ") &&
+                        !locatorExists("className", classValue) &&
+                        !(0, xpathHelpers_js_1.isNumberExist)(classValue)) {
+                        const prevClassLocator = record.locators.find((l) => l.name === "className");
+                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "className", classValue, targetElement)) {
+                            excludedAttributes.push("className");
+                            createLocator(prevClassLocator, {
+                                name: "className",
+                                type: "static",
+                                isRecorded: "Y",
+                                value: classValue
+                            });
+                        }
+                    }
+                    (0, cssSelector_js_1.parseCssSelectors)(targetElement, "single").forEach((cssSelector) => {
+                        if (cssSelector.value &&
+                            !locatorExists("cssSelector", cssSelector.value)) {
+                            createLocator(undefined, {
+                                name: "cssSelector",
+                                value: cssSelector.value,
+                                type: "static",
+                                isRecorded: "Y"
+                            });
+                        }
+                    });
+                    const allAttributes = Array.from(targetElement.attributes);
+                    const includedAttributes = allAttributes.filter((attr) => !excludedAttributes.includes(attr.name));
+                    //If any direct locator is broken then we consider it as broken xpath
+                    let xpathResults = [];
+                    try {
+                        xpathResults =
+                            (0, xpath_js_1.parseDOM)(targetElement, docmt, false, true, includedAttributes, [], platform) ??
+                                [];
+                    }
+                    catch (error) {
+                        console.error("Error generating XPath candidates:", error);
+                    }
+                    if (xpathResults.length === 0 && ffXpath) {
+                        xpathResults.push({ value: ffXpath });
+                    }
+                    xpathResults.forEach(result => {
+                        if (!result.value)
+                            return;
+                        if (result.key === "iosClassChain") {
+                            createLocator(undefined, {
+                                name: "class Chain",
+                                value: result.value,
+                                type: "static",
+                                isRecorded: "Y"
+                            });
+                        }
+                        else if (result.key === "iosPredicateString") {
+                            createLocator(undefined, {
+                                name: "predicate String",
+                                value: result.value,
+                                type: "static",
+                                isRecorded: "Y"
+                            });
+                        }
+                        else {
+                            createLocator(undefined, {
+                                name: "xpath",
+                                value: result.value,
+                                type: "static",
+                                isRecorded: "Y"
+                            });
+                        }
+                    });
+                    try {
+                        for (const loc of record.locators) {
+                            if (!loc.value)
+                                continue;
+                            for (const relation of relations) {
+                                if (loc.value.includes(relation)) {
+                                    const relativeXpath = checkReferenceElementIsValid(loc.value, relation, docmt);
+                                    if (relativeXpath) {
+                                        createLocator(loc, {
+                                            name: "xpath",
+                                            value: relativeXpath,
+                                            isRecorded: loc.isRecorded !== "" &&
+                                                locator.isRecorded !== null
+                                                ? locator.isRecorded
+                                                : "Y"
+                                        });
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error processing locator:", locator, error);
+                    }
+                    if (finalLocators.length < 5) {
+                        const fallbackCandidates = [
+                            { name: "id", value: getId(targetElement) },
+                            { name: "name", value: getName(targetElement) },
+                            { name: "className", value: getClassName(targetElement) },
+                            { name: "tagName", value: targetElement.tagName },
+                            {
+                                name: "linkText",
+                                value: targetElement.tagName.toLowerCase() === "a"
+                                    ? getVisibleText(targetElement)
+                                    : null
+                            }
+                        ];
+                        for (const candidate of fallbackCandidates) {
+                            if (finalLocators.length > 4)
+                                break;
+                            const { name, value } = candidate;
+                            if (!value)
+                                continue;
+                            if ((0, xpathHelpers_js_1.isNumberExist)(value))
+                                continue;
+                            if (name === "className" && value.includes(" "))
+                                continue;
+                            if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, name, value, targetElement)) {
+                                createLocator(undefined, {
+                                    name,
+                                    type: "static",
+                                    value,
+                                    isRecorded: "Y",
+                                    isSelfHealed: "Y"
+                                });
+                            }
+                        }
+                        if (finalLocators.length < 5) {
+                            (0, cssSelector_js_1.parseCssSelectors)(targetElement, "multiple").forEach((cssSelector) => {
+                                if (finalLocators.length > 4)
+                                    return;
+                                if (!cssSelector.value)
+                                    return;
+                                if (!(0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "cssSelector", cssSelector.value, targetElement)) {
+                                    return;
+                                }
+                                createLocator(undefined, {
+                                    name: "cssSelector",
+                                    type: "static",
+                                    value: cssSelector.value,
+                                    isRecorded: "Y",
+                                    isSelfHealed: "Y"
+                                });
+                            });
+                        }
+                    }
+                    const finalAutoHealedLocators = finalLocators.map((obj) => ({
+                        ...obj,
+                        value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded)
+                    }));
+                    const jsonResult = [
+                        {
+                            locators: finalAutoHealedLocators.filter((locator) => locator?.value != null && locator.value !== ""),
+                            // isShared: `${record.isShared}`,
+                        }
+                    ];
+                    return jsonResult;
+                }
+            }
+            catch (error) {
+                console.error("Error processing locator:", locator, error);
+                continue;
+            }
+        }
+        catch (error) {
+            console.error("Error processing locator:", locator, error);
+            continue;
+        }
+    }
+    return null;
+};
+exports.getElementsFromHTML = getElementsFromHTML;

package/dist/fireflinkData/fireflinkLocators/types/locator.d.ts

@@ -0,0 +1,17 @@
+export interface Locator {
+    name: string;
+    type: string;
+    value: string;
+    reference: string;
+    status: string;
+    isRecorded: string;
+    isSelfHealed?: string;
+}
+export interface ElementRecord {
+    locators: Locator[];
+}
+export type SelectorMode = "single" | "multiple";
+export type XPathEntry = {
+    key: string;
+    value: string;
+};

package/dist/fireflinkData/fireflinkLocators/types/locator.js

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

package/dist/fireflinkData/fireflinkLocators/utils/androidSelector.d.ts

@@ -0,0 +1,2 @@
+import { XPathEntry } from "../types/locator.js";
+export declare const generateAndroidLocators: (element: HTMLElement | Element, docmt: Document, isTarget: boolean) => XPathEntry[];

package/dist/fireflinkData/fireflinkLocators/utils/androidSelector.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAndroidLocators = void 0;
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const addLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
+    const xpath = (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, attribute, value, false, isTarget, 'android');
+    if (xpath &&
+        (0, xpathHelpers_js_1.getCountOfXPath)(xpath, element, docmt) === 1) {
+        locators.push({
+            key,
+            value: xpath
+        });
+    }
+};
+const generateAndroidLocators = (element, docmt, isTarget) => {
+    const locators = [];
+    const resourceId = element.getAttribute("resource-id");
+    const contentDesc = element.getAttribute("content-desc");
+    const text = element.getAttribute("text");
+    if (resourceId) {
+        addLocator(locators, "androidResourceID", "@resource-id", resourceId, element, docmt, isTarget);
+    }
+    if (contentDesc) {
+        addLocator(locators, "androidAccessibilityID", "@content-desc", contentDesc, element, docmt, isTarget);
+    }
+    if (text) {
+        addLocator(locators, "androidText", "@text", text, element, docmt, isTarget);
+    }
+    return locators;
+};
+exports.generateAndroidLocators = generateAndroidLocators;

package/dist/fireflinkData/fireflinkLocators/utils/cssSelector.d.ts

@@ -0,0 +1,19 @@
+import { SelectorMode } from "../types/locator.js";
+export declare const parseCssSelectors: (el: Element, mode?: SelectorMode) => {
+    key: string;
+    value: string;
+}[];
+export declare const getIdCssPath: (el: HTMLElement | Element) => string | undefined;
+export declare const getAttributeCssPath: (el: Element) => string | undefined;
+export declare const getClassCssPath: (el: HTMLElement | Element) => string | undefined;
+export declare const getAbsoluteCssPath: (el: Element) => string | undefined;
+export declare const cssSelectors: {
+    parseCssSelectors: (el: Element, mode?: SelectorMode) => {
+        key: string;
+        value: string;
+    }[];
+    getIdCssPath: (el: HTMLElement | Element) => string | undefined;
+    getAttributeCssPath: (el: Element) => string | undefined;
+    getClassCssPath: (el: HTMLElement | Element) => string | undefined;
+    getAbsoluteCssPath: (el: Element) => string | undefined;
+};