@dev-blinq/cucumber_client 1.0.1452-dev → 1.0.1453-dev

package/bin/assets/scripts/dom_parent.js

@@ -1,137 +1,132 @@
 class DOM_Parent {
+  getActualParent(element) {
+    if (!element || !(element instanceof Element)) {
+      throw new Error("Invalid element provided");
+    }
+
+    // TODO: account for slotted elements
+
+    if (element.assignedSlot) {
+      return element.assignedSlot;
+    }
+    // Get the actual parent element, skipping shadow DOM if necessary
+    let parent = element.parentElement;
+    if (parent) {
+      return parent;
+    }
+    const parentNode = element.parentNode;
+    if (parentNode && parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      // If the parent is a shadow root, return its host
+      return parentNode.host || null;
+    }
+    return null;
+  }
+
+  getFullAncestorChain(element) {
+    if (!element || !(element instanceof Element)) {
+      throw new Error("Invalid element provided");
+    }
+
+    const ancestors = [];
+    let currentElement = element;
+
+    while (currentElement) {
+      ancestors.push(currentElement);
+      currentElement = this.getActualParent(currentElement);
+    }
+
+    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");
+    }
+    if (!targetParent || !(targetParent instanceof Element)) {
+      throw new Error("Invalid target parent provided");
+    }
+
+    let count = 0;
+    let currentElement = element;
+
+    while (currentElement && currentElement !== targetParent) {
+      currentElement = this.getActualParent(currentElement);
+      count++;
+    }
+
+    return currentElement === targetParent ? count : -1; // Return -1 if target parent is not found
+  }
 
-    getActualParent(element) {
-        if (!element || !(element instanceof Element)) {
-            throw new Error('Invalid element provided');
-        }
-
-        // TODO: account for slotted elements 
-
-        if (element.assignedSlot) {
-            return element.assignedSlot
-        }
-        // Get the actual parent element, skipping shadow DOM if necessary
-        let parent = element.parentElement;
-        if (parent) {
-            return parent;
-        }
-        const parentNode = element.parentNode;
-        if (parentNode && parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-            // If the parent is a shadow root, return its host
-            return parentNode.host || null;
-        }
-        return null;
-
-    }
-
-    getFullAncestorChain(element) {
-        if (!element || !(element instanceof Element)) {
-            throw new Error('Invalid element provided');
-        }
-
-        const ancestors = [];
-        let currentElement = element;
-
-        while (currentElement) {
-            ancestors.push(currentElement);
-            currentElement = this.getActualParent(currentElement);
-        }
-
-        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');
-        }
-        if (!targetParent || !(targetParent instanceof Element)) {
-            throw new Error('Invalid target parent provided');
-        }
-
-        let count = 0;
-        let currentElement = element;
-
-        while (currentElement && currentElement !== targetParent) {
-            currentElement = this.getActualParent(currentElement);
-            count++;
-        }
-
-        return currentElement === targetParent ? count : -1; // Return -1 if target parent is not found
-    }
-
-    containsElementCrossShadow(element, target) {
-        if (!element || !(element instanceof Element)) {
-            throw new Error('Invalid element provided');
-        }
-        if (!target || !(target instanceof Element)) {
-            throw new Error('Invalid target provided');
-        }
-
-        // Check if the element contains the target, accounting for shadow DOM
-        let currentElement = target;
-
-        while (currentElement) {
-            if (currentElement === element) {
-                return true;
-            }
-            currentElement = this.getActualParent(currentElement);
-        }
-
-        return false;
-    }
-
-    findLowestCommonAncestor(elements) {
-        if (!Array.isArray(elements) || elements.length === 0) {
-            throw new Error('Invalid elements array provided');
-        }
-
-        // Ensure all elements are valid
-        for (const el of elements) {
-            if (!(el instanceof Element)) {
-                throw new Error('All items in the array must be DOM Elements');
-            }
-        }
-
-        // Start with the first element's ancestors
-        let commonAncestors = this.getFullAncestorChain(elements[0]);
-
-        commonAncestors.reverse(); // Reverse to start from the closest ancestor
-
-        // Iterate through the rest of the elements
-        for (let i = 1; i < elements.length; i++) {
-            const currentAncestors = this.getFullAncestorChain(elements[i]);
-            currentAncestors.reverse(); // Reverse to start from the closest ancestor
-            commonAncestors = commonAncestors.filter(ancestor =>
-                currentAncestors.includes(ancestor)
-            );
-        }
-
-        // Return the lowest common ancestor, or null if none found
-        return commonAncestors.length > 0 ? commonAncestors[commonAncestors.length - 1] : null;
-    }
-
-    /**
+  containsElementCrossShadow(element, target) {
+    if (!element || !(element instanceof Element)) {
+      throw new Error("Invalid element provided");
+    }
+    if (!target || !(target instanceof Element)) {
+      throw new Error("Invalid target provided");
+    }
+
+    // Check if the element contains the target, accounting for shadow DOM
+    let currentElement = target;
+
+    while (currentElement) {
+      if (currentElement === element) {
+        return true;
+      }
+      currentElement = this.getActualParent(currentElement);
+    }
+
+    return false;
+  }
+
+  findLowestCommonAncestor(elements) {
+    if (!Array.isArray(elements) || elements.length === 0) {
+      throw new Error("Invalid elements array provided");
+    }
+
+    // Ensure all elements are valid
+    for (const el of elements) {
+      if (!(el instanceof Element)) {
+        throw new Error("All items in the array must be DOM Elements");
+      }
+    }
+
+    // Start with the first element's ancestors
+    let commonAncestors = this.getFullAncestorChain(elements[0]);
+
+    commonAncestors.reverse(); // Reverse to start from the closest ancestor
+
+    // Iterate through the rest of the elements
+    for (let i = 1; i < elements.length; i++) {
+      const currentAncestors = this.getFullAncestorChain(elements[i]);
+      currentAncestors.reverse(); // Reverse to start from the closest ancestor
+      commonAncestors = commonAncestors.filter((ancestor) => currentAncestors.includes(ancestor));
+    }
+
+    // Return the lowest common ancestor, or null if none found
+    return commonAncestors.length > 0 ? commonAncestors[commonAncestors.length - 1] : null;
+  }
+
+  /**
  *  Finds the branching parent for a target element within an array of elements
  * The branching parent is the direct child of the common ancestor that contains the target
  * @param {Element[]} elements - Array of elements (target must be included)
@@ -139,47 +134,47 @@ class DOM_Parent {
 
  * @returns {Element|null} - The branching parent element, or null if not found
  */
-    findBranchingParent(elements, target) {
-        if (!Array.isArray(elements) || elements.length === 0) {
-            throw new Error('Invalid elements array provided');
-        }
-        if (!(target instanceof Element)) {
-            throw new Error('Target must be a DOM Element');
-        }
-
-        // Ensure all elements are valid
-        for (const el of elements) {
-            if (!(el instanceof Element)) {
-                throw new Error('All items in the array must be DOM Elements');
-            }
-        }
-        // Check if the target is in the elements array
-        if (!elements.includes(target)) {
-            // throw new Error("Target element must be included in the elements array");
-            console.warn("Target element must be included in the elements array, returning null");
-            return null;
-        }
-        const allTargetparents = this.getFullAncestorChain(target);
-
-        //  reverse the order of parents to start from the closest parent
-        allTargetparents.reverse();
-
-        // Find the parent that only contains the target and no other elements
-        let branchingParent = null;
-        for (const parent of allTargetparents) {
-            /// find all elements that are inside this parent
-            const allElementsThatAreInsideParent = elements.filter(el => this.containsElementCrossShadow(parent, el));
-            // If the parent contains only the target element, it is the branching parent
-            if (allElementsThatAreInsideParent.length === 1 && allElementsThatAreInsideParent[0] === target) {
-                branchingParent = parent;
-                break;
-            }
-        }
-        if (branchingParent) {
-            return branchingParent;
-        }
-
-        return null; // No branching parent found
+  findBranchingParent(elements, target) {
+    if (!Array.isArray(elements) || elements.length === 0) {
+      throw new Error("Invalid elements array provided");
+    }
+    if (!(target instanceof Element)) {
+      throw new Error("Target must be a DOM Element");
     }
+
+    // Ensure all elements are valid
+    for (const el of elements) {
+      if (!(el instanceof Element)) {
+        throw new Error("All items in the array must be DOM Elements");
+      }
+    }
+    // Check if the target is in the elements array
+    if (!elements.includes(target)) {
+      // throw new Error("Target element must be included in the elements array");
+      console.warn("Target element must be included in the elements array, returning null");
+      return null;
+    }
+    const allTargetparents = this.getFullAncestorChain(target);
+
+    //  reverse the order of parents to start from the closest parent
+    allTargetparents.reverse();
+
+    // Find the parent that only contains the target and no other elements
+    let branchingParent = null;
+    for (const parent of allTargetparents) {
+      /// find all elements that are inside this parent
+      const allElementsThatAreInsideParent = elements.filter((el) => this.containsElementCrossShadow(parent, el));
+      // If the parent contains only the target element, it is the branching parent
+      if (allElementsThatAreInsideParent.length === 1 && allElementsThatAreInsideParent[0] === target) {
+        branchingParent = parent;
+        break;
+      }
+    }
+    if (branchingParent) {
+      return branchingParent;
+    }
+
+    return null; // No branching parent found
+  }
 }
-export default DOM_Parent;
+export default DOM_Parent;

package/bin/assets/scripts/event_utils.js

@@ -4,102 +4,102 @@ const closestCrossShadow = __PW.domUtils.closestCrossShadow;
 const isElementVisible = __PW.domUtils.isElementVisible;
 
 export default class EventUtils {
-    deepEventTarget(event) {
-        return event.composedPath()[0];
-    }
-    deepActiveElement(document) {
-        let activeElement = document.activeElement;
-        while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)
-            activeElement = activeElement.shadowRoot.activeElement;
-        return activeElement;
-    }
-    modifiersForEvent(event) {
-        return (event.altKey ? 1 : 0) | (event.ctrlKey ? 2 : 0) | (event.metaKey ? 4 : 0) | (event.shiftKey ? 8 : 0);
-    }
-    buttonForEvent(event) {
-        switch (event.which) {
-            case 1:
-                return "left";
-            case 2:
-                return "middle";
-            case 3:
-                return "right";
-        }
+  deepEventTarget(event) {
+    return event.composedPath()[0];
+  }
+  deepActiveElement(document) {
+    let activeElement = document.activeElement;
+    while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)
+      activeElement = activeElement.shadowRoot.activeElement;
+    return activeElement;
+  }
+  modifiersForEvent(event) {
+    return (event.altKey ? 1 : 0) | (event.ctrlKey ? 2 : 0) | (event.metaKey ? 4 : 0) | (event.shiftKey ? 8 : 0);
+  }
+  buttonForEvent(event) {
+    switch (event.which) {
+      case 1:
         return "left";
+      case 2:
+        return "middle";
+      case 3:
+        return "right";
     }
-    positionForEvent(event) {
-        const targetElement = event.target;
-        if (targetElement.nodeName !== "CANVAS") return;
-        return {
-            x: event.offsetX,
-            y: event.offsetY,
-        };
-    }
-    consumeEvent(e) {
-        e.preventDefault();
-        e.stopPropagation();
-        e.stopImmediatePropagation();
-    }
-    asCheckbox(node) {
-        if (!node || node.nodeName !== "INPUT") return null;
-        const inputElement = node;
-        return ["checkbox", "radio"].includes(inputElement.type) ? inputElement : null;
-    }
-    isRangeInput(node) {
-        if (!node || node.nodeName !== "INPUT") return false;
-        const inputElement = node;
-        return inputElement.type.toLowerCase() === "range";
-    }
-    addEventListener(target, eventName, listener, useCapture) {
-        target.addEventListener(eventName, listener, useCapture);
-        const remove = () => {
-            target.removeEventListener(eventName, listener, useCapture);
-        };
-        return remove;
-    }
-    removeEventListeners(listeners) {
-        for (const listener of listeners) listener();
-        listeners.splice(0, listeners.length);
-    }
+    return "left";
+  }
+  positionForEvent(event) {
+    const targetElement = event.target;
+    if (targetElement.nodeName !== "CANVAS") return;
+    return {
+      x: event.offsetX,
+      y: event.offsetY,
+    };
+  }
+  consumeEvent(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.stopImmediatePropagation();
+  }
+  asCheckbox(node) {
+    if (!node || node.nodeName !== "INPUT") return null;
+    const inputElement = node;
+    return ["checkbox", "radio"].includes(inputElement.type) ? inputElement : null;
+  }
+  isRangeInput(node) {
+    if (!node || node.nodeName !== "INPUT") return false;
+    const inputElement = node;
+    return inputElement.type.toLowerCase() === "range";
+  }
+  addEventListener(target, eventName, listener, useCapture) {
+    target.addEventListener(eventName, listener, useCapture);
+    const remove = () => {
+      target.removeEventListener(eventName, listener, useCapture);
+    };
+    return remove;
+  }
+  removeEventListeners(listeners) {
+    for (const listener of listeners) listener();
+    listeners.splice(0, listeners.length);
+  }
 
-    getNearestInteractiveElement(targetElement, root = window.document) {
-        try {
-            if (!targetElement.matches("input,textarea,select") && !targetElement.isContentEditable) {
-                const interactiveParent = closestCrossShadow(
-                    targetElement,
-                    "button,select,input,[role=button],[role=checkbox],[role=radio],a,[role=link]",
-                    root
-                );
-                if (interactiveParent && isElementVisible(interactiveParent)) return interactiveParent;
-            }
-            return targetElement;
-        } catch (e) {
-            console.error(e);
-            // bvtRecorderBindings.log(`Error in getNearestInteractiveElement: ${e.message}`);
-            return targetElement;
-        }
+  getNearestInteractiveElement(targetElement, root = window.document) {
+    try {
+      if (!targetElement.matches("input,textarea,select") && !targetElement.isContentEditable) {
+        const interactiveParent = closestCrossShadow(
+          targetElement,
+          "button,select,input,[role=button],[role=checkbox],[role=radio],a,[role=link]",
+          root
+        );
+        if (interactiveParent && isElementVisible(interactiveParent)) return interactiveParent;
+      }
+      return targetElement;
+    } catch (e) {
+      console.error(e);
+      // bvtRecorderBindings.log(`Error in getNearestInteractiveElement: ${e.message}`);
+      return targetElement;
     }
-    shouldGenerateKeyPressFor(event) {
-        // Enter aka. new line is handled in input event.
-        if (
-            event.key === "Enter" &&
-            (this.deepEventTarget(event).nodeName === "TEXTAREA" || this.deepEventTarget(event).isContentEditable)
-        )
-            return false;
-        // Backspace, Delete, AltGraph are changing input, will handle it there.
-        if (["Backspace", "Delete", "AltGraph"].includes(event.key)) return false;
-        // Ignore the QWERTZ shortcut for creating a at sign on MacOS
-        if (event.key === "@" && event.code === "KeyL") return false;
-        // Allow and ignore common used shortcut for pasting.
-        if (navigator.platform.includes("Mac")) {
-            if (event.key === "v" && event.metaKey) return false;
-        } else {
-            if (event.key === "v" && event.ctrlKey) return false;
-            if (event.key === "Insert" && event.shiftKey) return false;
-        }
-        if (["Shift", "Control", "Meta", "Alt", "Process"].includes(event.key)) return false;
-        const hasModifier = event.ctrlKey || event.altKey || event.metaKey;
-        if (event.key.length === 1 && !hasModifier) return !!this.asCheckbox(this.deepEventTarget(event));
-        return true;
+  }
+  shouldGenerateKeyPressFor(event) {
+    // Enter aka. new line is handled in input event.
+    if (
+      event.key === "Enter" &&
+      (this.deepEventTarget(event).nodeName === "TEXTAREA" || this.deepEventTarget(event).isContentEditable)
+    )
+      return false;
+    // Backspace, Delete, AltGraph are changing input, will handle it there.
+    if (["Backspace", "Delete", "AltGraph"].includes(event.key)) return false;
+    // Ignore the QWERTZ shortcut for creating a at sign on MacOS
+    if (event.key === "@" && event.code === "KeyL") return false;
+    // Allow and ignore common used shortcut for pasting.
+    if (navigator.platform.includes("Mac")) {
+      if (event.key === "v" && event.metaKey) return false;
+    } else {
+      if (event.key === "v" && event.ctrlKey) return false;
+      if (event.key === "Insert" && event.shiftKey) return false;
     }
-}
+    if (["Shift", "Control", "Meta", "Alt", "Process"].includes(event.key)) return false;
+    const hasModifier = event.ctrlKey || event.altKey || event.metaKey;
+    if (event.key.length === 1 && !hasModifier) return !!this.asCheckbox(this.deepEventTarget(event));
+    return true;
+  }
+}