ff-automationv2 2.2.29 → 2.2.31

package/dist/fireflinkData/fireflinkLocators/parser/getElementsFromHTML.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getElementsFromHTML = void 0;
+exports.getAiElementsFromHTML = void 0;
 const xpath_js_1 = require("../utils/xpath.js");
 const cssSelector_js_1 = require("../utils/cssSelector.js");
 const jsdom_1 = require("jsdom");
 const xpathHelpers_js_1 = require("../utils/xpathHelpers.js");
+const domSanitizer_js_1 = require("../../../utils/helpers/domSanitizer.js");
 const logData_js_1 = require("../../../utils/logger/logData.js");
-const getElementFromCssSelector = (docmt, selector) => {
+const getAiElementFromCssSelector = (docmt, selector) => {
     try {
         const found = docmt.querySelector(selector);
         if (found)
@@ -16,12 +17,12 @@ const getElementFromCssSelector = (docmt, selector) => {
         console.error("Invalid CSS selector:", selector, error);
         return null;
     }
-    return getElementFromShadowRoot(docmt.body, selector);
+    return getAiElementFromShadowRoot(docmt.body, selector);
 };
-const isCssSelectorLocator = (locator) => {
+const isAiCssSelectorLocator = (locator) => {
     return locator.name?.toLowerCase().includes("cssselector") ?? false;
 };
-const getElementFromShadowRoot = (el, selector) => {
+const getAiElementFromShadowRoot = (el, selector) => {
     const shadowRoot = el.shadowRoot;
     if (shadowRoot && !selector.includes("dynamic")) {
         return shadowRoot.querySelector(selector);
@@ -32,7 +33,7 @@ const getElementFromShadowRoot = (el, selector) => {
             if (elements[i].shadowRoot) {
                 const { shadowRoot } = elements[i];
                 if (shadowRoot) {
-                    const nestedElement = getElementFromShadowRoot(shadowRoot, selector);
+                    const nestedElement = getAiElementFromShadowRoot(shadowRoot, selector);
                     if (nestedElement) {
                         return nestedElement;
                     }
@@ -48,32 +49,32 @@ const getElementFromShadowRoot = (el, selector) => {
     }
     return null;
 };
-const getId = (element) => {
+const getaiId = (element) => {
     return element?.id || null;
 };
-const getClassName = (element) => {
-    if (element instanceof element.ownerDocument.defaultView.SVGElement) {
+const getAiClassName = (element) => {
+    const svgClass = element.ownerDocument?.defaultView?.SVGElement;
+    if (svgClass && element instanceof svgClass) {
         const cls = element.className;
         if (typeof cls === "string") {
             return cls;
         }
         return cls?.baseVal || null;
     }
-    return element.className || null;
+    return element.getAttribute("class") || element.className || null;
 };
-const getVisibleText = (element) => {
+const getAiVisibleText = (element) => {
     return element.textContent?.trim() || null;
 };
-const getName = (element) => {
-    const elementEl = element;
-    if (elementEl.hasAttribute("name")) {
-        const attrValue = elementEl.getAttribute("name");
+const getAiName = (element) => {
+    if (element.hasAttribute("name")) {
+        const attrValue = element.getAttribute("name");
         const name = `${attrValue}`;
         return name || null;
     }
     return null;
 };
-const relations = [
+const aiRelations = [
     "/preceding-sibling",
     "/following-sibling",
     "/parent",
@@ -85,26 +86,23 @@ const relations = [
     "/preceding",
     "/following"
 ];
-function getElementFromXPath(docmt, xpath, platform) {
+function getAiElementFromXPath(docmt, xpath, platform) {
     if (platform !== "web") {
         const ffMatch = xpath.match(/^\/\/\*\[@FF-inspecter="([^"]+)"\]$/);
         if (ffMatch) {
             return docmt.querySelector(`[FF-inspecter="${ffMatch[1]}"]`);
         }
     }
-    return (0, xpathHelpers_js_1.evaluateXPath)(xpath, docmt, "first").singleNodeValue;
+    return (0, xpathHelpers_js_1.evaluateAiXPath)(xpath, docmt, "first").singleNodeValue;
 }
-function checkReferenceElementIsValid(locator, relation, docmt) {
+function checkAiReferenceElementIsValid(locator, relation, docmt) {
     if (locator.includes(relation)) {
         const locatotSplitArray = locator.split(relation);
         const sourceLoc = locatotSplitArray[0].trim();
-        const window = docmt.defaultView;
-        if (!window)
-            return null;
         if (!locator.includes("dynamic")) {
-            const sourceElement = (0, xpathHelpers_js_1.evaluateXPath)(sourceLoc, docmt, "first").singleNodeValue;
+            const sourceElement = (0, xpathHelpers_js_1.evaluateAiXPath)(sourceLoc, docmt, "first").singleNodeValue;
             if (sourceElement) {
-                const completeElement = (0, xpathHelpers_js_1.evaluateXPath)(locator, docmt, "first").singleNodeValue;
+                const completeElement = (0, xpathHelpers_js_1.evaluateAiXPath)(locator, docmt, "first").singleNodeValue;
                 let relativeXpath;
                 if (completeElement) {
                     relativeXpath = locator;
@@ -123,12 +121,12 @@ function checkReferenceElementIsValid(locator, relation, docmt) {
     }
     return null;
 }
-const getElementsFromHTML = (record, htmlString, platform) => {
+const getAiElementsFromHTML = (record, htmlString, platform) => {
     const virtualConsole = new jsdom_1.VirtualConsole();
     let docmt;
     if (platform === "web") {
         try {
-            const dom = new jsdom_1.JSDOM(htmlString, {
+            const dom = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(htmlString), {
                 resources: "usable",
                 runScripts: "outside-only",
                 pretendToBeVisual: true,
@@ -138,7 +136,7 @@ const getElementsFromHTML = (record, htmlString, platform) => {
             docmt = dom.window.document;
         }
         catch (e) {
-            logData_js_1.logger.error("Unable to parse XML : ", e.message);
+            logData_js_1.logger.error("Unable to parse HTML : ", e.message);
             return null;
         }
     }
@@ -155,15 +153,15 @@ const getElementsFromHTML = (record, htmlString, platform) => {
             return null;
         }
     }
-    const elementsToRemove = docmt.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source");
-    if (elementsToRemove) {
-        elementsToRemove.forEach((tag) => {
+    const aiElementsToRemove = docmt.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source");
+    if (aiElementsToRemove) {
+        aiElementsToRemove.forEach((tag) => {
             tag.remove();
         });
     }
-    const finalLocatorsSet = new Set();
+    const finalAiLocatorsSet = new Set();
     const finalLocators = [];
-    function createLocator(base, overrides = {}) {
+    function createAiLocator(base, overrides = {}) {
         const newLocator = {
             name: overrides.name ?? base?.name,
             type: overrides.type ?? base?.type,
@@ -172,12 +170,12 @@ const getElementsFromHTML = (record, htmlString, platform) => {
             status: overrides.status ?? base?.status,
             isRecorded: overrides.isRecorded ?? base?.isRecorded
         };
-        newLocator.isSelfHealed = "Y";
-        pushUniqueLocator(newLocator);
+        newLocator.isAiRecorded = "Y";
+        pushAiUniqueLocator(newLocator);
     }
-    function resolveElement(ctx, locator, selector) {
-        if (isCssSelectorLocator(locator)) {
-            return getElementFromCssSelector(ctx, selector);
+    function resolveAiElement(ctx, locator, selector) {
+        if (isAiCssSelectorLocator(locator)) {
+            return getAiElementFromCssSelector(ctx, selector);
         }
         else if (locator.name.includes("id") || selector.startsWith("#")) {
             return ctx.querySelector("#" + (0, xpathHelpers_js_1.escapeAttrValue)(selector));
@@ -200,11 +198,11 @@ const getElementsFromHTML = (record, htmlString, platform) => {
         }
         else if ((locator.name.includes("xpath") || selector.startsWith("//")) &&
             !locator.type.match("dynamic")) {
-            const el = getElementFromXPath(ctx, selector, platform);
+            const el = getAiElementFromXPath(ctx, selector, platform);
             if (el) {
-                createLocator(locator, {
+                createAiLocator(locator, {
                     value: selector,
-                    isRecorded: String(locator.isRecorded).includes("N") ? "N" : "Y"
+                    isRecorded: "N"
                 });
             }
             return el;
@@ -213,14 +211,14 @@ const getElementsFromHTML = (record, htmlString, platform) => {
             return ctx.querySelector(selector);
         }
     }
-    function findInIframes(docmt, locator, selector) {
+    function aiFindInIframes(docmt, locator, selector) {
         const iframes = docmt.querySelectorAll("iframe");
         for (const iframe of iframes) {
             try {
                 const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
                 if (!iframeDoc)
                     continue;
-                const el = resolveElement(iframeDoc, locator, selector);
+                const el = resolveAiElement(iframeDoc, locator, selector);
                 if (el)
                     return el;
             }
@@ -230,15 +228,15 @@ const getElementsFromHTML = (record, htmlString, platform) => {
         }
         return null;
     }
-    function pushUniqueLocator(obj) {
+    function pushAiUniqueLocator(obj) {
         const key = `${obj.name}:${obj.value}`;
-        if (!finalLocatorsSet.has(key)) {
-            finalLocatorsSet.add(key);
+        if (!finalAiLocatorsSet.has(key)) {
+            finalAiLocatorsSet.add(key);
             finalLocators.push(obj);
         }
     }
     /** Locator Value Cleaner (Handles Special Scenarios) **/
-    const cleanLocatorValue = (val, type, isRecorded) => {
+    const cleanAiLocatorValue = (val, type) => {
         if (!val)
             return null;
         if (val.toLowerCase().includes('ff-inspecter') || val.toLowerCase().includes('ff-inspect')) {
@@ -266,7 +264,7 @@ const getElementsFromHTML = (record, htmlString, platform) => {
         if (type === "id" || type === "name") {
             cleaned = cleaned.replace(/['"]/g, "").trim();
         }
-        if (platform === "web" && type === "xpath" && isRecorded === "Y" && !val.startsWith("//"))
+        if (platform === "web" && type === "xpath" && !val.startsWith("//"))
             return null;
         // Final check for empty strings
         if (!cleaned || /^['"]{2}$/.test(cleaned))
@@ -278,7 +276,7 @@ const getElementsFromHTML = (record, htmlString, platform) => {
             const recordedNLocators = record.locators.filter((l) => l.isRecorded === "N");
             if (recordedNLocators.length > 0) {
                 for (const locator of recordedNLocators) {
-                    createLocator(locator);
+                    createAiLocator(locator);
                 }
             }
             const isDynamic = String(locator.value || locator.type || "");
@@ -286,7 +284,7 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                 isDynamic.match("dynamic") ||
                 isDynamic.includes("{") ||
                 isDynamic.includes("}")) {
-                createLocator(locator);
+                createAiLocator(locator);
                 continue;
             }
             // if (record.isShared.includes("Y")) {
@@ -302,110 +300,110 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                     }
                     const trimmedSelector = selector.trim();
                     //normal DOM
-                    targetElement = resolveElement(docmt, locator, trimmedSelector);
+                    targetElement = resolveAiElement(docmt, locator, trimmedSelector);
                     //iframe (if not found)
                     if (!targetElement && platform === "web") {
-                        targetElement = findInIframes(docmt, locator, trimmedSelector);
+                        targetElement = aiFindInIframes(docmt, locator, trimmedSelector);
                     }
                     //shadow DOM (if still not found)
                     if (!targetElement && platform === "web") {
-                        targetElement = getElementFromShadowRoot(docmt.body, trimmedSelector);
+                        targetElement = getAiElementFromShadowRoot(docmt.body, trimmedSelector);
                     }
                     if (!targetElement) {
                         console.warn("Locator failed:", trimmedSelector);
                         continue locators;
                     }
                 }
-                const locatorExists = (name, value) => {
+                const locatorAiExists = (name, value) => {
                     const key = `${name}:${value}`;
-                    return finalLocatorsSet.has(key);
+                    return finalAiLocatorsSet.has(key);
                 };
                 if (targetElement) {
                     const excludedAttributes = [];
-                    const idValue = getId(targetElement);
+                    const idValue = getaiId(targetElement);
                     const ffXpath = targetElement.getAttribute("ff-xpath");
                     if (idValue &&
-                        !locatorExists("id", idValue) &&
-                        !(0, xpathHelpers_js_1.isNumberExist)(idValue)) {
+                        !locatorAiExists("id", idValue) &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(idValue)) {
                         const prevId = record.locators.find((l) => l.name === "id");
-                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "id", idValue, targetElement)) {
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "id", idValue, targetElement)) {
                             excludedAttributes.push("id");
-                            createLocator(prevId, {
+                            createAiLocator(prevId, {
                                 name: "id",
                                 type: "static",
-                                isRecorded: "Y",
+                                isRecorded: "N",
                                 value: idValue
                             });
                         }
                     }
                     const tagName = targetElement.tagName;
-                    if (tagName && !locatorExists("tagName", tagName)) {
+                    if (tagName && platform === "web" && !locatorAiExists("tagName", tagName)) {
                         const prevTag = record.locators.find((l) => l.name === "tagName");
-                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "tagName", tagName, targetElement)) {
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "tagName", tagName, targetElement)) {
                             excludedAttributes.push("tagName");
-                            createLocator(prevTag, {
+                            createAiLocator(prevTag, {
                                 name: "tagName",
                                 type: "static",
-                                isRecorded: "Y",
+                                isRecorded: "N",
                                 value: tagName
                             });
                         }
                     }
-                    const textValue = getVisibleText(targetElement);
+                    const textValue = getAiVisibleText(targetElement);
                     if (targetElement.tagName.toLowerCase() === "a" &&
                         textValue &&
-                        !(0, xpathHelpers_js_1.isNumberExist)(textValue)) {
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(textValue)) {
                         const prevLinkText = record.locators.find((l) => l.name === "linkText");
-                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "linkText", textValue, targetElement)) {
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "linkText", textValue, targetElement)) {
                             excludedAttributes.push("linkText");
-                            createLocator(prevLinkText, {
+                            createAiLocator(prevLinkText, {
                                 name: "linkText",
                                 type: "static",
-                                isRecorded: "Y",
+                                isRecorded: "N",
                                 value: textValue
                             });
                         }
                     }
-                    const nameLocator = getName(targetElement);
+                    const nameLocator = getAiName(targetElement);
                     if (nameLocator &&
-                        !locatorExists("name", nameLocator) &&
-                        !(0, xpathHelpers_js_1.isNumberExist)(nameLocator)) {
+                        !locatorAiExists("name", nameLocator) &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(nameLocator)) {
                         const prevName = record.locators.find((l) => l.name === "name");
-                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "name", nameLocator, targetElement)) {
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "name", nameLocator, targetElement)) {
                             excludedAttributes.push("name");
-                            createLocator(prevName, {
+                            createAiLocator(prevName, {
                                 name: "name",
                                 type: "static",
-                                isRecorded: "Y",
+                                isRecorded: "N",
                                 value: nameLocator
                             });
                         }
                     }
-                    const classValue = getClassName(targetElement);
+                    const classValue = getAiClassName(targetElement);
                     if (classValue &&
                         classValue.trim() !== "" &&
                         !classValue.includes(" ") &&
-                        !locatorExists("className", classValue) &&
-                        !(0, xpathHelpers_js_1.isNumberExist)(classValue)) {
+                        !locatorAiExists("className", classValue) &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(classValue)) {
                         const prevClassLocator = record.locators.find((l) => l.name === "className");
-                        if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "className", classValue, targetElement)) {
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "className", classValue, targetElement)) {
                             excludedAttributes.push("className");
-                            createLocator(prevClassLocator, {
+                            createAiLocator(prevClassLocator, {
                                 name: "className",
                                 type: "static",
-                                isRecorded: "Y",
+                                isRecorded: "N",
                                 value: classValue
                             });
                         }
                     }
-                    (0, cssSelector_js_1.parseCssSelectors)(targetElement, "single").forEach((cssSelector) => {
+                    (0, cssSelector_js_1.parseAiCssSelectors)(targetElement, "single").forEach((cssSelector) => {
                         if (cssSelector.value &&
-                            !locatorExists("cssSelector", cssSelector.value)) {
-                            createLocator(undefined, {
+                            !locatorAiExists("cssSelector", cssSelector.value)) {
+                            createAiLocator(undefined, {
                                 name: "cssSelector",
                                 value: cssSelector.value,
                                 type: "static",
-                                isRecorded: "Y"
+                                isRecorded: "N"
                             });
                         }
                     });
@@ -415,7 +413,7 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                     let xpathResults = [];
                     try {
                         xpathResults =
-                            (0, xpath_js_1.parseDOM)(targetElement, docmt, false, true, includedAttributes, [], platform) ??
+                            (0, xpath_js_1.aiParseDOM)(targetElement, docmt, true, includedAttributes, platform) ??
                                 [];
                     }
                     catch (error) {
@@ -428,27 +426,35 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                         if (!result.value)
                             return;
                         if (result.key === "iosClassChain") {
-                            createLocator(undefined, {
-                                name: "class Chain",
+                            createAiLocator(undefined, {
+                                name: "iOSClassChain",
                                 value: result.value,
                                 type: "static",
-                                isRecorded: "Y"
+                                isRecorded: "N"
                             });
                         }
                         else if (result.key === "iosPredicateString") {
-                            createLocator(undefined, {
-                                name: "predicate String",
+                            createAiLocator(undefined, {
+                                name: "iOSNsPredicateString",
                                 value: result.value,
                                 type: "static",
-                                isRecorded: "Y"
+                                isRecorded: "N"
                             });
                         }
+                        // else if (result.key === "iosAccessibilityID") {
+                        //   createAiLocator(undefined, {
+                        //     name: "accessibilityId",
+                        //     value: result.value,
+                        //     type: "static",
+                        //     isRecorded: "N"
+                        //   });
+                        // }
                         else {
-                            createLocator(undefined, {
+                            createAiLocator(undefined, {
                                 name: "xpath",
                                 value: result.value,
                                 type: "static",
-                                isRecorded: "Y"
+                                isRecorded: "N"
                             });
                         }
                     });
@@ -456,17 +462,14 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                         for (const loc of record.locators) {
                             if (!loc.value)
                                 continue;
-                            for (const relation of relations) {
+                            for (const relation of aiRelations) {
                                 if (loc.value.includes(relation)) {
-                                    const relativeXpath = checkReferenceElementIsValid(loc.value, relation, docmt);
+                                    const relativeXpath = checkAiReferenceElementIsValid(loc.value, relation, docmt);
                                     if (relativeXpath) {
-                                        createLocator(loc, {
+                                        createAiLocator(loc, {
                                             name: "xpath",
                                             value: relativeXpath,
-                                            isRecorded: loc.isRecorded !== "" &&
-                                                locator.isRecorded !== null
-                                                ? locator.isRecorded
-                                                : "Y"
+                                            isRecorded: "N"
                                         });
                                         break;
                                     }
@@ -479,14 +482,14 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                     }
                     if (finalLocators.length < 5) {
                         const fallbackCandidates = [
-                            { name: "id", value: getId(targetElement) },
-                            { name: "name", value: getName(targetElement) },
-                            { name: "className", value: getClassName(targetElement) },
+                            { name: "id", value: getaiId(targetElement) },
+                            { name: "name", value: getAiName(targetElement) },
+                            { name: "className", value: getAiClassName(targetElement) },
                             { name: "tagName", value: targetElement.tagName },
                             {
                                 name: "linkText",
                                 value: targetElement.tagName.toLowerCase() === "a"
-                                    ? getVisibleText(targetElement)
+                                    ? getAiVisibleText(targetElement)
                                     : null
                             }
                         ];
@@ -496,46 +499,59 @@ const getElementsFromHTML = (record, htmlString, platform) => {
                             const { name, value } = candidate;
                             if (!value)
                                 continue;
-                            if ((0, xpathHelpers_js_1.isNumberExist)(value))
+                            if ((0, xpathHelpers_js_1.isAiNumberExist)(value))
                                 continue;
                             if (name === "className" && value.includes(" "))
                                 continue;
-                            if ((0, xpathHelpers_js_1.isUniqueInDOM)(docmt, name, value, targetElement)) {
-                                createLocator(undefined, {
+                            if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, name, value, targetElement)) {
+                                createAiLocator(undefined, {
                                     name,
                                     type: "static",
                                     value,
-                                    isRecorded: "Y",
-                                    isSelfHealed: "Y"
+                                    isRecorded: "N",
+                                    isAiRecorded: "Y"
                                 });
                             }
                         }
                         if (finalLocators.length < 5) {
-                            (0, cssSelector_js_1.parseCssSelectors)(targetElement, "multiple").forEach((cssSelector) => {
+                            (0, cssSelector_js_1.parseAiCssSelectors)(targetElement, "multiple").forEach((cssSelector) => {
                                 if (finalLocators.length > 4)
                                     return;
                                 if (!cssSelector.value)
                                     return;
-                                if (!(0, xpathHelpers_js_1.isUniqueInDOM)(docmt, "cssSelector", cssSelector.value, targetElement)) {
+                                if (!(0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "cssSelector", cssSelector.value, targetElement)) {
                                     return;
                                 }
-                                createLocator(undefined, {
+                                createAiLocator(undefined, {
                                     name: "cssSelector",
                                     type: "static",
                                     value: cssSelector.value,
-                                    isRecorded: "Y",
-                                    isSelfHealed: "Y"
+                                    isRecorded: "N",
+                                    isAiRecorded: "Y"
                                 });
                             });
                         }
                     }
                     const finalAutoHealedLocators = finalLocators.map((obj) => ({
                         ...obj,
-                        value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded)
+                        value: cleanAiLocatorValue(obj.value, obj.name)
                     }));
+                    const getLocatorPriority = (name) => {
+                        const lower = (name || "").toLowerCase();
+                        if (lower === "id")
+                            return 1;
+                        if (lower === "name")
+                            return 2;
+                        if (lower === "xpath")
+                            return 3;
+                        return 4;
+                    };
+                    const validLocators = finalAutoHealedLocators
+                        .filter((locator) => locator?.value != null && locator.value !== "")
+                        .sort((a, b) => getLocatorPriority(a.name) - getLocatorPriority(b.name));
                     const jsonResult = [
                         {
-                            locators: finalAutoHealedLocators.filter((locator) => locator?.value != null && locator.value !== ""),
+                            locators: validLocators,
                             // isShared: `${record.isShared}`,
                         }
                     ];
@@ -554,4 +570,4 @@ const getElementsFromHTML = (record, htmlString, platform) => {
     }
     return null;
 };
-exports.getElementsFromHTML = getElementsFromHTML;
+exports.getAiElementsFromHTML = getAiElementsFromHTML;

package/dist/fireflinkData/fireflinkLocators/types/locator.d.ts

@@ -5,7 +5,7 @@ export interface Locator {
     reference: string;
     status: string;
     isRecorded: string;
-    isSelfHealed?: string;
+    isAiRecorded?: string;
 }
 export interface ElementRecord {
     locators: Locator[];
@@ -15,3 +15,13 @@ export type XPathEntry = {
     key: string;
     value: string;
 };
+export interface AiDomContext {
+    tag: string;
+    attributes: Attr[];
+    normalizedText: string;
+    filteredText: string;
+    parent: Element | null;
+    ancestors: Element[];
+    previousSiblings: Element[];
+    nextSiblings: Element[];
+}

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

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