ff-automationv2 2.2.0 → 2.2.2

package/dist/fireflinkData/fireflinkLocators/elementsFromHTML.d.ts

@@ -0,0 +1,24 @@
+type ElementDetails = {
+    id?: string | null;
+    className?: string | null;
+    xpathByText?: string | null;
+    xpathById?: string | null;
+    xpathByClass?: string | null;
+    xpathAbsolute?: string | null;
+    xpathByName?: string | null;
+    xpathByPlaceholder?: string | null;
+    xpathByType?: string | null;
+    visibleText?: string | null;
+    relativeXpath?: string | null;
+    [key: string]: any;
+};
+interface Locator {
+    name: string;
+    type: string;
+    value: string;
+    reference: string;
+    status: string;
+    isRecorded: string;
+}
+declare const getElementsFromHTML: (locators: Locator[], htmlString: string) => ElementDetails | null;
+export { getElementsFromHTML };

package/dist/fireflinkData/fireflinkLocators/elementsFromHTML.js

@@ -0,0 +1,511 @@
+import { JSDOM, VirtualConsole } from "jsdom";
+import { logger } from "../../utils/logger/logData.js";
+const isUnique = (xpathResult) => {
+    return xpathResult && xpathResult.snapshotLength === 1;
+};
+const getElementFromShadowRoot = (element, selector) => {
+    const shadowRoot = element.shadowRoot;
+    if (shadowRoot && !selector.includes("dynamic")) {
+        return shadowRoot.querySelector(selector);
+    }
+    return null;
+};
+const isSVGElement = (element) => {
+    return (typeof window !== "undefined" &&
+        typeof SVGElement !== "undefined" &&
+        element instanceof SVGElement);
+};
+const getXPath = (element, xpath) => {
+    const window = element.ownerDocument.defaultView;
+    if (!window)
+        return null;
+    const xpathEvaluator = new window.XPathEvaluator();
+    const xpathResult = xpathEvaluator.evaluate(xpath, element.ownerDocument, null, window.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+    return isUnique(xpathResult) ? xpath : null;
+};
+const getId = (element) => {
+    return element?.id || null;
+};
+const getClassName = (element) => {
+    return element.className || null;
+};
+const getVisibleText = (element) => {
+    return element.textContent?.trim() || null;
+};
+const getXPathByText = (element) => {
+    const text = getVisibleText(element);
+    if (text) {
+        const xpath = `//${element.nodeName.toLowerCase()}[text()='${text}']`;
+        return getXPath(element, xpath);
+    }
+    return null;
+};
+const getXPathById = (element) => {
+    if (element.id) {
+        const xpath = `//${element.nodeName.toLowerCase()}[@id='${element.id}']`;
+        return getXPath(element, xpath);
+    }
+    return null;
+};
+const getXPathByClass = (element) => {
+    const classNames = element.classList;
+    if (classNames.length > 0) {
+        const xpath = `//${element.nodeName.toLowerCase()}[@class='${classNames[0]}']`;
+        return getXPath(element, xpath);
+    }
+    return null;
+};
+const getXpathByName = (element) => {
+    const selector = element.nodeName.toLowerCase();
+    const elementEl = element;
+    if (elementEl.hasAttribute("name")) {
+        const attrValue = elementEl.getAttribute("name");
+        const xpath = `//${selector}[@name='${attrValue}']`;
+        return getXPath(element, xpath) || null;
+    }
+    return 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 getFFxpath = (element) => {
+    const elementEl = element;
+    if (elementEl.hasAttribute("ff-xpath") && !elementEl.getAttribute("ff-xpath")?.includes("/iframe")) {
+        const attrValue = elementEl.getAttribute("ff-xpath");
+        const name = `${attrValue}`;
+        return name || null;
+    }
+    return null;
+};
+const getXpathByPlaceholder = (element) => {
+    const selector = element.nodeName.toLowerCase();
+    const elementEl = element;
+    if (elementEl.hasAttribute("placeholder")) {
+        const attrValue = elementEl.getAttribute("placeholder");
+        const xpath = `//${selector}[@placeholder='${attrValue}']`;
+        return getXPath(element, xpath) || null;
+    }
+    return null;
+};
+const getXpathByType = (element) => {
+    const selector = element.nodeName.toLowerCase();
+    const elementEl = element;
+    if (elementEl.hasAttribute("type")) {
+        const attrValue = elementEl.getAttribute("type");
+        const xpath = `//${selector}[@type='${attrValue}']`;
+        return getXPath(element, xpath) || null;
+    }
+    return null;
+};
+const getXPathAbsolute = (element) => {
+    const path = [];
+    while (element && element.nodeType === 1) {
+        // ELEMENT_NODE
+        let selector = element.nodeName.toLowerCase();
+        let sibling = element;
+        let siblingCount = 1;
+        while ((sibling = sibling.previousElementSibling)) {
+            if (sibling.nodeName.toLowerCase() === element.nodeName.toLowerCase()) {
+                siblingCount++;
+            }
+        }
+        if (siblingCount > 1) {
+            selector += `[${siblingCount}]`;
+        }
+        path.unshift(selector);
+        element = element.parentNode;
+    }
+    return "//" + path.join("/");
+};
+const relations = [
+    "/preceding-sibling",
+    "/following-sibling",
+    "/parent",
+    "/descendant",
+    "/ancestor",
+    "/self",
+    "/ancestor-or-self",
+    "/child",
+    "/preceding",
+    "/following",
+];
+function getElementFromXPath(tempDiv, xpath) {
+    const currentElement = tempDiv;
+    const window = currentElement.ownerDocument.defaultView;
+    if (!window)
+        return null;
+    const xpathEvaluator = new window.XPathEvaluator();
+    const xpathResult = xpathEvaluator.evaluate(xpath, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    return xpathResult.singleNodeValue;
+}
+function checkReferenceElementIsValid(locator, relation, tempDiv) {
+    if (locator.includes(relation)) {
+        const locatotSplitArray = locator.split(relation);
+        const sourceLoc = locatotSplitArray[0].trim();
+        const currentElement = tempDiv;
+        const window = currentElement.ownerDocument.defaultView;
+        if (!window)
+            return null;
+        if (!locator.includes("dynamic")) {
+            const xpathEvaluator = new window.XPathEvaluator();
+            const xpathResult = xpathEvaluator.evaluate(sourceLoc, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+            const sourceElement = xpathResult.singleNodeValue;
+            if (sourceElement) {
+                const xpathResultComplete = xpathEvaluator.evaluate(locator, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+                const completeElement = xpathResultComplete.singleNodeValue;
+                let relativeXpath;
+                if (completeElement) {
+                    relativeXpath = locator;
+                    return relativeXpath;
+                }
+                else {
+                    logger.error("Complete Locator is Invalid:", locator);
+                    relativeXpath = locator;
+                    return relativeXpath;
+                }
+            }
+            else {
+                logger.error("Source Locator Not Found:", sourceLoc);
+            }
+        }
+    }
+    return null;
+}
+const getElementsFromHTML = (locators, htmlString) => {
+    const virtualConsole = new VirtualConsole();
+    const dom = new JSDOM(htmlString, {
+        resources: "usable",
+        runScripts: "outside-only", // Prevents inline script execution in JSDOM
+        pretendToBeVisual: true,
+        virtualConsole,
+        includeNodeLocations: true,
+    });
+    const document = dom.window.document;
+    global.SVGElement = dom.window.SVGElement;
+    const tempDiv = document.createElement("div");
+    const elementsToRemove = document.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg");
+    if (elementsToRemove) {
+        elementsToRemove.forEach((tag) => {
+            tag.remove();
+        });
+    }
+    tempDiv.innerHTML = document.body.innerHTML;
+    // tempDiv.innerHTML = htmlString;
+    const finalLocators = [];
+    for (const locator of locators) {
+        try {
+            const isDynamic = String(locator.value || locator.type || "");
+            if (isDynamic.includes("dynamic") ||
+                isDynamic.match("dynamic") ||
+                isDynamic.includes("{") ||
+                isDynamic.includes("}")) {
+                finalLocators.push({
+                    name: locator.name,
+                    type: locator.type,
+                    value: locator.value,
+                    reference: locator.reference,
+                    status: locator.status,
+                    isRecorded: locator.isRecorded,
+                });
+                continue;
+            }
+            const isRecorded = String(locator.isRecorded || "");
+            if (isRecorded.includes("N") || isRecorded.match("N")) {
+                finalLocators.push({
+                    name: locator.name,
+                    type: locator.type,
+                    value: locator.value,
+                    reference: locator.reference,
+                    status: locator.status,
+                    isRecorded: locator.isRecorded,
+                });
+            }
+            try {
+                let targetElement = null;
+                if (locator.value.startsWith("iframe")) {
+                    const iframe = tempDiv.querySelector(locator.value);
+                    if (iframe) {
+                        const iframeDocument = iframe.contentDocument || iframe.contentWindow?.document;
+                        if (iframeDocument) {
+                            targetElement = iframeDocument.querySelector(locator.value.slice(6));
+                        }
+                    }
+                }
+                else {
+                    const selectors = locator.value.split(">>>"); // Custom delimiter for shadow DOM
+                    let currentElement = tempDiv;
+                    for (const selector of selectors) {
+                        if (currentElement) {
+                            const trimmedSelector = selector.trim();
+                            if (locator.name.includes("id") ||
+                                trimmedSelector.startsWith("#")) {
+                                targetElement = currentElement.querySelector("#" + trimmedSelector);
+                            }
+                            else if (locator.name.includes("className") ||
+                                trimmedSelector.startsWith(".")) {
+                                targetElement = currentElement.querySelector("." + trimmedSelector);
+                            }
+                            else if ((locator.name.includes("xpath") ||
+                                trimmedSelector.startsWith("//")) &&
+                                !locator.type.match("dynamic")) {
+                                targetElement = getElementFromXPath(tempDiv, trimmedSelector);
+                            }
+                            else {
+                                targetElement = currentElement.querySelector(trimmedSelector);
+                                if (!targetElement) {
+                                    targetElement = getElementFromShadowRoot(currentElement, trimmedSelector);
+                                }
+                            }
+                            if (!targetElement &&
+                                isSVGElement(currentElement) &&
+                                !locator.type.match("dynamic")) {
+                                targetElement = currentElement.querySelector(trimmedSelector);
+                            }
+                            currentElement = targetElement;
+                        }
+                    }
+                }
+                const locatorExists = (name, value) => {
+                    return finalLocators.some((_loc) => _loc.name === name &&
+                        _loc.value === value &&
+                        (!_loc.value.includes("dynamic") ||
+                            !locator.type.match("dynamic")));
+                };
+                const xpathFunctions = [
+                    { name: "xpath", value: getXPathByText },
+                    { name: "xpath", value: getXPathById },
+                    { name: "xpath", value: getXPathByClass },
+                    { name: "xpath", value: getXPathAbsolute },
+                    { name: "xpath", value: getXpathByName },
+                    { name: "xpath", value: getXpathByPlaceholder },
+                    { name: "xpath", value: getXpathByType },
+                ];
+                if (targetElement) {
+                    const idValue = getId(targetElement);
+                    if (idValue && !locatorExists("id", idValue)) {
+                        locators.forEach(() => {
+                            if (locator.value === idValue) {
+                                finalLocators.push({
+                                    name: "id",
+                                    type: locator.type,
+                                    value: idValue,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: locator.isRecorded,
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                            else {
+                                finalLocators.push({
+                                    name: "id",
+                                    type: locator.type,
+                                    value: idValue,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: "Y",
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                        });
+                    }
+                    if (getVisibleText(targetElement)) {
+                        const textValue = getVisibleText(targetElement);
+                        locators.forEach((_loc) => {
+                            if (_loc.value === textValue) {
+                                finalLocators.push({
+                                    name: "linkText",
+                                    type: "static",
+                                    value: textValue,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: locator.isRecorded,
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                            else {
+                                finalLocators.push({
+                                    name: "linkText",
+                                    type: "static",
+                                    value: textValue,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: "Y",
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                        });
+                    }
+                    if (getName(targetElement)) {
+                        const nameLocator = getName(targetElement);
+                        locators.forEach((_loc) => {
+                            if (_loc.value === nameLocator) {
+                                finalLocators.push({
+                                    name: "name",
+                                    type: "static",
+                                    value: nameLocator,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: locator.isRecorded,
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                            else {
+                                finalLocators.push({
+                                    name: "name",
+                                    type: "static",
+                                    value: nameLocator,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: "Y",
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                        });
+                    }
+                    if (getFFxpath(targetElement)) {
+                        const nameLocator = getFFxpath(targetElement);
+                        locators.forEach((_loc) => {
+                            if (_loc.value === nameLocator) {
+                                finalLocators.push({
+                                    name: "xpath",
+                                    type: "static",
+                                    value: nameLocator,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: locator.isRecorded,
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                            else {
+                                finalLocators.push({
+                                    name: "xpath",
+                                    type: "static",
+                                    value: nameLocator,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: "Y",
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                        });
+                    }
+                    const classValue = getClassName(targetElement);
+                    if (classValue &&
+                        classValue.trim() !== "" &&
+                        !locatorExists("className", classValue)) {
+                        locators.forEach((_loc) => {
+                            if (_loc.value === classValue) {
+                                finalLocators.push({
+                                    name: "className",
+                                    type: locator.type,
+                                    value: classValue,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: locator.isRecorded,
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                            else {
+                                finalLocators.push({
+                                    name: "className",
+                                    type: locator.type,
+                                    value: classValue,
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: "Y",
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                        });
+                    }
+                    xpathFunctions.forEach((fn) => {
+                        locators.forEach((_loc) => {
+                            if (_loc.value === fn.value(targetElement)) {
+                                finalLocators.push({
+                                    name: fn.name,
+                                    type: locator.type,
+                                    value: fn.value(targetElement),
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: locator.isRecorded,
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                            else {
+                                finalLocators.push({
+                                    name: fn.name,
+                                    type: locator.type,
+                                    value: fn.value(targetElement),
+                                    reference: locator.reference,
+                                    status: locator.status,
+                                    isRecorded: "Y",
+                                    isAiRecorded: "Y",
+                                });
+                            }
+                        });
+                    });
+                    for (const locator of locators) {
+                        try {
+                            let relativeXpath = null;
+                            if (locator.value) {
+                                for (const relation of relations) {
+                                    if (locator.value.includes(relation)) {
+                                        relativeXpath = checkReferenceElementIsValid(locator.value, relation, tempDiv);
+                                        if (relativeXpath) {
+                                            finalLocators.push({
+                                                name: "xpath",
+                                                type: locator.type,
+                                                value: relativeXpath,
+                                                reference: locator.reference,
+                                                status: locator.status,
+                                                isRecorded: locator.isRecorded !== "" &&
+                                                    locator.isRecorded !== null
+                                                    ? locator.isRecorded
+                                                    : "Y",
+                                            });
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : Error processing locator:`, locator, error.message);
+                        }
+                    }
+                    const uniqueLocators = new Map();
+                    finalLocators.forEach((_loc) => {
+                        if (!uniqueLocators.has(_loc.value)) {
+                            uniqueLocators.set(_loc.value, _loc);
+                        }
+                    });
+                    const ffLoc = Array.from(uniqueLocators.values());
+                    const jsonResult = [
+                        {
+                            locators: ffLoc.filter((locator) => Object.prototype.hasOwnProperty.call(locator, "value") &&
+                                locator?.value !== null &&
+                                locator.value !== ""),
+                        },
+                    ];
+                    return jsonResult;
+                }
+            }
+            catch (error) {
+                logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : Error processing locator:`, locator, error.message);
+                continue;
+            }
+        }
+        catch (error) {
+            logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : Error processing locator:`, locator, error.message);
+            continue;
+        }
+    }
+    return null;
+};
+export { getElementsFromHTML };

package/dist/fireflinkData/fireflinkLocators/getListOfLocators.d.ts

@@ -0,0 +1,3 @@
+export declare class ElementGetter {
+    getFireFlinkElement(html: string, attribute: string): Promise<any>;
+}

package/dist/fireflinkData/fireflinkLocators/getListOfLocators.js

@@ -0,0 +1,24 @@
+import { logger } from "../../utils/logger/logData.js";
+import { getElementsFromHTML } from "./elementsFromHTML.js";
+export class ElementGetter {
+    async getFireFlinkElement(html, attribute) {
+        const formattedAttribute = attribute.replace('[', '//*[@');
+        try {
+            const result = getElementsFromHTML([
+                {
+                    name: "xpath",
+                    type: "Static",
+                    value: formattedAttribute,
+                    reference: "local",
+                    status: "NOT_USED",
+                    isRecorded: "Y",
+                }
+            ], html);
+            return Array.isArray(result) && result.length > 0 ? JSON.parse(JSON.stringify(result[0], null, 4)) : null;
+        }
+        catch (error) {
+            logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : `, "Unable to find the element", error);
+            return "";
+        }
+    }
+}

package/dist/fireflinkData/fireflinkLocators/typeList.d.ts

@@ -0,0 +1 @@
+export declare const normalizedElementType: Record<string, string>;

package/dist/fireflinkData/fireflinkLocators/typeList.js

@@ -0,0 +1,30 @@
+const elementType = {
+    'Link': 'link',
+    'Text Field': 'textfield',
+    'Icon': 'icon',
+    'Button': 'button',
+    'Radio Button': 'radioButton',
+    'Text': 'text',
+    'Textarea': 'textarea',
+    'Image': 'image',
+    'Dropdown': 'dropdown',
+    'Checkbox': 'checkbox',
+    'Tab': 'tab',
+    'Action Overflow button': 'action overflow button',
+    'Hamburger menu': 'hamburger icon',
+    'Toggle Button': 'toggle button',
+    'Suggestion': 'suggestion',
+    'Time Picker': 'time picker',
+    'Date Picker': 'date picker',
+    'Toaster Message': 'toaster message',
+    'Card': 'card',
+    'Tooltip': 'tooltip',
+    'Option': 'option',
+    'Calender': 'calender',
+    'Sliders': 'sliders',
+    'Visual Testing': 'visual testing'
+};
+export const normalizedElementType = Object.fromEntries(Object.entries(elementType).map(([key, value]) => [
+    key.toLowerCase().replace(/\s+/g, ""),
+    value,
+]));

package/dist/fireflinkData/fireflinkScript/scriptGenrationData.d.ts

@@ -0,0 +1,14 @@
+import { IScriptGenerationData } from "../../core/interfaces/scriptGenrationDataInterface.js";
+export declare class ScriptDataAppender {
+    private data;
+    private queue;
+    private errorNLP;
+    private concurrencyLimit;
+    add(task: () => Promise<IScriptGenerationData>): void;
+    private process;
+    private retry;
+    waitForAllSteps(): Promise<void>;
+    getData(): IScriptGenerationData[];
+    setErrorNLP(nlp: string): void;
+    getErrorNLP(): string;
+}

package/dist/fireflinkData/fireflinkScript/scriptGenrationData.js

@@ -0,0 +1,60 @@
+export class ScriptDataAppender {
+    constructor() {
+        this.data = [];
+        this.queue = [];
+        this.errorNLP = "";
+        this.concurrencyLimit = 5;
+    }
+    add(task) {
+        const job = async () => {
+            await this.retry(async () => {
+                const item = await task();
+                this.process(item);
+            }, 3);
+        };
+        this.queue.push(job);
+    }
+    process(item) {
+        this.data.push(item);
+    }
+    async retry(fn, retries) {
+        for (let i = 0; i <= retries; i++) {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                if (i === retries) {
+                    console.error("Step failed:", err);
+                    this.errorNLP = err?.message ?? "Unknown error";
+                    throw err;
+                }
+            }
+        }
+    }
+    async waitForAllSteps() {
+        const workers = [];
+        while (this.queue.length > 0 || workers.length > 0) {
+            while (workers.length < this.concurrencyLimit && this.queue.length > 0) {
+                const job = this.queue.shift();
+                const worker = job().finally(() => {
+                    const index = workers.indexOf(worker);
+                    if (index > -1)
+                        workers.splice(index, 1);
+                });
+                workers.push(worker);
+            }
+            if (workers.length > 0) {
+                await Promise.race(workers);
+            }
+        }
+    }
+    getData() {
+        return this.data;
+    }
+    setErrorNLP(nlp) {
+        this.errorNLP = nlp;
+    }
+    getErrorNLP() {
+        return this.errorNLP;
+    }
+}

package/dist/imageAnalysisMobile/annotatedScreenshotMobile.d.ts

@@ -0,0 +1 @@
+export declare function annotateScreenshot(driver: any, xmlSource: string): Promise<Buffer>;