ff-automationv2 2.2.28 → 2.2.30

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cssSelectors = exports.getAiAbsoluteCssPath = exports.getAiClassCssPath = exports.getAiAttributeCssPath = exports.getIdAiCssPath = exports.parseAiCssSelectors = void 0;
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const escapeAiCssAttributeValue = (value) => {
+    return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+};
+const isAiCssSelectorUnique = (selector, el, root) => {
+    try {
+        const matches = root.querySelectorAll(selector);
+        return matches.length === 1 && matches[0] === el;
+    }
+    catch {
+        return false;
+    }
+};
+const parseAiCssSelectors = (el, mode = "single") => {
+    const selectors = [];
+    const root = el.getRootNode();
+    try {
+        const idPath = (0, exports.getIdAiCssPath)(el);
+        if (idPath && isAiCssSelectorUnique(idPath, el, root)) {
+            selectors.push({ key: "cssSelector by id", value: idPath });
+            if (mode === "single")
+                return selectors;
+        }
+        const classPath = (0, exports.getAiClassCssPath)(el);
+        if (classPath && isAiCssSelectorUnique(classPath, el, root)) {
+            selectors.push({ key: "cssSelector by class", value: classPath });
+        }
+        const namePath = (0, exports.getAiAttributeCssPath)(el);
+        if (namePath) {
+            selectors.push({ key: "cssSelector by name", value: namePath });
+        }
+    }
+    catch (e) {
+        logData_js_1.logger.error(e);
+    }
+    return selectors;
+};
+exports.parseAiCssSelectors = parseAiCssSelectors;
+function cssAiEscape(value) {
+    return value.replace(/([ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, "\\$1");
+}
+const getIdAiCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
+        return;
+    const tagName = el.tagName.toLowerCase();
+    if (tagName.includes("style") || tagName.includes("script"))
+        return;
+    const path = [];
+    let currentEl = el;
+    while (currentEl && currentEl.nodeType === 1) {
+        let selector = currentEl.nodeName?.toLowerCase();
+        if (currentEl.id && !(0, xpathHelpers_js_1.isAiNumberExist)(currentEl.id)) {
+            selector += `#${cssAiEscape(currentEl.id)}`;
+            path.unshift(selector);
+            break;
+        }
+        else {
+            let sib = currentEl;
+            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 = currentEl.parentElement;
+            if (nth === 1 && parent?.childElementCount > 1) {
+                selector += `:nth-child(${nth})`;
+            }
+        }
+        path.unshift(selector);
+        currentEl = currentEl.parentElement;
+    }
+    return path.join(" > ");
+};
+exports.getIdAiCssPath = getIdAiCssPath;
+const EXCLUDED_ATTRS = new Set([
+    "id",
+    "class",
+    "style",
+    "ff-inspect",
+    "ff-inspecter",
+    "ff-xpath"
+]);
+function getAiAttributeSelectors(el) {
+    return Array.from(el.attributes)
+        .filter((attr) => !EXCLUDED_ATTRS.has(attr?.name?.toLowerCase()) &&
+        attr.value &&
+        !(0, xpathHelpers_js_1.isAiNumberExist)(attr.value))
+        .map((attr) => `[${attr.name}="${escapeAiCssAttributeValue(attr.value)}"]`);
+}
+const getAiAttributeCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
+        return;
+    const root = el.getRootNode();
+    const tag = el.tagName.toLowerCase();
+    if (tag === "style" || tag === "script")
+        return;
+    const attrSelectors = getAiAttributeSelectors(el);
+    for (const attrSelector of attrSelectors) {
+        const candidate = `${tag}${attrSelector}`;
+        if (isAiCssSelectorUnique(candidate, el, root)) {
+            return candidate;
+        }
+    }
+    return;
+};
+exports.getAiAttributeCssPath = getAiAttributeCssPath;
+const getAiClassCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
+        return;
+    const tagName = el.tagName.toLowerCase();
+    if (tagName.includes("style") || tagName.includes("script"))
+        return;
+    const path = [];
+    let currentEl = el;
+    while (currentEl && currentEl.nodeType === 1) {
+        let selector = currentEl.nodeName?.toLowerCase();
+        const className = currentEl.getAttribute("class") || currentEl.className;
+        if (typeof className === "string" &&
+            className &&
+            !(0, xpathHelpers_js_1.isAiNumberExist)(className)) {
+            currentEl.classList?.remove("marked-element-temp");
+            currentEl.classList?.remove("removePointers");
+            if (className) {
+                selector += `.${className.trim().replace(/\s+/g, ".")}`;
+                path.unshift(selector);
+                break;
+            }
+        }
+        else {
+            let sib = currentEl;
+            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 = currentEl.parentElement;
+            if (nth === 1 && parent?.childElementCount > 1) {
+                selector += `:nth-child(${nth})`;
+            }
+        }
+        path.unshift(selector);
+        currentEl = currentEl.parentElement;
+    }
+    return path.join(" > ");
+};
+exports.getAiClassCssPath = getAiClassCssPath;
+const getAiAbsoluteCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
+        return;
+    const path = [];
+    while (el && el.nodeType === 1) {
+        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.getAiAbsoluteCssPath = getAiAbsoluteCssPath;
+exports.cssSelectors = {
+    parseAiCssSelectors: exports.parseAiCssSelectors,
+    getIdAiCssPath: exports.getIdAiCssPath,
+    getAiAttributeCssPath: exports.getAiAttributeCssPath,
+    getAiClassCssPath: exports.getAiClassCssPath,
+    getAiAbsoluteCssPath: exports.getAiAbsoluteCssPath
+};

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

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

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

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAiIOSLocators = void 0;
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const addAiLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
+    const xpath = (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, attribute, value, isTarget, 'ios');
+    if (xpath &&
+        (0, xpathHelpers_js_1.getAiCountOfXPath)(xpath, element, docmt) === 1) {
+        locators.push({
+            key,
+            value: xpath
+        });
+    }
+};
+const generateAiIOSLocators = (element, docmt, isTarget) => {
+    const locators = [];
+    const name = element.getAttribute("name");
+    const label = element.getAttribute("label");
+    const value = element.getAttribute("value");
+    const classChain = getAiOptimalClassChain(docmt, element, [
+        "label",
+        "name",
+        "value",
+    ]);
+    const predicate = getAiOptimalPredicateString(docmt, element, [
+        "label",
+        "name",
+        "value",
+        "type",
+    ]);
+    if (name) {
+        addAiLocator(locators, "iosAccessibilityID", "@name", name, element, docmt, isTarget);
+    }
+    if (label) {
+        addAiLocator(locators, "iosLabel", "@label", label, element, docmt, isTarget);
+    }
+    if (value) {
+        addAiLocator(locators, "iosValue", "@value", value, element, docmt, isTarget);
+    }
+    if (locators.length === 0) {
+        let absoluteXpath = (0, xpathHelpers_js_1.getAiAbsoluteXPath)(element, docmt);
+        if (absoluteXpath) {
+            if (absoluteXpath.startsWith('/AppiumAUT')) {
+                absoluteXpath = absoluteXpath.substring('/AppiumAUT'.length);
+                if (!absoluteXpath.startsWith('/')) {
+                    absoluteXpath = `/${absoluteXpath}`;
+                }
+            }
+            else if (absoluteXpath.startsWith('AppiumAUT')) {
+                absoluteXpath = absoluteXpath.substring('AppiumAUT'.length);
+                if (!absoluteXpath.startsWith('/')) {
+                    absoluteXpath = `/${absoluteXpath}`;
+                }
+            }
+            locators.push({
+                key: "absoluteXPath",
+                value: absoluteXpath
+            });
+        }
+    }
+    if (locators.length === 0) {
+        if (classChain) {
+            locators.push({
+                key: "iosClassChain",
+                value: `**${classChain}`,
+            });
+        }
+        if (predicate) {
+            locators.push({
+                key: "iosPredicateString",
+                value: predicate,
+            });
+        }
+    }
+    return locators;
+};
+exports.generateAiIOSLocators = generateAiIOSLocators;
+function getAiOptimalClassChain(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.isAiNumberExist)(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.getAiCountOfXPath)(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.findAiXpathWithIndex)(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
+        const parent = domNode.parentElement || domNode.parentNode;
+        return (getAiOptimalClassChain(doc, parent, 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 getAiOptimalPredicateString(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.isAiNumberExist)(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.getAiCountOfXPath)(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 findAiRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
+export declare const getAiSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
+declare const referenceXpath: {
+    findAiRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
+    getAiDescendantXpath: (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;
+    getAiAncestorBridgeXpath: (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;
+    }[];
+    getAiXpathRelationExpression: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: string, xpath1: any[], xpath2: any[], isIndex: boolean, multiElementReferenceMode: boolean) => {
+        key: string;
+        value: any;
+    }[];
+    getAiTraverseXpathExpression: (xpathe1: string, absoluteXpathElements: string[], element2: HTMLElement | Element, refExpectElement: Array<HTMLElement | Element>, docmt: Node, relation: string, isIndex: boolean, multiElementReferenceMode: boolean) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getAiSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
+};
+export default referenceXpath;