webdriverio 8.33.0 → 9.0.0-alpha.0

package/README.md

@@ -3,7 +3,7 @@ WebdriverIO
 
 > Next-gen browser and mobile automation test framework for Node.js
 
-This package provides an easy-to-manage API and a lot of syntactical sugar on top of the WebDriver specification. You can use WebdriverIO as a standalone package or via a test runner using [`@wdio/cli`](https://webdriver.io/docs/clioptions). WebdriverIO allows you to run tests locally using the WebDriver or Chrome DevTools protocol as well as remote user agents using cloud providers like [Sauce Labs](https://saucelabs.com/).
+This package provides an easy-to-manage API and a lot of syntactical sugar on top of the WebDriver specification. You can use WebdriverIO as a standalone package or via a test runner using [`@wdio/cli`](https://webdriver.io/docs/clioptions). WebdriverIO allows you to run tests locally using the WebDriver as well as remote user agents using cloud providers like [Sauce Labs](https://saucelabs.com/).
 
 ## Installation
 

package/build/cjs/package.json

@@ -1,3 +1,5 @@
 {
-    "type": "commonjs"
+    "name": "webdriverio-cjs",
+    "type": "commonjs",
+    "private": true
 }

package/build/commands/browser/$$.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"$$.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/$$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAIvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,EAAE,CACpB,IAAI,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,EAC/C,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,EAAE,GAAG,WAAW,CAAC,OAAO,EAAE,GAAG,WAAW,EAAE,qCAmBlF"}
+{"version":3,"file":"$$.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/$$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAMvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,EAAE,CACpB,IAAI,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,EAC/C,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,EAAE,GAAG,WAAW,CAAC,OAAO,EAAE,GAAG,WAAW,EAAE,GAChF,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC,CA2CnC"}

package/build/commands/browser/$$.js

@@ -1,5 +1,7 @@
 import { findElements, enhanceElementsArray, isElement, findElement } from '../../utils/index.js';
 import { getElements } from '../../utils/getElementObject.js';
+import { findDeepElements } from '../../utils/index.js';
+import { DEEP_SELECTOR } from '../../constants.js';
 /**
  * The `$$` command is a short and handy way in order to fetch multiple elements on the page.
  * It returns a `ChainablePromiseArray` containing a set of WebdriverIO elements.
@@ -41,6 +43,29 @@ import { getElements } from '../../utils/getElementObject.js';
  *
  */
 export async function $$(selector) {
+    /**
+     * do a deep lookup if
+     * - we are using Bidi
+     * - have a string selector
+     * - that is not a deep selector
+     */
+    if (this.isBidi && typeof selector === 'string' && !selector.startsWith(DEEP_SELECTOR)) {
+        /**
+         * run this in Node.js land if we are using browser runner
+         */
+        if (globalThis.wdio?.execute) {
+            const command = '$$';
+            const res = 'elementId' in this
+                ? await globalThis.wdio.executeWithScope(command, this.elementId, selector)
+                : await globalThis.wdio.execute(command, selector);
+            const elements = await getElements.call(this, selector, res);
+            return enhanceElementsArray(elements, this, selector);
+        }
+        const res = await findDeepElements.call(this, selector);
+        const elements = await getElements.call(this, selector, res);
+        const a = enhanceElementsArray(elements, this, selector);
+        return a;
+    }
     let res = Array.isArray(selector)
         ? selector
         : await findElements.call(this, selector);

package/build/commands/browser/$.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/$.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,CAAC,CACnB,IAAI,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,EAC/C,QAAQ,EAAE,QAAQ,GACnB,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAc9B"}
+{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/$.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,CAAC,CACnB,IAAI,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,EAC/C,QAAQ,EAAE,QAAQ,GACnB,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAuC9B"}

package/build/commands/browser/$.js

@@ -1,6 +1,7 @@
 import { ELEMENT_KEY } from 'webdriver';
-import { findElement } from '../../utils/index.js';
+import { findElement, findDeepElement } from '../../utils/index.js';
 import { getElement } from '../../utils/getElementObject.js';
+import { DEEP_SELECTOR } from '../../constants.js';
 /**
  * The `$` command is a short and handy way in order to fetch a single element on the page.
  *
@@ -61,6 +62,29 @@ import { getElement } from '../../utils/getElementObject.js';
  *
  */
 export async function $(selector) {
+    /**
+     * do a deep lookup if
+     * - we are using Bidi
+     * - have a string selector
+     * - that is not a deep selector
+     */
+    if (this.isBidi && typeof selector === 'string' && !selector.startsWith(DEEP_SELECTOR)) {
+        /**
+         * run this in Node.js land if we are using browser runner
+         */
+        if (globalThis.wdio) {
+            /**
+             * `res` is an element reference as we strip down the element
+             * result to its element id
+             */
+            const res = 'elementId' in this
+                ? await globalThis.wdio.executeWithScope('$', this.elementId, selector)
+                : await globalThis.wdio.execute('$', selector);
+            return getElement.call(this, selector, res);
+        }
+        const res = await findDeepElement.call(this, selector);
+        return getElement.call(this, selector, res);
+    }
     /**
      * convert protocol result into WebdriverIO element
      * e.g. when element was fetched with `getActiveElement`

package/build/commands/browser/getPuppeteer.d.ts

@@ -1,4 +1,4 @@
-import type { Browser as PuppeteerBrowser } from 'puppeteer-core/lib/esm/puppeteer/api/Browser.js';
+import type { Browser as PuppeteerBrowser } from 'puppeteer-core';
 /**
  * Get the [Puppeteer Browser instance](https://pptr.dev/#?product=Puppeteer&version=v5.1.0&show=api-class-browser)
  * to run commands with Puppeteer. Note that all Puppeteer commands are

package/build/commands/browser/getPuppeteer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPuppeteer.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getPuppeteer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,iDAAiD,CAAA;AAOlG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,YAAY,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,6BAgG5D"}
+{"version":3,"file":"getPuppeteer.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getPuppeteer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAa,OAAO,IAAI,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAM5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,YAAY,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,6BAyG5D"}

package/build/commands/browser/getPuppeteer.js

@@ -1,5 +1,5 @@
-import puppeteer from 'puppeteer-core';
 import logger from '@wdio/logger';
+import { userImport } from '@wdio/utils';
 import { FF_REMOTE_DEBUG_ARG } from '../../constants.js';
 const log = logger('webdriverio');
 /**
@@ -38,6 +38,11 @@ const log = logger('webdriverio');
  * @return {PuppeteerBrowser}  initiated puppeteer instance connected to the browser
  */
 export async function getPuppeteer() {
+    const puppeteer = await userImport('puppeteer-core');
+    if (!puppeteer) {
+        throw new Error('You need to install "puppeteer-core" package as a dependency ' +
+            'in order to use the "getPuppeteer" method');
+    }
     /**
      * check if we already connected Puppeteer and if so return
      * that instance

package/build/commands/browser/getWindowSize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getWindowSize.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getWindowSize.ts"],"names":[],"mappings":"AAEA,UAAU,WAAW;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,wBAS5D"}
+{"version":3,"file":"getWindowSize.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/getWindowSize.ts"],"names":[],"mappings":"AAEA,UAAU,WAAW;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,wBAK5D"}

package/build/commands/browser/getWindowSize.js

@@ -19,9 +19,6 @@ import { getBrowserObject } from '../../utils/index.js';
  */
 export async function getWindowSize() {
     const browser = getBrowserObject(this);
-    if (!browser.isW3C) {
-        return browser._getWindowSize();
-    }
     const { width, height } = await browser.getWindowRect();
     return { width, height };
 }

package/build/commands/browser/keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/keys.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,IAAI,CACtB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,iBAyC3B"}
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/keys.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,IAAI,CACtB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,iBAkC3B"}

package/build/commands/browser/keys.js

@@ -26,23 +26,17 @@ export async function keys(value) {
      * replace key with corresponding unicode character
      */
     if (typeof value === 'string') {
-        keySequence = checkUnicode(value, this.isDevTools);
+        keySequence = checkUnicode(value);
     }
     else if (Array.isArray(value)) {
         const charArray = value;
         for (const charSet of charArray) {
-            keySequence = keySequence.concat(checkUnicode(charSet, this.isDevTools));
+            keySequence = keySequence.concat(checkUnicode(charSet));
         }
     }
     else {
         throw new Error('"keys" command requires a string or array of strings as parameter');
     }
-    /**
-     * JsonWireProtocol action
-     */
-    if (!this.isW3C) {
-        return this.sendKeys(keySequence);
-    }
     /**
      * W3C way of handle it key actions
      */

package/build/commands/browser/mock.d.ts

@@ -1,7 +1,7 @@
-import type Interception from '../../utils/interception/index.js';
+import type { CDPSession } from 'puppeteer-core';
 import type { Mock } from '../../types.js';
 import type { MockFilterOptions } from '../../utils/interception/types.js';
-import type { CDPSession } from 'puppeteer-core/lib/esm/puppeteer/common/Connection.js';
+import type Interception from '../../utils/interception/index.js';
 export declare const SESSION_MOCKS: Record<string, Set<Interception>>;
 export declare const CDP_SESSIONS: Record<string, CDPSession>;
 /**

package/build/commands/browser/mock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/mock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,mCAAmC,CAAA;AAIjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uDAAuD,CAAA;AAEvF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAY,CAAC,CAAM,CAAA;AAClE,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,wBAAsB,IAAI,CACtB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,aAAa,CAAC,EAAE,iBAAiB,iBA6DpC"}
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/mock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAOhD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,KAAK,YAAY,MAAM,mCAAmC,CAAA;AAEjE,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAY,CAAC,CAAM,CAAA;AAClE,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,wBAAsB,IAAI,CACtB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,aAAa,CAAC,EAAE,iBAAiB,iBA8DpC"}

package/build/commands/browser/mock.js

@@ -147,7 +147,9 @@ export async function mock(url, filterOptions) {
         await client.send('Fetch.enable', {
             patterns: [{ requestStage: 'Request' }, { requestStage: 'Response' }]
         });
-        client.on('Fetch.requestPaused', NetworkInterception
+        client.on('Fetch.requestPaused', 
+        // @ts-expect-error fix me
+        NetworkInterception
             .handleRequestInterception(client, SESSION_MOCKS[handle]));
     }
     const networkInterception = new NetworkInterception(url, filterOptions, browser);

package/build/commands/browser/saveScreenshot.d.ts

@@ -14,10 +14,10 @@
  *
  * When running from a hook, make sure to explicitly define the hook as async:
  * <example>
-  :wdio.conf.js
-  afterTest: async function(test) {
-      await browser.saveScreenshot('./some/path/screenshot.png');
-  }
+    :wdio.conf.js
+    afterTest: async function(test) {
+        await browser.saveScreenshot('./some/path/screenshot.png');
+    }
  * </example>
  * @alias browser.saveScreenshot
  * @param   {String}  filepath  path to the generated image (`.png` suffix is required) relative to the execution directory

package/build/commands/browser/saveScreenshot.js

@@ -15,10 +15,10 @@ import { getAbsoluteFilepath, assertDirectoryExists } from '../../utils/index.js
  *
  * When running from a hook, make sure to explicitly define the hook as async:
  * <example>
-  :wdio.conf.js
-  afterTest: async function(test) {
-      await browser.saveScreenshot('./some/path/screenshot.png');
-  }
+    :wdio.conf.js
+    afterTest: async function(test) {
+        await browser.saveScreenshot('./some/path/screenshot.png');
+    }
  * </example>
  * @alias browser.saveScreenshot
  * @param   {String}  filepath  path to the generated image (`.png` suffix is required) relative to the execution directory

package/build/commands/browser/setTimeout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setTimeout.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/setTimeout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,wBAAsB,UAAU,CAC5B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAC5B,OAAO,CAAC,IAAI,CAAC,CAiCf"}
+{"version":3,"file":"setTimeout.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/setTimeout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,wBAAsB,UAAU,CAC5B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAC5B,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/build/commands/browser/setTimeout.js

@@ -50,16 +50,5 @@ export async function setTimeout(timeouts) {
     const pageLoad = timeouts['page load'] || timeouts.pageLoad;
     const script = timeouts.script;
     const setTimeouts = this.setTimeouts.bind(this);
-    /**
-     * JsonWireProtocol action
-     */
-    if (!this.isW3C) {
-        await Promise.all([
-            isFinite(implicit) && setTimeouts('implicit', implicit),
-            isFinite(pageLoad) && setTimeouts('page load', pageLoad),
-            isFinite(script) && setTimeouts('script', script),
-        ].filter(Boolean));
-        return;
-    }
     return setTimeouts(implicit, pageLoad, script);
 }

package/build/commands/browser/setWindowSize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setWindowSize.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/setWindowSize.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,iBAuBjB"}
+{"version":3,"file":"setWindowSize.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/setWindowSize.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,iBAmBjB"}

package/build/commands/browser/setWindowSize.js

@@ -33,8 +33,5 @@ export async function setWindowSize(width, height) {
         throw new Error('setWindowSize expects width and height to be a number in the 0 to 2^31 − 1 range');
     }
     const browser = getBrowserObject(this);
-    if (!browser.isW3C) {
-        return browser._setWindowSize(width, height);
-    }
     await browser.setWindowRect(null, null, width, height);
 }

package/build/commands/browser/url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/url.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,GAAG,CACrB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,IAAI,EAAE,MAAM,mBAoBf"}
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/commands/browser/url.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,GAAG,CACrB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,IAAI,EAAE,MAAM,mBAqBf"}

package/build/commands/browser/url.js

@@ -46,7 +46,8 @@ export async function url(path) {
         const context = await this.getWindowHandle();
         const res = await this.browsingContextNavigate({
             context,
-            url: path
+            url: path,
+            wait: 'interactive'
         });
         return res.url;
     }

package/build/commands/element/addValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addValue.d.ts","sourceRoot":"","sources":["../../../src/commands/element/addValue.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CACpB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,iBAoBzB"}
+{"version":3,"file":"addValue.d.ts","sourceRoot":"","sources":["../../../src/commands/element/addValue.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CACpB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,iBAezB"}

package/build/commands/element/addValue.js

@@ -36,9 +36,5 @@ export function addValue(value) {
         throw new Error('The setValue/addValue command only take string or number values. ' +
             'If you like to use special characters, use the "keys" command.');
     }
-    if (this.isW3C) {
-        return this.elementSendKeys(this.elementId, value.toString());
-    }
-    // @ts-expect-error command is not typed as JWP command
-    return this.elementSendKeys(this.elementId, [value.toString()]);
+    return this.elementSendKeys(this.elementId, value.toString());
 }

package/build/commands/element/click.d.ts

@@ -78,5 +78,5 @@ import type { ClickOptions } from '../../types.js';
  * @param {number=}           options.y      Number (optional)
  * @param {boolean=}           options.skipRelease         Boolean (optional)
  */
-export declare function click(this: WebdriverIO.Element, options?: ClickOptions): Promise<void>;
+export declare function click(this: WebdriverIO.Element, options?: Partial<ClickOptions>): Promise<void>;
 //# sourceMappingURL=click.d.ts.map

package/build/commands/element/click.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../src/commands/element/click.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAIlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAAsB,KAAK,CACvB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE,YAAY,iBA+EzB"}
+{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../src/commands/element/click.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAAgB,KAAK,CACjB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,iBAUlC"}

package/build/commands/element/click.js

@@ -1,5 +1,6 @@
 import logger from '@wdio/logger';
 import { getBrowserObject } from '../../utils/index.js';
+import { buttonValue } from '../../utils/actions/index.js';
 const log = logger('webdriver');
 /**
  *
@@ -80,72 +81,82 @@ const log = logger('webdriver');
  * @param {number=}           options.y      Number (optional)
  * @param {boolean=}           options.skipRelease         Boolean (optional)
  */
-export async function click(options) {
-    if (typeof options === 'undefined') {
-        return this.elementClick(this.elementId);
-    }
-    if (typeof options !== 'object' || Array.isArray(options)) {
-        throw new TypeError('Options must be an object');
-    }
-    let button = (options.button || 0);
-    const { x: xOffset = 0, y: yOffset = 0, skipRelease = false } = options || {};
-    if (typeof xOffset !== 'number'
-        || typeof yOffset !== 'number'
-        || !Number.isInteger(xOffset)
-        || !Number.isInteger(yOffset)) {
-        throw new TypeError('Coordinates must be integers');
+export function click(options) {
+    if (typeof options !== 'undefined') {
+        if (typeof options !== 'object' || Array.isArray(options)) {
+            throw new TypeError('Options must be an object');
+        }
+        return actionClick(this, options);
     }
-    if (options.button === 'left') {
-        button = 0;
+    return elementClick(this);
+}
+/**
+* Workaround function, because sometimes browser.action().move() flaky and isn't able to scroll pointer to into view
+* Moreover the action  with 'nearest' behavior by default where element is aligned at the bottom of its ancestor.
+* and could be overlapped. Scroll to center should definitely work even if element was covered with sticky header/footer
+*/
+async function workaround(element) {
+    await element.scrollIntoView({ block: 'center', inline: 'center' });
+}
+async function elementClick(element) {
+    try {
+        return await element.elementClick(element.elementId);
     }
-    if (options.button === 'middle') {
-        button = 1;
+    catch (error) {
+        let err = error;
+        if (typeof error === 'string') {
+            err = new Error(error);
+        }
+        if (!err.message.includes('element click intercepted')) {
+            // we only apply the workaround when the click got intercepted
+            // so that the middleware can handle any other errors
+            throw err;
+        }
+        await workaround(element);
+        return element.elementClick(element.elementId);
     }
-    if (options.button === 'right') {
-        button = 2;
+}
+async function actionClick(element, options) {
+    const defaultOptions = {
+        button: 0,
+        x: 0,
+        y: 0,
+        skipRelease: false,
+    };
+    const { button, x, y, skipRelease } = { ...defaultOptions, ...options };
+    if (typeof x !== 'number'
+        || typeof y !== 'number'
+        || !Number.isInteger(x)
+        || !Number.isInteger(y)) {
+        throw new TypeError('Coordinates must be integers');
     }
-    if (![0, 1, 2].includes(button)) {
+    if (!buttonValue.includes(button)) {
         throw new Error('Button type not supported.');
     }
-    if (this.isW3C) {
-        const browser = getBrowserObject(this);
-        if (xOffset || yOffset) {
-            const { width, height } = await browser.getElementRect(this.elementId);
-            if ((xOffset && xOffset < (-Math.floor(width / 2))) || (xOffset && xOffset > Math.floor(width / 2))) {
-                log.warn('xOffset would cause a out of bounds error as it goes outside of element');
-            }
-            if ((yOffset && yOffset < (-Math.floor(height / 2))) || (yOffset && yOffset > Math.floor(height / 2))) {
-                log.warn('yOffset would cause a out of bounds error as it goes outside of element');
-            }
-        }
-        const clickNested = async () => {
-            await browser.action('pointer', {
-                parameters: { pointerType: 'mouse' }
-            })
-                .move({
-                origin: this,
-                x: xOffset,
-                y: yOffset
-            })
-                .down({ button })
-                .up({ button })
-                .perform(skipRelease);
-        };
-        try {
-            await clickNested();
+    const browser = getBrowserObject(element);
+    if (x || y) {
+        const { width, height } = await browser.getElementRect(element.elementId);
+        if ((x && x < (-Math.floor(width / 2))) || (x && x > Math.floor(width / 2))) {
+            log.warn('x would cause a out of bounds error as it goes outside of element');
         }
-        catch {
-            /**
-            * Workaround, because sometimes browser.action().move() flaky and isn't able to scroll pointer to into view
-            * Moreover the action  with 'nearest' behavior by default where element is aligned at the bottom of its ancestor.
-            * and could be overlapped. Scroll to center should definitely work even if element was covered with sticky header/footer
-            */
-            await this.scrollIntoView({ block: 'center', inline: 'center' });
-            await clickNested();
+        if ((y && y < (-Math.floor(height / 2))) || (y && y > Math.floor(height / 2))) {
+            log.warn('y would cause a out of bounds error as it goes outside of element');
         }
-        return;
     }
-    const { width, height } = await this.getElementSize(this.elementId);
-    await this.moveToElement(this.elementId, xOffset + (width / 2), yOffset + (height / 2));
-    return this.positionClick(button);
+    const clickNested = async () => {
+        await browser.action('pointer', {
+            parameters: { pointerType: 'mouse' }
+        })
+            .move({ origin: element, x, y })
+            .down({ button })
+            .up({ button })
+            .perform(skipRelease);
+    };
+    try {
+        return await clickNested();
+    }
+    catch {
+        await workaround(element);
+        return clickNested();
+    }
 }

package/build/commands/element/doubleClick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doubleClick.d.ts","sourceRoot":"","sources":["../../../src/commands/element/doubleClick.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,WAAW,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,iBAqB3D"}
+{"version":3,"file":"doubleClick.d.ts","sourceRoot":"","sources":["../../../src/commands/element/doubleClick.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,WAAW,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,iBAa3D"}

package/build/commands/element/doubleClick.js

@@ -23,13 +23,6 @@ import { getBrowserObject } from '../../utils/index.js';
  *
  */
 export async function doubleClick() {
-    /**
-     * move to element
-     */
-    if (!this.isW3C) {
-        await this.moveTo();
-        return this.positionDoubleClick();
-    }
     /**
      * W3C way of handle the double click actions
      */

package/build/commands/element/dragAndDrop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dragAndDrop.d.ts","sourceRoot":"","sources":["../../../src/commands/element/dragAndDrop.ts"],"names":[],"mappings":"AASA,KAAK,kBAAkB,GAAG;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,kBAAkB,GAAG;IACtB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,CAAC,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,WAAW,CAC7B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,MAAM,EAAE,WAAW,CAAC,OAAO,GAAG,kBAAkB,EAChD,EAAE,QAAa,EAAE,GAAE,kBAAuB,iBAmE7C"}
+{"version":3,"file":"dragAndDrop.d.ts","sourceRoot":"","sources":["../../../src/commands/element/dragAndDrop.ts"],"names":[],"mappings":"AAOA,KAAK,kBAAkB,GAAG;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,kBAAkB,GAAG;IACtB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,CAAC,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,WAAW,CAC7B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,MAAM,EAAE,WAAW,CAAC,OAAO,GAAG,kBAAkB,EAChD,EAAE,QAAa,EAAE,GAAE,kBAAuB,iBAuD7C"}

package/build/commands/element/dragAndDrop.js

@@ -1,7 +1,6 @@
 import { ELEMENT_KEY } from 'webdriver';
 import { getBrowserObject } from '../../utils/index.js';
 const ACTION_BUTTON = 0;
-const sleep = (time = 0) => new Promise((resolve) => setTimeout(resolve, time));
 /**
  *
  * Drag an item to a destination element or position.
@@ -60,15 +59,6 @@ export async function dragAndDrop(target, { duration = 10 } = {}) {
      * allow to specify an element or an x/y vector
      */
     const isMovingToElement = target.constructor.name === 'Element';
-    if (!this.isW3C) {
-        await this.moveTo();
-        await this.buttonDown(ACTION_BUTTON);
-        isMovingToElement
-            ? await moveToElement.moveTo()
-            : await this.moveToElement(null, moveToCoordinates.x, moveToCoordinates.y);
-        await sleep(duration);
-        return this.buttonUp(ACTION_BUTTON);
-    }
     const sourceRef = { [ELEMENT_KEY]: this[ELEMENT_KEY] };
     const targetRef = { [ELEMENT_KEY]: moveToElement[ELEMENT_KEY] };
     const origin = sourceRef;

package/build/commands/element/getLocation.js

@@ -28,14 +28,9 @@ import { getElementRect } from '../../utils/index.js';
  */
 export async function getLocation(prop) {
     let location = {};
-    if (this.isW3C) {
-        location = await getElementRect(this);
-        delete location.width;
-        delete location.height;
-    }
-    else {
-        location = await this.getElementLocation(this.elementId);
-    }
+    location = await getElementRect(this);
+    delete location.width;
+    delete location.height;
     if (prop === 'x' || prop === 'y') {
         return location[prop];
     }

package/build/commands/element/getProperty.d.ts

@@ -14,5 +14,5 @@
  * @param {string} property  name of the element property
  * @return {Object|String|Boolean|Number|null} the value of the property of the selected element
  */
-export declare function getProperty(this: WebdriverIO.Element, property: string): Promise<any>;
+export declare function getProperty(this: WebdriverIO.Element, property: string): Promise<string>;
 //# sourceMappingURL=getProperty.d.ts.map

package/build/commands/element/getProperty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getProperty.d.ts","sourceRoot":"","sources":["../../../src/commands/element/getProperty.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACvB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,QAAQ,EAAE,MAAM,gBAYnB"}
+{"version":3,"file":"getProperty.d.ts","sourceRoot":"","sources":["../../../src/commands/element/getProperty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACvB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,QAAQ,EAAE,MAAM,mBAGnB"}

package/build/commands/element/getProperty.js

@@ -1,5 +1,3 @@
-import { getBrowserObject } from '../../utils/index.js';
-import getPropertyScript from '../../scripts/getProperty.js';
 /**
  * The Get Element Property command will return the result of getting a property of an element.
  *
@@ -17,9 +15,5 @@ import getPropertyScript from '../../scripts/getProperty.js';
  * @return {Object|String|Boolean|Number|null} the value of the property of the selected element
  */
 export function getProperty(property) {
-    if (this.isW3C) {
-        return this.getElementProperty(this.elementId, property);
-    }
-    const browser = getBrowserObject(this);
-    return browser.execute(getPropertyScript, { ELEMENT: this.elementId }, property);
+    return this.getElementProperty(this.elementId, property);
 }

package/build/commands/element/getSize.js

@@ -27,9 +27,7 @@ import { getElementRect } from '../../utils/index.js';
  *
  */
 export async function getSize(prop) {
-    const rect = this.isW3C
-        ? await getElementRect(this)
-        : await this.getElementSize(this.elementId);
+    const rect = await getElementRect(this);
     if (prop && typeof rect[prop] === 'number') {
         return rect[prop];
     }