ff-automationv2 2.2.28 → 2.2.29

package/dist/automation/actions/interaction/get/getAudioWidth.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAudioWidth = void 0;
-const getAudioWidth = async (args) => {
-    try {
-        const element = await args.driver.$(args.selector);
-        // Get rendered width of the audio element
-        const _audioWidth = await args.driver.execute((el) => {
-            return el.offsetWidth;
-        }, element);
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: "GetAudioWidth",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
-        });
-    }
-    catch (error) {
-        args.scriptDataAppender.setErrorNLP("GetAudioWidth");
-        throw new Error("GetAudioWidth action failed", { cause: error });
-    }
-};
-exports.getAudioWidth = getAudioWidth;

package/dist/automation/actions/interaction/get/getVideoDimension.d.ts

@@ -1,2 +0,0 @@
-import { getVideoDimensionInterface } from "../../interface/getActionInterface.js";
-export declare const getVideoDimension: (args: getVideoDimensionInterface) => Promise<void>;

package/dist/automation/actions/interaction/get/getVideoDimension.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoDimension = void 0;
-const getVideoDimension = async (args) => {
-    try {
-        const element = await args.driver.$(args.selector);
-        // Get intrinsic video resolution
-        const videoWidth = await element.getProperty("videoWidth");
-        const videoHeight = await element.getProperty("videoHeight");
-        // Optional: combine into dimension string if needed internally
-        const _dimension = `${videoWidth}x${videoHeight}`;
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: "GetVideoDimension",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
-        });
-    }
-    catch (error) {
-        args.scriptDataAppender.setErrorNLP("GetVideoDimension");
-        throw new Error("GetVideoDimension action failed", { cause: error });
-    }
-};
-exports.getVideoDimension = getVideoDimension;

package/dist/automation/actions/interaction/get/getVideoHeight.d.ts

@@ -1,2 +0,0 @@
-import { getVideoHeightInterface } from "../../interface/getActionInterface.js";
-export declare const getVideoHeight: (args: getVideoHeightInterface) => Promise<void>;

package/dist/automation/actions/interaction/get/getVideoHeight.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoHeight = void 0;
-const getVideoHeight = async (args) => {
-    try {
-        const element = await args.driver.$(args.selector);
-        // Get actual rendered video height (videoHeight gives intrinsic height)
-        const _heightValue = await element.getProperty("videoHeight");
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: "GetVideoHeight",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
-        });
-    }
-    catch (error) {
-        args.scriptDataAppender.setErrorNLP("GetVideoHeight");
-        throw new Error("GetVideoHeight action failed", { cause: error });
-    }
-};
-exports.getVideoHeight = getVideoHeight;

package/dist/automation/actions/interaction/get/getVideoWidth.d.ts

@@ -1,2 +0,0 @@
-import { getVideoWidthInterface } from "../../interface/getActionInterface.js";
-export declare const getVideoWidth: (args: getVideoWidthInterface) => Promise<void>;

package/dist/automation/actions/interaction/get/getVideoWidth.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoWidth = void 0;
-const getVideoWidth = async (args) => {
-    try {
-        const element = await args.driver.$(args.selector);
-        // videoWidth returns intrinsic resolution width
-        const _videoWidth = await element.getProperty("videoWidth");
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: "GetVideoWidth",
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
-        });
-    }
-    catch (error) {
-        args.scriptDataAppender.setErrorNLP("GetVideoWidth");
-        throw new Error("GetVideoWidth action failed", { cause: error });
-    }
-};
-exports.getVideoWidth = getVideoWidth;

package/dist/fireflinkData/fireflinkLocators/elementsFromHTML.js

@@ -1,514 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getElementsFromHTML = void 0;
-const jsdom_1 = require("jsdom");
-const logData_js_1 = require("../../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 {
-                    logData_js_1.logger.error("Complete Locator is Invalid:", locator);
-                    relativeXpath = locator;
-                    return relativeXpath;
-                }
-            }
-            else {
-                logData_js_1.logger.error("Source Locator Not Found:", sourceLoc);
-            }
-        }
-    }
-    return null;
-}
-const getElementsFromHTML = (locators, htmlString) => {
-    const virtualConsole = new jsdom_1.VirtualConsole();
-    const dom = new jsdom_1.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) {
-                            logData_js_1.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) {
-                logData_js_1.logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : Error processing locator:`, locator, error.message);
-                continue;
-            }
-        }
-        catch (error) {
-            logData_js_1.logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : Error processing locator:`, locator, error.message);
-            continue;
-        }
-    }
-    return null;
-};
-exports.getElementsFromHTML = getElementsFromHTML;

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

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