@dev-blinq/cucumber_client 1.0.1426-dev → 1.0.1426-stage

package/bin/assets/scripts/unique_locators.js

@@ -158,8 +158,7 @@ class LocatorGenerator {
       const tSelectorList = [];
       for (const selectorPart of selectorPartList) {
         const { engine, selector } = selectorPart;
-        if (textToIgnore && selector.includes(textToIgnore)
-        ) {
+        if (textToIgnore && selector.includes(textToIgnore)) {
           continue;
         }
         if (engine === "css") {
@@ -218,6 +217,53 @@ class LocatorGenerator {
     }
     return result;
   }
+  toContextLocators(element, contextElement, options = {}) {
+    const commonParent = this.dom_Parent.findLowestCommonAncestor([contextElement, element]);
+    const climb = this.dom_Parent.getClimbCountToParent(contextElement, commonParent);
+    const text = contextElement.innerText.trim();
+
+    const prefix = `internal:text="${text}" >> ${this.getXPathSelector(climb)}`;
+    const result = this.getElementLocators(element, {
+      root: commonParent,
+      strategies: {
+        [this.locatorStrategies.custom]: true,
+        [this.locatorStrategies.text]: true,
+        [this.locatorStrategies.no_text]: true,
+      },
+      prefix,
+      ...options,
+    });
+
+    const attachContextToLocators = (locs) => {
+      locs.forEach((loc) => {
+        loc.climb = climb;
+        loc.text = text;
+      });
+    };
+
+    const allStrategyLocators = result.allStrategyLocators;
+    const locators = result.locators;
+    if (allStrategyLocators) {
+      const allLocators = [];
+      for (const strategy in allStrategyLocators) {
+        if (strategy === "strategy") continue;
+        const locators = allStrategyLocators[strategy];
+        if (locators.length === 0) continue;
+        allLocators.push(...locators);
+        allStrategyLocators[strategy] = [];
+      }
+      attachContextToLocators(allLocators);
+      allStrategyLocators[this.locatorStrategies.context] = allLocators;
+      allStrategyLocators.strategy = this.locatorStrategies.context;
+      result.locators = allLocators;
+      return result;
+    }
+    if (locators) {
+      attachContextToLocators(locators);
+      return result;
+    }
+    return result;
+  }
   getContextLocators(element, locators) {
     if (!locators || !Array.isArray(locators)) {
       console.error("Locators must be an array");
@@ -442,12 +488,16 @@ class LocatorGenerator {
   categorizeLocators(element, locators, options) {
     const unique = [];
     const nonUnique = [];
+    const visible = options?.visible ?? true;
     try {
       for (const locator of locators) {
         if (!locator || !locator.css || typeof locator.css !== "string") {
           console.error("Locator must have a valid css selector found: ", locator);
           continue;
         }
+        if (visible === false) {
+          locator.visible = false;
+        }
         const elements = this.getMatchingElements(locator.css, options);
         if (elements.length === 0) {
           console.warn(`No elements found for locator: ${locator.css}`);
@@ -626,7 +676,7 @@ class LocatorGenerator {
 
   getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
     try {
-      const { maxLocators = 5, root = window.document.body } = options;
+      const { maxLocators = 5, root = window.document.body, prefix } = options;
 
       if (!element) {
         return [];
@@ -646,13 +696,7 @@ class LocatorGenerator {
             },
           ];
         } else {
-          return [
-            {
-              css: ":root",
-              score: 1,
-              priority: 1,
-            },
-          ];
+          return [];
         }
       }
 
@@ -679,12 +723,13 @@ class LocatorGenerator {
 
       const elementsCache = new Map();
 
-      const allAncestors = this.dom_Parent.getFullAncestorChainToRoot(element, root);
+      const allAncestors = prefix ? [element] : this.dom_Parent.getFullAncestorChainToRoot(element, root);
       allAncestors.shift(); // remove the element itself from the ancestors
 
       const cache = new Map();
       const textToIgnore = this.PW.selectorUtils.elementText(cache, element).full.trim();
       const ancestorLocators = [];
+      let uniqueAncestor = null;
       for (const ancestor of allAncestors) {
         const _locators = locatorGenerator(ancestor, { ...options, textToIgnore });
         if (!_locators || !Array.isArray(_locators) || _locators.length === 0) {
@@ -697,11 +742,15 @@ class LocatorGenerator {
         });
         elementsCache.set(ancestor, _categorized);
         if (_categorized.unique.length > 0) {
+          uniqueAncestor = {
+            element: ancestor,
+            locators: _categorized,
+          };
           break;
         }
       }
 
-      const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
+      // const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
 
       for (const locator of nonUnique) {
         const selector = locator.css ?? locator.selector;
@@ -710,6 +759,27 @@ class LocatorGenerator {
           console.warn(`No elements found for locator: ${selector}`);
           continue;
         }
+        if (!uniqueAncestor) {
+          const elements = this.getMatchingElements(selector, options);
+          if (elements.length === 1 && elements[0] === element) {
+            result.push({
+              css: selector,
+              score: locator.score,
+              priority: 1,
+            });
+          } else {
+            const index = elements.indexOf(element);
+            if (index !== -1) {
+              result.push({
+                css: selector,
+                index,
+                score: locator.score + 200,
+                priority: 2,
+              });
+            }
+          }
+          continue;
+        }
 
         for (const unique_locator of uniqueAncestor.locators.unique) {
           const fullSelector = `${unique_locator.css} >> ${selector}`;
@@ -748,9 +818,32 @@ class LocatorGenerator {
       return [];
     }
   }
+  isElementVisible(element) {
+    if (!(element instanceof Element)) return false;
+    const style = window.getComputedStyle(element);
+    if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+    const rect = element.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    return true;
+  }
   getElementLocators(element, options = {}) {
+    const isVisible = this.isElementVisible(element);
+    if (isVisible === false) {
+      console.warn("Element is not visible: ", element);
+      options.visible = isVisible;
+    }
     try {
-      const { excludeText = false } = options;
+      const {
+        excludeText = false,
+        strategies = {
+          [this.locatorStrategies.custom]: true,
+          [this.locatorStrategies.context]: true,
+          [this.locatorStrategies.text]: true,
+          [this.locatorStrategies.text_with_index]: true,
+          [this.locatorStrategies.digitIgnore]: true,
+          [this.locatorStrategies.no_text]: true,
+        },
+      } = options;
 
       const allStrategyLocators = {
         [this.locatorStrategies.custom]: [],
@@ -760,7 +853,12 @@ class LocatorGenerator {
         [this.locatorStrategies.digitIgnore]: [],
         [this.locatorStrategies.no_text]: [],
       };
-      if (this.options?.customAttributes) {
+      if (
+        strategies[this.locatorStrategies.custom] &&
+        this.options?.customAttributes &&
+        Array.isArray(this.options.customAttributes) &&
+        this.options.customAttributes.length > 0
+      ) {
         console.groupCollapsed("Generating Custom locators for element:", element);
         const customLocators = this.getUniqueLocators(element, this.getCustomLocators.bind(this), options);
         if (customLocators.length > 0) {
@@ -769,43 +867,53 @@ class LocatorGenerator {
       }
       console.groupEnd();
       if (!excludeText) {
-        console.groupCollapsed("Generating Text locators for element:", element);
-        const basicLocators = this.getUniqueLocators(element, this.getTextLocators.bind(this), options);
-        console.groupEnd();
-        if (basicLocators.length > 0) {
-          allStrategyLocators[this.locatorStrategies.text] = basicLocators;
-        }
+        if (strategies[this.locatorStrategies.text]) {
+          console.groupCollapsed("Generating Text locators for element:", element);
 
-        const textWithIndexLocators = this.getTextwithIndexLocators(basicLocators);
-        if (textWithIndexLocators.length > 0) {
-          allStrategyLocators[this.locatorStrategies.text_with_index] = textWithIndexLocators;
-        }
-        const digitIgnoreLocators = this.getDigitIgnoreLocators(element, basicLocators);
-        if (digitIgnoreLocators.length > 0) {
-          allStrategyLocators[this.locatorStrategies.digitIgnore] = digitIgnoreLocators;
-        }
-        const contextLocators = this.getContextLocators(element, basicLocators);
-        if (contextLocators.length > 0) {
-          allStrategyLocators[this.locatorStrategies.context] = contextLocators;
+          const basicLocators = this.getUniqueLocators(element, this.getTextLocators.bind(this), options);
+          console.groupEnd();
+          if (basicLocators.length > 0) {
+            allStrategyLocators[this.locatorStrategies.text] = basicLocators;
+          }
+          if (strategies[this.locatorStrategies.text_with_index]) {
+            const textWithIndexLocators = this.getTextwithIndexLocators(basicLocators);
+            if (textWithIndexLocators.length > 0) {
+              allStrategyLocators[this.locatorStrategies.text_with_index] = textWithIndexLocators;
+            }
+          }
+          if (strategies[this.locatorStrategies.digitIgnore]) {
+            const digitIgnoreLocators = this.getDigitIgnoreLocators(element, basicLocators);
+            if (digitIgnoreLocators.length > 0) {
+              allStrategyLocators[this.locatorStrategies.digitIgnore] = digitIgnoreLocators;
+            }
+          }
+          if (strategies[this.locatorStrategies.context]) {
+            const contextLocators = this.getContextLocators(element, basicLocators);
+            if (contextLocators.length > 0) {
+              allStrategyLocators[this.locatorStrategies.context] = contextLocators;
+            }
+          }
         }
       }
-      console.groupCollapsed("Generating No Text locators for element:", element);
-      const noTextLocators = this.getUniqueLocators(element, this.getNoTextLocators.bind(this), options);
+      if (strategies[this.locatorStrategies.no_text]) {
+        console.groupCollapsed("Generating No Text locators for element:", element);
+        const noTextLocators = this.getUniqueLocators(element, this.getNoTextLocators.bind(this), options);
 
-      if (noTextLocators.length > 0) {
-        allStrategyLocators[this.locatorStrategies.no_text] = noTextLocators;
-      } else {
-        const _locators = [];
-        _locators.push({
-          css: this.generateUniqueCSSSelector(element, options),
-          score: 500,
-          priority: 3,
-        });
-        if (_locators.length > 0) {
-          allStrategyLocators[this.locatorStrategies.no_text] = _locators;
+        if (noTextLocators.length > 0) {
+          allStrategyLocators[this.locatorStrategies.no_text] = noTextLocators;
+        } else {
+          const _locators = [];
+          _locators.push({
+            css: this.generateUniqueCSSSelector(element, options),
+            score: 500,
+            priority: 3,
+          });
+          if (_locators.length > 0) {
+            allStrategyLocators[this.locatorStrategies.no_text] = _locators;
+          }
         }
+        console.groupEnd();
       }
-      console.groupEnd();
 
       let bestStrategy = this.getBestStrategy(allStrategyLocators);
       if (!bestStrategy) {