ff-dom 1.0.18-beta.6 → 1.0.18

package/dist/index.browser.js

@@ -865,9 +865,9 @@ const getReferenceElementsXpath = (domNode, docmt, isTarget) => {
     }
     return xpaths1;
 };
-const parseXml = (xmlStr) => {
+const parseXml = (xmlStr, type) => {
     if (window.DOMParser) {
-        return new window.DOMParser().parseFromString(xmlStr, "text/xml");
+        return new window.DOMParser().parseFromString(xmlStr, type);
     }
     return null;
 };
@@ -1614,6 +1614,7 @@ const addAllXPathAttributes = (attributes, targetElemt, docmt, isIndex, isTarget
     catch (error) {
         console.log(error);
     }
+    return xpathData$1;
 };
 const parseDOM = (element, doc, isIndex, isTarget) => {
     xpathData$1 = [];
@@ -2185,10 +2186,27 @@ const referenceXpath = {
     getReferenceElementXpath,
 };
 
-const getElementFromShadowRoot = (element, selector) => {
-    const shadowRoot = element.shadowRoot;
-    if (shadowRoot && !selector.includes("dynamic")) {
-        return shadowRoot.querySelector(selector);
+const getElementFromShadowRoot = (el, selector) => {
+    // const shadowRoot = (element as HTMLElement).shadowRoot;
+    // if (shadowRoot && !selector.includes("dynamic")) {
+    //   return shadowRoot.querySelector(selector);
+    // }
+    const elements = Array.from(el.querySelectorAll('*'));
+    try {
+        for (let i = 0; i < elements.length; i++) {
+            if (elements[i].shadowRoot) {
+                const { shadowRoot } = elements[i];
+                if (shadowRoot) {
+                    getElementFromShadowRoot(shadowRoot, selector);
+                    if (shadowRoot && !selector.includes("dynamic")) {
+                        return shadowRoot.querySelector(selector);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.log(error);
     }
     return null;
 };
@@ -2222,30 +2240,27 @@ const relations = [
     "/preceding",
     "/following",
 ];
-function getElementFromXPath(tempDiv, xpath) {
-    let currentElement = tempDiv;
-    const window = currentElement.ownerDocument.defaultView;
+function getElementFromXPath(docmt, xpath) {
+    const window = docmt.defaultView;
     if (!window)
         return null;
     const xpathEvaluator = new window.XPathEvaluator();
-    const xpathResult = xpathEvaluator.evaluate(xpath, currentElement.ownerDocument, //here even tempDiv can be passed
-    null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const xpathResult = xpathEvaluator.evaluate(xpath, docmt, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
     return xpathResult.singleNodeValue;
 }
-function checkReferenceElementIsValid(locator, relation, tempDiv) {
+function checkReferenceElementIsValid(locator, relation, docmt) {
     if (locator.includes(relation)) {
         const locatotSplitArray = locator.split(relation);
         const sourceLoc = locatotSplitArray[0].trim();
-        let currentElement = tempDiv;
-        const window = currentElement.ownerDocument.defaultView;
+        const window = docmt.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 xpathResult = xpathEvaluator.evaluate(sourceLoc, docmt, 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 xpathResultComplete = xpathEvaluator.evaluate(locator, docmt, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
                 const completeElement = xpathResultComplete.singleNodeValue;
                 let relativeXpath;
                 if (completeElement) {
@@ -2266,16 +2281,12 @@ function checkReferenceElementIsValid(locator, relation, tempDiv) {
     return null;
 }
 const getElementsFromHTML = (record, docmt) => {
-    const document = docmt;
-    // global.SVGElement = document.defaultView?.SVGElement!;
-    const tempDiv = document.createElement("div");
-    const elementsToRemove = document.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg");
+    const elementsToRemove = docmt.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;
     const finalLocatorsSet = new Set();
     let finalLocators = [];
     function createLocator(base, overrides = {}) {
@@ -2349,135 +2360,126 @@ const getElementsFromHTML = (record, docmt) => {
             if (record.isShared.includes("Y")) {
                 break locators;
             }
-            for (const relation of relations) {
-                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));
-                            }
+            try {
+                let targetElement = null;
+                if (locator.value.startsWith("iframe")) {
+                    const iframe = docmt.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")) {
-                                    if (tempDiv?.innerHTML) {
-                                        const normalizedXPath = normalizeXPath(trimmedSelector);
-                                        targetElement = getElementFromXPath(tempDiv, normalizedXPath);
-                                        if (targetElement) {
-                                            createLocator(locator, {
-                                                value: trimmedSelector,
-                                                isRecorded: String(locator.isRecorded).includes("N")
-                                                    ? "N"
-                                                    : "Y",
-                                            });
-                                        }
-                                    }
-                                }
-                                else {
-                                    targetElement = currentElement.querySelector(trimmedSelector);
-                                    if (!targetElement) {
-                                        targetElement = getElementFromShadowRoot(currentElement, trimmedSelector);
-                                    }
-                                }
-                                if (!targetElement &&
-                                    isSvg(currentElement) &&
-                                    !locator.type.match("dynamic")) {
-                                    targetElement = currentElement.querySelector(trimmedSelector);
+                }
+                else {
+                    const selectors = locator.value.split(">>>"); // Custom delimiter for shadow DOM
+                    for (const selector of selectors) {
+                        if (docmt) {
+                            const trimmedSelector = selector.trim();
+                            if (locator.name.includes("id") ||
+                                trimmedSelector.startsWith("#")) {
+                                targetElement = docmt.querySelector("#" + trimmedSelector);
+                            }
+                            else if (locator.name.includes("className") ||
+                                trimmedSelector.startsWith(".")) {
+                                targetElement = docmt.querySelector("." + trimmedSelector);
+                            }
+                            else if ((locator.name.includes("xpath") ||
+                                trimmedSelector.startsWith("//")) &&
+                                !locator.type.match("dynamic")) {
+                                const normalizedXPath = normalizeXPath(trimmedSelector);
+                                targetElement = getElementFromXPath(docmt, normalizedXPath);
+                                if (targetElement) {
+                                    createLocator(locator, {
+                                        value: trimmedSelector,
+                                        isRecorded: String(locator.isRecorded).includes("N")
+                                            ? "N"
+                                            : "Y",
+                                    });
                                 }
-                                currentElement = targetElement;
                             }
                             else {
-                                console.error("Element not found at:", selector);
-                                break;
+                                targetElement = docmt.querySelector(trimmedSelector);
+                                if (!targetElement) {
+                                    targetElement = getElementFromShadowRoot(docmt.body, trimmedSelector);
+                                }
                             }
                         }
+                        else {
+                            console.error("Element not found at:", selector);
+                            break;
+                        }
                     }
-                    const locatorExists = (name, value) => {
-                        const key = `${name}:${value}`;
-                        return finalLocatorsSet.has(key);
-                    };
-                    if (targetElement) {
-                        const idValue = getId(targetElement);
-                        if (idValue && !locatorExists("id", idValue)) {
-                            record.locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: "id",
-                                    value: idValue,
-                                    isRecorded: loc.value === idValue && loc.name === "id"
-                                        ? loc.isRecorded
-                                        : "Y",
-                                    isSelfHealed: loc.value === idValue && loc.name === "id"
-                                        ? loc.isSelfHealed
-                                        : "Y",
-                                });
+                }
+                const locatorExists = (name, value) => {
+                    const key = `${name}:${value}`;
+                    return finalLocatorsSet.has(key);
+                };
+                if (targetElement) {
+                    const idValue = getId(targetElement);
+                    if (idValue && !locatorExists("id", idValue)) {
+                        record.locators.forEach((loc) => {
+                            createLocator(loc, {
+                                name: "id",
+                                value: idValue,
+                                isRecorded: loc.value === idValue && loc.name === "id"
+                                    ? loc.isRecorded
+                                    : "Y",
+                                isSelfHealed: loc.value === idValue && loc.name === "id"
+                                    ? loc.isSelfHealed
+                                    : "Y",
                             });
-                        }
-                        const textValue = getVisibleText(targetElement);
-                        if (textValue) {
-                            record.locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: "linkText",
-                                    type: "static",
-                                    value: textValue,
-                                    isRecorded: loc.value === textValue ? loc.isRecorded : "Y",
-                                    isSelfHealed: loc.value === textValue ? loc.isSelfHealed : "Y",
-                                });
+                        });
+                    }
+                    const textValue = getVisibleText(targetElement);
+                    if (textValue) {
+                        record.locators.forEach((loc) => {
+                            createLocator(loc, {
+                                name: "linkText",
+                                type: "static",
+                                value: textValue,
+                                isRecorded: loc.value === textValue ? loc.isRecorded : "Y",
+                                isSelfHealed: loc.value === textValue ? loc.isSelfHealed : "Y",
                             });
-                        }
-                        const nameLocator = getName(targetElement);
-                        if (nameLocator && !locatorExists("name", nameLocator)) {
-                            record.locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: "name",
-                                    type: "static",
-                                    value: nameLocator,
-                                    isRecorded: loc.value === nameLocator && loc.name === "name"
-                                        ? loc.isRecorded
-                                        : "Y",
-                                    isSelfHealed: loc.value === nameLocator && loc.name === "name"
-                                        ? loc.isSelfHealed
-                                        : "Y",
-                                });
+                        });
+                    }
+                    const nameLocator = getName(targetElement);
+                    if (nameLocator && !locatorExists("name", nameLocator)) {
+                        record.locators.forEach((loc) => {
+                            createLocator(loc, {
+                                name: "name",
+                                type: "static",
+                                value: nameLocator,
+                                isRecorded: loc.value === nameLocator && loc.name === "name"
+                                    ? loc.isRecorded
+                                    : "Y",
+                                isSelfHealed: loc.value === nameLocator && loc.name === "name"
+                                    ? loc.isSelfHealed
+                                    : "Y",
                             });
-                        }
-                        const classValue = getClassName(targetElement);
-                        if (classValue &&
-                            classValue.trim() !== "" &&
-                            !locatorExists("className", classValue)) {
-                            record.locators.forEach((loc) => {
-                                createLocator(loc, {
-                                    name: "className",
-                                    value: classValue,
-                                    isRecorded: loc.value === classValue && loc.name === "className"
-                                        ? loc.isRecorded
-                                        : "Y",
-                                    isSelfHealed: loc.value === classValue && loc.name === "className"
-                                        ? loc.isSelfHealed
-                                        : "Y",
-                                });
+                        });
+                    }
+                    const classValue = getClassName(targetElement);
+                    if (classValue &&
+                        classValue.trim() !== "" &&
+                        !locatorExists("className", classValue)) {
+                        record.locators.forEach((loc) => {
+                            createLocator(loc, {
+                                name: "className",
+                                value: classValue,
+                                isRecorded: loc.value === classValue && loc.name === "className"
+                                    ? loc.isRecorded
+                                    : "Y",
+                                isSelfHealed: loc.value === classValue && loc.name === "className"
+                                    ? loc.isSelfHealed
+                                    : "Y",
                             });
-                        }
-                        const xpathResults = parseDOM(targetElement, document, false, true);
-                        xpathResults.forEach((result) => {
-                            const fnValue = result.value;
+                        });
+                    }
+                    const xpathResults = parseDOM(targetElement, docmt, false, true);
+                    xpathResults.forEach((result) => {
+                        const fnValue = result.value;
+                        if (fnValue && !locatorExists(result.key.replace('xpath by', '').trim(), fnValue)) {
                             record.locators.forEach((loc) => {
                                 createLocator(loc, {
                                     name: 'xpath',
@@ -2486,71 +2488,71 @@ const getElementsFromHTML = (record, docmt) => {
                                     isSelfHealed: loc.value === fnValue ? loc.isSelfHealed : 'Y',
                                 });
                             });
-                        });
-                        for (const locator of record.locators) {
-                            try {
-                                for (const loc of record.locators) {
-                                    if (!loc.value)
-                                        continue;
-                                    for (const relation of relations) {
-                                        if (loc.value.includes(relation)) {
-                                            const relativeXpath = checkReferenceElementIsValid(loc.value, relation, tempDiv);
-                                            if (relativeXpath) {
-                                                createLocator(loc, {
-                                                    name: "xpath",
-                                                    value: relativeXpath,
-                                                    isRecorded: locator.isRecorded !== "" &&
-                                                        locator.isRecorded !== null
-                                                        ? locator.isRecorded
-                                                        : "Y",
-                                                });
-                                                break;
-                                            }
+                        }
+                    });
+                    for (const locator of record.locators) {
+                        try {
+                            for (const loc of record.locators) {
+                                if (!loc.value)
+                                    continue;
+                                for (const relation of relations) {
+                                    if (loc.value.includes(relation)) {
+                                        const relativeXpath = checkReferenceElementIsValid(loc.value, relation, docmt);
+                                        if (relativeXpath) {
+                                            createLocator(loc, {
+                                                name: "xpath",
+                                                value: relativeXpath,
+                                                isRecorded: locator.isRecorded !== "" &&
+                                                    locator.isRecorded !== null
+                                                    ? locator.isRecorded
+                                                    : "Y",
+                                            });
+                                            break;
                                         }
                                     }
                                 }
                             }
-                            catch (error) {
-                                console.error("Error processing locator:", locator, error);
-                            }
                         }
-                        const finalAutoHealedLocators = finalLocators.map((obj) => ({
-                            ...obj,
-                            value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded),
-                        }));
-                        const finalUniqueAutoHealedLocators = finalAutoHealedLocators.reduce((unique, locator) => {
-                            if (locator.value &&
-                                !unique.some((l) => l.value === locator.value)) {
-                                unique.push(locator);
-                            }
-                            return unique;
-                        }, []);
-                        const jsonResult = [
-                            {
-                                name: `${record.name}`,
-                                desc: `${record.desc}`,
-                                type: `${record.type}`,
-                                locators: finalUniqueAutoHealedLocators.filter((locator) => locator?.value != null && locator.value !== ""),
-                                isShared: `${record.isShared}`,
-                                projectId: `${record.projectId}`,
-                                projectType: `${record.projectType}`,
-                                isRecorded: `${record.isRecorded}`,
-                                folder: `${record.folder}`,
-                                parentId: `${record.parentId}`,
-                                parentName: `${record.parentName}`,
-                                platform: `${record.platform}`,
-                                licenseId: `${record.licenseId}`,
-                                licenseType: `${record.licenseType}`,
-                                userId: `${record.userId}`,
-                            },
-                        ];
-                        return jsonResult;
+                        catch (error) {
+                            console.error("Error processing locator:", locator, error);
+                        }
                     }
+                    const finalAutoHealedLocators = finalLocators.map((obj) => ({
+                        ...obj,
+                        value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded),
+                    }));
+                    const finalUniqueAutoHealedLocators = finalAutoHealedLocators.reduce((unique, locator) => {
+                        if (locator.value &&
+                            !unique.some((l) => l.value === locator.value)) {
+                            unique.push(locator);
+                        }
+                        return unique;
+                    }, []);
+                    const jsonResult = [
+                        {
+                            name: `${record.name}`,
+                            desc: `${record.desc}`,
+                            type: `${record.type}`,
+                            locators: finalUniqueAutoHealedLocators.filter((locator) => locator?.value != null && locator.value !== ""),
+                            isShared: `${record.isShared}`,
+                            projectId: `${record.projectId}`,
+                            projectType: `${record.projectType}`,
+                            isRecorded: `${record.isRecorded}`,
+                            folder: `${record.folder}`,
+                            parentId: `${record.parentId}`,
+                            parentName: `${record.parentName}`,
+                            platform: `${record.platform}`,
+                            licenseId: `${record.licenseId}`,
+                            licenseType: `${record.licenseType}`,
+                            userId: `${record.userId}`,
+                        },
+                    ];
+                    return jsonResult;
                 }
-                catch (error) {
-                    console.error("Error processing locator:", locator, error);
-                    continue;
-                }
+            }
+            catch (error) {
+                console.error("Error processing locator:", locator, error);
+                continue;
             }
         }
         catch (error) {