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

package/bin/assets/scripts/dom_parent.js

@@ -0,0 +1,185 @@
+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
+    }
+
+    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)
+ * @param {Element} target - Target element to find branching parent for
+
+ * @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
+    }
+}
+export default DOM_Parent;

package/bin/assets/scripts/event_utils.js

@@ -0,0 +1,105 @@
+import { __PW } from "./pw";
+
+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";
+        }
+        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;
+        }
+    }
+    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;
+    }
+}