ff-dom 1.0.16 → 1.0.17

package/src/utils/getElementsFromHTML.ts

@@ -1,5 +1,4 @@
-//@ts-nocheck
-import { JSDOM, VirtualConsole } from "jsdom";
+import { JSDOM, VirtualConsole } from 'jsdom';
 
 type ElementDetails = {
   id?: string | null;
@@ -25,7 +24,7 @@ const getElementFromShadowRoot = (
   selector: string
 ): Element | null => {
   const shadowRoot = (element as HTMLElement).shadowRoot;
-  if (shadowRoot && !selector.includes("dynamic")) {
+  if (shadowRoot && !selector.includes('dynamic')) {
     return shadowRoot.querySelector(selector);
   }
   return null;
@@ -33,8 +32,8 @@ const getElementFromShadowRoot = (
 
 const isSVGElement = (element: Element): boolean => {
   return (
-    typeof window !== "undefined" &&
-    typeof SVGElement !== "undefined" &&
+    typeof window !== 'undefined' &&
+    typeof SVGElement !== 'undefined' &&
     element instanceof SVGElement
   );
 };
@@ -44,13 +43,7 @@ const getXPath = (element: Element, xpath: string): string | null => {
   if (!window) return null;
 
   const xpathEvaluator = new window.XPathEvaluator();
-  const xpathResult = xpathEvaluator.evaluate(
-    xpath,
-    element.ownerDocument,
-    null,
-    window.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
-    null
-  );
+  const xpathResult = xpathEvaluator.evaluate(xpath, element.ownerDocument, null, window.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
 
   return isUnique(xpathResult) ? xpath : null;
 };
@@ -99,24 +92,22 @@ const getXpathByName = (element: Element): string | null => {
   const selector = element.nodeName.toLowerCase();
   const elementEl = element as HTMLElement;
 
-  if (elementEl.hasAttribute("name")) {
-    const attrValue = elementEl.getAttribute("name");
+  if (elementEl.hasAttribute('name')) {
+    const attrValue = elementEl.getAttribute('name');
     const xpath = `//${selector}[@name='${attrValue}']`;
     return getXPath(element, xpath) || null;
   }
-
   return null;
 };
 
 const getName = (element: Element): string | null => {
   const elementEl = element as HTMLElement;
 
-  if (elementEl.hasAttribute("name")) {
-    const attrValue = elementEl.getAttribute("name");
+  if (elementEl.hasAttribute('name')) {
+    const attrValue = elementEl.getAttribute('name');
     const name = `${attrValue}`;
     return name || null;
   }
-
   return null;
 };
 
@@ -124,12 +115,11 @@ const getXpathByPlaceholder = (element: Element): string | null => {
   const selector = element.nodeName.toLowerCase();
   const elementEl = element as HTMLElement;
 
-  if (elementEl.hasAttribute("placeholder")) {
-    const attrValue = elementEl.getAttribute("placeholder");
+  if (elementEl.hasAttribute('placeholder')) {
+    const attrValue = elementEl.getAttribute('placeholder');
     const xpath = `//${selector}[@placeholder='${attrValue}']`;
     return getXPath(element, xpath) || null;
   }
-
   return null;
 };
 
@@ -137,12 +127,11 @@ const getXpathByType = (element: Element): string | null => {
   const selector = element.nodeName.toLowerCase();
   const elementEl = element as HTMLElement;
 
-  if (elementEl.hasAttribute("type")) {
-    const attrValue = elementEl.getAttribute("type");
+  if (elementEl.hasAttribute('type')) {
+    const attrValue = elementEl.getAttribute('type');
     const xpath = `//${selector}[@type='${attrValue}']`;
     return getXPath(element, xpath) || null;
   }
-
   return null;
 };
 
@@ -166,33 +155,33 @@ const getXPathAbsolute = (element: Element): string => {
     path.unshift(selector);
     element = element.parentNode as Element;
   }
-  return "//" + path.join("/");
+  return '//' + path.join('/');
 };
 
 const relations: string[] = [
-  "/preceding-sibling",
-  "/following-sibling",
-  "/parent",
-  "/descendant",
-  "/ancestor",
-  "/self",
-  "/ancestor-or-self",
-  "/child",
-  "/preceding",
-  "/following",
+  '/preceding-sibling',
+  '/following-sibling',
+  '/parent',
+  '/descendant',
+  '/ancestor',
+  '/self',
+  '/ancestor-or-self',
+  '/child',
+  '/preceding',
+  '/following',
 ];
 
 const normalizeXPath = (xpath: string): string => {
+  // Replace text() comparisons like text() = 'something' with normalize-space(.) = 'something'
+  // to avoid issues with whitespace differences
   xpath = xpath.replace(/text\(\)\s*=\s*['"](.+?)['"]/g, "normalize-space(.)='$1'");
-  xpath = xpath.replace(/\.\s*=\s*['"](.+?)['"]/g, "normalize-space(.)='$1'");
 
+  // Replace direct . = 'something' comparisons with normalize-space(.) = 'something' for consistent text matching
+  xpath = xpath.replace(/\.\s*=\s*['"](.+?)['"]/g, "normalize-space(.)='$1'");
   return xpath;
 };
 
-function getElementFromXPath(
-  tempDiv: HTMLElement,
-  xpath: string
-): Element | null {
+function getElementFromXPath(tempDiv: HTMLElement, xpath: string): Element | null {
   let currentElement: Element | null = tempDiv;
   const window = currentElement.ownerDocument.defaultView;
   if (!window) return null;
@@ -208,18 +197,14 @@ function getElementFromXPath(
   return xpathResult.singleNodeValue as Element | null;
 }
 
-function checkReferenceElementIsValid(
-  locator: string,
-  relation: string,
-  tempDiv: HTMLElement
-): string | null {
+function checkReferenceElementIsValid(locator: string, relation: string, tempDiv: HTMLElement): string | null {
   if (locator.includes(relation)) {
     const locatotSplitArray: string[] = locator.split(relation);
     const sourceLoc = locatotSplitArray[0].trim();
     let currentElement: Element | null = tempDiv;
     const window = currentElement.ownerDocument.defaultView;
     if (!window) return null;
-    if (!locator.includes("dynamic")) {
+    if (!locator.includes('dynamic')) {
       const xpathEvaluator = new window.XPathEvaluator();
       const xpathResult = xpathEvaluator.evaluate(
         sourceLoc,
@@ -244,12 +229,12 @@ function checkReferenceElementIsValid(
           relativeXpath = locator;
           return relativeXpath;
         } else {
-          console.error("Complete Locator is Invalid:", locator);
+          console.error('Complete Locator is Invalid:', locator);
           relativeXpath = locator;
           return relativeXpath;
         }
       } else {
-        console.error("Source Locator Not Found:", sourceLoc);
+        console.error('Source Locator Not Found:', sourceLoc);
       }
     }
   }
@@ -262,6 +247,7 @@ interface Locator {
   reference: string;
   status: string;
   isRecorded: string;
+  isSelfHealed?: string;
 }
 
 const getElementsFromHTML = (
@@ -284,8 +270,8 @@ const getElementsFromHTML = (
 ): ElementDetails | null => {
   const virtualConsole = new VirtualConsole();
   const dom = new JSDOM(htmlString, {
-    resources: "usable",
-    runScripts: "outside-only", // Prevents inline script execution in JSDOM
+    resources: 'usable',
+    runScripts: 'outside-only', // Prevents inline script execution in JSDOM
     pretendToBeVisual: true,
     virtualConsole,
     includeNodeLocations: true,
@@ -293,10 +279,8 @@ const getElementsFromHTML = (
 
   const document = dom.window.document;
   global.SVGElement = dom.window.SVGElement;
-  const tempDiv = document.createElement("div");
-  const elementsToRemove = document.querySelectorAll(
-    "script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg"
-  );
+  const tempDiv = document.createElement('div');
+  const elementsToRemove = document.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg");
 
   if (elementsToRemove) {
     elementsToRemove.forEach((tag) => {
@@ -305,52 +289,101 @@ const getElementsFromHTML = (
   }
 
   tempDiv.innerHTML = document.body.innerHTML;
-  let finalLocators = [];
+  const finalLocatorsSet: Set<string> = new Set();
+  let finalLocators: any[] = [];
+
+  function createLocator(base: any, overrides: Partial<any> = {}) {
+    const newLocator: any = {
+      name: overrides.name ?? base?.name,
+      type: overrides.type ?? base?.type,
+      value: overrides.value ?? base?.value,
+      reference: overrides.reference ?? base?.reference,
+      status: overrides.status ?? base?.status,
+      isRecorded: overrides.isRecorded ?? base?.isRecorded,
+    };
+
+      if (overrides.hasOwnProperty('isSelfHealed')) {
+        newLocator.isSelfHealed = overrides.isSelfHealed;
+      } else if (base?.hasOwnProperty('isSelfHealed')) {
+        newLocator.isSelfHealed = base.isSelfHealed;
+      }
+
+    pushUniqueLocator(newLocator);
+  }
+
+  function pushUniqueLocator(obj: any) {
+    const key = `${obj.name}:${obj.value}`;
+    if (!finalLocatorsSet.has(key)) {
+      finalLocatorsSet.add(key);
+      finalLocators.push(obj);
+    }
+  }
+
+  /** Locator Value Cleaner (Handles Special Scenarios) **/
+  const cleanLocatorValue = (val: string | null | undefined, type?: string, isRecorded?: string): string | null => {
+    if (!val) return null;
+
+    let cleaned = val.trim();
+
+    // Return null for empty or literal "null"
+    if (!cleaned || cleaned.toLowerCase() === 'null') return null;
+
+    // Unescape any escaped quotes
+    cleaned = cleaned.replace(/\\"/g, '"').replace(/\\'/g, "'");
+
+    // Remove surrounding single or double quotes
+    cleaned = cleaned.replace(/^['"](.+?)['"]$/, '$1');
+
+    // Replace double single quotes with a single quote inside XPath
+    cleaned = cleaned.replace(/''/g, "'");
+
+    // Normalize double quotes in XPath attribute selectors [@id="" -> [@id='']
+    cleaned = cleaned.replace(
+      /\[@(id|name)=['"]{2}(.+?)['"]{2}\]/g,
+      "[@$1='$2']"
+    );
+
+    // For DOM selectors (id or name), remove ALL quotes
+    if (type === 'id' || type === 'name') {
+      cleaned = cleaned.replace(/['"]/g, '').trim();
+    }
+
+    if(type === 'xpath' && isRecorded === 'Y' && !val.startsWith('//')) return null;
+
+    // Final check for empty strings
+    if (!cleaned || /^['"]{2}$/.test(cleaned)) return null;
+
+    return cleaned;
+  };
 
   locators: for (const locator of locators) {
     try {
-      const isRecorded = String(locator.isRecorded || "");
-      const recordedNLocators = locators.filter((l) => l.isRecorded === "N");
+      const isRecorded = String(locator.isRecorded || '');
+      const recordedNLocators = locators.filter((l) => l.isRecorded === 'N');
 
       if (recordedNLocators.length > 0) {
         for (const locator of recordedNLocators) {
-          finalLocators.push({
-            name: locator.name,
-            type: locator.type,
-            value: locator.value,
-            reference: locator.reference,
-            status: locator.status,
-            isRecorded: locator.isRecorded,
-          });
+          createLocator(locator);
         }
       }
 
-      let relativeXpath: string | null = null;
-      const isDynamic = String(locator.value || locator.type || "");
+      const isDynamic = String(locator.value || locator.type || '');
       if (
-        isDynamic.includes("dynamic") ||
-        isDynamic.match("dynamic") ||
-        isDynamic.includes("{") ||
-        isDynamic.includes("}")
+        isDynamic.includes('dynamic') || isDynamic.match('dynamic') ||
+        isDynamic.includes('{') || isDynamic.includes('}')
       ) {
-        finalLocators.push({
-          name: locator.name,
-          type: locator.type,
-          value: locator.value,
-          reference: locator.reference,
-          status: locator.status,
-          isRecorded: locator.isRecorded,
-        });
+        createLocator(locator);
         continue;
       }
 
-      if (isShared.includes("Y")) {
+      if (isShared.includes('Y')) {
         break locators;
       }
+
       for (const relation of relations) {
         try {
           let targetElement: Element | null = null;
-          if (locator.value.startsWith("iframe")) {
+          if (locator.value.startsWith('iframe')) {
             const iframe = tempDiv.querySelector(
               locator.value
             ) as HTMLIFrameElement;
@@ -364,254 +397,139 @@ const getElementsFromHTML = (
               }
             }
           } else {
-            const selectors = locator.value.split(">>>"); // Custom delimiter for shadow DOM
+            const selectors = locator.value.split('>>>'); // Custom delimiter for shadow DOM
             let currentElement: Element | null = tempDiv;
 
             for (const selector of selectors) {
               if (currentElement) {
                 const trimmedSelector = selector.trim();
-                if (
-                  locator.name.includes("id") ||
-                  trimmedSelector.startsWith("#")
-                ) {
-                  targetElement = currentElement.querySelector(
-                    "#" + trimmedSelector
-                  );
+                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("className") ||
-                  trimmedSelector.startsWith(".")
-                ) {
-                  targetElement = currentElement.querySelector(
-                    "." + trimmedSelector
-                  );
-                } else if (
-                  (locator.name.includes("xpath") ||
-                    trimmedSelector.startsWith("//")) &&
-                  !locator.type.match("dynamic")
+                  (locator.name.includes('xpath') || trimmedSelector.startsWith('//')) &&
+                  !locator.type.match('dynamic')
                 ) {
                   if (tempDiv.innerHTML) {
                     const normalizedXPath = normalizeXPath(trimmedSelector);
-                    targetElement = getElementFromXPath(
-                      tempDiv,
-                      normalizedXPath
-                    );
+                    targetElement = getElementFromXPath(tempDiv,normalizedXPath);
                     if (targetElement) {
-                      finalLocators.push({
-                        name: locator.name,
-                        type: locator.type,
+                      createLocator(locator, {
                         value: trimmedSelector,
-                        reference: locator.reference,
-                        status: locator.status,
-                        isRecorded: String(locator.isRecorded).includes("N")
-                          ? "N"
-                          : "Y",
+                        isRecorded: String(locator.isRecorded).includes('N') ? 'N' : 'Y',
                       });
                     }
                   }
                 } else {
                   targetElement = currentElement.querySelector(trimmedSelector);
                   if (!targetElement) {
-                    targetElement = getElementFromShadowRoot(
-                      currentElement,
-                      trimmedSelector
-                    );
+                    targetElement = getElementFromShadowRoot(currentElement, trimmedSelector);
                   }
                 }
 
-                if (
-                  !targetElement &&
-                  isSVGElement(currentElement) &&
-                  !locator.type.match("dynamic")
-                ) {
+                if (!targetElement && isSVGElement(currentElement) && !locator.type.match('dynamic')) {
                   targetElement = currentElement.querySelector(trimmedSelector);
                 }
-
                 currentElement = targetElement;
               } else {
-                console.error("Element not found at:", selector);
+                console.error('Element not found at:', selector);
                 break;
               }
             }
           }
 
-          const locatorExists = (name: string, value: string) => {
-            return finalLocators.some(
-              (loc) =>
-                loc.name === name &&
-                loc.value === value &&
-                (!loc.value.includes("dynamic") ||
-                  !locator.type.match("dynamic"))
-            );
+          const locatorExists = (name: string, value: string): boolean => {
+            const key = `${name}:${value}`;
+            return finalLocatorsSet.has(key);
           };
 
           const xpathFunctions = [
-            { name: "xpath", value: getXPathByText },
-            { name: "xpath", value: getXPathById },
-            { name: "xpath", value: getXPathByClass },
-            { name: "xpath", value: getXPathAbsolute },
-            { name: "xpath", value: getXpathByName },
-            { name: "xpath", value: getXpathByPlaceholder },
-            { name: "xpath", value: getXpathByType },
+            { name: 'xpath', value: getXPathByText },
+            { name: 'xpath', value: getXPathById },
+            { name: 'xpath', value: getXPathByClass },
+            { name: 'xpath', value: getXPathAbsolute },
+            { name: 'xpath', value: getXpathByName },
+            { name: 'xpath', value: getXpathByPlaceholder },
+            { name: 'xpath', value: getXpathByType },
           ];
 
           if (targetElement) {
             const idValue = getId(targetElement);
-            if (idValue && !locatorExists("id", idValue)) {
+            if (idValue && !locatorExists('id', idValue)) {
               locators.forEach((loc) => {
-                if (locator.value === idValue && locator.name === "id") {
-                  finalLocators.push({
-                    name: "id",
-                    type: locator.type,
-                    value: idValue,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: locator.isRecorded,
-                  });
-                } else {
-                  finalLocators.push({
-                    name: "id",
-                    type: locator.type,
-                    value: idValue,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: "Y",
-                    isSelfHealed: "Y",
-                  });
-                }
+                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'
+                });
               });
             }
-            if (getVisibleText(targetElement)) {
-              const textValue = getVisibleText(targetElement);
+
+            const textValue = getVisibleText(targetElement);
+            if (textValue) {
               locators.forEach((loc) => {
-                if (loc.value === textValue) {
-                  finalLocators.push({
-                    name: "linkText",
-                    type: "static",
-                    value: textValue,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: locator.isRecorded,
-                  });
-                } else {
-                  finalLocators.push({
-                    name: "linkText",
-                    type: "static",
-                    value: textValue,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: "Y",
-                    isSelfHealed: "Y",
-                  });
-                }
+                createLocator(loc, {
+                  name: 'linkText',
+                  type: 'static',
+                  value: textValue,
+                  isRecorded: loc.value === textValue ? loc.isRecorded : 'Y',
+                  isSelfHealed: loc.value === textValue ? loc.isSelfHealed : 'Y',
+                });        
               });
             }
 
-            if (getName(targetElement)) {
-              const nameLocator = getName(targetElement);
-              if (nameLocator && !locatorExists("name", nameLocator)) {
-                locators.forEach((loc) => {
-                  if (loc.value === nameLocator && locator.name === "name") {
-                    finalLocators.push({
-                      name: "name",
-                      type: "static",
-                      value: nameLocator,
-                      reference: locator.reference,
-                      status: locator.status,
-                      isRecorded: locator.isRecorded,
-                    });
-                  } else {
-                    finalLocators.push({
-                      name: "name",
-                      type: "static",
-                      value: nameLocator,
-                      reference: locator.reference,
-                      status: locator.status,
-                      isRecorded: "Y",
-                      isSelfHealed: "Y",
-                    });
-                  }
+            const nameLocator = getName(targetElement);
+            if (nameLocator && !locatorExists('name', nameLocator)) {
+              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)
-            ) {
+            if (classValue && classValue.trim() !== '' && !locatorExists('className', classValue)) {
               locators.forEach((loc) => {
-                if (loc.value === classValue && locator.name === "className") {
-                  finalLocators.push({
-                    name: "className",
-                    type: locator.type,
-                    value: classValue,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: locator.isRecorded,
-                  });
-                } else {
-                  finalLocators.push({
-                    name: "className",
-                    type: locator.type,
-                    value: classValue,
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: "Y",
-                    isSelfHealed: "Y",
-                  });
-                }
+                 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',
+                });
               });
             }
+
             xpathFunctions.forEach((fn) => {
+              const fnValue = fn.value(targetElement);
               locators.forEach((loc) => {
-                if (loc.value === fn.value(targetElement)) {
-                  finalLocators.push({
-                    name: fn.name,
-                    type: locator.type,
-                    value: fn.value(targetElement),
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: locator.isRecorded,
-                  });
-                } else {
-                  finalLocators.push({
-                    name: fn.name,
-                    type: locator.type,
-                    value: fn.value(targetElement),
-                    reference: locator.reference,
-                    status: locator.status,
-                    isRecorded: "Y",
-                    isSelfHealed: "Y",
-                  });
-                }
+                createLocator(loc, {
+                  name: fn.name,
+                  value: fnValue,
+                  isRecorded: loc.value === fnValue ? loc.isRecorded : 'Y',
+                  isSelfHealed: loc.value === fnValue ? loc.isSelfHealed : 'Y',
+                });
               });
             });
 
             for (const locator of locators) {
               try {
-                let relativeXpath = null;
-                if (locator.value) {
-                  for (const relation of relations) {
-                    if (locator.value.includes(relation)) {
-                      relativeXpath = checkReferenceElementIsValid(
-                        locator.value,
-                        relation,
-                        tempDiv
-                      );
+                for (const loc of locators) {
+                  if (!loc.value) continue;
 
+                  for (const relation of relations) {
+                    if (loc.value.includes(relation)) {
+                      const relativeXpath = checkReferenceElementIsValid(loc.value, relation, tempDiv);
                       if (relativeXpath) {
-                        finalLocators.push({
-                          name: "xpath",
-                          type: locator.type,
+                        createLocator(loc, {
+                          name: 'xpath',
                           value: relativeXpath,
-                          reference: locator.reference,
-                          status: locator.status,
-                          isRecorded:
-                            locator.isRecorded !== "" ||
-                            locator.isRecorded !== null
-                              ? locator.isRecorded
-                              : "Y",
+                          isRecorded: locator.isRecorded !== '' && locator.isRecorded !== null ? locator.isRecorded : 'Y',
                         });
                         break;
                       }
@@ -619,40 +537,30 @@ const getElementsFromHTML = (
                   }
                 }
               } catch (error) {
-                console.error("Error processing locator:", locator, error);
+                console.error('Error processing locator:', locator, error);
               }
             }
 
-            let uniqueLocators = new Map();
+            const finalAutoHealedLocators = finalLocators.map((obj) => ({
+              ...obj,
+              value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded),
+            }));
 
-             finalLocators.forEach((obj) => {
-              let val = obj.value;
-              if (obj.isRecorded === 'Y' && val) {
-                val = String(val).replace(/"/g, "'").replace(/\\'/g, "'");
-              }
-
-              // filter out redundant/invalid values
-              if (!val || val === 'null' || val === "''") return;
-
-              // ensure unique entries
-              if (!uniqueLocators.has(val)) {
-                uniqueLocators.set(val, { ...obj, value: val });
-              }
-            });
-
-            let ffLoc = Array.from(uniqueLocators.values());
+            const finalUniqueAutoHealedLocators: Locator[] = finalAutoHealedLocators.reduce(
+              (unique: Locator[], locator: Locator) => {
+                if (locator.value && !unique.some((l: Locator) => l.value === locator.value)) {
+                  unique.push(locator);
+                }
+                return unique;
+              }, [] as Locator[]
+            );
 
             const jsonResult = [
               {
                 name: `${name}`,
                 desc: `${desc}`,
                 type: `${type}`,
-                locators: ffLoc.filter(
-                  (locator) =>
-                    locator.hasOwnProperty("value") &&
-                    locator?.value !== null &&
-                    locator.value !== ""
-                ),
+                locators: finalUniqueAutoHealedLocators.filter((locator) => locator?.value != null && locator.value !== ''),
                 isShared: `${isShared}`,
                 projectId: `${projectId}`,
                 projectType: `${projectType}`,
@@ -670,16 +578,16 @@ const getElementsFromHTML = (
             return jsonResult;
           }
         } catch (error) {
-          console.error("Error processing locator:", locator, error);
+          console.error('Error processing locator:', locator, error);
           continue;
         }
       }
     } catch (error) {
-      console.error("Error processing locator:", locator, error);
+      console.error('Error processing locator:', locator, error);
       continue;
     }
   }
   return null;
 };
 
-export { getElementsFromHTML };
+export { getElementsFromHTML };