webdriverio 7.17.0 → 7.17.3

package/build/scripts/isElementDisplayed.js

@@ -0,0 +1,216 @@
+"use strict";
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * check if element is visible
+ * @param  {HTMLElement} elem  element to check
+ * @return {Boolean}           true if element is within viewport
+ */
+function isElementDisplayed(element) {
+    function nodeIsElement(node) {
+        if (!node) {
+            return false;
+        }
+        switch (node.nodeType) {
+            case Node.ELEMENT_NODE:
+            case Node.DOCUMENT_NODE:
+            case Node.DOCUMENT_FRAGMENT_NODE:
+                return true;
+            default:
+                return false;
+        }
+    }
+    function parentElementForElement(element) {
+        if (!element) {
+            return null;
+        }
+        return enclosingNodeOrSelfMatchingPredicate(element.parentNode, nodeIsElement);
+    }
+    function enclosingNodeOrSelfMatchingPredicate(targetNode, predicate) {
+        for (let node = targetNode; node && node !== targetNode.ownerDocument; node = node.parentNode)
+            if (predicate(node)) {
+                return node;
+            }
+        return null;
+    }
+    function enclosingElementOrSelfMatchingPredicate(targetElement, predicate) {
+        for (let element = targetElement; element && element !== targetElement.ownerDocument; element = parentElementForElement(element))
+            if (predicate(element)) {
+                return element;
+            }
+        return null;
+    }
+    function cascadedStylePropertyForElement(element, property) {
+        if (!element || !property) {
+            return null;
+        }
+        // if document-fragment, skip it and use element.host instead. This happens
+        // when the element is inside a shadow root.
+        // window.getComputedStyle errors on document-fragment.
+        if (element instanceof DocumentFragment) {
+            element = element.host;
+        }
+        let computedStyle = window.getComputedStyle(element);
+        let computedStyleProperty = computedStyle.getPropertyValue(property);
+        if (computedStyleProperty && computedStyleProperty !== 'inherit') {
+            return computedStyleProperty;
+        }
+        // Ideally getPropertyValue would return the 'used' or 'actual' value, but
+        // it doesn't for legacy reasons. So we need to do our own poor man's cascade.
+        // Fall back to the first non-'inherit' value found in an ancestor.
+        // In any case, getPropertyValue will not return 'initial'.
+        // FIXME: will this incorrectly inherit non-inheritable CSS properties?
+        // I think all important non-inheritable properties (width, height, etc.)
+        // for our purposes here are specially resolved, so this may not be an issue.
+        // Specification is here: https://drafts.csswg.org/cssom/#resolved-values
+        let parentElement = parentElementForElement(element);
+        return cascadedStylePropertyForElement(parentElement, property);
+    }
+    function elementSubtreeHasNonZeroDimensions(element) {
+        let boundingBox = element.getBoundingClientRect();
+        if (boundingBox.width > 0 && boundingBox.height > 0) {
+            return true;
+        }
+        // Paths can have a zero width or height. Treat them as shown if the stroke width is positive.
+        if (element.tagName.toUpperCase() === 'PATH' && boundingBox.width + boundingBox.height > 0) {
+            let strokeWidth = cascadedStylePropertyForElement(element, 'stroke-width');
+            return !!strokeWidth && (parseInt(strokeWidth, 10) > 0);
+        }
+        let cascadedOverflow = cascadedStylePropertyForElement(element, 'overflow');
+        if (cascadedOverflow === 'hidden') {
+            return false;
+        }
+        // If the container's overflow is not hidden and it has zero size, consider the
+        // container to have non-zero dimensions if a child node has non-zero dimensions.
+        return Array.from(element.childNodes).some((childNode) => {
+            if (childNode.nodeType === Node.TEXT_NODE) {
+                return true;
+            }
+            if (nodeIsElement(childNode)) {
+                return elementSubtreeHasNonZeroDimensions(childNode);
+            }
+            return false;
+        });
+    }
+    function elementOverflowsContainer(element) {
+        let cascadedOverflow = cascadedStylePropertyForElement(element, 'overflow');
+        if (cascadedOverflow !== 'hidden') {
+            return false;
+        }
+        // FIXME: this needs to take into account the scroll position of the element,
+        // the display modes of it and its ancestors, and the container it overflows.
+        // See Selenium's bot.dom.getOverflowState atom for an exhaustive list of edge cases.
+        return true;
+    }
+    function isElementSubtreeHiddenByOverflow(element) {
+        if (!element) {
+            return false;
+        }
+        if (!elementOverflowsContainer(element)) {
+            return false;
+        }
+        if (!element.childNodes.length) {
+            return false;
+        }
+        // This element's subtree is hidden by overflow if all child subtrees are as well.
+        return Array.from(element.childNodes).every((childNode) => {
+            // Returns true if the child node is overflowed or otherwise hidden.
+            // Base case: not an element, has zero size, scrolled out, or doesn't overflow container.
+            // Visibility of text nodes is controlled by parent
+            if (childNode.nodeType === Node.TEXT_NODE) {
+                return false;
+            }
+            if (!nodeIsElement(childNode)) {
+                return true;
+            }
+            if (!elementSubtreeHasNonZeroDimensions(childNode)) {
+                return true;
+            }
+            // Recurse.
+            return isElementSubtreeHiddenByOverflow(childNode);
+        });
+    }
+    // walk up the tree testing for a shadow root
+    function isElementInsideShadowRoot(element) {
+        if (!element) {
+            return false;
+        }
+        if (element.parentNode && element.parentNode.host) {
+            return true;
+        }
+        return isElementInsideShadowRoot(element.parentNode);
+    }
+    // This is a partial reimplementation of Selenium's "element is displayed" algorithm.
+    // When the W3C specification's algorithm stabilizes, we should implement that.
+    // If this command is misdirected to the wrong document (and is NOT inside a shadow root), treat it as not shown.
+    if (!isElementInsideShadowRoot(element) && !document.contains(element)) {
+        return false;
+    }
+    // Special cases for specific tag names.
+    switch (element.tagName.toUpperCase()) {
+        case 'BODY':
+            return true;
+        case 'SCRIPT':
+        case 'NOSCRIPT':
+            return false;
+        case 'OPTGROUP':
+        case 'OPTION': {
+            // Option/optgroup are considered shown if the containing <select> is shown.
+            let enclosingSelectElement = enclosingNodeOrSelfMatchingPredicate(element, (e) => e.tagName.toUpperCase() === 'SELECT');
+            return isElementDisplayed(enclosingSelectElement);
+        }
+        case 'INPUT':
+            // <input type="hidden"> is considered not shown.
+            if (element.type === 'hidden') {
+                return false;
+            }
+            break;
+        // case 'MAP':
+        // FIXME: Selenium has special handling for <map> elements. We don't do anything now.
+        default:
+            break;
+    }
+    if (cascadedStylePropertyForElement(element, 'visibility') !== 'visible') {
+        return false;
+    }
+    let hasAncestorWithZeroOpacity = !!enclosingElementOrSelfMatchingPredicate(element, (e) => {
+        return Number(cascadedStylePropertyForElement(e, 'opacity')) === 0;
+    });
+    let hasAncestorWithDisplayNone = !!enclosingElementOrSelfMatchingPredicate(element, (e) => {
+        return cascadedStylePropertyForElement(e, 'display') === 'none';
+    });
+    if (hasAncestorWithZeroOpacity || hasAncestorWithDisplayNone) {
+        return false;
+    }
+    if (!elementSubtreeHasNonZeroDimensions(element)) {
+        return false;
+    }
+    if (isElementSubtreeHiddenByOverflow(element)) {
+        return false;
+    }
+    return true;
+}
+exports.default = isElementDisplayed;

package/build/scripts/isElementInViewport.d.ts

@@ -0,0 +1,10 @@
+/**
+ * check if element is within the viewport
+ * https://gist.github.com/davidtheclark/5515733#gistcomment-2113205
+ *
+ * Please update `isElementClickable.js` if the script is updated!
+ * @param  {HTMLElement} elem  element to check
+ * @return {Boolean}           true if element is within viewport
+ */
+export default function isElementInViewport(elem: HTMLElement): boolean;
+//# sourceMappingURL=isElementInViewport.d.ts.map

package/build/scripts/isElementInViewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isElementInViewport.d.ts","sourceRoot":"","sources":["../../src/scripts/isElementInViewport.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAE,IAAI,EAAE,WAAW,WAc7D"}

package/build/scripts/isElementInViewport.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * check if element is within the viewport
+ * https://gist.github.com/davidtheclark/5515733#gistcomment-2113205
+ *
+ * Please update `isElementClickable.js` if the script is updated!
+ * @param  {HTMLElement} elem  element to check
+ * @return {Boolean}           true if element is within viewport
+ */
+function isElementInViewport(elem) {
+    if (!elem.getBoundingClientRect) {
+        return false;
+    }
+    const rect = elem.getBoundingClientRect();
+    const windowHeight = (window.innerHeight || document.documentElement.clientHeight);
+    const windowWidth = (window.innerWidth || document.documentElement.clientWidth);
+    const vertInView = (rect.top <= windowHeight) && ((rect.top + rect.height) > 0);
+    const horInView = (rect.left <= windowWidth) && ((rect.left + rect.width) > 0);
+    return (vertInView && horInView);
+}
+exports.default = isElementInViewport;

package/build/scripts/isFocused.d.ts

@@ -0,0 +1,7 @@
+/**
+ * checks if given element is focused
+ * @param  {HTMLElement} elem  element to check
+ * @return {Boolean}           true if element is focused
+ */
+export default function isFocused(elem: Element): boolean;
+//# sourceMappingURL=isFocused.d.ts.map

package/build/scripts/isFocused.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFocused.d.ts","sourceRoot":"","sources":["../../src/scripts/isFocused.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAE,IAAI,EAAE,OAAO,WAE/C"}

package/build/scripts/isFocused.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * checks if given element is focused
+ * @param  {HTMLElement} elem  element to check
+ * @return {Boolean}           true if element is focused
+ */
+function isFocused(elem) {
+    return elem === document.activeElement;
+}
+exports.default = isFocused;

package/build/scripts/newWindow.d.ts

@@ -0,0 +1,10 @@
+/**
+ * opens new window via window.open
+ * @param  {String} url            The URL to be loaded in the newly opened window.
+ * @param  {String} windowName     A string name for the new window.
+ * @param  {String} windowFeatures An optional parameter listing the features (size, position, scrollbars, etc.) of the new window as a string.
+ *
+ * @see  https://developer.mozilla.org/en-US/docs/Web/API/Window.open
+ */
+export default function newWindow(url: string, windowName: string, windowFeatures: string): void;
+//# sourceMappingURL=newWindow.d.ts.map

package/build/scripts/newWindow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newWindow.d.ts","sourceRoot":"","sources":["../../src/scripts/newWindow.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC7B,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,QAGzB"}

package/build/scripts/newWindow.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * opens new window via window.open
+ * @param  {String} url            The URL to be loaded in the newly opened window.
+ * @param  {String} windowName     A string name for the new window.
+ * @param  {String} windowFeatures An optional parameter listing the features (size, position, scrollbars, etc.) of the new window as a string.
+ *
+ * @see  https://developer.mozilla.org/en-US/docs/Web/API/Window.open
+ */
+function newWindow(url, windowName, windowFeatures) {
+    window.open(url, windowName || '', windowFeatures || '');
+}
+exports.default = newWindow;

package/build/scripts/resq.d.ts

@@ -0,0 +1,6 @@
+export declare const waitToLoadReact: () => void;
+export declare const react$: (selector: string, props: any[], state: Record<string, any>, reactElement: HTMLElement) => HTMLElement | {
+    message: string;
+} | null;
+export declare const react$$: (selector: string, props: any[], state: Record<string, string>, reactElement: HTMLElement) => HTMLElement[];
+//# sourceMappingURL=resq.d.ts.map

package/build/scripts/resq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resq.d.ts","sourceRoot":"","sources":["../../src/scripts/resq.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe,YAE3B,CAAA;AAED,eAAO,MAAM,MAAM,aACL,MAAM,SACT,GAAG,EAAE,SACL,OAAO,MAAM,EAAE,GAAG,CAAC,gBACZ,WAAW;;QA0B5B,CAAA;AAED,eAAO,MAAM,OAAO,aACN,MAAM,SACT,GAAG,EAAE,SACL,OAAO,MAAM,EAAE,MAAM,CAAC,gBACf,WAAW,kBAkC5B,CAAA"}

package/build/scripts/resq.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.react$$ = exports.react$ = exports.waitToLoadReact = void 0;
+const waitToLoadReact = function waitToLoadReact() {
+    window.resq.waitToLoadReact();
+};
+exports.waitToLoadReact = waitToLoadReact;
+const react$ = function react$(selector, props, state, reactElement) {
+    props = props || {};
+    state = state || {};
+    let element = window.resq.resq$(selector, reactElement);
+    if (Object.keys(props).length) {
+        // not yet typed https://github.com/baruchvlz/resq/issues/69
+        element = element.byProps(props);
+    }
+    if (Object.keys(state).length) {
+        // not yet typed https://github.com/baruchvlz/resq/issues/69
+        element = element.byState(state);
+    }
+    if (!element.name) {
+        return { message: `React element with selector "${selector}" wasn't found` };
+    }
+    // resq returns an array of HTMLElements if the React component is a fragment
+    // if the element is a fragment, we return the first child to be passed into the driver
+    return element.isFragment && element.node
+        ? element.node[0]
+        : element.node;
+};
+exports.react$ = react$;
+const react$$ = function react$$(selector, props, state, reactElement) {
+    let elements = window.resq.resq$$(selector, reactElement);
+    if (Object.keys(props).length) {
+        // not yet typed https://github.com/baruchvlz/resq/issues/69
+        elements = elements.byProps(props);
+    }
+    if (Object.keys(state).length) {
+        // not yet typed https://github.com/baruchvlz/resq/issues/69
+        elements = elements.byState(state);
+    }
+    if (!elements.length) {
+        return [];
+    }
+    // resq returns an array of HTMLElements if the React component is a fragment
+    // this avoids having nested arrays of nodes which the driver does not understand
+    // [[div, div], [div, div]] => [div, div, div, div]
+    let nodes = [];
+    elements.forEach(element => {
+        const { node, isFragment } = element;
+        if (isFragment) {
+            nodes = nodes.concat(node || []);
+        }
+        else if (node) {
+            nodes.push(node);
+        }
+    });
+    return [...nodes];
+};
+exports.react$$ = react$$;

package/build/scripts/shadowFnFactory.d.ts

@@ -0,0 +1,2 @@
+export declare const shadowFnFactory: (elementSelector: string, qsAll?: boolean) => any;
+//# sourceMappingURL=shadowFnFactory.d.ts.map

package/build/scripts/shadowFnFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowFnFactory.d.ts","sourceRoot":"","sources":["../../src/scripts/shadowFnFactory.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,oBAA6B,MAAM,yBAW9D,CAAA"}

package/build/scripts/shadowFnFactory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shadowFnFactory = void 0;
+// generate a function that can be used to query shadowRoots
+const shadowFnFactory = function (elementSelector, qsAll = false) {
+    const strFn = `
+    (function() {
+      // element has a shadowRoot property
+      if (this.shadowRoot) {
+        return this.shadowRoot.querySelector${qsAll ? 'All' : ''}('${elementSelector}')
+      }
+      // fall back to querying the element directly if not
+      return this.querySelector${qsAll ? 'All' : ''}('${elementSelector}')
+    })`;
+    return eval(strFn);
+};
+exports.shadowFnFactory = shadowFnFactory;