@dev-blinq/cucumber_client 1.0.1416-dev → 1.0.1417-dev

package/bin/client/code_gen/page_reflection.js

@@ -452,6 +452,126 @@ this.imports[2].node.source.value
     let startEnd = this._getVariableStartEnd("elements");
     this._replaceCode(code, startEnd[0], startEnd[1]);
   }
+  mergeSimilarElements() {
+    const elements = this.getVariableDeclarationAsObject("elements");
+    if (elements === null) {
+      return;
+    }
+
+    const keys = Object.keys(elements);
+
+    // Ensure each element has element_key
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (!elements[key].element_key) {
+        elements[key].element_key = key;
+      }
+    }
+
+    const replacedKeys = {};
+    const mergedElements = {};
+
+    // Walk from end so "later" keys win (your intended behavior)
+    for (let i = keys.length - 1; i >= 0; i--) {
+      const currentElement = elements[keys[i]];
+      let foundMatch = false;
+
+      for (let j = i - 1; j >= 0; j--) {
+        const nextElement = elements[keys[j]];
+
+        if (this._isSimilarElement(currentElement, nextElement)) {
+          // Keep currentElement, replace earlier key with current's key
+          mergedElements[currentElement.element_key] = currentElement;
+          replacedKeys[nextElement.element_key] = currentElement.element_key;
+          foundMatch = true;
+
+          // Remove the earlier key so we don't carry it forward
+          keys.splice(j, 1);
+
+          // Since we removed an index before i, adjust i so it still points to currentElement
+          i--;
+
+          // IMPORTANT: compensate for splice so the loop’s j-- lands on the same logical next item
+          j++;
+        }
+      }
+
+      if (!foundMatch) {
+        mergedElements[currentElement.element_key] = currentElement;
+      }
+    }
+
+    // If no replacements occurred, nothing else to do
+    if (Object.keys(replacedKeys).length === 0) {
+      return;
+    }
+
+    // Replace all element references in file content
+    for (const key in replacedKeys) {
+      const regexp = new RegExp(`elements\\[\\s*["']${key}["']\\s*\\]`, "g");
+      this.fileContent = this.fileContent.replace(regexp, () => {
+        return `elements["${replacedKeys[key]}"]`;
+      });
+    }
+
+    // Save merged elements back
+    this.insertElements(mergedElements);
+  }
+
+  //const regexp = new RegExp(`elements\\[\\s*["']${key}["']\\s*\\]`, "g");
+  /*
+  element shape example:
+  {
+    locators: [
+      { css: 'internal:text="YES Subscription"s', priority: 1 },
+      { css: 'internal:text="YES Subscription"i', priority: 1 },
+      { css: 'h3 >> internal:has-text="YES Subscription"i', priority: 1 },
+      { css: 'h3 >> internal:has-text=/^YES Subscription$/', priority: 1 },
+      { css: 'internal:role=heading[name="YES Subscription"s]', priority: 1 },
+    ],
+    element_name: "YES Subscription heading",
+    element_key: "heading_yes_subscription",
+  }
+*/
+
+  _isSimilarElement(element1, element2) {
+    if (!element1 || !element2) return false;
+
+    const locs1 = Array.isArray(element1.locators) ? element1.locators : [];
+    const locs2 = Array.isArray(element2.locators) ? element2.locators : [];
+
+    // If both empty, fallback to false (names/keys already handled)
+    if (locs1.length === 0 && locs2.length === 0) return false;
+    if (locs1.length === 0 || locs2.length === 0) return false;
+
+    // Decide which set is "less" (subset candidate) and "more" (superset candidate)
+    const moreLocatorsElement = locs1.length >= locs2.length ? locs1 : locs2;
+    const lessLocatorsElement = locs1.length >= locs2.length ? locs2 : locs1;
+
+    // Helper: check if all key/value pairs in 'needle' exist identically in 'hay' (superset)
+    const locatorIncludes = (hay, needle) => {
+      if (hay == null || needle == null) return false;
+      // Only consider known keys; ignore undefined values
+      // ignore priority
+      const KEYS = ["css", "index", "text", "climb"];
+      for (const k of KEYS) {
+        if (needle[k] !== undefined) {
+          if (!(k in hay)) return false;
+          // Strict equality comparison for predictability
+          if (hay[k] !== needle[k]) return false;
+        }
+      }
+      return true;
+    };
+
+    // For every locator in the smaller set, we require a matching superset locator in the larger set
+    for (const less of lessLocatorsElement) {
+      const match = moreLocatorsElement.some((more) => locatorIncludes(more, less));
+      if (!match) return false;
+    }
+
+    return true;
+  }
   removeUnusedElements() {
     const usedElementsKeys = this.getUsedElementsKeys();
     const elements = this.getVariableDeclarationAsObject("elements");

package/package.json

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