@serenity-js/webdriverio 3.1.6 → 3.2.0

package/src/screenplay/index.ts

@@ -1,2 +1,2 @@
-export * from './abilities';
-export * from './models';
+export * from './abilities/index.js';
+export * from './models/index.js';

package/src/screenplay/models/WebdriverIOBrowsingSession.ts

@@ -1,13 +1,13 @@
 import { LogicError } from '@serenity-js/core';
-import { CorrelationId } from '@serenity-js/core/lib/model';
+import { CorrelationId } from '@serenity-js/core/lib/model/index.js';
 import { BrowsingSession, ModalDialogHandler } from '@serenity-js/web';
-import type { Page } from 'puppeteer-core/lib/cjs/puppeteer/api/Page';
-import * as wdio from 'webdriverio';
+import type { Page } from 'puppeteer-core';
+import type { Browser } from 'webdriverio';
 
-import { WebdriverIOPage } from '../models';
-import { WebdriverIOErrorHandler } from './WebdriverIOErrorHandler';
-import { WebdriverIOModalDialogHandler } from './WebdriverIOModalDialogHandler';
-import { WebdriverIOPuppeteerModalDialogHandler } from './WebdriverIOPuppeteerModalDialogHandler';
+import { WebdriverIOPage } from '../models/index.js';
+import { WebdriverIOErrorHandler } from './WebdriverIOErrorHandler.js';
+import { WebdriverIOModalDialogHandler } from './WebdriverIOModalDialogHandler.js';
+import { WebdriverIOPuppeteerModalDialogHandler } from './WebdriverIOPuppeteerModalDialogHandler.js';
 
 /**
  * WebdriverIO-specific implementation of {@apilink BrowsingSession}.
@@ -16,7 +16,7 @@ import { WebdriverIOPuppeteerModalDialogHandler } from './WebdriverIOPuppeteerMo
  */
 export class WebdriverIOBrowsingSession extends BrowsingSession<WebdriverIOPage> {
 
-    constructor(protected readonly browser: wdio.Browser<'async'>) {
+    constructor(protected readonly browser: Browser) {
         super();
 
         if (! browser.$ || ! browser.$$) {

package/src/screenplay/models/WebdriverIOCookie.ts

@@ -1,7 +1,7 @@
 import { Timestamp } from '@serenity-js/core';
 import { Cookie, CookieData, CookieMissingError } from '@serenity-js/web';
 import { ensure, isDefined } from 'tiny-types';
-import * as wdio from 'webdriverio';
+import type { Browser } from 'webdriverio';
 
 /**
  * WebdriverIO-specific implementation of {@apilink Cookie}.
@@ -11,7 +11,7 @@ import * as wdio from 'webdriverio';
 export class WebdriverIOCookie extends Cookie {
 
     constructor(
-        private readonly browser: wdio.Browser<'async'>,
+        private readonly browser: Browser,
         cookieName: string,
     ) {
         super(cookieName);

package/src/screenplay/models/WebdriverIOErrorHandler.ts

@@ -1,4 +1,4 @@
-import { WebdriverProtocolErrorCode } from './WebdriverProtocolErrorCode';
+import { WebdriverProtocolErrorCode } from './WebdriverProtocolErrorCode.js';
 
 export class WebdriverIOErrorHandler {
 

package/src/screenplay/models/WebdriverIOModalDialogHandler.ts

@@ -1,8 +1,8 @@
 import { AbsentModalDialog, AcceptedModalDialog, DismissedModalDialog, ModalDialog, ModalDialogHandler } from '@serenity-js/web';
-import * as wdio from 'webdriverio';
+import type { Browser } from 'webdriverio';
 
-import { WebdriverIOErrorHandler } from './WebdriverIOErrorHandler';
-import { WebdriverProtocolErrorCode } from './WebdriverProtocolErrorCode';
+import { WebdriverIOErrorHandler } from './WebdriverIOErrorHandler.js';
+import { WebdriverProtocolErrorCode } from './WebdriverProtocolErrorCode.js';
 
 /**
  * WebdriverIO-specific implementation of {@apilink ModalDialogHandler},
@@ -27,7 +27,7 @@ export class WebdriverIOModalDialogHandler extends ModalDialogHandler {
     private currentHandler: () => Promise<void>;
 
     constructor(
-        private readonly browser: wdio.Browser<'async'>,
+        private readonly browser: Browser,
         private readonly errorHandler: WebdriverIOErrorHandler,
     ) {
         super();

package/src/screenplay/models/WebdriverIOPage.ts

@@ -1,27 +1,27 @@
 import { LogicError } from '@serenity-js/core';
-import { CorrelationId } from '@serenity-js/core/lib/model';
+import { CorrelationId } from '@serenity-js/core/lib/model/index.js';
 import { BrowserWindowClosedError, Cookie, CookieData, Key, ModalDialogHandler, Page, PageElement, PageElements, Selector } from '@serenity-js/web';
 import { URL } from 'url';
-import * as wdio from 'webdriverio';
+import type { Browser, Element } from 'webdriverio';
 
-import { WebdriverIOLocator, WebdriverIORootLocator } from './locators';
-import { WebdriverIOBrowsingSession } from './WebdriverIOBrowsingSession';
-import { WebdriverIOCookie } from './WebdriverIOCookie';
-import { WebdriverIOErrorHandler } from './WebdriverIOErrorHandler';
-import { WebdriverIOPageElement } from './WebdriverIOPageElement';
+import { WebdriverIOLocator, WebdriverIORootLocator } from './locators/index.js';
+import { WebdriverIOBrowsingSession } from './WebdriverIOBrowsingSession.js';
+import { WebdriverIOCookie } from './WebdriverIOCookie.js';
+import { WebdriverIOErrorHandler } from './WebdriverIOErrorHandler.js';
+import { WebdriverIOPageElement } from './WebdriverIOPageElement.js';
 
 /**
  * WebdriverIO-specific implementation of {@apilink Page}.
  *
  * @group Models
  */
-export class WebdriverIOPage extends Page<wdio.Element<'async'>> {
+export class WebdriverIOPage extends Page<Element> {
 
     private lastScriptExecutionSummary: LastScriptExecutionSummary;
 
     constructor(
         session: WebdriverIOBrowsingSession,
-        private readonly browser: wdio.Browser<'async'>,
+        private readonly browser: Browser,
         modalDialogHandler: ModalDialogHandler,
         private readonly errorHandler: WebdriverIOErrorHandler,
         pageId: CorrelationId,
@@ -34,13 +34,13 @@ export class WebdriverIOPage extends Page<wdio.Element<'async'>> {
         );
     }
 
-    locate(selector: Selector): PageElement<wdio.Element<'async'>> {
+    locate(selector: Selector): PageElement<Element> {
         return new WebdriverIOPageElement(
             new WebdriverIOLocator(this.rootLocator, selector, this.errorHandler)
         )
     }
 
-    locateAll(selector: Selector): PageElements<wdio.Element<'async'>> {
+    locateAll(selector: Selector): PageElements<Element> {
         return new PageElements(
             new WebdriverIOLocator(this.rootLocator, selector, this.errorHandler)
         );
@@ -68,10 +68,6 @@ export class WebdriverIOPage extends Page<wdio.Element<'async'>> {
                 return key;
             }
 
-            if (this.browser.isDevTools) {
-                return key.devtoolsName;
-            }
-
             return key.utf16codePoint;
         });
 

package/src/screenplay/models/WebdriverIOPageElement.ts

@@ -1,17 +1,17 @@
 import { LogicError } from '@serenity-js/core';
 import { Key, PageElement, SelectOption, SwitchableOrigin } from '@serenity-js/web';
-import * as scripts from '@serenity-js/web/lib/scripts';
-import * as wdio from 'webdriverio';
+import * as scripts from '@serenity-js/web/lib/scripts/index.js';
+import type { Browser, Element } from 'webdriverio';
 
-import { WebdriverIOLocator } from './locators';
-import { WebdriverProtocolErrorCode } from './WebdriverProtocolErrorCode';
+import { WebdriverIOLocator } from './locators/index.js';
+import { WebdriverProtocolErrorCode } from './WebdriverProtocolErrorCode.js';
 
 /**
  * WebdriverIO-specific implementation of {@apilink PageElement}.
  *
  * @group Models
  */
-export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
+export class WebdriverIOPageElement extends PageElement<Element> {
     of(parent: WebdriverIOPageElement): WebdriverIOPageElement {
         return new WebdriverIOPageElement(this.locator.of(parent.locator))
     }
@@ -23,20 +23,17 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
         }
 
         // eslint-disable-next-line unicorn/consistent-function-scoping
-        async function removeCharactersFrom(browser: wdio.Browser<'async'>, inputElement: wdio.Element<'async'>, numberOfCharacters: number): Promise<void> {
-            const homeKey   = browser.isDevTools ? Key.Home.devtoolsName : Key.Home.utf16codePoint;
-            const deleteKey = browser.isDevTools ? Key.Delete.devtoolsName : Key.Delete.utf16codePoint;
-
+        async function removeCharactersFrom(browser: Browser, inputElement: Element, numberOfCharacters: number): Promise<void> {
             await browser.execute(
-                /* istanbul ignore next */
+                /* c8 ignore next */
                 function focusOn(element: any) {
                     element.focus();
                 },
                 element
             );
-            await inputElement.keys([
-                homeKey,
-                ...times(numberOfCharacters, deleteKey),
+            await browser.keys([
+                Key.Home.utf16codePoint,
+                ...times(numberOfCharacters, Key.Delete.utf16codePoint),
             ]);
         }
 
@@ -69,8 +66,10 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
     }
 
     async enterValue(value: string | number | Array<string | number>): Promise<void> {
-        const element = await this.nativeElement();
-        await element.addValue(value);
+        const text      = Array.isArray(value) ? value.join('') : value;
+        const element   = await this.nativeElement();
+
+        await element.addValue(text);
     }
 
     async scrollIntoView(): Promise<void> {
@@ -106,7 +105,7 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
         const browser = await this.browserFor(element);
 
         const options = await browser.execute(
-            /* istanbul ignore next */
+            /* c8 ignore start */
             (select: HTMLSelectElement) => {
                 const options = [];
                 select.querySelectorAll('option').forEach((option: HTMLOptionElement) => {
@@ -121,6 +120,7 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
                 return options;
             },
             element as unknown
+            /* c8 ignore stop */
         );
 
         return options.map(option =>
@@ -145,7 +145,7 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
 
     async switchTo(): Promise<SwitchableOrigin> {
         try {
-            const element: wdio.Element<'async'> = await this.locator.nativeElement()
+            const element: Element = await this.locator.nativeElement()
 
             if (element.error) {
                 throw element.error;
@@ -169,7 +169,7 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
             else {
                 // focus on element
                 const previouslyFocusedElement = await browser.execute(
-                    /* istanbul ignore next */
+                    /* c8 ignore next */
                     function focusOn(element: any) {
                         const currentlyFocusedElement = document.activeElement;
                         element.focus();
@@ -181,7 +181,7 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
                 return {
                     switchBack: async (): Promise<void> => {
                         await browser.execute(
-                            /* istanbul ignore next */
+                            /* c8 ignore next */
                             function focusOn(element: any) {
                                 element.focus();
                             },
@@ -253,8 +253,8 @@ export class WebdriverIOPageElement extends PageElement<wdio.Element<'async'>> {
 
     // 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'>;
+    private async browserFor(nativeElement: Element | Browser): Promise<Browser> {
+        const element = nativeElement as Element;
         return element.parent
             ? this.browserFor(element.parent)
             : nativeElement

package/src/screenplay/models/WebdriverIOPuppeteerModalDialogHandler.ts

@@ -1,6 +1,11 @@
-import { AbsentModalDialog, AcceptedModalDialog, DismissedModalDialog, ModalDialog, ModalDialogHandler } from '@serenity-js/web';
-import type { Page } from 'puppeteer-core/lib/cjs/puppeteer/api/Page';
-import type { Dialog } from 'puppeteer-core/lib/cjs/puppeteer/common/Dialog';
+import {
+    AbsentModalDialog,
+    AcceptedModalDialog,
+    DismissedModalDialog,
+    ModalDialog,
+    ModalDialogHandler
+} from '@serenity-js/web';
+import type { Dialog, Page } from 'puppeteer-core';
 
 /**
  * WebdriverIO-specific implementation of {@apilink {ModalDialogHandler}, applicable when WebdriverIO

package/src/screenplay/models/index.ts

@@ -1,4 +1,4 @@
-export * from './WebdriverIOBrowsingSession';
-export * from './WebdriverIOCookie';
-export * from './WebdriverIOPage';
-export * from './WebdriverIOPageElement';
+export * from './WebdriverIOBrowsingSession.js';
+export * from './WebdriverIOCookie.js';
+export * from './WebdriverIOPage.js';
+export * from './WebdriverIOPageElement.js';

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

@@ -1,20 +1,20 @@
 import { f, LogicError } from '@serenity-js/core';
 import { ByCss, ByCssContainingText, ByDeepCss, ById, ByTagName, ByXPath, Locator, PageElement, RootLocator, Selector } from '@serenity-js/web';
-import * as wdio from 'webdriverio';
+import type { Element } from 'webdriverio';
 
-import { WebdriverIOErrorHandler } from '../WebdriverIOErrorHandler';
-import { WebdriverIOPageElement } from '../WebdriverIOPageElement';
-import { WebdriverIORootLocator } from './WebdriverIORootLocator';
+import { WebdriverIOErrorHandler } from '../WebdriverIOErrorHandler.js';
+import { WebdriverIOPageElement } from '../WebdriverIOPageElement.js';
+import { WebdriverIORootLocator } from './WebdriverIORootLocator.js';
 
 /**
  * WebdriverIO-specific implementation of {@apilink Locator}.
  *
  * @group Models
  */
-export class WebdriverIOLocator extends Locator<wdio.Element<'async'>, string> {
+export class WebdriverIOLocator extends Locator<Element, string> {
 
     constructor(
-        parent: RootLocator<wdio.Element<'async'>>,
+        parent: RootLocator<Element>,
         selector: Selector,
         private readonly errorHandler: WebdriverIOErrorHandler,
     ) {
@@ -60,7 +60,7 @@ export class WebdriverIOLocator extends Locator<wdio.Element<'async'>, string> {
         }
     }
 
-    async nativeElement(): Promise<wdio.Element<'async'>> {
+    async nativeElement(): Promise<Element> {
         try {
             return await this.resolveNativeElement();
         }
@@ -69,7 +69,7 @@ export class WebdriverIOLocator extends Locator<wdio.Element<'async'>, string> {
         }
     }
 
-    private async resolveNativeElement(): Promise<wdio.Element<'async'>> {
+    private async resolveNativeElement(): Promise<Element> {
         const parent = await this.parent.nativeElement();
 
         if (parent.error) {
@@ -85,24 +85,24 @@ export class WebdriverIOLocator extends Locator<wdio.Element<'async'>, string> {
         return element;
     }
 
-    async allNativeElements(): Promise<Array<wdio.Element<'async'>>> {
+    async allNativeElements(): Promise<Array<Element>> {
         const parent = await this.parent.nativeElement();
         return parent.$$(this.nativeSelector());
     }
 
-    of(parent: WebdriverIOLocator): Locator<wdio.Element<'async'>, string> {
+    of(parent: WebdriverIOLocator): Locator<Element, string> {
         return new WebdriverIOLocator(parent, this.selector, this.errorHandler);
     }
 
-    locate(child: WebdriverIOLocator): Locator<wdio.Element<'async'>, string> {
+    locate(child: WebdriverIOLocator): Locator<Element, string> {
         return new WebdriverIOLocator(this, child.selector, this.errorHandler);
     }
 
-    element(): PageElement<wdio.Element<'async'>> {
+    element(): PageElement<Element> {
         return new WebdriverIOPageElement(this);
     }
 
-    async allElements(): Promise<Array<PageElement<wdio.Element<'async'>>>> {
+    async allElements(): Promise<Array<PageElement<Element>>> {
         const elements = await this.allNativeElements();
 
         return elements.map(childElement =>
@@ -123,19 +123,19 @@ export class WebdriverIOLocator extends Locator<wdio.Element<'async'>, string> {
  */
 class ExistingElementLocator extends WebdriverIOLocator {
     constructor(
-        parentRoot: RootLocator<wdio.Element<'async'>>,
+        parentRoot: RootLocator<Element>,
         selector: Selector,
         errorHandler: WebdriverIOErrorHandler,
-        private readonly existingNativeElement: wdio.Element<'async'>,
+        private readonly existingNativeElement: Element,
     ) {
         super(parentRoot, selector, errorHandler);
     }
 
-    async nativeElement(): Promise<wdio.Element<'async'>> {
+    async nativeElement(): Promise<Element> {
         return this.existingNativeElement;
     }
 
-    async allNativeElements(): Promise<Array<wdio.Element<'async'>>> {
+    async allNativeElements(): Promise<Array<Element>> {
         return [ this.existingNativeElement ];
     }
 }

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

@@ -1,13 +1,13 @@
 import { RootLocator } from '@serenity-js/web';
-import * as wdio from 'webdriverio';
+import type { Browser, Element } from 'webdriverio';
 
 /**
  * WebdriverIO-specific implementation of {@apilink RootLocator}.
  *
  * @group Models
  */
-export class WebdriverIORootLocator extends RootLocator<wdio.Browser<'async'>> {
-    constructor(private readonly browser: wdio.Browser<'async'>) {
+export class WebdriverIORootLocator extends RootLocator<Browser> {
+    constructor(private readonly browser: Browser) {
         super();
     }
 
@@ -15,11 +15,11 @@ export class WebdriverIORootLocator extends RootLocator<wdio.Browser<'async'>> {
         return true;
     }
 
-    async nativeElement(): Promise<Pick<wdio.Browser<'async'>, '$' | '$$'>> {
+    async nativeElement(): Promise<Pick<Browser, '$' | '$$'>> {
         return this.browser;
     }
 
-    async switchToFrame(frame: wdio.Element<'async'>): Promise<void> {
+    async switchToFrame(frame: Element): Promise<void> {
         await this.browser.switchToFrame(frame);
     }
 

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

@@ -1,2 +1,2 @@
-export * from './WebdriverIOLocator';
-export * from './WebdriverIORootLocator';
+export * from './WebdriverIOLocator.js';
+export * from './WebdriverIORootLocator.js';

package/lib/adapter/WebdriverIOConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebdriverIOConfig.d.ts","sourceRoot":"","sources":["../../src/adapter/WebdriverIOConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4GG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,UAAU;IAEzD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,cAAc,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnD"}

package/lib/adapter/WebdriverIOConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebdriverIOConfig.js","sourceRoot":"","sources":["../../src/adapter/WebdriverIOConfig.ts"],"names":[],"mappings":""}

package/tsconfig.build.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.build.json",
-  "compilerOptions": {
-    "outDir": "lib",
-    "rootDir": "src",
-    "lib": [
-      "es2019",
-      "dom"
-    ],
-    "types": [
-      "webdriverio/async"
-    ]
-  },
-  "include": [
-    "src/**/*.ts"
-  ]
-}