@dev-blinq/cucumber_client 1.0.1195-dev → 1.0.1196-dev

package/bin/assets/preload/locators.js

@@ -697,6 +697,24 @@ function querySelector_shadow_aware(element, selector) {
 }
 window.querySelector_shadow_aware = querySelector_shadow_aware;
 
+function findElement(css, scope = document) {
+  // return null if no css provided
+  if (!css) return null;
+  const selector = window.__injectedScript.parseSelector(css);
+  try {
+    const elements = window.__injectedScript.querySelectorAll(selector, scope, true);
+    if (!elements) return null;
+    if (elements.length === 1) {
+      return elements[0];
+    } else {
+      return elements;
+    }
+  } catch (error) {
+    return null;
+  }
+}
+window.findElement = findElement;
+
 // export {
 // 	getUniqueLocators,
 // 	getBasicInfo,

package/bin/assets/preload/recorderv3.js

@@ -1355,7 +1355,8 @@ function countAccurances(css, scope = document) {
 }
 window.countAccurances = countAccurances;
 function findElement(css, scope = document) {
-  // return null if no css provided
+  // Note: If you change anything iin this function
+  // please change it in locators.js
   if (!css) return null;
   const selector = window.__injectedScript.parseSelector(css);
   try {

package/bin/client/operations/dump_tree.js

@@ -378,6 +378,81 @@ const findLocatorByText = async (context, texts, backendNodeId) => {
     await _closeCDP();
   }
 };
+function classifyLocatorsByStrategy(locators) {
+  const locs = [];
+
+  const allStrategyLocators = {
+    basic: [],
+    no_text: [],
+    ignore_digit: [],
+    context: [],
+    strategy: "basic",
+  };
+
+  const regexRegex = /\/.*\\[d][+].*\//;
+  for (const locator of locators) {
+    if (locator.mode) {
+      const { mode, ...rest } = locator;
+      locs.push(rest);
+      allStrategyLocators[locator.mode.toLowerCase()].push(rest);
+    } else if (locator.text && locator.text.length > 0) {
+      locs.push({
+        ...locator,
+        mode: "CONTEXT",
+      });
+      allStrategyLocators["context"].push(locator);
+    } else if (regexRegex.test(locator.css)) {
+      locs.push({
+        ...locator,
+        mode: "IGNORE_DIGIT",
+      });
+      allStrategyLocators["ignore_digit"].push(locator);
+    } else if (locator.css.includes("text=") || locator.css.includes("[name=") || locator.css.includes("label=")) {
+      locs.push(locator);
+      allStrategyLocators["basic"].push(locator);
+    } else {
+      locs.push({
+        ...locator,
+        mode: "NO_TEXT",
+      });
+      allStrategyLocators["no_text"].push(locator);
+    }
+  }
+  if (allStrategyLocators["context"].length > 0) {
+    allStrategyLocators["strategy"] = "context";
+  } else if (allStrategyLocators["basic"].length === 0 && allStrategyLocators["no_text"].length > 0) {
+    allStrategyLocators["strategy"] = "no_text";
+  }
+
+  return {
+    locators: locs,
+    allStrategyLocators,
+  };
+}
+
+async function filterLocators(cssLocators, elObjectId) {
+  const kept = [];
+  for (const selector of cssLocators) {
+    // call window.findElement(selector) === el
+    const { result } = await cdp.send("Runtime.callFunctionOn", {
+      functionDeclaration: `
+        function(element,selector) {
+          console.log("filterLocators in progress");
+          console.log(element,selector);
+          return window.findElement(selector) === element;
+        }
+      `,
+      objectId: elObjectId,
+      arguments: [{ objectId: elObjectId }, { value: selector }],
+      returnByValue: true,
+    });
+
+    if (result.value) {
+      kept.push(selector);
+    }
+  }
+  return kept;
+}
 
 async function getRecorderLocators(context, backendNodeId) {
   if (!cdp) {
@@ -388,7 +463,8 @@ async function getRecorderLocators(context, backendNodeId) {
       backendNodeId: backendNodeId,
     });
     const objectId = domNode.object.objectId;
-    let res = await cdp.send("Runtime.callFunctionOn", {
+    let locators = [];
+    locators = await cdp.send("Runtime.callFunctionOn", {
       functionDeclaration:
         "function(element,options) { console.log(element,options); return window.getPWLocators(element,options); }",
       objectId: objectId,
@@ -405,8 +481,87 @@ async function getRecorderLocators(context, backendNodeId) {
       ],
       returnByValue: true,
     });
+    if (!locators || !locators.result || !locators.result.value) {
+      locators = [];
+    } else {
+      locators = locators.result?.value;
+    }
+    let cssLocators = [];
+    try {
+      let origenCss = await cdp.send("Runtime.callFunctionOn", {
+        functionDeclaration:
+          "function(element) { console.log(element); return window.generateUniqueCSSSelector(element); }",
+        objectId: objectId,
+        arguments: [
+          {
+            objectId: objectId,
+          },
+        ],
+        returnByValue: true,
+      });
+      origenCss = origenCss.result?.value;
+      if (origenCss) {
+        cssLocators.push(origenCss);
+      }
+      let noClasses = await cdp.send("Runtime.callFunctionOn", {
+        functionDeclaration:
+          "function(element,options) { console.log(element,options); return window.CssSelectorGenerator.getCssSelector(element,options); }",
+        objectId: objectId,
+        arguments: [
+          {
+            objectId: objectId,
+          },
+          {
+            value: {
+              blacklist: [/^(?!.*h\d).*?\d.*/, /\[style/, /\[data-input-id/, /\[blinq-container/],
+              combineWithinSelector: true,
+              combineBetweenSelectors: true,
+              selectors: ["id", "attribute", "tag", "nthchild", "nthoftype"],
+              maxCombinations: 100,
+            },
+          },
+        ],
+        returnByValue: true,
+      });
+      noClasses = noClasses.result?.value;
+      if (!cssLocators.includes(noClasses)) {
+        cssLocators.push(noClasses);
+      }
+      let withClasses = await cdp.send("Runtime.callFunctionOn", {
+        functionDeclaration:
+          "function(element,options) { console.log(element,options); return window.CssSelectorGenerator.getCssSelector(element,options); }",
+        objectId: objectId,
+        arguments: [
+          {
+            objectId: objectId,
+          },
+          {
+            value: {
+              blacklist: [/^(?!.*h\d).*?\d.*/, /\[style/, /\[data-input-id/, /\[blinq-container/],
+              combineWithinSelector: true,
+              combineBetweenSelectors: true,
+              selectors: ["id", "attribute", "tag", "nthchild", "nthoftype", "class"],
+              maxCombinations: 100,
+            },
+          },
+        ],
+        returnByValue: true,
+      });
+      withClasses = withClasses.result?.value;
+      if (!cssLocators.includes(withClasses)) {
+        cssLocators.push(withClasses);
+      }
+      cssLocators.sort((a, b) => a.length - b.length);
+
+      cssLocators = await filterLocators(cssLocators, objectId);
+    } catch (err) {
+      console.error("Error in generateUniqueCSSSelector", error);
+    }
+    locators?.push(...cssLocators.map((css) => ({ mode: "NO_TEXT", css })));
+
+    const result = classifyLocatorsByStrategy(locators);
 
-    return res.result;
+    return { ...result, element_name: "" };
   } finally {
     await _closeCDP();
   }

package/package.json

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