ff-automationv2 2.2.28 → 2.2.29

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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cssSelectors = exports.getAbsoluteCssPath = exports.getClassCssPath = exports.getAttributeCssPath = exports.getIdCssPath = exports.parseCssSelectors = void 0;
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const escapeCssAttributeValue = (value) => {
+    return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+};
+const isCssSelectorUnique = (selector, el, root) => {
+    try {
+        const matches = root.querySelectorAll(selector);
+        return matches.length === 1 && matches[0] === el;
+    }
+    catch {
+        return false;
+    }
+};
+const parseCssSelectors = (el, mode = "single") => {
+    const selectors = [];
+    const root = el.getRootNode();
+    try {
+        const idPath = (0, exports.getIdCssPath)(el);
+        if (idPath && isCssSelectorUnique(idPath, el, root)) {
+            selectors.push({ key: "cssSelector by id", value: idPath });
+            if (mode === "single")
+                return selectors;
+        }
+        const classPath = (0, exports.getClassCssPath)(el);
+        if (classPath && isCssSelectorUnique(classPath, el, root)) {
+            selectors.push({ key: "cssSelector by class", value: classPath });
+        }
+        const namePath = (0, exports.getAttributeCssPath)(el);
+        if (namePath) {
+            selectors.push({ key: "cssSelector by name", value: namePath });
+        }
+    }
+    catch (e) {
+        logData_js_1.logger.error(e);
+    }
+    return selectors;
+};
+exports.parseCssSelectors = parseCssSelectors;
+function cssEscape(value) {
+    return value.replace(/([ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, "\\$1");
+}
+const getIdCssPath = (el) => {
+    const view = el.ownerDocument?.defaultView;
+    if (!view || !(el instanceof view.Element))
+        return;
+    const tagName = el.tagName.toLowerCase();
+    if (tagName.includes("style") || tagName.includes("script"))
+        return;
+    const path = [];
+    while (el?.nodeType === 1) {
+        let selector = el.nodeName?.toLowerCase();
+        if (el.id && !(0, xpathHelpers_js_1.isNumberExist)(el.id)) {
+            selector += `#${cssEscape(el.id)}`;
+            path.unshift(selector);
+            break;
+        }
+        else {
+            let sib = el;
+            let nth = 1;
+            if (sib.previousElementSibling) {
+                while ((sib = sib.previousElementSibling)) {
+                    if (sib.nodeName?.toLowerCase() === selector)
+                        nth++;
+                }
+            }
+            if (nth !== 1) {
+                selector += `:nth-of-type(${nth})`;
+            }
+            const parent = el.parentElement;
+            if (nth === 1 && parent?.childElementCount > 1) {
+                selector += `:nth-child(${nth})`;
+            }
+        }
+        path.unshift(selector);
+        el = el.parentElement;
+    }
+    return path.join(" > ");
+};
+exports.getIdCssPath = getIdCssPath;
+const EXCLUDED_ATTRS = new Set([
+    "id",
+    "class",
+    "style",
+    "ff-inspect",
+    "ff-inspecter",
+    "ff-xpath"
+]);
+function getAttributeSelectors(el) {
+    return Array.from(el.attributes)
+        .filter((attr) => !EXCLUDED_ATTRS.has(attr?.name?.toLowerCase()) &&
+        attr.value &&
+        !(0, xpathHelpers_js_1.isNumberExist)(attr.value))
+        .map((attr) => `[${attr.name}="${escapeCssAttributeValue(attr.value)}"]`);
+}
+const getAttributeCssPath = (el) => {
+    const view = el.ownerDocument?.defaultView;
+    if (!view || !(el instanceof view.Element))
+        return;
+    const root = el.getRootNode();
+    const tag = el.tagName.toLowerCase();
+    if (tag === "style" || tag === "script")
+        return;
+    const attrSelectors = getAttributeSelectors(el);
+    for (const attrSelector of attrSelectors) {
+        const candidate = `${tag}${attrSelector}`;
+        if (isCssSelectorUnique(candidate, el, root)) {
+            return candidate;
+        }
+    }
+    return;
+};
+exports.getAttributeCssPath = getAttributeCssPath;
+const getClassCssPath = (el) => {
+    const view = el.ownerDocument?.defaultView;
+    if (!view || !(el instanceof view.Element))
+        return;
+    const tagName = el.tagName.toLowerCase();
+    if (tagName.includes("style") || tagName.includes("script"))
+        return;
+    const path = [];
+    const NodeRef = el.ownerDocument.defaultView.Node;
+    while (el?.nodeType === NodeRef.ELEMENT_NODE) {
+        let selector = el.nodeName?.toLowerCase();
+        if (typeof el.className === "string" &&
+            el.className &&
+            !(0, xpathHelpers_js_1.isNumberExist)(el.className)) {
+            el.classList.remove("marked-element-temp");
+            el.classList.remove("removePointers");
+            if (el.className) {
+                selector += `.${el.className.trim().replace(/\s+/g, ".")}`;
+                path.unshift(selector);
+                break;
+            }
+        }
+        else {
+            let sib = el;
+            let nth = 1;
+            if (sib.previousElementSibling) {
+                while ((sib = sib.previousElementSibling)) {
+                    if (sib.nodeName?.toLowerCase() === selector)
+                        nth++;
+                }
+            }
+            if (nth !== 1) {
+                selector += `:nth-of-type(${nth})`;
+            }
+            const parent = el.parentElement;
+            if (nth === 1 && parent?.childElementCount > 1) {
+                selector += `:nth-child(${nth})`;
+            }
+        }
+        path.unshift(selector);
+        el = el.parentElement;
+    }
+    return path.join(" > ");
+};
+exports.getClassCssPath = getClassCssPath;
+const getAbsoluteCssPath = (el) => {
+    const view = el.ownerDocument?.defaultView;
+    if (!view || !(el instanceof view.Element))
+        return;
+    const path = [];
+    const NodeRef = el.ownerDocument.defaultView.Node;
+    while (el && el.nodeType === NodeRef.ELEMENT_NODE) {
+        const tagName = el.tagName.toLowerCase();
+        if (tagName === "style" || tagName === "script")
+            return;
+        let selector = tagName;
+        const parent = el.parentNode;
+        if (parent) {
+            const siblings = Array.from(parent.children).filter((c) => c.tagName === el.tagName);
+            if (siblings.length > 1) {
+                selector += `:nth-of-type(${siblings.indexOf(el) + 1})`;
+            }
+        }
+        path.unshift(selector);
+        el = el.parentElement;
+    }
+    return path.join(" > ");
+};
+exports.getAbsoluteCssPath = getAbsoluteCssPath;
+exports.cssSelectors = {
+    parseCssSelectors: exports.parseCssSelectors,
+    getIdCssPath: exports.getIdCssPath,
+    getAttributeCssPath: exports.getAttributeCssPath,
+    getClassCssPath: exports.getClassCssPath,
+    getAbsoluteCssPath: exports.getAbsoluteCssPath
+};

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

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

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIOSLocators = void 0;
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const addLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
+    const xpath = (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, attribute, value, false, isTarget, 'ios');
+    if (xpath &&
+        (0, xpathHelpers_js_1.getCountOfXPath)(xpath, element, docmt) === 1) {
+        locators.push({
+            key,
+            value: xpath
+        });
+    }
+};
+const generateIOSLocators = (element, docmt, isTarget) => {
+    const locators = [];
+    const name = element.getAttribute("name");
+    const label = element.getAttribute("label");
+    const value = element.getAttribute("value");
+    const classChain = getOptimalClassChain(docmt, element, [
+        "label",
+        "name",
+        "value",
+    ]);
+    const predicate = getOptimalPredicateString(docmt, element, [
+        "label",
+        "name",
+        "value",
+        "type",
+    ]);
+    if (name) {
+        addLocator(locators, "iosAccessibilityID", "@name", name, element, docmt, isTarget);
+    }
+    if (label) {
+        addLocator(locators, "iosLabel", "@label", label, element, docmt, isTarget);
+    }
+    if (value) {
+        addLocator(locators, "iosValue", "@value", value, element, docmt, isTarget);
+    }
+    if (classChain) {
+        locators.push({
+            key: "iosClassChain",
+            value: `**${classChain}`,
+        });
+    }
+    if (predicate) {
+        locators.push({
+            key: "iosPredicateString",
+            value: predicate,
+        });
+    }
+    return locators;
+};
+exports.generateIOSLocators = generateIOSLocators;
+function getOptimalClassChain(doc, domNode, uniqueAttributes) {
+    try {
+        // BASE CASE #1: If this isn't an element, we're above the root, or this is `XCUIElementTypeApplication`,
+        // which is not an official XCUITest element, return empty string
+        if (!domNode ||
+            domNode.nodeType !== 1 ||
+            domNode.tagName === "XCUIElementTypeApplication") {
+            return "";
+        }
+        // BASE CASE #2: If this node has a unique class chain based on attributes then return it
+        for (const attrName of uniqueAttributes) {
+            const attrValue = domNode.getAttribute(attrName);
+            if (attrValue && !(0, xpathHelpers_js_1.isNumberExist)(attrValue)) {
+                const xpathe = `//${domNode.tagName || '*'}[@${attrName}="${attrValue}"]`;
+                let classChain = `/${domNode.tagName || '*'}[\`${attrName} == "${attrValue}"\`]`;
+                let othersWithAttr;
+                // If the XPath does not parse, move to the next unique attribute
+                try {
+                    othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, domNode, doc);
+                }
+                catch (ign) {
+                    logData_js_1.logger.error(ign);
+                    continue;
+                }
+                if (othersWithAttr === 1) {
+                    return classChain;
+                }
+                // If the attribute isn't actually unique, get it's index too
+                if (othersWithAttr > 1) {
+                    const index = (0, xpathHelpers_js_1.findXpathWithIndex)(xpathe, domNode, doc, 0);
+                    if (index) {
+                        classChain = `${classChain}[${index}]`;
+                        return classChain;
+                    }
+                }
+            }
+        }
+        // Get the relative xpath of this node using tagName
+        let classChain = `/${domNode.tagName}`;
+        // If this node has siblings of the same tagName, get the index of this node
+        if (domNode.parentNode) {
+            // Get the siblings
+            const childNodes = Array.prototype.slice
+                .call(domNode.parentNode.childNodes, 0)
+                .filter((childNode) => childNode.nodeType === 1 && childNode.tagName === domNode.tagName);
+            // If there's more than one sibling, append the index
+            if (childNodes.length > 1) {
+                const index = childNodes.indexOf(domNode);
+                classChain += `[${index + 1}]`;
+            }
+        }
+        // Make a recursive call to this nodes parents and prepend it to this xpath
+        return (getOptimalClassChain(doc, domNode.parentElement, uniqueAttributes) +
+            classChain);
+    }
+    catch (error) {
+        // If there's an unexpected exception, abort and don't get an XPath
+        logData_js_1.logger.error(`The most optimal '-ios class chain' could not be determined because an error was thrown: '${JSON.stringify(error, null, 2)}'`);
+        return null;
+    }
+}
+function getOptimalPredicateString(doc, domNode, uniqueAttributes) {
+    try {
+        // BASE CASE #1: If this isn't an element, we're above the root, or this is `XCUIElementTypeApplication`,
+        // which is not an official XCUITest element, return empty string
+        if (!domNode ||
+            domNode.nodeType !== 1 ||
+            domNode.tagName === "XCUIElementTypeApplication") {
+            return "";
+        }
+        // BASE CASE #2: Check all attributes and try to find the best way
+        const xpathAttributes = [];
+        const predicateString = [];
+        for (const attrName of uniqueAttributes) {
+            const attrValue = domNode.getAttribute(attrName);
+            if (!attrValue) {
+                continue;
+            }
+            if (attrValue && !(0, xpathHelpers_js_1.isNumberExist)(attrValue)) {
+                xpathAttributes.push(`@${attrName}="${attrValue}"`);
+                const xpathe = `//*[${xpathAttributes.join(' and ')}]`;
+                predicateString.push(`${attrName} == "${attrValue}"`);
+                let othersWithAttr;
+                // If the XPath does not parse, move to the next unique attribute
+                try {
+                    othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, domNode, doc);
+                }
+                catch (ign) {
+                    logData_js_1.logger.error(ign);
+                    continue;
+                }
+                // If the attribute isn't actually unique, get it's index too
+                if (othersWithAttr === 1) {
+                    return predicateString.join(' AND ');
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If there's an unexpected exception, abort and don't get an XPath
+        logData_js_1.logger.error(`The most optimal '-ios predicate string' could not be determined because an error was thrown: '${JSON.stringify(error, null, 2)}'`);
+    }
+    return null;
+}

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

@@ -0,0 +1,35 @@
+export declare const findRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
+export declare const getSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
+declare const referenceXpath: {
+    findRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
+    getDescendantXpath: (refExpectElement: Array<HTMLElement | Element>, docmt: Document, xpaths1: {
+        key: string;
+        value: string;
+    }[], xpaths2: {
+        key: string;
+        value: string;
+    }[], relation: "descendant" | "descendant-or-self", isIndex?: boolean, multiElementReferenceMode?: boolean) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getAncestorBridgeXpath: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: "ancestor" | "ancestor-or-self", xpaths1: {
+        key: string;
+        value: string;
+    }[], xpaths2: {
+        key: string;
+        value: string;
+    }[], isIndex: boolean) => {
+        key: string;
+        value: string;
+    }[];
+    getXpathRelationExpression: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: string, xpath1: any[], xpath2: any[], isIndex: boolean, multiElementReferenceMode: boolean) => {
+        key: string;
+        value: any;
+    }[];
+    getTraverseXpathExpression: (xpathe1: string, absoluteXpathElements: string[], element2: HTMLElement | Element, refExpectElement: Array<HTMLElement | Element>, docmt: Node, relation: string, isIndex: boolean, multiElementReferenceMode: boolean) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
+};
+export default referenceXpath;