@serenity-js/webdriverio 2.33.1 → 3.0.0-rc.11

package/src/screenplay/models/WebdriverIOFrame.ts

@@ -0,0 +1,38 @@
+import { LogicError } from '@serenity-js/core';
+import { Frame, Locator } from '@serenity-js/web';
+import * as wdio from 'webdriverio';
+
+export class WebdriverIOFrame extends Frame<wdio.Element<'async'>> {
+    constructor(
+        private readonly browser: wdio.Browser<'async'>,
+        locator: Locator<wdio.Element<'async'>>
+    ) {
+        super(locator);
+    }
+
+    async isPresent(): Promise<boolean> {
+        const element = await this.locator.nativeElement();
+        return element.isExisting();
+    }
+
+    async switchTo(): Promise<{ switchBack(): Promise<void> }> {
+        const element: wdio.Element<'async'> = await this.locator.nativeElement()
+
+        if (element.error) {
+            throw new LogicError(`Couldn't locate frame ${ this.locator }`, element.error);
+        }
+
+        try {
+            await this.browser.switchToFrame(element);
+
+            return {
+                switchBack: async (): Promise<void> => {
+                    await this.browser.switchToParentFrame();
+                }
+            }
+        }
+        catch (error) {
+            throw new LogicError(`Couldn't switch to a frame located ${ this.locator }`, error);
+        }
+    }
+}

package/src/screenplay/models/WebdriverIOModalDialog.ts

@@ -0,0 +1,45 @@
+import { ModalDialog } from '@serenity-js/web';
+import { Browser } from 'webdriverio';
+
+export class WebdriverIOModalDialog extends ModalDialog {
+    constructor(private readonly browser: Browser<'async'>) {
+        super();
+    }
+
+    accept(): Promise<void> {
+        return this.browser.acceptAlert();
+    }
+
+    dismiss(): Promise<void> {
+        return this.browser.dismissAlert();
+    }
+    text(): Promise<string> {
+        return this.browser.getAlertText();
+    }
+
+    async enterValue(value: string | number | (string | number)[]): Promise<void> {
+        const text = [].concat(value).join('');
+
+        await this.browser.sendAlertText(text);
+
+        // Puppeteer auto-accepts the dialog upon sendAlertText
+        // other implementations require the dialog to be closed
+        if (! this.browser.isDevTools) {
+            await this.browser.acceptAlert();
+        }
+    }
+
+    isPresent(): Promise<boolean> {
+        return this.browser.getAlertText()
+            .then(() => true, error => {
+                if (error && (
+                    error.name === 'no such alert'
+                    || error.message.startsWith('no such alert')
+                )) {
+                    return false;
+                }
+
+                throw error;
+            });
+    }
+}

package/src/screenplay/models/WebdriverIOPage.ts

@@ -0,0 +1,128 @@
+import { Page } from '@serenity-js/web';
+import { URL } from 'url';
+import * as wdio from 'webdriverio';
+
+export class WebdriverIOPage extends Page {
+    constructor(
+        private readonly browser: wdio.Browser<'async'>,
+        handle: string
+    ) {
+        super(handle);
+    }
+
+    title(): Promise<string> {
+        return this.switchToAndPerform(async browser => {
+            return browser.getTitle();
+        });
+    }
+
+    name(): Promise<string> {
+        return this.switchToAndPerform(async browser => {
+            return browser.execute(`return window.name`);
+        });
+    }
+
+    async url(): Promise<URL> {
+        return this.switchToAndPerform(async browser => {
+            return new URL(await browser.getUrl());
+        });
+    }
+
+    async viewportSize(): Promise<{ width: number, height: number }> {
+        return this.switchToAndPerform(async browser => {
+            if (! browser.isDevTools) {
+                const calculatedViewportSize = await browser.execute(`
+                    return {
+                        width:  Math.max(document.documentElement.clientWidth,  window.innerWidth || 0),
+                        height: Math.max(document.documentElement.clientHeight, window.innerHeight || 0),
+                    }
+                `) as { width: number, height: number };
+
+                // Chrome headless hard-codes window.innerWidth and window.innerHeight to 0
+                if (calculatedViewportSize.width > 0 && calculatedViewportSize.height > 0) {
+                    return calculatedViewportSize;
+                }
+            }
+
+            return browser.getWindowSize();
+        });
+    }
+
+    setViewportSize(size: { width: number, height: number }): Promise<void> {
+        return this.switchToAndPerform(async browser => {
+            let desiredWindowSize = size;
+
+            if (! browser.isDevTools) {
+                desiredWindowSize = await browser.execute(`
+                var currentViewportWidth  = Math.max(document.documentElement.clientWidth, window.innerWidth || 0)
+                var currentViewportHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0)
+                
+                return {
+                    width:  Math.max(window.outerWidth  - currentViewportWidth  + ${ size.width },  ${ size.width }),
+                    height: Math.max(window.outerHeight - currentViewportHeight + ${ size.height }, ${ size.height }),
+                };
+            `);
+            }
+
+            return browser.setWindowSize(desiredWindowSize.width, desiredWindowSize.height);
+        });
+    }
+
+    async close(): Promise<void> {
+        return this.switchToAndPerform(browser => browser.closeWindow());
+    }
+
+    async closeOthers(): Promise<void> {
+        const windowHandles = await this.browser.getWindowHandles();
+
+        for (const handle of windowHandles) {
+            if (handle !== this.handle) {
+                await this.browser.switchToWindow(handle);
+                await this.browser.closeWindow();
+            }
+        }
+
+        await this.browser.switchToWindow(this.handle);
+    }
+
+    async isPresent(): Promise<boolean> {
+        const currentPageHandle = await this.browser.getWindowHandle();
+        const desiredPageHandle = this.handle;
+
+        const isOpen = await this.browser.switchToWindow(desiredPageHandle).then(() => true, _error => false);
+
+        await this.browser.switchToWindow(currentPageHandle);
+
+        return isOpen;
+    }
+
+    async switchTo(): Promise<{ switchBack(): Promise<void> }> {
+        const originalWindowHandle = await this.browser.getWindowHandle();
+
+        await this.browser.switchToWindow(this.handle);
+
+        return {
+            switchBack: async (): Promise<void> => {
+                await this.browser.switchToWindow(originalWindowHandle);
+            }
+        }
+    }
+
+    private async switchToAndPerform<T>(action: (browser: wdio.Browser<'async'>) => Promise<T> | T): Promise<T> {
+        const currentPageHandle = await this.browser.getWindowHandle();
+        const desiredPageHandle = this.handle;
+        const shouldSwitch      = currentPageHandle !== desiredPageHandle;
+
+        if (shouldSwitch) {
+            await this.browser.switchToWindow(desiredPageHandle);
+        }
+
+        const result = await action(this.browser);
+
+        if (shouldSwitch) {
+            await this.browser.switchToWindow(currentPageHandle);
+        }
+
+        return result;
+    }
+}

package/src/screenplay/models/WebdriverIOPageElement.ts

@@ -0,0 +1,227 @@
+import { PageElement } from '@serenity-js/web';
+import * as wdio from 'webdriverio';
+
+export class WebdriverIOPageElement
+    extends PageElement<wdio.Element<'async'>>
+{
+    of(parent: WebdriverIOPageElement): WebdriverIOPageElement {
+        return new WebdriverIOPageElement(this.locator.of(parent.locator))
+    }
+
+    async clearValue(): Promise<void> {
+        const element = await this.nativeElement();
+        return element.clearValue();
+    }
+
+    async click(): Promise<void> {
+        const element = await this.nativeElement();
+        return element.click();
+    }
+
+    async doubleClick(): Promise<void> {
+        const element = await this.nativeElement();
+        return element.doubleClick();
+    }
+
+    async enterValue(value: string | number | Array<string | number>): Promise<void> {
+        const element = await this.nativeElement();
+        return element.addValue(value);
+    }
+
+    async scrollIntoView(): Promise<void> {
+        const element = await this.nativeElement();
+        return element.scrollIntoView();
+    }
+
+    async hoverOver(): Promise<void> {
+        const element = await this.nativeElement();
+        return element.moveTo();
+    }
+
+    async rightClick(): Promise<void> {
+        const element = await this.nativeElement();
+        return element.click({ button: 'right' });
+    }
+
+    async attribute(name: string): Promise<string> {
+        const element = await this.nativeElement();
+        return element.getAttribute(name);
+    }
+
+    async text(): Promise<string> {
+        const element = await this.nativeElement();
+        return element.getText();
+    }
+
+    async value(): Promise<string> {
+        const element = await this.nativeElement();
+        return element.getValue();
+    }
+
+    async isActive(): Promise<boolean> {
+        const element = await this.nativeElement();
+        return element.isFocused();
+    }
+
+    async isClickable(): Promise<boolean> {
+        const element = await this.nativeElement();
+        return element.isClickable();
+    }
+
+    async isEnabled(): Promise<boolean> {
+        const element = await this.nativeElement();
+        return element.isEnabled();
+    }
+
+    async isPresent(): Promise<boolean> {
+        const element = await this.nativeElement();
+        return element.isExisting();
+    }
+
+    async isSelected(): Promise<boolean> {
+        const element = await this.nativeElement();
+        return element.isSelected();
+    }
+
+    /**
+     * @desc
+     *  Checks if the PageElement:
+     *  - is displayed,
+     *  - is visible within the browser viewport,
+     *  - has not its center covered by other elements
+     *
+     * @see https://webdriver.io/docs/api/element/isDisplayedInViewport/
+     */
+    async isVisible(): Promise<boolean> { // isVisible?
+        const element = await this.nativeElement();
+
+        if (! await element.isDisplayed()) {
+            return false;
+        }
+
+        if (! await element.isDisplayedInViewport()) {
+            return false;
+        }
+
+        const browser = await this.browserFor(element);
+
+        /* eslint-disable no-var,unicorn/consistent-function-scoping,unicorn/prevent-abbreviations,@typescript-eslint/ban-ts-comment,unicorn/no-for-loop,prefer-const */
+
+        // get element at cx/cy and see if the element we found is our element, and therefore it's visible.
+        return browser.execute(
+            /* istanbul ignore next */
+            function isVisible(element: any) {
+
+                if (!element.getBoundingClientRect || !element.scrollIntoView || !element.contains || !element.getClientRects || !document.elementFromPoint) {
+                    return false
+                }
+
+                // Edge before switching to Chromium
+                const isOldEdge = !!window['StyleMedia']
+
+                // get overlapping element
+                function getOverlappingElement (elem: HTMLElement, context?: Document) {
+                    context = context || document
+                    const elemDimension = elem.getBoundingClientRect()
+                    const x = elemDimension.left + (elem.clientWidth / 2)
+                    const y = elemDimension.top + (elem.clientHeight / 2)
+                    return context.elementFromPoint(x, y)
+                }
+
+                // get overlapping element rects (currently only the first)
+                // applicable if element's text is multiline.
+                function getOverlappingRects (elem: HTMLElement, context?: Document) {
+                    context = context || document
+                    const elems = []
+
+                    const rects = elem.getClientRects()
+                    // webdriver clicks on center of the first element's rect (line of text), it might change in future
+                    const rect = rects[0]
+                    const x = rect.left + (rect.width / 2)
+                    const y = rect.top + (rect.height / 2)
+                    elems.push(context.elementFromPoint(x, y))
+
+                    return elems
+                }
+
+                // get overlapping elements
+                function getOverlappingElements (elem: HTMLElement, context?: Document) {
+                    return [getOverlappingElement(elem, context)].concat(getOverlappingRects(elem, context))
+                }
+
+                // is a node a descendant of a given node
+                function nodeContains (elem: HTMLElement, otherNode: HTMLElement) {
+                    // Edge doesn't support neither Shadow Dom nor contains if ShadowRoot polyfill is used
+                    if (isOldEdge) {
+                        let tmpElement = otherNode as HTMLElement | ShadowRoot | Element
+                        while (tmpElement) {
+                            if (tmpElement === elem) {
+                                return true
+                            }
+
+                            tmpElement = tmpElement.parentNode as ShadowRoot
+                            // DocumentFragment / ShadowRoot polyfill like ShadyRoot
+                            if (tmpElement && tmpElement.nodeType === 11 && tmpElement.host) {
+                                tmpElement = tmpElement.host
+                            }
+                        }
+                        return false
+                    }
+
+                    return elem.contains(otherNode)
+                }
+
+                // is one of overlapping elements the `elem` or one of its child
+                function isOverlappingElementMatch (elementsFromPoint: HTMLElement[], elem: HTMLElement): boolean {
+                    if (elementsFromPoint.some(function (elementFromPoint) {
+                        return elementFromPoint === elem || nodeContains(elem, elementFromPoint)
+                    })) {
+                        return true
+                    }
+
+                    // shadow root
+                    // filter unique elements with shadowRoot
+                    // @ts-ignore
+                    let elemsWithShadowRoot = [].concat(elementsFromPoint)
+                    elemsWithShadowRoot = elemsWithShadowRoot.filter(function (x: HTMLElement) {
+                        return x && x.shadowRoot && x.shadowRoot.elementFromPoint
+                    })
+
+                    // getOverlappingElements of every element with shadowRoot
+                    let shadowElementsFromPoint: HTMLElement[] = []
+                    for (let i = 0; i < elemsWithShadowRoot.length; ++i) {
+                        let shadowElement = elemsWithShadowRoot[i]
+                        shadowElementsFromPoint = shadowElementsFromPoint.concat(
+                            getOverlappingElements(elem, (shadowElement as HTMLElement).shadowRoot as any) as any
+                        )
+                    }
+                    // remove duplicates and parents
+                    // @ts-ignore
+                    shadowElementsFromPoint = [].concat(shadowElementsFromPoint)
+                    shadowElementsFromPoint = shadowElementsFromPoint.filter(function (x) {
+                        return !elementsFromPoint.includes(x)
+                    })
+
+                    if (shadowElementsFromPoint.length === 0) {
+                        return false
+                    }
+
+                    return isOverlappingElementMatch(shadowElementsFromPoint, elem)
+                }
+
+                return isOverlappingElementMatch(getOverlappingElements(element) as any as HTMLElement[], element)
+            },
+            element,
+        );
+
+        /* eslint-enable no-var,unicorn/consistent-function-scoping,unicorn/prevent-abbreviations,@typescript-eslint/ban-ts-comment,unicorn/no-for-loop,prefer-const */
+    }
+
+    // based on https://github.com/webdriverio/webdriverio/blob/dec6da76b0e218af935dbf39735ae3491d5edd8c/packages/webdriverio/src/utils/index.ts#L98
+    private async browserFor(nativeElement: wdio.Element<'async'> | wdio.Browser<'async'>): Promise<wdio.Browser<'async'>> {
+        const element = nativeElement as wdio.Element<'async'>;
+        return element.parent
+            ? this.browserFor(element.parent)
+            : nativeElement
+    }
+}

package/src/screenplay/models/index.ts

@@ -0,0 +1,5 @@
+export * from './WebdriverIOCookie';
+export * from './WebdriverIOFrame';
+export * from './WebdriverIOModalDialog';
+export * from './WebdriverIOPage';
+export * from './WebdriverIOPageElement';

package/src/screenplay/models/locators/WebdriverIOLocator.ts

@@ -0,0 +1,43 @@
+import { Locator, PageElement, Selector } from '@serenity-js/web';
+import * as wdio from 'webdriverio';
+
+import { WebdriverIOPageElement } from '../WebdriverIOPageElement';
+import { WebdriverIONativeElementRoot } from './WebdriverIONativeElementRoot';
+
+export class WebdriverIOLocator<Selector_Type extends Selector> extends Locator<wdio.Element<'async'>, WebdriverIONativeElementRoot, Selector_Type> {
+
+    static createRootLocator<ST extends Selector>(browser: WebdriverIONativeElementRoot, selector: ST, webdriverioSelector: string): WebdriverIOLocator<ST> {
+        return new WebdriverIOLocator(
+            () => browser,
+            selector,
+            (root: WebdriverIONativeElementRoot) => root.$(webdriverioSelector) as unknown as wdio.Element<'async'>,
+            (root: WebdriverIONativeElementRoot) => root.$$(webdriverioSelector)
+        );
+    }
+
+    of(parent: WebdriverIOLocator<unknown>): Locator<wdio.Element<'async'>, WebdriverIONativeElementRoot, Selector_Type> {
+        return new WebdriverIOLocator(
+            () => parent.nativeElement(),
+            this.selector,
+            (parentRoot: WebdriverIONativeElementRoot) => this.locateElement(parentRoot),
+            (parentRoot: WebdriverIONativeElementRoot) => this.locateAllElements(parentRoot),
+        );
+    }
+
+    element(): PageElement<wdio.Element<'async'>> {
+        return new WebdriverIOPageElement(this);
+    }
+
+    async allElements(): Promise<Array<PageElement<wdio.Element<'async'>>>> {
+        const elements = await this.locateAllElements(await this.parentRoot());
+
+        return elements.map(childElement =>
+            new WebdriverIOPageElement(new WebdriverIOLocator(
+                () => this.parentRoot(),
+                this.selector,
+                () => childElement,
+                () => [ childElement ],
+            ))
+        );
+    }
+}

package/src/screenplay/models/locators/WebdriverIONativeElementRoot.ts

@@ -0,0 +1,3 @@
+import * as wdio from 'webdriverio';
+
+export type WebdriverIONativeElementRoot = Pick<wdio.Browser<'async'>, '$' | '$$'>;

package/src/screenplay/models/locators/index.ts

@@ -0,0 +1,2 @@
+export * from './WebdriverIOLocator';
+export * from './WebdriverIONativeElementRoot';

package/lib/expectations/ElementExpectation.d.ts

@@ -1,11 +0,0 @@
-import { AnswersQuestions, Expectation, ExpectationOutcome } from '@serenity-js/core';
-import { Element } from 'webdriverio';
-/**
- * @access private
- */
-export declare class ElementExpectation extends Expectation<any, Element<'async'>> {
-    private readonly fn;
-    static forElementTo(message: string, fn: (actual: Element<'async'>) => Promise<boolean>): Expectation<any, Element<'async'>>;
-    constructor(subject: string, fn: (actual: Element<'async'>) => Promise<boolean>);
-    answeredBy(actor: AnswersQuestions): (actual: Element<'async'>) => Promise<ExpectationOutcome<boolean, Element<'async'>>>;
-}

package/lib/expectations/ElementExpectation.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElementExpectation = void 0;
-const core_1 = require("@serenity-js/core");
-/**
- * @access private
- */
-class ElementExpectation extends core_1.Expectation {
-    constructor(subject, fn) {
-        super(subject);
-        this.fn = fn;
-    }
-    static forElementTo(message, fn) {
-        return new ElementExpectation(message, fn);
-    }
-    answeredBy(actor) {
-        return (actual) => this.fn(actual)
-            .then(expectationMet => expectationMet
-            ? new core_1.ExpectationMet(this.toString(), undefined, actual)
-            : new core_1.ExpectationNotMet(this.toString(), undefined, actual))
-            .catch(error => {
-            return new core_1.ExpectationNotMet(`${this.toString()} (${error.message})`, undefined, actual);
-        });
-    }
-}
-exports.ElementExpectation = ElementExpectation;
-//# sourceMappingURL=ElementExpectation.js.map

package/lib/expectations/ElementExpectation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ElementExpectation.js","sourceRoot":"","sources":["../../src/expectations/ElementExpectation.ts"],"names":[],"mappings":";;;AAAA,4CAAyH;AAGzH;;GAEG;AACH,MAAa,kBAAmB,SAAQ,kBAAkC;IAKtE,YACI,OAAe,EACE,EAAkD;QAEnE,KAAK,CAAC,OAAO,CAAC,CAAC;QAFE,OAAE,GAAF,EAAE,CAAgD;IAGvE,CAAC;IATD,MAAM,CAAC,YAAY,CAAC,OAAe,EAAE,EAAkD;QACnF,OAAO,IAAI,kBAAkB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC/C,CAAC;IASD,UAAU,CAAC,KAAuB;QAC9B,OAAO,CAAC,MAAwB,EAAE,EAAE,CAChC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC;aACV,IAAI,CAAC,cAAc,CAAC,EAAE,CACnB,cAAc;YACV,CAAC,CAAC,IAAI,qBAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC;YACxD,CAAC,CAAC,IAAI,wBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,CAClE;aACA,KAAK,CAAC,KAAK,CAAC,EAAE;YACX,OAAO,IAAI,wBAAiB,CAAC,GAAI,IAAI,CAAC,QAAQ,EAAG,KAAM,KAAK,CAAC,OAAQ,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACjG,CAAC,CAAC,CAAC;IACf,CAAC;CACJ;AAxBD,gDAwBC"}

package/lib/expectations/index.d.ts

@@ -1,6 +0,0 @@
-export * from './isActive';
-export * from './isClickable';
-export * from './isEnabled';
-export * from './isPresent';
-export * from './isSelected';
-export * from './isVisible';

package/lib/expectations/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./isActive"), exports);
-__exportStar(require("./isClickable"), exports);
-__exportStar(require("./isEnabled"), exports);
-__exportStar(require("./isPresent"), exports);
-__exportStar(require("./isSelected"), exports);
-__exportStar(require("./isVisible"), exports);
-//# sourceMappingURL=index.js.map

package/lib/expectations/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expectations/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,6CAA2B;AAC3B,gDAA8B;AAC9B,8CAA4B;AAC5B,8CAA4B;AAC5B,+CAA6B;AAC7B,8CAA4B"}

package/lib/expectations/isActive.d.ts

@@ -1,15 +0,0 @@
-import { Expectation } from '@serenity-js/core';
-import { Element } from 'webdriverio';
-/**
- * @desc
- *  Expectation that the element is active (has focus).
- *  If the selector matches multiple elements, it will return true if one of the elements has focus.
- *
- * @returns {@serenity-js/core/lib/screenplay/questions~Expectation<boolean, Element<'async'>>}
- *
- * @see https://webdriver.io/docs/api/element/isFocused/
- * @see {@link @serenity-js/assertions~Ensure}
- * @see {@link @serenity-js/core/lib/screenplay/questions~Check}
- * @see {@link Wait}
- */
-export declare function isActive(): Expectation<boolean, Element<'async'>>;

package/lib/expectations/isActive.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isActive = void 0;
-const ElementExpectation_1 = require("./ElementExpectation");
-/**
- * @desc
- *  Expectation that the element is active (has focus).
- *  If the selector matches multiple elements, it will return true if one of the elements has focus.
- *
- * @returns {@serenity-js/core/lib/screenplay/questions~Expectation<boolean, Element<'async'>>}
- *
- * @see https://webdriver.io/docs/api/element/isFocused/
- * @see {@link @serenity-js/assertions~Ensure}
- * @see {@link @serenity-js/core/lib/screenplay/questions~Check}
- * @see {@link Wait}
- */
-function isActive() {
-    return ElementExpectation_1.ElementExpectation.forElementTo('become active', actual => actual.isFocused());
-}
-exports.isActive = isActive;
-//# sourceMappingURL=isActive.js.map

package/lib/expectations/isActive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isActive.js","sourceRoot":"","sources":["../../src/expectations/isActive.ts"],"names":[],"mappings":";;;AAGA,6DAA0D;AAE1D;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ;IACpB,OAAO,uCAAkB,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;AAC1F,CAAC;AAFD,4BAEC"}

package/lib/expectations/isClickable.d.ts

@@ -1,20 +0,0 @@
-import { Expectation } from '@serenity-js/core';
-import { Element } from 'webdriverio';
-/**
- * @desc
- *  Expectation that an element is clickable, which means:
- *  - it exists
- *  - it is visible
- *  - it is within viewport (if not, try to scroll to it)
- *  - its center is not overlapped with another element
- *  - it is not disabled
- *  otherwise return false.
- *
- * @returns {@serenity-js/core/lib/screenplay/questions~Expectation<boolean, Element<'async'>>}
- *
- * @see https://webdriver.io/docs/api/element/isClickable/
- * @see {@link @serenity-js/assertions~Ensure}
- * @see {@link @serenity-js/core/lib/screenplay/questions~Check}
- * @see {@link Wait}
- */
-export declare function isClickable(): Expectation<boolean, Element<'async'>>;

package/lib/expectations/isClickable.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClickable = void 0;
-const ElementExpectation_1 = require("./ElementExpectation");
-/**
- * @desc
- *  Expectation that an element is clickable, which means:
- *  - it exists
- *  - it is visible
- *  - it is within viewport (if not, try to scroll to it)
- *  - its center is not overlapped with another element
- *  - it is not disabled
- *  otherwise return false.
- *
- * @returns {@serenity-js/core/lib/screenplay/questions~Expectation<boolean, Element<'async'>>}
- *
- * @see https://webdriver.io/docs/api/element/isClickable/
- * @see {@link @serenity-js/assertions~Ensure}
- * @see {@link @serenity-js/core/lib/screenplay/questions~Check}
- * @see {@link Wait}
- */
-function isClickable() {
-    return ElementExpectation_1.ElementExpectation.forElementTo('become clickable', actual => actual.isClickable());
-}
-exports.isClickable = isClickable;
-//# sourceMappingURL=isClickable.js.map

package/lib/expectations/isClickable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isClickable.js","sourceRoot":"","sources":["../../src/expectations/isClickable.ts"],"names":[],"mappings":";;;AAGA,6DAA0D;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,WAAW;IACvB,OAAO,uCAAkB,CAAC,YAAY,CAAC,kBAAkB,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;AAC/F,CAAC;AAFD,kCAEC"}