webdriverio 7.20.7 → 7.20.8-alpha.504

package/build/constants.d.ts

@@ -10,5 +10,72 @@ export declare const DRIVER_DEFAULT_ENDPOINT: {
 };
 export declare const FF_REMOTE_DEBUG_ARG = "-remote-debugging-port";
 export declare const DEEP_SELECTOR = ">>>";
+export declare const ARIA_SELECTOR = "aria/";
 export declare const ERROR_REASON: string[];
+/**
+ * Special Characters
+ */
+export declare const Key: {
+    /**
+     * Special control key that works cross browser for Mac, where it's the command key, and for
+     * Windows or Linux, where it is the control key.
+     */
+    readonly Ctrl: "WDIO_CONTROL";
+    readonly NULL: "";
+    readonly Cancel: "";
+    readonly Help: "";
+    readonly Backspace: "";
+    readonly Tab: "";
+    readonly Clear: "";
+    readonly Return: "";
+    readonly Enter: "";
+    readonly Shift: "";
+    readonly Control: "";
+    readonly Alt: "";
+    readonly Pause: "";
+    readonly Escape: "";
+    readonly Space: "";
+    readonly PageUp: "";
+    readonly PageDown: "";
+    readonly End: "";
+    readonly Home: "";
+    readonly ArrowLeft: "";
+    readonly ArrowUp: "";
+    readonly ArrowRight: "";
+    readonly ArrowDown: "";
+    readonly Insert: "";
+    readonly Delete: "";
+    readonly Semicolon: "";
+    readonly Equals: "";
+    readonly Numpad0: "";
+    readonly Numpad1: "";
+    readonly Numpad2: "";
+    readonly Numpad3: "";
+    readonly Numpad4: "";
+    readonly Numpad5: "";
+    readonly Numpad6: "";
+    readonly Numpad7: "";
+    readonly Numpad8: "";
+    readonly Numpad9: "";
+    readonly Multiply: "";
+    readonly Add: "";
+    readonly Separator: "";
+    readonly Subtract: "";
+    readonly Decimal: "";
+    readonly Divide: "";
+    readonly F1: "";
+    readonly F2: "";
+    readonly F3: "";
+    readonly F4: "";
+    readonly F5: "";
+    readonly F6: "";
+    readonly F7: "";
+    readonly F8: "";
+    readonly F9: "";
+    readonly F10: "";
+    readonly F11: "";
+    readonly F12: "";
+    readonly Command: "";
+    readonly ZenkakuHankaku: "";
+};
 //# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAqC,MAAM,aAAa,CAAA;AA4B7E,eAAO,MAAM,WAAW,wCAAwC,CAAA;AAEhE,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,UAAU,CAuQtF,CAAA;AAED,eAAO,MAAM,uBAAuB,UAA0E,CAAA;AAE9G,eAAO,MAAM,uBAAuB;;;;;CAKnC,CAAA;AAED,eAAO,MAAM,mBAAmB,2BAA2B,CAAA;AAC3D,eAAO,MAAM,aAAa,QAAQ,CAAA;AAElC,eAAO,MAAM,YAAY,UAKxB,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAqC,MAAM,aAAa,CAAA;AAqC7E,eAAO,MAAM,WAAW,wCAAwC,CAAA;AAEhE,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,UAAU,CAwRtF,CAAA;AAED,eAAO,MAAM,uBAAuB,UAA0E,CAAA;AAE9G,eAAO,MAAM,uBAAuB;;;;;CAKnC,CAAA;AAED,eAAO,MAAM,mBAAmB,2BAA2B,CAAA;AAC3D,eAAO,MAAM,aAAa,QAAQ,CAAA;AAClC,eAAO,MAAM,aAAa,UAAU,CAAA;AAEpC,eAAO,MAAM,YAAY,UAKxB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,GAAG;IACZ;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DG,CAAA"}

package/build/constants.js

@@ -1,6 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ERROR_REASON = exports.DEEP_SELECTOR = exports.FF_REMOTE_DEBUG_ARG = exports.DRIVER_DEFAULT_ENDPOINT = exports.W3C_SELECTOR_STRATEGIES = exports.WDIO_DEFAULTS = exports.ELEMENT_KEY = void 0;
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { UNICODE_CHARACTERS } from '@wdio/utils';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+var SupportedAutomationProtocols;
+(function (SupportedAutomationProtocols) {
+    SupportedAutomationProtocols["browser"] = "browser-runner/build/browser/driver.js";
+    SupportedAutomationProtocols["webdriver"] = "webdriver";
+    SupportedAutomationProtocols["devtools"] = "devtools";
+    SupportedAutomationProtocols["stub"] = "./protocol-stub.js";
+})(SupportedAutomationProtocols || (SupportedAutomationProtocols = {}));
 /* istanbul ignore next */
 const HOOK_DEFINITION = {
     type: 'object',
@@ -25,19 +35,28 @@ const HOOK_DEFINITION = {
         }
     }
 };
-exports.ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
-exports.WDIO_DEFAULTS = {
+export const ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
+export const WDIO_DEFAULTS = {
     /**
      * allows to specify automation protocol
      */
     automationProtocol: {
         type: 'string',
         validate: (param) => {
-            if (!['webdriver', 'devtools', './protocol-stub'].includes(param.toLowerCase())) {
+            /**
+             * path when proxy is used for browser testing
+             */
+            if (param.endsWith(SupportedAutomationProtocols.browser)) {
+                return;
+            }
+            if (!Object.values(SupportedAutomationProtocols).includes(param.toLowerCase())) {
                 throw new Error(`Currently only "webdriver" and "devtools" is supproted as automationProtocol, you set "${param}"`);
             }
             try {
-                require.resolve(param);
+                const id = param === SupportedAutomationProtocols.stub
+                    ? resolve(__dirname, '..', 'build', param)
+                    : param;
+                require.resolve(id);
             }
             catch (err) {
                 /* istanbul ignore next */
@@ -238,6 +257,13 @@ exports.WDIO_DEFAULTS = {
     maxInstancesPerCapability: {
         type: 'number'
     },
+    /**
+     * whether or not testrunner should inject `browser`, `$` and `$$` as
+     * global environment variables
+     */
+    injectGlobals: {
+        type: 'boolean'
+    },
     /**
      * list of strings to watch of `wdio` command is called with `--watch` flag
      */
@@ -270,18 +296,85 @@ exports.WDIO_DEFAULTS = {
     onComplete: HOOK_DEFINITION,
     onReload: HOOK_DEFINITION
 };
-exports.W3C_SELECTOR_STRATEGIES = ['css selector', 'link text', 'partial link text', 'tag name', 'xpath'];
-exports.DRIVER_DEFAULT_ENDPOINT = {
+export const W3C_SELECTOR_STRATEGIES = ['css selector', 'link text', 'partial link text', 'tag name', 'xpath'];
+export const DRIVER_DEFAULT_ENDPOINT = {
     method: 'GET',
     host: 'localhost',
     port: 4444,
     path: '/status'
 };
-exports.FF_REMOTE_DEBUG_ARG = '-remote-debugging-port';
-exports.DEEP_SELECTOR = '>>>';
-exports.ERROR_REASON = [
+export const FF_REMOTE_DEBUG_ARG = '-remote-debugging-port';
+export const DEEP_SELECTOR = '>>>';
+export const ARIA_SELECTOR = 'aria/';
+export const ERROR_REASON = [
     'Failed', 'Aborted', 'TimedOut', 'AccessDenied', 'ConnectionClosed',
     'ConnectionReset', 'ConnectionRefused', 'ConnectionAborted',
     'ConnectionFailed', 'NameNotResolved', 'InternetDisconnected',
     'AddressUnreachable', 'BlockedByClient', 'BlockedByResponse'
 ];
+/**
+ * Special Characters
+ */
+export const Key = {
+    /**
+     * Special control key that works cross browser for Mac, where it's the command key, and for
+     * Windows or Linux, where it is the control key.
+     */
+    Ctrl: 'WDIO_CONTROL',
+    NULL: UNICODE_CHARACTERS.NULL,
+    Cancel: UNICODE_CHARACTERS.Cancel,
+    Help: UNICODE_CHARACTERS.Help,
+    Backspace: UNICODE_CHARACTERS.Backspace,
+    Tab: UNICODE_CHARACTERS.Tab,
+    Clear: UNICODE_CHARACTERS.Clear,
+    Return: UNICODE_CHARACTERS.Return,
+    Enter: UNICODE_CHARACTERS.Enter,
+    Shift: UNICODE_CHARACTERS.Shift,
+    Control: UNICODE_CHARACTERS.Control,
+    Alt: UNICODE_CHARACTERS.Alt,
+    Pause: UNICODE_CHARACTERS.Pause,
+    Escape: UNICODE_CHARACTERS.Escape,
+    Space: UNICODE_CHARACTERS.Space,
+    PageUp: UNICODE_CHARACTERS.PageUp,
+    PageDown: UNICODE_CHARACTERS.PageDown,
+    End: UNICODE_CHARACTERS.End,
+    Home: UNICODE_CHARACTERS.Home,
+    ArrowLeft: UNICODE_CHARACTERS.ArrowLeft,
+    ArrowUp: UNICODE_CHARACTERS.ArrowUp,
+    ArrowRight: UNICODE_CHARACTERS.ArrowRight,
+    ArrowDown: UNICODE_CHARACTERS.ArrowDown,
+    Insert: UNICODE_CHARACTERS.Insert,
+    Delete: UNICODE_CHARACTERS.Delete,
+    Semicolon: UNICODE_CHARACTERS.Semicolon,
+    Equals: UNICODE_CHARACTERS.Equals,
+    Numpad0: UNICODE_CHARACTERS['Numpad 0'],
+    Numpad1: UNICODE_CHARACTERS['Numpad 1'],
+    Numpad2: UNICODE_CHARACTERS['Numpad 2'],
+    Numpad3: UNICODE_CHARACTERS['Numpad 3'],
+    Numpad4: UNICODE_CHARACTERS['Numpad 4'],
+    Numpad5: UNICODE_CHARACTERS['Numpad 5'],
+    Numpad6: UNICODE_CHARACTERS['Numpad 6'],
+    Numpad7: UNICODE_CHARACTERS['Numpad 7'],
+    Numpad8: UNICODE_CHARACTERS['Numpad 8'],
+    Numpad9: UNICODE_CHARACTERS['Numpad 9'],
+    Multiply: UNICODE_CHARACTERS.Multiply,
+    Add: UNICODE_CHARACTERS.Add,
+    Separator: UNICODE_CHARACTERS.Separator,
+    Subtract: UNICODE_CHARACTERS.Subtract,
+    Decimal: UNICODE_CHARACTERS.Decimal,
+    Divide: UNICODE_CHARACTERS.Divide,
+    F1: UNICODE_CHARACTERS.F1,
+    F2: UNICODE_CHARACTERS.F2,
+    F3: UNICODE_CHARACTERS.F3,
+    F4: UNICODE_CHARACTERS.F4,
+    F5: UNICODE_CHARACTERS.F5,
+    F6: UNICODE_CHARACTERS.F6,
+    F7: UNICODE_CHARACTERS.F7,
+    F8: UNICODE_CHARACTERS.F8,
+    F9: UNICODE_CHARACTERS.F9,
+    F10: UNICODE_CHARACTERS.F10,
+    F11: UNICODE_CHARACTERS.F11,
+    F12: UNICODE_CHARACTERS.F12,
+    Command: UNICODE_CHARACTERS.Command,
+    ZenkakuHankaku: UNICODE_CHARACTERS.ZenkakuHankaku
+};

package/build/index.d.ts

@@ -1,13 +1,72 @@
-import { Options, Capabilities } from '@wdio/types';
-import SevereServiceErrorImport from './utils/SevereServiceError';
+import type { Options, Capabilities } from '@wdio/types';
+import SevereServiceErrorImport from './utils/SevereServiceError.js';
 import type { AttachOptions } from './types';
 export declare type RemoteOptions = Options.WebdriverIO & Omit<Options.Testrunner, 'capabilities'>;
+export declare const Key: {
+    readonly Ctrl: "WDIO_CONTROL";
+    readonly NULL: "";
+    readonly Cancel: "";
+    readonly Help: "";
+    readonly Backspace: "";
+    readonly Tab: "";
+    readonly Clear: "";
+    readonly Return: "";
+    readonly Enter: "";
+    readonly Shift: "";
+    readonly Control: "";
+    readonly Alt: "";
+    readonly Pause: "";
+    readonly Escape: "";
+    readonly Space: "";
+    readonly PageUp: "";
+    readonly PageDown: "";
+    readonly End: "";
+    readonly Home: "";
+    readonly ArrowLeft: "";
+    readonly ArrowUp: "";
+    readonly ArrowRight: "";
+    readonly ArrowDown: "";
+    readonly Insert: "";
+    readonly Delete: "";
+    readonly Semicolon: "";
+    readonly Equals: "";
+    readonly Numpad0: "";
+    readonly Numpad1: "";
+    readonly Numpad2: "";
+    readonly Numpad3: "";
+    readonly Numpad4: "";
+    readonly Numpad5: "";
+    readonly Numpad6: "";
+    readonly Numpad7: "";
+    readonly Numpad8: "";
+    readonly Numpad9: "";
+    readonly Multiply: "";
+    readonly Add: "";
+    readonly Separator: "";
+    readonly Subtract: "";
+    readonly Decimal: "";
+    readonly Divide: "";
+    readonly F1: "";
+    readonly F2: "";
+    readonly F3: "";
+    readonly F4: "";
+    readonly F5: "";
+    readonly F6: "";
+    readonly F7: "";
+    readonly F8: "";
+    readonly F9: "";
+    readonly F10: "";
+    readonly F11: "";
+    readonly F12: "";
+    readonly Command: "";
+    readonly ZenkakuHankaku: "";
+};
 /**
  * A method to create a new session with WebdriverIO.
  *
  * <b>
  * NOTE: If you hit "error TS2694: Namespace 'global.WebdriverIO' has no exported member 'Browser'" when using typescript,
- * add "webdriverio/async" into tsconfig.json's "types" array will solve it: <code> { "compilerOptions": { "types": ["webdriverio/async"] } } </code>
+ * add "@wdio/globals/types" into tsconfig.json's "types" array will solve it: <code> { "compilerOptions": { "types": ["@wdio/globals/types"] } } </code>
  * </b>
  *
  * @param  {Object} [params={}]       Options to create the session with
@@ -19,7 +78,7 @@ export declare const remote: (params: RemoteOptions, remoteModifier?: Function)
 export declare const attach: (attachOptions: AttachOptions) => Promise<WebdriverIO.Browser>;
 /**
  * WebdriverIO allows you to run multiple automated sessions in a single test.
- * This is handy when you’re testing features that require multiple users (for example, chat or WebRTC applications).
+ * This is handy when you're testing features that require multiple users (for example, chat or WebRTC applications).
  *
  * Instead of creating a couple of remote instances where you need to execute common commands like newSession() or url() on each instance,
  * you can simply create a multiremote instance and control all browsers at the same time.
@@ -40,6 +99,6 @@ export declare const multiremote: (params: Capabilities.MultiRemoteCapabilities,
     automationProtocol?: string | undefined;
 }) => Promise<WebdriverIO.MultiRemoteBrowser>;
 export declare const SevereServiceError: typeof SevereServiceErrorImport;
-export * from './types';
-export * from './utils/interception/types';
+export * from './types.js';
+export * from './utils/interception/types.js';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAKnD,OAAO,wBAAwB,MAAM,4BAA4B,CAAA;AAOjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,oBAAY,aAAa,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;AAE1F;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,WAA2B,aAAa,mBAAmB,QAAQ,KAAG,QAAQ,YAAY,OAAO,CA+CnH,CAAA;AAED,eAAO,MAAM,MAAM,kBAAkC,aAAa,KAAG,QAAQ,YAAY,OAAO,CAmB/F,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,WACZ,aAAa,uBAAuB;;MAE7C,QAAQ,YAAY,kBAAkB,CAgExC,CAAA;AAED,eAAO,MAAM,kBAAkB,iCAA2B,CAAA;AAC1D,cAAc,SAAS,CAAA;AACvB,cAAc,4BAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAIxD,OAAO,wBAAwB,MAAM,+BAA+B,CAAA;AAOpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C,oBAAY,aAAa,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;AAC1F,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAc,CAAA;AAE9B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,WAA2B,aAAa,mBAAmB,QAAQ,KAAG,QAAQ,YAAY,OAAO,CA6CnH,CAAA;AAED,eAAO,MAAM,MAAM,kBAAkC,aAAa,KAAG,QAAQ,YAAY,OAAO,CAmB/F,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,WACZ,aAAa,uBAAuB;;MAE7C,QAAQ,YAAY,kBAAkB,CAgExC,CAAA;AAED,eAAO,MAAM,kBAAkB,iCAA2B,CAAA;AAC1D,cAAc,YAAY,CAAA;AAC1B,cAAc,+BAA+B,CAAA"}

package/build/index.js

@@ -1,51 +1,19 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SevereServiceError = exports.multiremote = exports.attach = exports.remote = void 0;
-const logger_1 = __importDefault(require("@wdio/logger"));
-const webdriver_1 = __importDefault(require("webdriver"));
-const webdriver_2 = require("webdriver");
-const config_1 = require("@wdio/config");
-const utils_1 = require("@wdio/utils");
-const multiremote_1 = __importDefault(require("./multiremote"));
-const SevereServiceError_1 = __importDefault(require("./utils/SevereServiceError"));
-const detectBackend_1 = __importDefault(require("./utils/detectBackend"));
-const constants_1 = require("./constants");
-const utils_2 = require("./utils");
+import logger from '@wdio/logger';
+import WebDriver, { DEFAULTS } from 'webdriver';
+import { validateConfig } from '@wdio/config';
+import { wrapCommand } from '@wdio/utils';
+import MultiRemote from './multiremote.js';
+import SevereServiceErrorImport from './utils/SevereServiceError.js';
+import detectBackend from './utils/detectBackend.js';
+import { WDIO_DEFAULTS, Key as KeyConstant } from './constants.js';
+import { getPrototype, addLocatorStrategyHandler, isStub, getAutomationProtocol, updateCapabilities } from './utils/index.js';
+export const Key = KeyConstant;
 /**
  * A method to create a new session with WebdriverIO.
  *
  * <b>
  * NOTE: If you hit "error TS2694: Namespace 'global.WebdriverIO' has no exported member 'Browser'" when using typescript,
- * add "webdriverio/async" into tsconfig.json's "types" array will solve it: <code> { "compilerOptions": { "types": ["webdriverio/async"] } } </code>
+ * add "@wdio/globals/types" into tsconfig.json's "types" array will solve it: <code> { "compilerOptions": { "types": ["@wdio/globals/types"] } } </code>
  * </b>
  *
  * @param  {Object} [params={}]       Options to create the session with
@@ -53,10 +21,10 @@ const utils_2 = require("./utils");
  * @return {object}                   browser object with sessionId
  * @see <a href="https://webdriver.io/docs/typescript">Typescript setup</a>
  */
-const remote = async function (params, remoteModifier) {
-    logger_1.default.setLogLevelsConfig(params.logLevels, params.logLevel);
-    const config = (0, config_1.validateConfig)(constants_1.WDIO_DEFAULTS, params, Object.keys(webdriver_2.DEFAULTS));
-    const automationProtocol = await (0, utils_2.getAutomationProtocol)(config);
+export const remote = async function (params, remoteModifier) {
+    logger.setLogLevelsConfig(params.logLevels, params.logLevel);
+    const config = validateConfig(WDIO_DEFAULTS, params, Object.keys(DEFAULTS));
+    const automationProtocol = await getAutomationProtocol(config);
     const modifier = (client, options) => {
         /**
          * overwrite instance options with default values of the protocol
@@ -70,49 +38,44 @@ const remote = async function (params, remoteModifier) {
         options.automationProtocol = automationProtocol;
         return client;
     };
-    const prototype = (0, utils_2.getPrototype)('browser');
-    const ProtocolDriver = (await Promise.resolve().then(() => __importStar(require(automationProtocol)))).default;
-    params = Object.assign({}, (0, detectBackend_1.default)(params), params);
-    await (0, utils_2.updateCapabilities)(params, automationProtocol);
-    const instance = await ProtocolDriver.newSession(params, modifier, prototype, utils_1.wrapCommand);
+    const prototype = getPrototype('browser');
+    const ProtocolDriver = (await import(automationProtocol)).default;
+    params = Object.assign({}, detectBackend(params), params);
+    updateCapabilities(params, automationProtocol);
+    const instance = await ProtocolDriver.newSession(params, modifier, prototype, wrapCommand);
     /**
      * we need to overwrite the original addCommand and overwriteCommand
-     * in order to wrap the function within Fibers (only if webdriverio
-     * is used with @wdio/cli)
      */
-    if (params.framework && !(0, utils_2.isStub)(automationProtocol)) {
+    if (params.framework && !isStub(automationProtocol)) {
         const origAddCommand = instance.addCommand.bind(instance);
-        instance.addCommand = (name, fn, attachToElement) => (origAddCommand(name, (0, utils_1.runFnInFiberContext)(fn), attachToElement));
+        instance.addCommand = (name, fn, attachToElement) => (origAddCommand(name, fn, attachToElement));
         const origOverwriteCommand = instance.overwriteCommand.bind(instance);
-        instance.overwriteCommand = (name, fn, attachToElement) => (origOverwriteCommand(name, (0, utils_1.runFnInFiberContext)(fn), attachToElement));
+        instance.overwriteCommand = (name, fn, attachToElement) => (origOverwriteCommand(name, fn, attachToElement));
     }
-    instance.addLocatorStrategy = (0, utils_2.addLocatorStrategyHandler)(instance);
+    instance.addLocatorStrategy = addLocatorStrategyHandler(instance);
     return instance;
 };
-exports.remote = remote;
-const attach = async function (attachOptions) {
-    var _a, _b;
+export const attach = async function (attachOptions) {
     /**
      * copy instances properties into new object
      */
     const params = {
         ...attachOptions,
         options: { ...attachOptions.options },
-        ...(0, detectBackend_1.default)(attachOptions),
+        ...detectBackend(attachOptions),
         requestedCapabilities: attachOptions.requestedCapabilities
     };
-    const prototype = (0, utils_2.getPrototype)('browser');
+    const prototype = getPrototype('browser');
     let automationProtocol = 'webdriver';
-    if ((_a = params.options) === null || _a === void 0 ? void 0 : _a.automationProtocol) {
-        automationProtocol = (_b = params.options) === null || _b === void 0 ? void 0 : _b.automationProtocol;
+    if (params.options?.automationProtocol) {
+        automationProtocol = params.options?.automationProtocol;
     }
-    const ProtocolDriver = (await Promise.resolve().then(() => __importStar(require(automationProtocol)))).default;
-    return ProtocolDriver.attachToSession(params, undefined, prototype, utils_1.wrapCommand);
+    const ProtocolDriver = (await import(automationProtocol)).default;
+    return ProtocolDriver.attachToSession(params, undefined, prototype, wrapCommand);
 };
-exports.attach = attach;
 /**
  * WebdriverIO allows you to run multiple automated sessions in a single test.
- * This is handy when you’re testing features that require multiple users (for example, chat or WebRTC applications).
+ * This is handy when you're testing features that require multiple users (for example, chat or WebRTC applications).
  *
  * Instead of creating a couple of remote instances where you need to execute common commands like newSession() or url() on each instance,
  * you can simply create a multiremote instance and control all browsers at the same time.
@@ -129,47 +92,46 @@ exports.attach = attach;
  *
  * @see <a href="https://webdriver.io/docs/multiremote">External document and example usage</a>.
  */
-const multiremote = async function (params, { automationProtocol } = {}) {
-    const multibrowser = new multiremote_1.default();
+export const multiremote = async function (params, { automationProtocol } = {}) {
+    const multibrowser = new MultiRemote();
     const browserNames = Object.keys(params);
     /**
      * create all instance sessions
      */
     await Promise.all(browserNames.map(async (browserName) => {
-        const instance = await (0, exports.remote)(params[browserName]);
+        const instance = await remote(params[browserName]);
         return multibrowser.addInstance(browserName, instance);
     }));
     /**
      * use attachToSession capability to wrap instances around blank pod
      */
-    const prototype = (0, utils_2.getPrototype)('browser');
-    const sessionParams = (0, utils_2.isStub)(automationProtocol) ? undefined : {
+    const prototype = getPrototype('browser');
+    const sessionParams = isStub(automationProtocol) ? undefined : {
         sessionId: '',
         isW3C: multibrowser.instances[browserNames[0]].isW3C,
         logLevel: multibrowser.instances[browserNames[0]].options.logLevel
     };
-    const ProtocolDriver = automationProtocol && (0, utils_2.isStub)(automationProtocol)
-        ? require(automationProtocol).default
-        : webdriver_1.default;
-    const driver = ProtocolDriver.attachToSession(sessionParams, multibrowser.modifier.bind(multibrowser), prototype, utils_1.wrapCommand);
+    const ProtocolDriver = automationProtocol && isStub(automationProtocol)
+        ? (await import(automationProtocol)).default
+        : WebDriver;
+    const driver = ProtocolDriver.attachToSession(sessionParams, multibrowser.modifier.bind(multibrowser), prototype, wrapCommand);
     /**
      * in order to get custom command overwritten or added to multiremote instance
      * we need to pass in the prototype of the multibrowser
      */
-    if (!(0, utils_2.isStub)(automationProtocol)) {
+    if (!isStub(automationProtocol)) {
         const origAddCommand = driver.addCommand.bind(driver);
         driver.addCommand = (name, fn, attachToElement) => {
-            return origAddCommand(name, (0, utils_1.runFnInFiberContext)(fn), attachToElement, Object.getPrototypeOf(multibrowser.baseInstance), multibrowser.instances);
+            return origAddCommand(name, fn, attachToElement, Object.getPrototypeOf(multibrowser.baseInstance), multibrowser.instances);
         };
         const origOverwriteCommand = driver.overwriteCommand.bind(driver);
         driver.overwriteCommand = (name, fn, attachToElement) => {
-            return origOverwriteCommand(name, (0, utils_1.runFnInFiberContext)(fn), attachToElement, Object.getPrototypeOf(multibrowser.baseInstance), multibrowser.instances);
+            return origOverwriteCommand(name, fn, attachToElement, Object.getPrototypeOf(multibrowser.baseInstance), multibrowser.instances);
         };
     }
-    driver.addLocatorStrategy = (0, utils_2.addLocatorStrategyHandler)(driver);
+    driver.addLocatorStrategy = addLocatorStrategyHandler(driver);
     return driver;
 };
-exports.multiremote = multiremote;
-exports.SevereServiceError = SevereServiceError_1.default;
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils/interception/types"), exports);
+export const SevereServiceError = SevereServiceErrorImport;
+export * from './types.js';
+export * from './utils/interception/types.js';

package/build/middlewares.d.ts

@@ -2,7 +2,7 @@
  * This method is an command wrapper for elements that checks if a command is called
  * that wasn't found on the page and automatically waits for it
  *
- * @param  {Function} fn  commandWrap from wdio-sync package (or shim if not running in sync)
+ * @param  {Function} fn  command shim
  */
 export declare const elementErrorHandler: (fn: Function) => (commandName: string, commandFn: Function) => (this: WebdriverIO.Element, ...args: any[]) => any;
 /**

package/build/middlewares.js

@@ -1,32 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.multiremoteHandler = exports.elementErrorHandler = void 0;
-const refetchElement_1 = __importDefault(require("./utils/refetchElement"));
-const implicitWait_1 = __importDefault(require("./utils/implicitWait"));
-const utils_1 = require("./utils");
-const constants_1 = require("./constants");
+import refetchElement from './utils/refetchElement.js';
+import implicitWait from './utils/implicitWait.js';
+import { getBrowserObject } from './utils/index.js';
+import { ELEMENT_KEY } from './constants.js';
 /**
  * This method is an command wrapper for elements that checks if a command is called
  * that wasn't found on the page and automatically waits for it
  *
- * @param  {Function} fn  commandWrap from wdio-sync package (or shim if not running in sync)
+ * @param  {Function} fn  command shim
  */
-const elementErrorHandler = (fn) => (commandName, commandFn) => {
+export const elementErrorHandler = (fn) => (commandName, commandFn) => {
     return function elementErrorHandlerCallback(...args) {
         return fn(commandName, async function elementErrorHandlerCallbackFn() {
-            const element = await (0, implicitWait_1.default)(this, commandName);
+            const element = await implicitWait(this, commandName);
             this.elementId = element.elementId;
-            this[constants_1.ELEMENT_KEY] = element.elementId;
+            this[ELEMENT_KEY] = element.elementId;
             try {
                 const result = await fn(commandName, commandFn).apply(this, args);
                 /**
                  * assume Safari responses like { error: 'no such element', message: '', stacktrace: '' }
                  * as `stale element reference`
                  */
-                const caps = (0, utils_1.getBrowserObject)(this).capabilities;
+                const caps = getBrowserObject(this).capabilities;
                 if (caps && caps.browserName === 'safari' &&
                     result && result.error === 'no such element') {
                     const errorName = 'stale element reference';
@@ -38,7 +32,7 @@ const elementErrorHandler = (fn) => (commandName, commandFn) => {
             }
             catch (err) {
                 if (err.name === 'stale element reference') {
-                    const element = await (0, refetchElement_1.default)(this, commandName);
+                    const element = await refetchElement(this, commandName);
                     this.elementId = element.elementId;
                     this.parent = element.parent;
                     return await fn(commandName, commandFn).apply(this, args);
@@ -48,11 +42,10 @@ const elementErrorHandler = (fn) => (commandName, commandFn) => {
         }).apply(this);
     };
 };
-exports.elementErrorHandler = elementErrorHandler;
 /**
  * handle single command calls from multiremote instances
  */
-const multiremoteHandler = (wrapCommand) => (commandName) => {
+export const multiremoteHandler = (wrapCommand) => (commandName) => {
     return wrapCommand(commandName, function (...args) {
         // @ts-ignore
         const commandResults = this.instances.map((instanceName) => {
@@ -62,4 +55,3 @@ const multiremoteHandler = (wrapCommand) => (commandName) => {
         return Promise.all(commandResults);
     });
 };
-exports.multiremoteHandler = multiremoteHandler;