ff-automationv2 2.2.28 → 2.2.29

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

@@ -0,0 +1,590 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartRelations = exports.findRelativeXpath = void 0;
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const xpathDataWithIndex = [];
+let xpathData = [];
+const reWhiteSpace = /^[\S]+( [\S]+)*$/gi;
+const findRelativeXpath = (element1, element2, docmt, xpaths1, xpaths2, isIndex, multiElementReferenceMode = false, allowedRelations = null) => {
+    let finalXpaths = [];
+    const relations = allowedRelations || [];
+    const tryRelation = (relation, useIndex) => {
+        let rel_xpath;
+        if (relation === "descendant" || relation === "descendant-or-self") {
+            rel_xpath =
+                getDescendantXpath([element1, element2], docmt, xpaths1, xpaths2, relation, useIndex, multiElementReferenceMode) || [];
+        }
+        else {
+            rel_xpath =
+                getXpathRelationExpression(element1, element2, relation, xpaths1, xpaths2, useIndex, multiElementReferenceMode) || [];
+        }
+        if (rel_xpath.length) {
+            finalXpaths = finalXpaths.concat(rel_xpath);
+        }
+    };
+    for (const relation of relations) {
+        tryRelation(relation, isIndex);
+    }
+    return finalXpaths;
+};
+exports.findRelativeXpath = findRelativeXpath;
+const descendantExpression = (refExpectElement, xpath2, relation, docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength = 0, multiElementReferenceMode = false) => {
+    let finalExpectedElementXpath;
+    if (xpath2.split(/\/(?=(?:[^']*\'[^\']*\')*[^\']*$)/g)?.length >=
+        expCommonParentXpathElements.length) {
+        const xpaths2Els = [];
+        const xpath2Elements = xpath2.split(/\/(?=(?:[^']*\'[^\']*\')*[^\']*$)/g);
+        for (let x = 1; x <= expCommonParentXpathElements.length; x++) {
+            xpaths2Els.unshift(x === expCommonParentXpathElements.length
+                ? expCommonParentXpathElements[expCommonParentXpathElements.length - x]
+                : xpath2Elements[xpath2Elements.length - x]);
+        }
+        const traverseXpath = getTraverseXpathExpression(`${step4 +
+            (refCommonParentXpathElementLength
+                ? "]".repeat(refCommonParentXpathElementLength)
+                : "")}`, xpaths2Els, refExpectElement[refExpectElement.length - 1], refExpectElement, docmt, relation, isIndex, multiElementReferenceMode);
+        if (traverseXpath) {
+            return traverseXpath;
+        }
+    }
+    else {
+        finalExpectedElementXpath = `//${step4 +
+            (refCommonParentXpathElementLength
+                ? "]".repeat(refCommonParentXpathElementLength)
+                : "")}/${relation}::${(0, xpathHelpers_js_1.replaceActualAttributes)(xpath2)}`;
+        let rel_count = (0, xpathHelpers_js_1.getCountOfXPath)(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt);
+        if (rel_count === 1) {
+            return [
+                {
+                    key: `dynamic ${relation}`,
+                    value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                }
+            ];
+        }
+        if (rel_count > 1) {
+            if (isIndex) {
+                finalExpectedElementXpath = (0, xpathHelpers_js_1.findXpathWithIndex)(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt, rel_count);
+                if (finalExpectedElementXpath) {
+                    rel_count = (0, xpathHelpers_js_1.getCountOfXPath)(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt);
+                    if (rel_count === 1) {
+                        return [
+                            {
+                                key: `dynamic ${relation} ${isIndex ? " index" : ""}`,
+                                value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                            }
+                        ];
+                    }
+                }
+            }
+        }
+    }
+};
+const getDescendantXpath = (refExpectElement, docmt, xpaths1, xpaths2, relation, isIndex = false, multiElementReferenceMode = false) => {
+    const refElement = refExpectElement[refExpectElement.length - 2];
+    const expElement = refExpectElement[refExpectElement.length - 1];
+    const expElementDocmnt = (0, xpathHelpers_js_1.getShadowRoot)(expElement) ?? expElement.ownerDocument;
+    const refAbsoluteXpath = xpaths1.find((x) => x?.key?.includes("absolute"))?.value ||
+        (0, xpathHelpers_js_1.getAbsoluteXPath)(refElement, refElement.ownerDocument);
+    const refFullXpathElements = [];
+    const refFullXpathElementsWithoutNumber = [];
+    refAbsoluteXpath.split("/").map((x) => refFullXpathElements.push(x));
+    refFullXpathElements.map((x) => refFullXpathElementsWithoutNumber.push(x.replace(/\[([0-9]+)\]/gm, "")));
+    const expAbsoluteXpath = xpaths2.find((x) => x?.key?.includes("absolute"))?.value ||
+        (0, xpathHelpers_js_1.getAbsoluteXPath)(expElement, expElement.ownerDocument);
+    const expFullXpathElements = [];
+    const expFullXpathElementsWithoutNumber = [];
+    expAbsoluteXpath.split("/").map((x) => expFullXpathElements.push(x));
+    expFullXpathElements.map((x) => expFullXpathElementsWithoutNumber.push(x.replace(/\[([0-9]+)\]/gm, "")));
+    let parentElementNumber = 0;
+    for (; parentElementNumber < refFullXpathElements.length; parentElementNumber++) {
+        if (refFullXpathElements[parentElementNumber] !=
+            expFullXpathElements[parentElementNumber]) {
+            break;
+        }
+    }
+    const refCommonParentXpathElements = [];
+    for (let i = parentElementNumber - 1; i < refFullXpathElements.length; i++) {
+        if (refFullXpathElements[i]) {
+            refCommonParentXpathElements.push(refFullXpathElementsWithoutNumber[i]);
+        }
+    }
+    const expCommonParentXpathElements = [];
+    for (let j = relation === "descendant" ? parentElementNumber : parentElementNumber - 1; j < expFullXpathElements.length; j++) {
+        if (expFullXpathElements[j]) {
+            if (expCommonParentXpathElements.length)
+                expCommonParentXpathElements.push(expFullXpathElementsWithoutNumber[j]);
+            else
+                expCommonParentXpathElements.push(expFullXpathElementsWithoutNumber[j].replace(/\[([0-9]+)\]/gm, ""));
+        }
+    }
+    xpathData = xpaths2;
+    let nodeXpath2;
+    if (refExpectElement[refExpectElement.length - 2].textContent) {
+        if (!reWhiteSpace.test(refExpectElement[refExpectElement.length - 2].textContent)) {
+            nodeXpath2 = (0, xpathHelpers_js_1.isSvg)(refExpectElement[refExpectElement.length - 2])
+                ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName}' and ${(0, xpathHelpers_js_1.getTextXpathFunction)(refExpectElement[refExpectElement.length - 2])})]`
+                : `${refExpectElement[refExpectElement.length - 2].tagName}[${(0, xpathHelpers_js_1.getTextXpathFunction)(refExpectElement[refExpectElement.length - 2])}]`;
+        }
+        else {
+            nodeXpath2 = (0, xpathHelpers_js_1.isSvg)(refExpectElement[refExpectElement.length - 2])
+                ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName}' and .=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.getTextContent)(refExpectElement[refExpectElement.length - 2]))}]`
+                : `${refExpectElement[refExpectElement.length - 2].tagName}[.=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.getTextContent)(refExpectElement[refExpectElement.length - 2]))}]`;
+        }
+        refCommonParentXpathElements[refCommonParentXpathElements.length - 1] =
+            nodeXpath2;
+        const refCommonParentXpath = refCommonParentXpathElements.join("[");
+        const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+        const step4 = refCommonParentXpath;
+        for (let i = 0; i < xpathData.length; i++) {
+            let xpath2;
+            if (xpathData[i].value.startsWith("//")) {
+                xpath2 = xpathData[i].value.substring(xpathData[i].value.indexOf("//") + 2);
+            }
+            else {
+                xpath2 = xpathData[i].value; // No need to modify the value
+            }
+            if (xpath2) {
+                return descendantExpression(refExpectElement, xpath2, relation, expElementDocmnt || docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength, multiElementReferenceMode);
+            }
+        }
+    }
+    if (refExpectElement[refExpectElement.length - 2].attributes) {
+        for (const attrName of Array.from(refExpectElement[refExpectElement.length - 2].attributes)) {
+            if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attrName, refExpectElement[refExpectElement.length - 2], false)) {
+                let attrValue = attrName.nodeValue;
+                if (attrValue) {
+                    attrValue = (0, xpathHelpers_js_1.sanitizeAttributeValue)(attrName.name, attrValue);
+                    const elementName = attrName.name;
+                    nodeXpath2 = (0, xpathHelpers_js_1.isSvg)(refExpectElement[refExpectElement.length - 2])
+                        ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName}' and @${elementName}=${(0, xpathHelpers_js_1.escapeCharacters)(attrValue)}]`
+                        : `${refExpectElement[refExpectElement.length - 2].tagName}[@${elementName}=${(0, xpathHelpers_js_1.escapeCharacters)(attrValue)}]`;
+                    refCommonParentXpathElements[refCommonParentXpathElements.length - 1] = nodeXpath2;
+                    const refCommonParentXpath = refCommonParentXpathElements.join("[");
+                    const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+                    const step4 = refCommonParentXpath;
+                    for (let i = 0; i < xpathData.length; i++) {
+                        let xpath2;
+                        if (xpathData[i].value.startsWith("//")) {
+                            xpath2 = xpathData[i].value.substring(xpathData[i].value.indexOf("//") + 2);
+                        }
+                        else {
+                            xpath2 = xpathData[i].value; // No need to modify the value
+                        }
+                        return descendantExpression(refExpectElement, xpath2, relation, expElementDocmnt || docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength, multiElementReferenceMode);
+                    }
+                }
+            }
+        }
+        for (const attrName of Array.from(refExpectElement[refExpectElement.length - 2].attributes)) {
+            if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attrName, refExpectElement[refExpectElement.length - 2], false)) {
+                const attrValue = attrName.nodeValue;
+                if (attrValue) {
+                    // attrValue = sanitizeAttributeValue(attrName.name, attrValue);
+                    const combinationXpath = (0, xpathHelpers_js_1.getCombinationXpath)(attrName, refExpectElement[refExpectElement.length - 2]);
+                    if (combinationXpath) {
+                        if (combinationXpath.startsWith("//")) {
+                            nodeXpath2 = combinationXpath.substring(combinationXpath.indexOf("//") + 2);
+                        }
+                        else {
+                            nodeXpath2 = combinationXpath; // No need to modify the value
+                        }
+                        refCommonParentXpathElements[refCommonParentXpathElements.length - 1] = nodeXpath2;
+                        const refCommonParentXpath = refCommonParentXpathElements.join("[");
+                        const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+                        const step4 = refCommonParentXpath;
+                        for (let i = 0; i < xpathData.length; i++) {
+                            let xpath2;
+                            if (xpathData[i].value.startsWith("//")) {
+                                xpath2 = xpathData[i].value.substring(xpathData[i].value.indexOf("//") + 2);
+                            }
+                            else {
+                                xpath2 = xpathData[i].value; // No need to modify the value
+                            }
+                            return descendantExpression(refExpectElement, xpath2, relation, expElementDocmnt || docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength, multiElementReferenceMode);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const refCommonParentXpath = refCommonParentXpathElements.join("[");
+    const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+    const step4 = refCommonParentXpath;
+    const traverseXpath = getTraverseXpathExpression(`${step4 +
+        (refCommonParentXpathElementLength
+            ? "]".repeat(refCommonParentXpathElementLength)
+            : "")}`, expCommonParentXpathElements, refExpectElement[refExpectElement.length - 1], refExpectElement, docmt, relation, isIndex, multiElementReferenceMode);
+    if (traverseXpath) {
+        return traverseXpath;
+    }
+};
+const getXpathRelationExpression = (element1, element2, relation, xpath1, xpath2, isIndex, multiElementReferenceMode) => {
+    let xpaths1;
+    let xpaths2;
+    logData_js_1.logger.info("getXpathRelationExpression", relation);
+    const finalXpaths = [];
+    try {
+        xpaths1 = xpath1.filter((x) => !x?.key?.includes("absolute"));
+        xpaths2 = xpath2.filter((x) => !x?.key?.includes("absolute"));
+        if (relation === "ancestor" || relation === "ancestor-or-self") {
+            const ancestorBridgeXpaths = getAncestorBridgeXpath(element1, element2, relation, xpaths1, xpaths2, isIndex);
+            if (ancestorBridgeXpaths.length) {
+                return ancestorBridgeXpaths;
+            }
+        }
+        for (let i = 0; i < xpaths1.length; i++) {
+            for (let j = 0; j < xpaths2.length; j++) {
+                let rel_xpath = `//${xpaths1[i].value.indexOf("//") !== 0
+                    ? (0, xpathHelpers_js_1.replaceActualAttributes)(xpaths1[i].value)
+                    : (0, xpathHelpers_js_1.replaceActualAttributes)(xpaths1[i].value.substring(xpaths1[i].value.indexOf("//") + 2))}/${relation}::${xpaths2[j].value.indexOf("//") !== 0
+                    ? (0, xpathHelpers_js_1.replaceActualAttributes)(xpaths2[j].value)
+                    : (0, xpathHelpers_js_1.replaceActualAttributes)(xpaths2[j].value.substring(xpaths2[j].value.indexOf("//") + 2))}`;
+                logData_js_1.logger.info("getXpathRelationExpression", rel_xpath);
+                const rel_count = (0, xpathHelpers_js_1.getCountOfXPath)(rel_xpath, element2, element2.ownerDocument);
+                if (rel_count > 1) {
+                    if (isIndex) {
+                        rel_xpath = (0, xpathHelpers_js_1.findXpathWithIndex)(rel_xpath, element2, element2.ownerDocument, rel_count);
+                        if (rel_xpath) {
+                            finalXpaths.push({
+                                key: `dynamic ${relation}${isIndex ? " index" : ""}`,
+                                value: (0, xpathHelpers_js_1.replaceTempAttributes)(rel_xpath)
+                            });
+                            return finalXpaths;
+                        }
+                    }
+                    else if (rel_count > 1) {
+                        if (xpathDataWithIndex.length) {
+                            if (rel_count < xpathDataWithIndex[0].count) {
+                                xpathDataWithIndex.pop();
+                                xpathDataWithIndex.push({
+                                    key: `relative xpath by relative child ${isIndex ? "index" : ""}`,
+                                    value: rel_xpath,
+                                    count: rel_count
+                                });
+                            }
+                        }
+                        else {
+                            xpathDataWithIndex.push({
+                                key: `relative xpath by relative child ${isIndex ? "index" : ""}`,
+                                value: rel_xpath,
+                                count: rel_count
+                            });
+                        }
+                    }
+                }
+                else if (rel_count === 1) {
+                    finalXpaths.push({
+                        key: `dynamic ${relation}`,
+                        value: (0, xpathHelpers_js_1.replaceTempAttributes)(rel_xpath)
+                    });
+                    return finalXpaths;
+                }
+            }
+        }
+        if (!finalXpaths.length) {
+            for (let i = 0; i < xpaths1.length; i++) {
+                for (let j = 0; j < xpaths2.length; j++) {
+                    const tempPath = `${xpaths2[j].value.indexOf("//") !== 0
+                        ? xpaths2[j].value
+                        : xpaths2[j].value.substring(xpaths2[j].value.indexOf("//") + 2)}`;
+                    const xpath2Elements = tempPath.split(/\/(?=(?:[^']*\'[^\']*\')*[^\']*$)/g);
+                    if (xpath2Elements.length > 1) {
+                        const traverseXpath = getTraverseXpathExpression(`${xpaths1[i].value.indexOf("//") !== 0
+                            ? (0, xpathHelpers_js_1.replaceActualAttributes)(xpaths1[i].value)
+                            : (0, xpathHelpers_js_1.replaceActualAttributes)(xpaths1[i].value.substring(xpaths1[i].value.indexOf("//") + 2))}`, xpath2Elements, element2, [element1, element2], element2.ownerDocument, relation, isIndex, multiElementReferenceMode);
+                        logData_js_1.logger.info("getXpathRelationExpression traverseXpath", traverseXpath);
+                        if (traverseXpath) {
+                            finalXpaths.push(...traverseXpath);
+                            return finalXpaths;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error("getXpathRelationExpression Error", error);
+    }
+    return finalXpaths;
+};
+const xpathStepSeparator = /\/(?=(?:[^']*'[^']*')*[^']*$)/g;
+const stripXpathPrefix = (xpath) => xpath.indexOf("//") === 0 ? xpath.substring(xpath.indexOf("//") + 2) : xpath;
+const getCommonAncestor = (element1, element2) => {
+    let currentNode = element1;
+    while (currentNode) {
+        if (currentNode.contains(element2)) {
+            return currentNode;
+        }
+        currentNode = currentNode.parentElement;
+    }
+    return null;
+};
+const getSingleStepXpath = (element, xpaths) => {
+    for (const xpath of xpaths) {
+        const xpathValue = stripXpathPrefix(xpath.value);
+        if (xpathValue && xpathValue.split(xpathStepSeparator).length === 1) {
+            return (0, xpathHelpers_js_1.replaceActualAttributes)(xpathValue);
+        }
+    }
+    if (element.textContent) {
+        const textXpath = (0, xpathHelpers_js_1.getTextXpathFunction)(element);
+        if (textXpath) {
+            return (0, xpathHelpers_js_1.isSvg)(element)
+                ? `*[local-name()='${element.tagName}' and ${textXpath}]`
+                : `${element.tagName}[${textXpath}]`;
+        }
+    }
+    if (element.attributes) {
+        for (const attrName of Array.from(element.attributes)) {
+            if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attrName, element, false) &&
+                attrName.nodeValue) {
+                return (0, xpathHelpers_js_1.isSvg)(element)
+                    ? `*[local-name()='${element.tagName}' and @${attrName.name}=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.sanitizeAttributeValue)(attrName.name, attrName.nodeValue))}]`
+                    : `${element.tagName}[@${attrName.name}=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.sanitizeAttributeValue)(attrName.name, attrName.nodeValue))}]`;
+            }
+        }
+    }
+    return (0, xpathHelpers_js_1.isSvg)(element)
+        ? `*[local-name()='${element.tagName}']`
+        : element.tagName;
+};
+const getRelativeXpathFromAncestor = (ancestorElement, targetElement, targetXPaths) => {
+    const steps = [];
+    let currentNode = targetElement;
+    while (currentNode && currentNode !== ancestorElement) {
+        const currentStep = currentNode === targetElement
+            ? getSingleStepXpath(targetElement, targetXPaths)
+            : (0, xpathHelpers_js_1.isSvg)(currentNode)
+                ? `*[local-name()='${currentNode.tagName}']`
+                : currentNode.tagName;
+        steps.unshift(currentStep);
+        currentNode = currentNode.parentElement;
+    }
+    return currentNode === ancestorElement ? steps.join("/") : "";
+};
+const getAncestorBridgeXpath = (element1, element2, relation, xpaths1, xpaths2, isIndex) => {
+    const finalXpaths = [];
+    const commonAncestor = getCommonAncestor(element1, element2);
+    if (!commonAncestor || commonAncestor === element2) {
+        return finalXpaths;
+    }
+    const ancestorNodeTest = (0, xpathHelpers_js_1.isSvg)(commonAncestor)
+        ? `*[local-name()='${commonAncestor.tagName}']`
+        : commonAncestor.tagName;
+    const targetRelativeXpath = getRelativeXpathFromAncestor(commonAncestor, element2, xpaths2);
+    if (!targetRelativeXpath) {
+        return finalXpaths;
+    }
+    for (const xpath of xpaths1) {
+        const referenceXpath = stripXpathPrefix(xpath.value);
+        if (!referenceXpath) {
+            continue;
+        }
+        let finalExpectedElementXpath = `//${(0, xpathHelpers_js_1.replaceActualAttributes)(referenceXpath)}/${relation}::${ancestorNodeTest}/${targetRelativeXpath}`;
+        let rel_count = (0, xpathHelpers_js_1.getCountOfXPath)(finalExpectedElementXpath, element2, element2.ownerDocument);
+        if (rel_count === 1) {
+            finalXpaths.push({
+                key: `dynamic ${relation} bridge`,
+                value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+            });
+            return finalXpaths;
+        }
+        if (rel_count > 1 && isIndex) {
+            finalExpectedElementXpath = (0, xpathHelpers_js_1.findXpathWithIndex)(finalExpectedElementXpath, element2, element2.ownerDocument, rel_count);
+            rel_count = finalExpectedElementXpath
+                ? (0, xpathHelpers_js_1.getCountOfXPath)(finalExpectedElementXpath, element2, element2.ownerDocument)
+                : 0;
+            if (finalExpectedElementXpath && rel_count === 1) {
+                finalXpaths.push({
+                    key: `dynamic ${relation} bridge index`,
+                    value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                });
+                return finalXpaths;
+            }
+        }
+    }
+    return finalXpaths;
+};
+// const getReferenceElementXpath = (element: HTMLElement | Element) => {
+//   let xpaths1: {
+//     key: string;
+//     value: string;
+//   }[];
+//   xpaths1 = parseDOM(element, element.ownerDocument, false, false,platform);
+//   if (!xpaths1?.length) {
+//     xpaths1 = parseDOM(element, element.ownerDocument, true, false,platform);
+//     xpaths1 = xpaths1?.map((x) =>
+//       x.value.charAt(0) == "(" &&
+//         findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+//         ? { key: "", value: removeParenthesis(x.value) }
+//         : { key: "", value: x.value }
+//     );
+//   } else {
+//     let xpaths = parseDOM(element, element.ownerDocument, true, false,platform);
+//     if (xpaths?.length) {
+//       xpaths = xpaths?.map((x) =>
+//         x.value.charAt(0) == "(" &&
+//           findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+//           ? { key: "", value: removeParenthesis(x.value) }
+//           : { key: "", value: x.value }
+//       );
+//       xpaths1 = xpaths1.concat(xpaths);
+//     }
+//   }
+//   if (!xpaths1?.length) {
+//     xpaths1 = [
+//       {
+//         key: "",
+//         value: getRelativeXPath(
+//           element,
+//           element.ownerDocument,
+//           false,
+//           false,
+//           Array.from(element.attributes)
+//         )
+//       }
+//     ];
+//   }
+//   if (!xpaths1?.length) {
+//     xpaths1 = [
+//       {
+//         key: "",
+//         value: getRelativeXPath(
+//           element,
+//           element.ownerDocument,
+//           true,
+//           false,
+//           Array.from(element.attributes)
+//         )
+//       }
+//     ];
+//     xpaths1 = xpaths1?.map((x) =>
+//       x.value.charAt(0) == "(" &&
+//         findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+//         ? { key: "", value: removeParenthesis(x.value) }
+//         : { key: "", value: x.value }
+//     );
+//   }
+//   if (!xpaths1?.length) {
+//     xpaths1 = getReferenceElementsXpath(element, element.ownerDocument, false);
+//   } else {
+//     const xpaths = getReferenceElementsXpath(
+//       element,
+//       element.ownerDocument,
+//       false
+//     );
+//     if (xpaths?.length) {
+//       xpaths1 = xpaths1.concat(xpaths);
+//     }
+//   }
+//   const referenceXpathElement = getAbsoluteXPath(
+//     element,
+//     element.ownerDocument
+//   );
+//   xpaths1 = xpaths1.filter((x) => x.value !== referenceXpathElement);
+//   xpaths1.push({
+//     key: "absolute xpath",
+//     value: referenceXpathElement.slice(1)
+//   });
+//   return xpaths1;
+// };
+const getTraverseXpathExpression = (xpathe1, absoluteXpathElements, element2, refExpectElement, docmt, relation, isIndex, multiElementReferenceMode) => {
+    let finalExpectedElementXpath;
+    if (!multiElementReferenceMode) {
+        for (let x = 1; x <= absoluteXpathElements.length; x++) {
+            const xpath2 = absoluteXpathElements
+                .slice(absoluteXpathElements.length - x, absoluteXpathElements.length)
+                .join("/");
+            finalExpectedElementXpath = `//${xpathe1}/${relation}::${(0, xpathHelpers_js_1.replaceActualAttributes)(xpath2)}`;
+            const rel_count = (0, xpathHelpers_js_1.getCountOfXPath)(finalExpectedElementXpath, element2, docmt);
+            if (rel_count === 1) {
+                return [
+                    {
+                        key: `dynamic ${relation}`,
+                        value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                    }
+                ];
+            }
+            if (rel_count > 1) {
+                if (isIndex) {
+                    finalExpectedElementXpath = (0, xpathHelpers_js_1.findXpathWithIndex)(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt, rel_count);
+                    if (finalExpectedElementXpath) {
+                        return [
+                            {
+                                key: `dynamic ${relation}${isIndex ? " index" : ""}`,
+                                value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                            }
+                        ];
+                    }
+                }
+            }
+        }
+    }
+    else {
+        const xpath2 = absoluteXpathElements.join("/");
+        finalExpectedElementXpath = `//${xpathe1}/${relation}::${(0, xpathHelpers_js_1.replaceActualAttributes)(xpath2)}`;
+        const rel_count = (0, xpathHelpers_js_1.getCountOfXPath)(finalExpectedElementXpath, element2, docmt);
+        if (rel_count === 1) {
+            return [
+                {
+                    key: `dynamic ${relation}`,
+                    value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                }
+            ];
+        }
+        if (rel_count > 1) {
+            if (isIndex) {
+                finalExpectedElementXpath = (0, xpathHelpers_js_1.findXpathWithIndex)(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt, rel_count);
+                if (finalExpectedElementXpath) {
+                    return [
+                        {
+                            key: `dynamic ${relation}${isIndex ? " index" : ""}`,
+                            value: (0, xpathHelpers_js_1.replaceTempAttributes)(finalExpectedElementXpath)
+                        }
+                    ];
+                }
+            }
+        }
+    }
+};
+const getSmartRelations = (element1, element2) => {
+    const pos = element1.compareDocumentPosition(element2);
+    const highPriority = [];
+    const mediumPriority = [];
+    const lowPriority = [];
+    //  Ancestor
+    if (pos & element1.ownerDocument.defaultView.Node.DOCUMENT_POSITION_CONTAINS) {
+        highPriority.push("ancestor", "ancestor-or-self", "parent");
+    }
+    //  Descendant direct
+    if (pos & element1.ownerDocument.defaultView.Node.DOCUMENT_POSITION_CONTAINED_BY) {
+        highPriority.push("child");
+    }
+    //  Siblings
+    if (element1.parentElement === element2.parentElement) {
+        highPriority.push("following-sibling", "preceding-sibling");
+    }
+    //  Directional
+    if (pos & element1.ownerDocument.defaultView.Node.DOCUMENT_POSITION_FOLLOWING) {
+        mediumPriority.push("following");
+    }
+    if (pos & element1.ownerDocument.defaultView.Node.DOCUMENT_POSITION_PRECEDING) {
+        mediumPriority.push("preceding");
+    }
+    // always include fallback
+    lowPriority.push("descendant", "descendant-or-self");
+    const relations = [...highPriority, ...mediumPriority, ...lowPriority];
+    return [...new Set(relations)];
+};
+exports.getSmartRelations = getSmartRelations;
+const referenceXpath = {
+    findRelativeXpath: exports.findRelativeXpath,
+    getDescendantXpath,
+    getAncestorBridgeXpath,
+    getXpathRelationExpression,
+    getTraverseXpathExpression,
+    // getReferenceElementXpath,
+    getSmartRelations: exports.getSmartRelations
+};
+exports.default = referenceXpath;

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

@@ -0,0 +1,38 @@
+import { platform } from "../../../core/types/scriptTypesType";
+export declare const generateIndexedXpaths: (element: Element, docmt: Document, platform: platform) => {
+    key: string;
+    value: string;
+}[];
+declare function getXPathUsingAttributeAndText(attributes: Attr[], targetElemt: HTMLElement | Element, docmt: Document, isTarget: boolean): string | undefined;
+export declare const attributesBasedXPath: (attr: Attr, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => string | undefined;
+export declare const getUniqueClassName: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => string | undefined;
+export declare const getTextXPath: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => string | undefined;
+export declare const parseDOM: (element: HTMLElement | Element, doc: Document, isIndex: boolean, isTarget: boolean, includedAttributes: Attr[] | undefined, strategies: string[] | undefined, platform: platform) => {
+    key: string;
+    value: string;
+}[];
+declare const xpath: {
+    parseDOM: (element: HTMLElement | Element, doc: Document, isIndex: boolean, isTarget: boolean, includedAttributes: Attr[] | undefined, strategies: string[] | undefined, platform: platform) => {
+        key: string;
+        value: string;
+    }[];
+    getTextXPath: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => string | undefined;
+    getUniqueClassName: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => string | undefined;
+    attributesBasedXPath: (attr: Attr, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => string | undefined;
+    addAllXPathAttributes: (attributes: Attr[], targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, platform: platform) => void;
+    addRelativeXpaths: (targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, attribute: Attr[], platform: platform) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getXPathUsingAttributeAndText: typeof getXPathUsingAttributeAndText;
+    getSiblingRelativeXPath: (domNode: HTMLElement | Element, docmt: Document, isTarget: boolean, nodeXpath: string, platform: platform) => null | undefined;
+    getChildRelativeXpath: (domNode: HTMLElement | Element, docmt: Document, node: HTMLElement | Element) => string | null;
+    getParentRelativeXpath: (domNode: HTMLElement, docmt: Document, node: HTMLElement | Element, isTarget: boolean, platform: platform) => any;
+    getUniqueParentXpath: (domNode: HTMLElement, docmt: Document, node: HTMLElement | Element, isTarget: boolean, nodeXpath: string, isIndex: boolean, platform: platform) => any;
+    checkRelativeXpathRelation: (nodeXpath1: string, nodeXpath2: string, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, relationType: string) => string | null;
+    buildAxesStrategyXpaths: (element: HTMLElement | Element, docmt: Document, isTarget: boolean, isIndex: boolean, platform: platform) => {
+        key: string;
+        value: string;
+    }[];
+};
+export default xpath;