@dev-blinq/cucumber_client 1.0.1265-dev → 1.0.1266-dev

package/bin/assets/bundled_scripts/recorder.js

@@ -316,6 +316,27 @@ var DOM_Parent = class {
     }
     return ancestors;
   }
+  getFullAncestorChainToRoot(element, root) {
+    if (!element || !(element instanceof Element)) {
+      throw new Error("Invalid element provided");
+    }
+    if (!root || !(root instanceof Element)) {
+      throw new Error("Invalid root provided");
+    }
+    if (!this.containsElementCrossShadow(root, element)) {
+      throw new Error("Root does not contain the element");
+    }
+    const ancestors = [];
+    let currentElement = element;
+    while (currentElement && currentElement !== root && this.containsElementCrossShadow(root, currentElement)) {
+      ancestors.push(currentElement);
+      currentElement = this.getActualParent(currentElement);
+    }
+    if (currentElement === root) {
+      ancestors.push(currentElement);
+    }
+    return ancestors;
+  }
   getClimbCountToParent(element, targetParent) {
     if (!element || !(element instanceof Element)) {
       throw new Error("Invalid element provided");
@@ -8230,6 +8251,7 @@ var LocatorGenerator = class {
     this.dom_Parent = new dom_parent_default();
     this.PW = __PW;
     this.injectedScript = injectedScript;
+    this.cache = /* @__PURE__ */ new Map();
   }
   getMatchingElements(selector, options = {}) {
     const { root = window.document, prefix, visible = true } = options;
@@ -8375,12 +8397,16 @@ var LocatorGenerator = class {
           const text = this.injectedScript.utils.elementText(/* @__PURE__ */ new Map(), textElement).full;
           if (!textSet.has(text)) {
             textSet.add(text);
-            result.push({
+            const loc = {
               css: restOfSelector,
               climb: climbCount,
               text,
               priority: 1
-            });
+            };
+            if (locator.index !== void 0) {
+              loc.index = locator.index;
+            }
+            result.push(loc);
           }
         }
       } catch (error) {
@@ -8481,7 +8507,10 @@ var LocatorGenerator = class {
     const nonUnique = [];
     for (const locator of locators) {
       const elements = this.getMatchingElements(locator.css, options);
-      if (elements.length === 1) {
+      if (elements.length === 0) {
+        console.warn(`No elements found for locator: ${locator.css}`);
+        continue;
+      } else if (elements.length === 1) {
         if (element === elements[0]) {
           locator.priority = 1;
           unique.push(locator);
@@ -8501,9 +8530,18 @@ var LocatorGenerator = class {
     }
     return { unique, nonUnique };
   }
+  getCategorizedLocators(element, options = {}) {
+    if (this.cache.has(element)) {
+      return this.cache.get(element);
+    }
+    const locators = this.getElementLocators(element, options);
+  }
   getUniqueLocators(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    return this.getUniqueLocators2(element, locatorGenerator, options);
+  }
+  getUniqueLocators1(element, locatorGenerator = this.getNoTextLocators, options = {}) {
     try {
-      const { maxLocators = 5, root = window.document.body, next = "LCA" } = options;
+      const { maxLocators = 5, root = window.document.body, next = "LCA", minLocators = 3 } = options;
       if (!element) {
         return [];
       }
@@ -8584,7 +8622,7 @@ var LocatorGenerator = class {
                 result.push(_locator);
               } else {
                 const index = _elements.indexOf(element);
-                if (index !== -1) {
+                if (index !== -1 && index < 5) {
                   _locator.css = fullSelector;
                   _locator.index = index;
                   _locator.priority = 2;
@@ -8595,7 +8633,7 @@ var LocatorGenerator = class {
             }
           } else {
             const index = elements.indexOf(element);
-            if (index !== -1) {
+            if (index !== -1 && index < 5) {
               locator.index = index;
               locator.priority = 2;
               result.push(locator);
@@ -8603,7 +8641,7 @@ var LocatorGenerator = class {
           }
         } else {
           const index = elements.indexOf(element);
-          if (index !== -1) {
+          if (index !== -1 && index < 5) {
             locator.index = index;
             locator.priority = 2;
             result.push(locator);
@@ -8614,7 +8652,7 @@ var LocatorGenerator = class {
         delete locator.engine;
         delete locator.selector;
       }
-      if (result.length === 0) {
+      if (result.length < minLocators && root && root.contains(element)) {
         const parent = this.dom_Parent.getActualParent(element);
         const locs = this.getUniqueLocators(parent, locatorGenerator, {
           ...options,
@@ -8631,6 +8669,124 @@ var LocatorGenerator = class {
       return [];
     }
   }
+  getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    try {
+      const { maxLocators = 5, root = window.document.body } = options;
+      if (!element) {
+        return [];
+      }
+      if (element === root) {
+        if (element === window.document.documentElement) {
+          return [
+            {
+              css: "html",
+              score: 1,
+              priority: 1
+            },
+            {
+              css: ":root",
+              score: 1,
+              priority: 1
+            }
+          ];
+        } else {
+          return [
+            {
+              css: ":root",
+              score: 1,
+              priority: 1
+              // }, {
+              // 	css: ":root",
+              // 	score: 1,
+              // 	priority: 1,
+            }
+          ];
+        }
+      }
+      console.log("Generating locators for element:", element);
+      const locators = locatorGenerator(element, options);
+      console.log("Generated locators:", locators);
+      if (!locators || !Array.isArray(locators)) {
+        console.error("Locator generator did not return an array of locators");
+        return [];
+      }
+      console.log("Categorizing locators for element:", element);
+      const categorizedLocators = this.categorizeLocators(element, locators, options);
+      console.log("Categorized locators:", categorizedLocators);
+      const { unique, nonUnique } = categorizedLocators;
+      const result = [];
+      if (unique.length > 0) {
+        result.push(...unique);
+      }
+      if (result.length >= maxLocators) {
+        return result.slice(0, maxLocators);
+      }
+      const elementsCache = /* @__PURE__ */ new Map();
+      const allAncestors = this.dom_Parent.getFullAncestorChainToRoot(element, root);
+      allAncestors.shift();
+      const ancestorLocators = [];
+      for (const ancestor of allAncestors) {
+        const _locators = locatorGenerator(ancestor, options);
+        if (!_locators || !Array.isArray(_locators) || _locators.length === 0) {
+          continue;
+        }
+        const _categorized = this.categorizeLocators(ancestor, _locators, options);
+        ancestorLocators.push({
+          element: ancestor,
+          locators: _categorized
+        });
+        elementsCache.set(ancestor, _categorized);
+        if (_categorized.unique.length > 0) {
+          break;
+        }
+      }
+      const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
+      for (const locator of nonUnique) {
+        const selector = locator.css ?? locator.selector;
+        const elements = locator.elements || this.getMatchingElements(selector, options);
+        if (elements.length === 0) {
+          console.warn(`No elements found for locator: ${selector}`);
+          continue;
+        }
+        for (const unique_locator of uniqueAncestor.locators.unique) {
+          const fullSelector = `${unique_locator.css} >> ${selector}`;
+          const elements2 = this.getMatchingElements(fullSelector, options);
+          if (elements2.length === 1 && elements2[0] === element) {
+            const effectiveScore = (unique_locator.score + locator.score) / 2 + 100;
+            const newLocator = {
+              ...unique_locator,
+              css: fullSelector,
+              score: effectiveScore,
+              priority: 1
+              // unique locators have higher priority
+            };
+            result.push(newLocator);
+          } else {
+            const index = elements2.indexOf(element);
+            if (index !== -1 && index < 5) {
+              const effectiveScore = (unique_locator.score + locator.score) / 2;
+              const newLocator = {
+                ...unique_locator,
+                css: fullSelector,
+                index,
+                score: effectiveScore + 200,
+                priority: 2
+                // non-unique locators have lower priority
+              };
+              result.push(newLocator);
+            }
+          }
+        }
+      }
+      result.sort((a, b) => a.score - b.score);
+      console.log("Final locators:", result, element);
+      console.groupEnd();
+      return result.slice(0, maxLocators);
+    } catch (error) {
+      console.error("Error in getUniqueLocators:", error);
+      return [];
+    }
+  }
   getElementLocators(element, options = {}) {
     var _a;
     const { excludeText = false } = options;

package/bin/assets/scripts/dom_parent.js

@@ -35,6 +35,28 @@ class DOM_Parent {
 
         return ancestors;
     }
+    getFullAncestorChainToRoot(element, root) {
+        if (!element || !(element instanceof Element)) {
+            throw new Error('Invalid element provided');
+        }
+        if (!root || !(root instanceof Element)) {
+            throw new Error('Invalid root provided');
+        }
+        if (!this.containsElementCrossShadow(root, element)) {
+            throw new Error('Root does not contain the element');
+        }
+        const ancestors = [];
+        let currentElement = element;
+        while (currentElement && currentElement !== root && this.containsElementCrossShadow(root, currentElement)) {
+            ancestors.push(currentElement);
+            currentElement = this.getActualParent(currentElement);
+
+        }
+        if (currentElement === root) {
+            ancestors.push(currentElement);
+        }
+        return ancestors;
+    }
     getClimbCountToParent(element, targetParent) {
         if (!element || !(element instanceof Element)) {
             throw new Error('Invalid element provided');

package/bin/assets/scripts/unique_locators.js

@@ -19,6 +19,7 @@ class LocatorGenerator {
 		this.dom_Parent = new DOM_Parent();
 		this.PW = __PW;
 		this.injectedScript = injectedScript;
+		this.cache = new Map();
 	}
 
 	getMatchingElements(selector, options = {}) {
@@ -176,13 +177,16 @@ class LocatorGenerator {
 					const text = this.injectedScript.utils.elementText(new Map(), textElement).full;
 					if (!textSet.has(text)) {
 						textSet.add(text);
-						result.push({
+						const loc = {
 							css: restOfSelector,
 							climb: climbCount,
 							text,
 							priority: 1,
-						});
-
+						}
+						if (locator.index !== undefined) {
+							loc.index = locator.index;
+						}
+						result.push(loc);
 					}
 
 
@@ -297,7 +301,10 @@ class LocatorGenerator {
 		const nonUnique = [];
 		for (const locator of locators) {
 			const elements = this.getMatchingElements(locator.css, options);
-			if (elements.length === 1) {
+			if (elements.length === 0) {
+				console.warn(`No elements found for locator: ${locator.css}`);
+				continue;
+			} else if (elements.length === 1) {
 				if (element === elements[0]) {
 					locator.priority = 1;
 					unique.push(locator);
@@ -318,13 +325,21 @@ class LocatorGenerator {
 		return { unique, nonUnique };
 	}
 
-
+	getCategorizedLocators(element, options = {}) {
+		if (this.cache.has(element)) {
+			return this.cache.get(element);
+		}
+		const locators = this.getElementLocators(element, options);
+	}
 
 
 	getUniqueLocators(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+		return this.getUniqueLocators2(element, locatorGenerator, options);
+	}
+	getUniqueLocators1(element, locatorGenerator = this.getNoTextLocators, options = {}) {
 		try {
 
-			const { maxLocators = 5, root = window.document.body, next = "LCA" } = options;
+			const { maxLocators = 5, root = window.document.body, next = "LCA", minLocators = 3 } = options;
 
 			if (!element) {
 				return [];
@@ -414,7 +429,7 @@ class LocatorGenerator {
 								result.push(_locator);
 							} else {
 								const index = _elements.indexOf(element);
-								if (index !== -1) {
+								if (index !== -1 && index < 5) {
 									// _locator.selector = fullSelector;
 									_locator.css = fullSelector;
 									_locator.index = index;
@@ -428,7 +443,7 @@ class LocatorGenerator {
 
 					} else {
 						const index = elements.indexOf(element);
-						if (index !== -1) {
+						if (index !== -1 && index < 5) {
 							locator.index = index
 							locator.priority = 2; // non-unique locators have lower priority
 							result.push(locator);
@@ -437,7 +452,7 @@ class LocatorGenerator {
 
 				} else {
 					const index = elements.indexOf(element);
-					if (index !== -1) {
+					if (index !== -1 && index < 5) {
 						locator.index = index
 						locator.priority = 2; // non-unique locators have lower priority
 						result.push(locator);
@@ -450,7 +465,7 @@ class LocatorGenerator {
 				delete locator.selector;
 			}
 
-			if (result.length === 0) {
+			if (result.length < minLocators && root && root.contains(element)) {
 				const parent = this.dom_Parent.getActualParent(element);
 				const locs = this.getUniqueLocators(parent, locatorGenerator, {
 					...options,
@@ -470,6 +485,137 @@ class LocatorGenerator {
 			return [];
 		}
 	}
+
+	getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+		try {
+
+			const { maxLocators = 5, root = window.document.body } = options;
+
+			if (!element) {
+				return [];
+			}
+			if (element === root) {
+				if (element === window.document.documentElement) {
+					return [{
+						css: "html",
+						score: 1,
+						priority: 1,
+					}, {
+						css: ":root",
+						score: 1,
+						priority: 1,
+					}
+					]
+				} else {
+					return [{
+						css: ":root",
+						score: 1,
+						priority: 1,
+						// }, {
+						// 	css: ":root",
+						// 	score: 1,
+						// 	priority: 1,
+					}
+					]
+				}
+			}
+
+			console.log("Generating locators for element:", element);
+			const locators = locatorGenerator(element, options);
+			console.log("Generated locators:", locators);
+			if (!locators || !Array.isArray(locators)) {
+				// throw new Error("Locator generator did not return an array of locators");
+				console.error("Locator generator did not return an array of locators");
+				return [];
+			}
+
+			console.log("Categorizing locators for element:", element);
+			const categorizedLocators = this.categorizeLocators(element, locators, options);
+			console.log("Categorized locators:", categorizedLocators);
+			// categorizedLocators.unique = limitLocators(categorizedLocators.unique, options);
+			// categorizedLocators.nonUnique = limitLocators(categorizedLocators.nonUnique, options);
+
+			const { unique, nonUnique } = categorizedLocators;
+			const result = [];
+			if (unique.length > 0) {
+				result.push(...unique);
+			}
+			if (result.length >= maxLocators) {
+				return result.slice(0, maxLocators);
+			}
+
+			const elementsCache = new Map();
+
+			const allAncestors = this.dom_Parent.getFullAncestorChainToRoot(element, root);
+			allAncestors.shift(); // remove the element itself from the ancestors
+
+			const ancestorLocators = [];
+			for (const ancestor of allAncestors) {
+				const _locators = locatorGenerator(ancestor, options);
+				if (!_locators || !Array.isArray(_locators) || _locators.length
+					=== 0) {
+					continue;
+				}
+				const _categorized = this.categorizeLocators(ancestor, _locators, options);
+				ancestorLocators.push({
+					element: ancestor,
+					locators: _categorized,
+				});
+				elementsCache.set(ancestor, _categorized);
+				if (_categorized.unique.length > 0) {
+					break;
+				}
+			}
+
+			const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
+
+			for (const locator of nonUnique) {
+				const selector = locator.css ?? locator.selector;
+				const elements = locator.elements || this.getMatchingElements(selector, options);
+				if (elements.length === 0) {
+					console.warn(`No elements found for locator: ${selector}`);
+					continue;
+				}
+
+				for (const unique_locator of uniqueAncestor.locators.unique) {
+					const fullSelector = `${unique_locator.css} >> ${selector}`;
+					const elements = this.getMatchingElements(fullSelector, options);
+					if (elements.length === 1 && elements[0] === element) {
+						const effectiveScore = (unique_locator.score + locator.score) / 2 + 100;
+						const newLocator = {
+							...unique_locator,
+							css: fullSelector,
+							score: effectiveScore,
+							priority: 1, // unique locators have higher priority
+						};
+						result.push(newLocator);
+					} else {
+						const index = elements.indexOf(element);
+						if (index !== -1 && index < 5) {
+							const effectiveScore = (unique_locator.score + locator.score) / 2;
+							const newLocator = {
+								...unique_locator,
+								css: fullSelector,
+								index,
+								score: effectiveScore + 200,
+								priority: 2, // non-unique locators have lower priority
+							};
+							result.push(newLocator);
+						}
+					}
+				}
+
+			}
+			result.sort((a, b) => a.score - b.score);
+			console.log("Final locators:", result, element);
+			console.groupEnd();
+			return result.slice(0, maxLocators);
+		}
+		catch (error) {
+			console.error("Error in getUniqueLocators:", error);
+			return [];
+		}
+	}
 	getElementLocators(element, options = {}) {
 
 		const { excludeText = false } = options;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1265-dev",
+  "version": "1.0.1266-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",