ff-automationv2 2.2.27 → 2.2.29

package/dist/domAnalysis/getRelaventElements.js

@@ -18,11 +18,20 @@ class DomProcessingEngine {
         const structured = this.relationshipBuilder.build(searched);
         return structured;
     }
-    mobileProcess(request) {
-        const { flatNodes, parentMap } = this.simplifier.simplifyMobile(request.rawDom);
-        logData_js_1.logger.saveJSON(flatNodes, `flat-dom-Mob-${request.stepCount}`);
-        const { results, indexMap } = this.searcher.searchBestMobile(flatNodes, request.keywords);
-        const grouped = this.relationshipBuilder.buildGroupedResultsMobile(results, flatNodes, indexMap, parentMap);
+    async mobileProcess(request) {
+        let grouped;
+        if (request.platform.toLowerCase() === "ios") {
+            const { flatNodes, parentMap, runtimeElements } = await this.simplifier.simplifyIosDom(request.rawDom, request.driver);
+            logData_js_1.logger.saveJSON(flatNodes, `flat-dom-ios-${request.stepCount}`);
+            const { results, indexMap } = await this.searcher.searchBestIos(flatNodes, request.keywords);
+            grouped = await this.relationshipBuilder.buildGroupedResultsIos(results, flatNodes, indexMap, parentMap, runtimeElements);
+        }
+        else {
+            const { flatNodes, parentMap } = await this.simplifier.simplifyAndroidDom(request.rawDom, request.stepAction, request.step);
+            logData_js_1.logger.saveJSON(flatNodes, `flat-dom-android-${request.stepCount}`);
+            const { results, indexMap } = await this.searcher.searchBestAndroid(flatNodes, request.keywords);
+            grouped = await this.relationshipBuilder.buildGroupedResultsAndroid(results, flatNodes, indexMap, parentMap);
+        }
         return grouped;
     }
 }

package/dist/domAnalysis/relativeElementsFromDom.d.ts

@@ -1,4 +1,5 @@
 export declare class DomRelationshipBuilder {
     build(nodes: any[]): any[];
-    buildGroupedResultsMobile(results: Record<string, any[]>, nodes: any[], indexMap: Record<string, number>, parentMap: Map<Element, Element | null>): any[][];
+    buildGroupedResultsAndroid(results: Record<string, any[]>, nodes: any[], indexMap: Record<string, number>, parentMap: Map<Element, Element | null>): any[][];
+    buildGroupedResultsIos(results: Record<string, any[]>, nodes: any[], indexMap: Record<string, number>, parentMap: Map<any, any>, runtimeElements: Record<number, any>): any[][];
 }

package/dist/domAnalysis/relativeElementsFromDom.js

@@ -61,7 +61,7 @@ class DomRelationshipBuilder {
         }
         return structured;
     }
-    buildGroupedResultsMobile(results, nodes, indexMap, parentMap) {
+    buildGroupedResultsAndroid(results, nodes, indexMap, parentMap) {
         const groupedResults = [];
         const usedNodes = new Set();
         const slim = (n) => {
@@ -193,5 +193,70 @@ class DomRelationshipBuilder {
         });
         return finalResults;
     }
+    buildGroupedResultsIos(results, nodes, indexMap, parentMap, runtimeElements) {
+        const grouped = new Map();
+        const slimIOS = (n) => {
+            const keys = [
+                "tag",
+                "FF-inspecter",
+                "value",
+                "name",
+                "label",
+                "class",
+                "pane-title",
+                "accessible",
+                "editable",
+                "enabled",
+                "traits"
+            ];
+            const out = {};
+            for (const k of keys) {
+                if (k in n)
+                    out[k] = n[k];
+            }
+            return out;
+        };
+        for (const matchedNodes of Object.values(results)) {
+            for (const node of matchedNodes) {
+                const ff = node["FF-inspecter"];
+                if (!ff || !(ff in indexMap))
+                    continue;
+                const item = nodes[indexMap[ff]];
+                const element = runtimeElements[item.id];
+                const parent = parentMap.get(element);
+                const parentKey = parent ? parent : ff;
+                if (!grouped.has(parentKey)) {
+                    grouped.set(parentKey, []);
+                }
+                grouped.get(parentKey).push(slimIOS(node));
+            }
+        }
+        const groupedResults = [];
+        for (const group of grouped.values()) {
+            const seenFF = new Set();
+            const uniqueGroup = [];
+            for (const node of group) {
+                const ff = node["FF-inspecter"];
+                if (!ff || seenFF.has(ff))
+                    continue;
+                seenFF.add(ff);
+                uniqueGroup.push(node);
+            }
+            if (uniqueGroup.length) {
+                groupedResults.push(uniqueGroup);
+            }
+        }
+        const ffNumber = (node) => {
+            const ff = node["FF-inspecter"] || "";
+            const parts = ff.split("-");
+            return parseInt(parts[parts.length - 1]) || 0;
+        };
+        groupedResults.sort((a, b) => {
+            const minA = Math.min(...a.map(ffNumber));
+            const minB = Math.min(...b.map(ffNumber));
+            return minA - minB;
+        });
+        return groupedResults;
+    }
 }
 exports.DomRelationshipBuilder = DomRelationshipBuilder;

package/dist/domAnalysis/searchBest.d.ts

@@ -1,7 +1,11 @@
 import { FlatNode } from "../core/interfaces/simplifyAndFlattenInterface";
 export declare class DomSearcher {
     search(nodes: FlatNode[], keywords: string[] | string, topN?: number, threshold?: number): any[];
-    searchBestMobile(nodes: FlatNode[], keywords: string[] | string, topN?: number, threshold?: number): {
+    searchBestAndroid(nodes: FlatNode[], keywords: string[] | string, topN?: number, threshold?: number): {
+        results: Record<string, any[]>;
+        indexMap: Record<string, number>;
+    };
+    searchBestIos(nodes: any[], keywords: string[] | string, topN?: number, threshold?: number): {
         results: Record<string, any[]>;
         indexMap: Record<string, number>;
     };

package/dist/domAnalysis/searchBest.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomSearcher = void 0;
+const fastest_levenshtein_1 = require("fastest-levenshtein");
 const fast_fuzzy_1 = require("fast-fuzzy");
+// import { logger } from "../utils/logger/logData";
 class DomSearcher {
     search(nodes, keywords, topN = 20, threshold = 40) {
         if (typeof keywords === "string") {
             keywords = keywords.replace(/[\[\]]/g, "");
             keywords = keywords.split(",").map(k => k.trim());
         }
-        keywords = keywords.map(k => k.replace(/[^a-zA-Z0-9\s]/g, " ").trim().toLowerCase());
+        keywords = keywords.map(k => (typeof k === "string" ? k : String(k))
+            .replace(/[^a-zA-Z0-9\s]/g, " ")
+            .trim()
+            .toLowerCase()
+            .replace(/\s+/g, ""));
         const ffNumber = (val) => {
             if (!val)
                 return 0;
@@ -51,31 +57,23 @@ class DomSearcher {
             }
         };
         const results = {};
+        const tempResults = {};
+        let hasAnyMatch = false;
         for (const kw of keywords) {
             const exact = [];
             const strong = [];
-            const fuzzyList = [];
             const tagMatches = [];
             for (let i = 0; i < nodes.length; i++) {
                 const node = nodes[i].node;
                 const searchText = (node.search || "").toLowerCase();
                 const tagName = (node.tag || "").toLowerCase();
-                let matched = false;
-                if (searchText == kw) {
+                if (searchText === kw) {
                     exact.push(i);
-                    matched = true;
                 }
                 if (searchText.includes(kw)) {
                     strong.push(i);
-                    matched = true;
                 }
-                if (!matched) {
-                    const score = (0, fast_fuzzy_1.fuzzy)(kw, searchText);
-                    if (score >= threshold / 100) {
-                        fuzzyList.push([score * 100, i]);
-                    }
-                }
-                if (kw == tagName || tagName.includes(kw)) {
+                if (kw === tagName || tagName.includes(kw)) {
                     tagMatches.push(i);
                 }
             }
@@ -90,7 +88,48 @@ class DomSearcher {
                 if (collected.length >= topN * 4)
                     break;
             }
-            if (collected.length < topN * 4) {
+            for (const idx of tagMatches) {
+                addWithContext(idx, collected);
+                if (collected.length >= topN * 4)
+                    break;
+            }
+            if (collected.length > 0) {
+                hasAnyMatch = true;
+            }
+            tempResults[kw] = collected;
+        }
+        if (!hasAnyMatch) {
+            for (const kw of keywords) {
+                const fuzzyList = [];
+                const tokens1 = Array.from(new Set(kw.toLowerCase().split(/\s+/)));
+                for (let i = 0; i < nodes.length; i++) {
+                    const node = nodes[i].node;
+                    const searchText = (node.search || "").toLowerCase();
+                    const tokens2 = searchText.split(/\s+/);
+                    // For each kw token, find best matching token in searchText
+                    const tokenScores = tokens1.map(t1 => {
+                        let best = 0;
+                        for (const t2 of tokens2) {
+                            if (t1 === t2) {
+                                best = 100;
+                                break;
+                            }
+                            const sim = (1 - (0, fastest_levenshtein_1.distance)(t1, t2) / Math.max(t1.length, t2.length))
+                                * 100;
+                            if (sim > best)
+                                best = sim;
+                        }
+                        return best;
+                    });
+                    const allMatched = tokenScores.every(s => s >= 50);
+                    if (!allMatched)
+                        continue;
+                    const score = tokenScores.reduce((a, b) => a + b, 0) / tokenScores.length;
+                    if (score >= threshold) {
+                        fuzzyList.push([score, i]);
+                    }
+                }
+                const collected = [];
                 fuzzyList
                     .sort((a, b) => b[0] - a[0])
                     .forEach(([_, idx]) => {
@@ -98,16 +137,14 @@ class DomSearcher {
                         addWithContext(idx, collected);
                     }
                 });
+                results[kw] = Array.from(new Set(collected)).map(i => nodes[i].node);
             }
-            if (collected.length < topN * 4) {
-                for (const idx of tagMatches) {
-                    addWithContext(idx, collected);
-                    if (collected.length >= topN * 4)
-                        break;
-                }
+        }
+        else {
+            for (const kw of keywords) {
+                const uniqueIdx = Array.from(new Set(tempResults[kw]));
+                results[kw] = uniqueIdx.map(i => nodes[i].node);
             }
-            const uniqueIdx = Array.from(new Set(collected));
-            results[kw] = uniqueIdx.map(i => nodes[i].node);
         }
         const seen = new Set();
         const unique = Object.values(results)
@@ -122,13 +159,13 @@ class DomSearcher {
         unique.sort((a, b) => ffNumber(a["FF-inspecter"]) - ffNumber(b["FF-inspecter"]));
         return unique;
     }
-    searchBestMobile(nodes, keywords, topN = 5, threshold = 60) {
+    searchBestAndroid(nodes, keywords, topN = 5, threshold = 40) {
         if (typeof keywords === "string") {
             keywords = keywords.replace(/[\[\]]/g, "")
                 .split(",")
                 .map(k => k.trim());
         }
-        keywords = keywords.map(k => String(k).toLowerCase());
+        keywords = keywords.map(k => String(k).toLowerCase().replace(/\s+/g, ""));
         const slim = (n) => {
             const allowed = [
                 "tag",
@@ -157,58 +194,124 @@ class DomSearcher {
                 indexMap[ff] = i;
         });
         const results = {};
+        const tempResults = {};
+        let hasAnyMatch = false;
         for (const kw of keywords) {
             const exact = [];
             const strong = [];
-            const fuzzyMatches = [];
             for (const item of nodes) {
                 const node = item.node;
                 const text = (item.search || "").toLowerCase();
-                const t = (node["text"] || "").toLowerCase();
-                const cd = (node["content-desc"] || "").toLowerCase();
-                const rid = (node["resource-id"] || "").toLowerCase();
                 const hint = (node["hint"] || "").toLowerCase();
                 // EXACT MATCH
-                if (text === kw ||
-                    t === kw ||
-                    cd === kw ||
-                    rid === kw ||
-                    hint === kw) {
+                if (text === kw || hint === kw) {
                     exact.push(node);
-                    continue;
                 }
-                // STRONG PARTIAL MATCH
-                if (text.includes(kw) ||
-                    t.includes(kw) ||
-                    cd.includes(kw) ||
-                    rid.includes(kw) ||
-                    hint.includes(kw)) {
+                // STRONG MATCH
+                else if (text.includes(kw) || hint.includes(kw)) {
                     strong.push(node);
-                    continue;
-                }
-                // FUZZY MATCH
-                const score = (0, fast_fuzzy_1.fuzzy)(kw, text) * 100;
-                if (score >= threshold) {
-                    fuzzyMatches.push([score, node]);
                 }
             }
-            let selected;
+            let selected = [];
             if (exact.length) {
                 selected = exact.slice(0, topN);
             }
             else if (strong.length) {
                 selected = strong.slice(0, topN);
             }
-            else {
+            if (selected.length > 0) {
+                hasAnyMatch = true;
+            }
+            tempResults[kw] = selected;
+        }
+        if (!hasAnyMatch) {
+            for (const kw of keywords) {
+                const fuzzyMatches = [];
+                for (const item of nodes) {
+                    const node = item.node;
+                    const text = (item.search || "").toLowerCase();
+                    const score = (0, fast_fuzzy_1.fuzzy)(kw, text) * 100;
+                    if (score >= threshold) {
+                        fuzzyMatches.push([score, node]);
+                    }
+                }
                 fuzzyMatches.sort((a, b) => b[0] - a[0]);
-                selected = fuzzyMatches.slice(0, topN).map(f => f[1]);
+                const selected = fuzzyMatches
+                    .slice(0, topN)
+                    .map(f => f[1]);
+                results[kw] = selected.map(slim);
+            }
+        }
+        else {
+            for (const kw of keywords) {
+                results[kw] = tempResults[kw].map(slim);
             }
-            results[kw] = selected.map(slim);
         }
         return {
             results,
             indexMap
         };
     }
+    searchBestIos(nodes, keywords, topN = 5, threshold = 40) {
+        if (typeof keywords === "string") {
+            keywords = keywords.replace(/[\[\]]/g, "")
+                .split(",")
+                .map(k => k.trim());
+        }
+        keywords = keywords.map(k => k.toLowerCase().replace(/\s+/g, ""));
+        const slim = (n) => {
+            const allowed = [
+                "tag", "FF-inspecter", "value", "name",
+                "label", "class", "pane-title",
+                "accessible", "editable", "enabled", "traits"
+            ];
+            const res = {};
+            for (const k of allowed)
+                if (k in n)
+                    res[k] = n[k];
+            return res;
+        };
+        const indexMap = {};
+        nodes.forEach((item, i) => {
+            const ff = item.node?.["FF-inspecter"];
+            if (ff)
+                indexMap[ff] = i;
+        });
+        const results = {};
+        for (const kw of keywords) {
+            const exact = [];
+            const strong = [];
+            const fuzzyMatches = [];
+            for (const item of nodes) {
+                const node = item.node || {};
+                const text = (item.search || "").toLowerCase();
+                const value = (node["value"] || "").toLowerCase();
+                const name = (node["name"] || "").toLowerCase();
+                const label = (node["label"] || "").toLowerCase();
+                if (text === kw || value === kw || name === kw || label === kw) {
+                    exact.push(node);
+                    continue;
+                }
+                if (text.includes(kw) || value.includes(kw) || name.includes(kw) || label.includes(kw)) {
+                    strong.push(node);
+                    continue;
+                }
+                const score = (0, fast_fuzzy_1.fuzzy)(kw, text) * 100;
+                if (score >= threshold)
+                    fuzzyMatches.push([score, node]);
+            }
+            let selected;
+            if (exact.length)
+                selected = exact.slice(0, topN);
+            else if (strong.length)
+                selected = strong.slice(0, topN);
+            else {
+                fuzzyMatches.sort((a, b) => b[0] - a[0]);
+                selected = fuzzyMatches.slice(0, topN).map(f => f[1]);
+            }
+            results[kw] = selected.map(slim);
+        }
+        return { results, indexMap };
+    }
 }
 exports.DomSearcher = DomSearcher;

package/dist/domAnalysis/simplifyAndFlatten.d.ts

@@ -1,5 +1,6 @@
-import { FlatNode, SimplifiedDomResult } from "../core/interfaces/simplifyAndFlattenInterface.js";
+import { FlatNode, SimplifiedDomResult, SimplifiedDomResultIos } from "../core/interfaces/simplifyAndFlattenInterface.js";
 export declare class DomSimplifier {
     simplify(rawDom: string): FlatNode[];
-    simplifyMobile(rawDom: string): SimplifiedDomResult;
+    simplifyAndroidDom(rawDom: string, stepAction: string, step: string): SimplifiedDomResult;
+    simplifyIosDom(rawDom: string, driver: WebdriverIO.Browser): Promise<SimplifiedDomResultIos>;
 }

package/dist/domAnalysis/simplifyAndFlatten.js

@@ -48,7 +48,7 @@ class DomSimplifier {
             if (!tag || tag === "meta")
                 return;
             const attribs = el.attribs ?? {};
-            if (tag !== "select" && tag !== "option") {
+            if (tag !== "select" && tag !== "option" && tag !== "mat-select" && tag !== "mat-option") {
                 if ((attribs["element-visibility"] === "hidden" ||
                     attribs["element-covered"] === "true")) {
                     return;
@@ -82,7 +82,7 @@ class DomSimplifier {
                 "style", "onclick", "onchange", "href",
                 "oninput", "onmouseover", "onfocus",
                 "ff-inspect", "element-visibility",
-                "element-pointer-events", "element-zindex", "element-covered"
+                "element-pointer-events", "element-zindex", "element-covered", "width", "height"
             ]);
             Object.entries(attribs).forEach(([key, val]) => {
                 if (!EXCLUDED_ATTRS.has(key.toLowerCase())) {
@@ -94,7 +94,7 @@ class DomSimplifier {
             // -----------------
             const parts = new Set();
             if (cleanText && cleanText.length <= 70) {
-                parts.add(cleanText.toLowerCase());
+                parts.add(cleanText.toLowerCase().replace(/\s+/g, ""));
             }
             const SEARCH_EXCLUDED = new Set([
                 "class", "style", "onclick", "onchange",
@@ -113,7 +113,7 @@ class DomSimplifier {
                     .trim()
                     .toLowerCase();
                 if (v)
-                    parts.add(v);
+                    parts.add(v.replace(/\s+/g, ""));
             });
             simplified["search"] = Array.from(parts).join(" ").trim();
             flatNodes.push({
@@ -123,7 +123,7 @@ class DomSimplifier {
         });
         return flatNodes;
     }
-    simplifyMobile(rawDom) {
+    simplifyAndroidDom(rawDom, stepAction, step) {
         const parser = new xmldom_1.DOMParser();
         const xmlDoc = parser.parseFromString(rawDom, "text/xml");
         const root = xmlDoc.documentElement;
@@ -181,7 +181,7 @@ class DomSimplifier {
             }
             const searchParts = [];
             if (simplified.text && simplified.text.trim()) {
-                searchParts.push(simplified.text);
+                searchParts.push(simplified.text.replace(/\s+/g, ""));
             }
             for (const key of [
                 "content-desc",
@@ -191,33 +191,126 @@ class DomSimplifier {
             ]) {
                 const val = simplified[key];
                 if (val && typeof val === "string" && val.trim()) {
-                    searchParts.push(val);
+                    searchParts.push(val.replace(/\s+/g, ""));
                 }
             }
             simplified["search"] = searchParts.join(" ").trim().toLowerCase();
-            if (!skipNode) {
+            if (stepAction === "verify" && (step.toLowerCase().includes("disable") || step.toLowerCase().includes("disabled"))) {
                 flatNodes.push({
                     node: simplified,
                     search: simplified["search"],
                     element: node._element
                 });
             }
-            const children = [];
-            for (const child of node.children || []) {
-                const simplifiedChild = simplifyAndFlatten(child);
-                if (simplifiedChild && simplifiedChild.enabled !== "false") {
-                    children.push(simplifiedChild);
+            else {
+                if (!skipNode) {
+                    flatNodes.push({
+                        node: simplified,
+                        search: simplified["search"],
+                        element: node._element
+                    });
                 }
             }
-            if (children.length) {
-                simplified["children"] = children;
+            for (const child of node.children || []) {
+                simplifyAndFlatten(child);
             }
-            return simplified;
         }
         simplifyAndFlatten(xmlTree);
         return {
             flatNodes, parentMap
         };
     }
+    async simplifyIosDom(rawDom, driver) {
+        const { width: screenWidth, height: screenHeight } = await driver.getWindowSize();
+        const parser = new xmldom_1.DOMParser();
+        const xmlDoc = parser.parseFromString(rawDom, "text/xml");
+        const root = xmlDoc.documentElement;
+        const flatNodes = [];
+        const runtimeElements = {};
+        const parentMap = new Map();
+        function xmlToTree(elem) {
+            const children = [];
+            for (let i = 0; i < elem.childNodes.length; i++) {
+                const child = elem.childNodes[i];
+                if (child.nodeType === 1) {
+                    const childElement = child;
+                    // store parent relationship
+                    parentMap.set(childElement, elem);
+                    children.push(xmlToTree(childElement));
+                }
+            }
+            const attributes = {};
+            for (let i = 0; i < elem.attributes.length; i++) {
+                const attr = elem.attributes[i];
+                attributes[attr.name] = attr.value;
+            }
+            return {
+                tag: elem.tagName,
+                attributes,
+                text: (elem.textContent || "").trim(),
+                _element: elem,
+                children
+            };
+        }
+        const xmlTree = xmlToTree(root);
+        function isOnScreen(x, y, w, h) {
+            return ((x + w) > 0 && x < screenWidth &&
+                (y + h) > 0 && y < screenHeight);
+        }
+        function simplifyAndFlatten(node) {
+            const attrs = node.attributes || {};
+            const x = parseInt(attrs["x"] || "0");
+            const y = parseInt(attrs["y"] || "0");
+            const w = parseInt(attrs["width"] || "0");
+            const h = parseInt(attrs["height"] || "0");
+            const skipNode = attrs["enabled"] === "false" ||
+                attrs["traits"] === "PlaysSound, KeyboardKey" ||
+                !isOnScreen(x, y, w, h);
+            const simplified = {};
+            simplified["tag"] = node.tag;
+            simplified["class"] = node.tag;
+            if (attrs["FF-inspecter"]) {
+                simplified["FF-inspecter"] = attrs["FF-inspecter"];
+            }
+            simplified["value"] = attrs["value"] || "";
+            const importantAttrs = [
+                "label", "name", "class", "accessible", "enabled", "traits"
+            ];
+            for (const attr of importantAttrs) {
+                if (attrs[attr]) {
+                    simplified[attr] = attrs[attr];
+                }
+            }
+            const searchParts = [];
+            if (simplified["value"]?.trim()) {
+                searchParts.push(simplified["value"].replace(/\s+/g, ""));
+            }
+            for (const key of ["name", "label"]) {
+                const val = simplified[key];
+                if (val?.trim()) {
+                    searchParts.push(val.replace(/\s+/g, ""));
+                }
+            }
+            simplified["search"] = searchParts.join(" ").toLowerCase();
+            if (!skipNode) {
+                const id = flatNodes.length;
+                flatNodes.push({
+                    node: simplified,
+                    search: simplified["search"],
+                    element: node._element
+                });
+                runtimeElements[id] = node._element;
+            }
+            for (const child of node.children || []) {
+                simplifyAndFlatten(child);
+            }
+        }
+        simplifyAndFlatten(xmlTree);
+        return {
+            flatNodes,
+            parentMap,
+            runtimeElements
+        };
+    }
 }
 exports.DomSimplifier = DomSimplifier;

package/dist/fireflinkData/fireflinkLocators/getListOfLocators.js

@@ -2,24 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElementGetter = void 0;
 const logData_js_1 = require("../../utils/logger/logData.js");
-const elementsFromHTML_js_1 = require("./elementsFromHTML.js");
+const getElementsFromHTML_js_1 = require("./parser/getElementsFromHTML.js");
+const platformContext_js_1 = require("../../utils/helpers/platformContext.js");
 class ElementGetter {
     async getFireFlinkElement(html, attribute) {
+        const platform = (0, platformContext_js_1.getPlatform)();
         const formattedAttribute = attribute.replace('[', '//*[@');
         try {
-            const result = (0, elementsFromHTML_js_1.getElementsFromHTML)([
-                {
-                    name: "xpath",
-                    type: "Static",
-                    value: formattedAttribute,
-                    reference: "local",
-                    status: "NOT_USED",
-                    isRecorded: "Y",
-                }
-            ], html);
+            // logger.info("formattedAttribute", formattedAttribute);
+            const result = (0, getElementsFromHTML_js_1.getElementsFromHTML)({
+                locators: [
+                    {
+                        name: "xpath",
+                        type: "Static",
+                        value: formattedAttribute,
+                        reference: "local",
+                        status: "NOT_USED",
+                        isRecorded: "Y",
+                    }
+                ]
+            }, html, platform);
             return Array.isArray(result) && result.length > 0 ? JSON.parse(JSON.stringify(result[0], null, 4)) : null;
         }
         catch (error) {
+            logData_js_1.logger.info("failed to get element from dom");
             logData_js_1.logger.error(`[${Object.getPrototypeOf(this).constructor.name}] : `, "Unable to find the element", error);
             return "";
         }