feat: improve suggested xpath generation logic (#2733)

* feat: adjjust parent node usage for xpath generation
This is better if the parent can be uniquely identified, but potentially worse if not.

* improve semi-unique xpath logic to use the result with smallest index

* allow specifying scope for xpath uniqueness

* WIP trying to use attributes instead of indices for target node

* use attributes for target node when possible

* adjust one test to its original behavior

* revert custom scope in _determineXpathUniqueness since it is unused

* add back accidentally removed test

* add another test to mirror its single parent version

* additional optimizations and 2 more tests

* change tuples to objects

* remove unused param in jsdoc

* formatting & comments

* reuse base class methods

* few more minor adjustments

* update tests again

* use fully unique attributes whenever possible

* clarify comment

* fix formatting

* address comments

* add another safeguard

* address comment

* address comments

Author: eglitise

app/common/renderer/utils/locator-generation/base.js

@@ -7,35 +7,39 @@ export class LocatorGeneratorBase {
   /**
    * @param {Document} doc - the document containing the DOM
    * @param {Node} domNode - the DOM node to generate locators for
+   * @param {Node | null} [contextNode] - optional context node to scope locator evaluation
    */
-  constructor(doc, domNode) {
+  constructor(doc, domNode, contextNode = null) {
     this._doc = doc;
     this._domNode = domNode;
+    this._contextNode = contextNode;
+    // We only use contextNode as the direct parent of domNode, so all axes will be '/'
+    this._nodeAxis = this._contextNode ? '/' : '//';
   }
 
   /**
    * Get sibling nodes with the same tag name
    *
+   * @param {Node} targetNode - the node to find siblings for, defaults to the main DOM node if not provided
    * @returns {Node[]} array of sibling nodes with the same tag name
    */
-  _getSiblingsWithSameTag() {
-    if (!this._domNode.parentNode) {
+  _getSiblingsWithSameTag(targetNode = this._domNode) {
+    if (!targetNode.parentNode) {
       return [];
     }
     return Array.prototype.slice
-      .call(this._domNode.parentNode.childNodes, 0)
-      .filter(
-        (childNode) => childNode.nodeType === 1 && childNode.tagName === this._domNode.tagName,
-      );
+      .call(targetNode.parentNode.childNodes, 0)
+      .filter((childNode) => childNode.nodeType === 1 && childNode.tagName === targetNode.tagName);
   }
 
   /**
    * Check if a node is a valid element node
    *
+   * @param {Node} targetNode - the node to check, defaults to the main DOM node if not provided
    * @returns {boolean} true if the node is a valid element
    */
-  _isValidElementNode() {
-    return this._domNode.tagName && this._domNode.nodeType === 1;
+  _isValidElementNode(targetNode = this._domNode) {
+    return targetNode?.tagName && targetNode?.nodeType === 1;
   }
 
   /**