@wdio/utils 7.20.3 → 7.20.8-alpha.504

package/build/constants.d.ts

@@ -3,80 +3,80 @@
  * https://w3c.github.io/webdriver/webdriver-spec.html#character-types
  */
 export declare const UNICODE_CHARACTERS: {
-    NULL: string;
-    Unidentified: string;
-    Cancel: string;
-    Help: string;
-    Backspace: string;
-    'Back space': string;
-    Tab: string;
-    Clear: string;
-    Return: string;
-    Enter: string;
-    Shift: string;
-    Control: string;
-    'Control Left': string;
-    'Control Right': string;
-    Alt: string;
-    Pause: string;
-    Escape: string;
-    Space: string;
-    ' ': string;
-    PageUp: string;
-    Pageup: string;
-    Page_Up: string;
-    PageDown: string;
-    Pagedown: string;
-    Page_Down: string;
-    End: string;
-    Home: string;
-    ArrowLeft: string;
-    'Left arrow': string;
-    Arrow_Left: string;
-    ArrowUp: string;
-    'Up arrow': string;
-    Arrow_Up: string;
-    ArrowRight: string;
-    'Right arrow': string;
-    Arrow_Right: string;
-    ArrowDown: string;
-    'Down arrow': string;
-    Arrow_Down: string;
-    Insert: string;
-    Delete: string;
-    Semicolon: string;
-    Equals: string;
-    'Numpad 0': string;
-    'Numpad 1': string;
-    'Numpad 2': string;
-    'Numpad 3': string;
-    'Numpad 4': string;
-    'Numpad 5': string;
-    'Numpad 6': string;
-    'Numpad 7': string;
-    'Numpad 8': string;
-    'Numpad 9': string;
-    Multiply: string;
-    Add: string;
-    Separator: string;
-    Subtract: string;
-    Decimal: string;
-    Divide: string;
-    F1: string;
-    F2: string;
-    F3: string;
-    F4: string;
-    F5: string;
-    F6: string;
-    F7: string;
-    F8: string;
-    F9: string;
-    F10: string;
-    F11: string;
-    F12: string;
-    Command: string;
-    Meta: string;
-    ZenkakuHankaku: string;
-    Zenkaku_Hankaku: string;
+    readonly NULL: "";
+    readonly Unidentified: "";
+    readonly Cancel: "";
+    readonly Help: "";
+    readonly Backspace: "";
+    readonly 'Back space': "";
+    readonly Tab: "";
+    readonly Clear: "";
+    readonly Return: "";
+    readonly Enter: "";
+    readonly Shift: "";
+    readonly Control: "";
+    readonly 'Control Left': "";
+    readonly 'Control Right': "";
+    readonly Alt: "";
+    readonly Pause: "";
+    readonly Escape: "";
+    readonly Space: "";
+    readonly ' ': "";
+    readonly PageUp: "";
+    readonly Pageup: "";
+    readonly Page_Up: "";
+    readonly PageDown: "";
+    readonly Pagedown: "";
+    readonly Page_Down: "";
+    readonly End: "";
+    readonly Home: "";
+    readonly ArrowLeft: "";
+    readonly 'Left arrow': "";
+    readonly Arrow_Left: "";
+    readonly ArrowUp: "";
+    readonly 'Up arrow': "";
+    readonly Arrow_Up: "";
+    readonly ArrowRight: "";
+    readonly 'Right arrow': "";
+    readonly Arrow_Right: "";
+    readonly ArrowDown: "";
+    readonly 'Down arrow': "";
+    readonly Arrow_Down: "";
+    readonly Insert: "";
+    readonly Delete: "";
+    readonly Semicolon: "";
+    readonly Equals: "";
+    readonly 'Numpad 0': "";
+    readonly 'Numpad 1': "";
+    readonly 'Numpad 2': "";
+    readonly 'Numpad 3': "";
+    readonly 'Numpad 4': "";
+    readonly 'Numpad 5': "";
+    readonly 'Numpad 6': "";
+    readonly 'Numpad 7': "";
+    readonly 'Numpad 8': "";
+    readonly 'Numpad 9': "";
+    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 Meta: "";
+    readonly ZenkakuHankaku: "";
+    readonly Zenkaku_Hankaku: "";
 };
 //# 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;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4E9B,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ErB,CAAA"}

package/build/constants.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNICODE_CHARACTERS = void 0;
 /**
  * unicode characters
  * https://w3c.github.io/webdriver/webdriver-spec.html#character-types
  */
-exports.UNICODE_CHARACTERS = {
+export const UNICODE_CHARACTERS = {
     'NULL': '\uE000',
     'Unidentified': '\uE000',
     'Cancel': '\uE001',

package/build/envDetector.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webdriverEnvironmentDetector = exports.devtoolsEnvironmentDetector = exports.sessionEnvironmentDetector = exports.capabilitiesEnvironmentDetector = exports.isW3C = void 0;
 const MOBILE_BROWSER_NAMES = ['ipad', 'iphone', 'android'];
 const MOBILE_CAPABILITIES = [
     'appium-version', 'appiumVersion', 'device-type', 'deviceType',
@@ -11,7 +8,7 @@ const MOBILE_CAPABILITIES = [
  * @param  {Object}  capabilities  caps of session response
  * @return {Boolean}               true if W3C (browser)
  */
-function isW3C(capabilities) {
+export function isW3C(capabilities) {
     /**
      * JSONWire protocol doesn't return a property `capabilities`.
      * Also check for Appium response as it is using JSONWire protocol for most of the part.
@@ -41,7 +38,6 @@ function isW3C(capabilities) {
         (capabilities.platformVersion || Object.prototype.hasOwnProperty.call(capabilities, 'setWindowRect')));
     return Boolean(hasW3CCaps || isAppium);
 }
-exports.isW3C = isW3C;
 /**
  * check if session is run by Chromedriver
  * @param  {Object}  capabilities  caps of session response
@@ -160,19 +156,18 @@ function isSeleniumStandalone(capabilities) {
  * @param  {string=} automationProtocol     `devtools`
  * @return {Object}                         object with environment flags
  */
-function capabilitiesEnvironmentDetector(capabilities, automationProtocol) {
+export function capabilitiesEnvironmentDetector(capabilities, automationProtocol) {
     return automationProtocol === 'devtools'
         ? devtoolsEnvironmentDetector(capabilities)
         : webdriverEnvironmentDetector(capabilities);
 }
-exports.capabilitiesEnvironmentDetector = capabilitiesEnvironmentDetector;
 /**
  * returns information about the environment when the session is created
  * @param  {Object}  capabilities           caps of session response
  * @param  {Object}  requestedCapabilities
  * @return {Object}                         object with environment flags
  */
-function sessionEnvironmentDetector({ capabilities, requestedCapabilities }) {
+export function sessionEnvironmentDetector({ capabilities, requestedCapabilities }) {
     return {
         isW3C: isW3C(capabilities),
         isChrome: isChrome(capabilities),
@@ -184,13 +179,12 @@ function sessionEnvironmentDetector({ capabilities, requestedCapabilities }) {
         isSeleniumStandalone: isSeleniumStandalone(capabilities)
     };
 }
-exports.sessionEnvironmentDetector = sessionEnvironmentDetector;
 /**
  * returns information about the environment when `devtools` protocol is used
  * @param  {Object}  capabilities           caps of session response
  * @return {Object}                         object with environment flags
  */
-function devtoolsEnvironmentDetector({ browserName }) {
+export function devtoolsEnvironmentDetector({ browserName }) {
     return {
         isDevTools: true,
         isW3C: true,
@@ -203,14 +197,13 @@ function devtoolsEnvironmentDetector({ browserName }) {
         isSeleniumStandalone: false,
     };
 }
-exports.devtoolsEnvironmentDetector = devtoolsEnvironmentDetector;
 /**
  * returns information about the environment before the session is created
  * `isW3C`, `isSeleniumStandalone` cannot be detected
  * @param  {Object}  capabilities           caps provided by user
  * @return {Object}                         object with environment flags
  */
-function webdriverEnvironmentDetector(capabilities) {
+export function webdriverEnvironmentDetector(capabilities) {
     return {
         isChrome: isChrome(capabilities),
         isFirefox: isFirefox(capabilities),
@@ -220,4 +213,3 @@ function webdriverEnvironmentDetector(capabilities) {
         isSauce: isSauce(capabilities)
     };
 }
-exports.webdriverEnvironmentDetector = webdriverEnvironmentDetector;

package/build/index.d.ts

@@ -1,16 +1,16 @@
-import initialisePlugin from './initialisePlugin';
-import { initialiseWorkerService, initialiseLauncherService } from './initialiseServices';
-import webdriverMonad from './monad';
-import { commandCallStructure, isValidParameter, getArgumentType, safeRequire, isFunctionAsync, transformCommandLogResult, canAccess, sleep } from './utils';
-import { wrapCommand, runFnInFiberContext, executeHooksWithArgs, hasWdioSyncSupport, executeSync, executeAsync } from './shim';
-import { testFnWrapper, runTestInFiberContext } from './test-framework';
-import { isW3C, capabilitiesEnvironmentDetector, sessionEnvironmentDetector, devtoolsEnvironmentDetector } from './envDetector';
-import { UNICODE_CHARACTERS } from './constants';
-export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeRequire, canAccess, sleep, 
+import initialisePlugin from './initialisePlugin.js';
+import { initialiseWorkerService, initialiseLauncherService } from './initialiseServices.js';
+import webdriverMonad from './monad.js';
+import { commandCallStructure, isValidParameter, getArgumentType, safeImport, isFunctionAsync, transformCommandLogResult, canAccess, sleep } from './utils.js';
+import { wrapCommand, executeHooksWithArgs, executeAsync } from './shim.js';
+import { testFnWrapper, runTestInFiberContext } from './test-framework/index.js';
+import { isW3C, capabilitiesEnvironmentDetector, sessionEnvironmentDetector, devtoolsEnvironmentDetector } from './envDetector.js';
+import { UNICODE_CHARACTERS } from './constants.js';
+export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeImport, canAccess, sleep, 
 /**
- * wdio-sync shim
+ * runner shim
  */
-wrapCommand, executeSync, executeAsync, runFnInFiberContext, runTestInFiberContext, testFnWrapper, executeHooksWithArgs, hasWdioSyncSupport, 
+wrapCommand, executeAsync, runTestInFiberContext, testFnWrapper, executeHooksWithArgs, 
 /**
  * environmentDetector
  */

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAA;AACzF,OAAO,cAAc,MAAM,SAAS,CAAA;AACpC,OAAO,EACH,oBAAoB,EAAE,gBAAgB,EAAE,eAAe,EAAE,WAAW,EACpE,eAAe,EAAE,yBAAyB,EAAE,SAAS,EAAE,KAAK,EAC/D,MAAM,SAAS,CAAA;AAChB,OAAO,EACH,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EACtD,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAChD,MAAM,QAAQ,CAAA;AACf,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EACH,KAAK,EAAE,+BAA+B,EACtC,0BAA0B,EAAE,2BAA2B,EAC1D,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAEhD,OAAO,EACH,gBAAgB,EAChB,yBAAyB,EACzB,uBAAuB,EACvB,eAAe,EACf,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,SAAS,EACT,KAAK;AAEL;;GAEG;AACH,WAAW,EACX,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,aAAa,EACb,oBAAoB,EACpB,kBAAkB;AAElB;;GAEG;AACH,KAAK,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,2BAA2B;AAE3B;;GAEG;AACH,kBAAkB,EACrB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAC5F,OAAO,cAAc,MAAM,YAAY,CAAA;AACvC,OAAO,EACH,oBAAoB,EAAE,gBAAgB,EAAE,eAAe,EAAE,UAAU,EACnE,eAAe,EAAE,yBAAyB,EAAE,SAAS,EAAE,KAAK,EAC/D,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC3E,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAChF,OAAO,EACH,KAAK,EAAE,+BAA+B,EACtC,0BAA0B,EAAE,2BAA2B,EAC1D,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EACH,gBAAgB,EAChB,yBAAyB,EACzB,uBAAuB,EACvB,eAAe,EACf,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,SAAS,EACT,KAAK;AAEL;;GAEG;AACH,WAAW,EACX,YAAY,EACZ,qBAAqB,EACrB,aAAa,EACb,oBAAoB;AAEpB;;GAEG;AACH,KAAK,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,2BAA2B;AAE3B;;GAEG;AACH,kBAAkB,EACrB,CAAA"}

package/build/index.js

@@ -1,40 +1,22 @@
-"use strict";
 /* istanbul ignore file */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNICODE_CHARACTERS = exports.devtoolsEnvironmentDetector = exports.capabilitiesEnvironmentDetector = exports.sessionEnvironmentDetector = exports.isW3C = exports.hasWdioSyncSupport = exports.executeHooksWithArgs = exports.testFnWrapper = exports.runTestInFiberContext = exports.runFnInFiberContext = exports.executeAsync = exports.executeSync = exports.wrapCommand = exports.sleep = exports.canAccess = exports.safeRequire = exports.getArgumentType = exports.isValidParameter = exports.commandCallStructure = exports.webdriverMonad = exports.transformCommandLogResult = exports.isFunctionAsync = exports.initialiseWorkerService = exports.initialiseLauncherService = exports.initialisePlugin = void 0;
-const initialisePlugin_1 = __importDefault(require("./initialisePlugin"));
-exports.initialisePlugin = initialisePlugin_1.default;
-const initialiseServices_1 = require("./initialiseServices");
-Object.defineProperty(exports, "initialiseWorkerService", { enumerable: true, get: function () { return initialiseServices_1.initialiseWorkerService; } });
-Object.defineProperty(exports, "initialiseLauncherService", { enumerable: true, get: function () { return initialiseServices_1.initialiseLauncherService; } });
-const monad_1 = __importDefault(require("./monad"));
-exports.webdriverMonad = monad_1.default;
-const utils_1 = require("./utils");
-Object.defineProperty(exports, "commandCallStructure", { enumerable: true, get: function () { return utils_1.commandCallStructure; } });
-Object.defineProperty(exports, "isValidParameter", { enumerable: true, get: function () { return utils_1.isValidParameter; } });
-Object.defineProperty(exports, "getArgumentType", { enumerable: true, get: function () { return utils_1.getArgumentType; } });
-Object.defineProperty(exports, "safeRequire", { enumerable: true, get: function () { return utils_1.safeRequire; } });
-Object.defineProperty(exports, "isFunctionAsync", { enumerable: true, get: function () { return utils_1.isFunctionAsync; } });
-Object.defineProperty(exports, "transformCommandLogResult", { enumerable: true, get: function () { return utils_1.transformCommandLogResult; } });
-Object.defineProperty(exports, "canAccess", { enumerable: true, get: function () { return utils_1.canAccess; } });
-Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
-const shim_1 = require("./shim");
-Object.defineProperty(exports, "wrapCommand", { enumerable: true, get: function () { return shim_1.wrapCommand; } });
-Object.defineProperty(exports, "runFnInFiberContext", { enumerable: true, get: function () { return shim_1.runFnInFiberContext; } });
-Object.defineProperty(exports, "executeHooksWithArgs", { enumerable: true, get: function () { return shim_1.executeHooksWithArgs; } });
-Object.defineProperty(exports, "hasWdioSyncSupport", { enumerable: true, get: function () { return shim_1.hasWdioSyncSupport; } });
-Object.defineProperty(exports, "executeSync", { enumerable: true, get: function () { return shim_1.executeSync; } });
-Object.defineProperty(exports, "executeAsync", { enumerable: true, get: function () { return shim_1.executeAsync; } });
-const test_framework_1 = require("./test-framework");
-Object.defineProperty(exports, "testFnWrapper", { enumerable: true, get: function () { return test_framework_1.testFnWrapper; } });
-Object.defineProperty(exports, "runTestInFiberContext", { enumerable: true, get: function () { return test_framework_1.runTestInFiberContext; } });
-const envDetector_1 = require("./envDetector");
-Object.defineProperty(exports, "isW3C", { enumerable: true, get: function () { return envDetector_1.isW3C; } });
-Object.defineProperty(exports, "capabilitiesEnvironmentDetector", { enumerable: true, get: function () { return envDetector_1.capabilitiesEnvironmentDetector; } });
-Object.defineProperty(exports, "sessionEnvironmentDetector", { enumerable: true, get: function () { return envDetector_1.sessionEnvironmentDetector; } });
-Object.defineProperty(exports, "devtoolsEnvironmentDetector", { enumerable: true, get: function () { return envDetector_1.devtoolsEnvironmentDetector; } });
-const constants_1 = require("./constants");
-Object.defineProperty(exports, "UNICODE_CHARACTERS", { enumerable: true, get: function () { return constants_1.UNICODE_CHARACTERS; } });
+import initialisePlugin from './initialisePlugin.js';
+import { initialiseWorkerService, initialiseLauncherService } from './initialiseServices.js';
+import webdriverMonad from './monad.js';
+import { commandCallStructure, isValidParameter, getArgumentType, safeImport, isFunctionAsync, transformCommandLogResult, canAccess, sleep } from './utils.js';
+import { wrapCommand, executeHooksWithArgs, executeAsync } from './shim.js';
+import { testFnWrapper, runTestInFiberContext } from './test-framework/index.js';
+import { isW3C, capabilitiesEnvironmentDetector, sessionEnvironmentDetector, devtoolsEnvironmentDetector } from './envDetector.js';
+import { UNICODE_CHARACTERS } from './constants.js';
+export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeImport, canAccess, sleep, 
+/**
+ * runner shim
+ */
+wrapCommand, executeAsync, runTestInFiberContext, testFnWrapper, executeHooksWithArgs, 
+/**
+ * environmentDetector
+ */
+isW3C, sessionEnvironmentDetector, capabilitiesEnvironmentDetector, devtoolsEnvironmentDetector, 
+/**
+ * constants
+ */
+UNICODE_CHARACTERS };

package/build/initialisePlugin.d.ts

@@ -1,9 +1,9 @@
-import { Services } from '@wdio/types';
+import type { Services } from '@wdio/types';
 /**
  * initialise WebdriverIO compliant plugins like reporter or services in the following way:
  * 1. if package name is scoped (starts with "@"), require scoped package name
  * 2. otherwise try to require "@wdio/<name>-<type>"
  * 3. otherwise try to require "wdio-<name>-<type>"
  */
-export default function initialisePlugin(name: string, type?: string): Services.ServicePlugin | Services.RunnerPlugin;
+export default function initialisePlugin(name: string, type?: string): Promise<Services.ServicePlugin | Services.RunnerPlugin>;
 //# sourceMappingURL=initialisePlugin.d.ts.map

package/build/initialisePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialisePlugin.d.ts","sourceRoot":"","sources":["../src/initialisePlugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAItC;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,YAAY,CAqCrH"}
+{"version":3,"file":"initialisePlugin.d.ts","sourceRoot":"","sources":["../src/initialisePlugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAI3C;;;;;GAKG;AACH,wBAA8B,gBAAgB,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,YAAY,CAAC,CAqCpI"}

package/build/initialisePlugin.js

@@ -1,22 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("./utils");
+import path from 'node:path';
+import { safeImport } from './utils.js';
 /**
  * initialise WebdriverIO compliant plugins like reporter or services in the following way:
  * 1. if package name is scoped (starts with "@"), require scoped package name
  * 2. otherwise try to require "@wdio/<name>-<type>"
  * 3. otherwise try to require "wdio-<name>-<type>"
  */
-function initialisePlugin(name, type) {
+export default async function initialisePlugin(name, type) {
     /**
      * directly import packages that are scoped or start with an absolute path
      */
-    if (name[0] === '@' || path_1.default.isAbsolute(name)) {
-        const service = (0, utils_1.safeRequire)(name);
+    if (name[0] === '@' || path.isAbsolute(name)) {
+        const service = await safeImport(name);
         if (service) {
             return service;
         }
@@ -27,14 +22,14 @@ function initialisePlugin(name, type) {
     /**
      * check for scoped version of plugin first (e.g. @wdio/sauce-service)
      */
-    const scopedPlugin = (0, utils_1.safeRequire)(`@wdio/${name.toLowerCase()}-${type}`);
+    const scopedPlugin = await safeImport(`@wdio/${name.toLowerCase()}-${type}`);
     if (scopedPlugin) {
         return scopedPlugin;
     }
     /**
      * check for old type of
      */
-    const plugin = (0, utils_1.safeRequire)(`wdio-${name.toLowerCase()}-${type}`);
+    const plugin = await safeImport(`wdio-${name.toLowerCase()}-${type}`);
     if (plugin) {
         return plugin;
     }
@@ -42,4 +37,3 @@ function initialisePlugin(name, type) {
         `"@wdio/${name.toLowerCase()}-${type}" nor as community package ` +
         `"wdio-${name.toLowerCase()}-${type}". Please make sure you have it installed!`);
 }
-exports.default = initialisePlugin;

package/build/initialiseServices.d.ts

@@ -7,10 +7,10 @@ import type { Capabilities, Services, Options } from '@wdio/types';
  *                            as a list of services that don't need to be
  *                            required in the worker
  */
-export declare function initialiseLauncherService(config: Omit<Options.Testrunner, 'capabilities' | keyof Services.HookFunctions>, caps: Capabilities.DesiredCapabilities): {
+export declare function initialiseLauncherService(config: Omit<Options.Testrunner, 'capabilities' | keyof Services.HookFunctions>, caps: Capabilities.DesiredCapabilities): Promise<{
     ignoredWorkerServices: string[];
     launcherServices: Services.ServiceInstance[];
-};
+}>;
 /**
  * initialise services for worker instance
  * @param  {Object} config                 wdio config
@@ -19,5 +19,5 @@ export declare function initialiseLauncherService(config: Omit<Options.Testrunne
  *                                         as they don't export a service for it
  * @return {Object[]}                      list if worker initiated worker services
  */
-export declare function initialiseWorkerService(config: Options.Testrunner, caps: Capabilities.DesiredCapabilities, ignoredWorkerServices?: string[]): Services.ServiceInstance[];
+export declare function initialiseWorkerService(config: Options.Testrunner, caps: Capabilities.DesiredCapabilities, ignoredWorkerServices?: string[]): Promise<Services.ServiceInstance[]>;
 //# sourceMappingURL=initialiseServices.d.ts.map

package/build/initialiseServices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialiseServices.d.ts","sourceRoot":"","sources":["../src/initialiseServices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAqFlE;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM,QAAQ,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,mBAAmB;;;EAiDjK;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,YAAY,CAAC,mBAAmB,EACtC,qBAAqB,GAAE,MAAM,EAAO,GACrC,QAAQ,CAAC,eAAe,EAAE,CA6B5B"}
+{"version":3,"file":"initialiseServices.d.ts","sourceRoot":"","sources":["../src/initialiseServices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAqFlE;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM,QAAQ,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,mBAAmB;;;GAiDvK;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CACzC,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,YAAY,CAAC,mBAAmB,EACtC,qBAAqB,GAAE,MAAM,EAAO,GACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC,CA6BrC"}

package/build/initialiseServices.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialiseWorkerService = exports.initialiseLauncherService = void 0;
-const logger_1 = __importDefault(require("@wdio/logger"));
-const initialisePlugin_1 = __importDefault(require("./initialisePlugin"));
-const log = (0, logger_1.default)('@wdio/utils:initialiseServices');
+import logger from '@wdio/logger';
+import initialisePlugin from './initialisePlugin.js';
+const log = logger('@wdio/utils:initialiseServices');
 /**
  * Maps list of services of a config file into a list of actionable objects
  * @param  {Object}    config            config of running session
  * @param  {Object}    caps              capabilities of running session
  * @return {[(Object|Class), Object][]}  list of services with their config objects
  */
-function initialiseServices(services) {
+async function initialiseServices(services) {
     const initialisedServices = [];
     for (let [serviceName, serviceConfig = {}] of services) {
         /**
@@ -56,7 +50,7 @@ function initialiseServices(services) {
          * ```
          */
         log.debug(`initialise service "${serviceName}" as NPM package`);
-        const service = (0, initialisePlugin_1.default)(serviceName, 'service');
+        const service = await initialisePlugin(serviceName, 'service');
         initialisedServices.push([service, serviceConfig, serviceName]);
     }
     return initialisedServices;
@@ -79,11 +73,11 @@ function sanitizeServiceArray(service) {
  *                            as a list of services that don't need to be
  *                            required in the worker
  */
-function initialiseLauncherService(config, caps) {
+export async function initialiseLauncherService(config, caps) {
     const ignoredWorkerServices = [];
     const launcherServices = [];
     try {
-        const services = initialiseServices(config.services.map(sanitizeServiceArray));
+        const services = await initialiseServices(config.services.map(sanitizeServiceArray));
         for (const [service, serviceConfig, serviceName] of services) {
             /**
              * add custom services as object or function
@@ -123,7 +117,6 @@ function initialiseLauncherService(config, caps) {
     }
     return { ignoredWorkerServices, launcherServices };
 }
-exports.initialiseLauncherService = initialiseLauncherService;
 /**
  * initialise services for worker instance
  * @param  {Object} config                 wdio config
@@ -132,12 +125,12 @@ exports.initialiseLauncherService = initialiseLauncherService;
  *                                         as they don't export a service for it
  * @return {Object[]}                      list if worker initiated worker services
  */
-function initialiseWorkerService(config, caps, ignoredWorkerServices = []) {
+export async function initialiseWorkerService(config, caps, ignoredWorkerServices = []) {
     const workerServices = config.services
         .map(sanitizeServiceArray)
         .filter(([serviceName]) => !ignoredWorkerServices.includes(serviceName));
     try {
-        const services = initialiseServices(workerServices);
+        const services = await initialiseServices(workerServices);
         return services.map(([service, serviceConfig, serviceName]) => {
             /**
              * add object service
@@ -159,4 +152,3 @@ function initialiseWorkerService(config, caps, ignoredWorkerServices = []) {
         return [];
     }
 }
-exports.initialiseWorkerService = initialiseWorkerService;

package/build/monad.d.ts

@@ -1,8 +1,11 @@
+import { EventEmitter } from 'node:events';
 interface PropertiesObject {
     [key: string | symbol]: PropertyDescriptor;
 }
 export default function WebDriver(options: Record<string, any>, modifier?: Function, propertiesObject?: PropertiesObject): {
-    (this: void, sessionId: string, commandWrapper?: Function): any;
+    (this: void, sessionId: string, commandWrapper?: Function, eventMiddleware?: {
+        socket: Partial<EventEmitter>;
+    }): any;
     /**
      * Enhance monad prototype with function
      * @param  {String}   name          name of function to attach to prototype

package/build/monad.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monad.d.ts","sourceRoot":"","sources":["../src/monad.ts"],"names":[],"mappings":"AAYA,UAAU,gBAAgB;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,CAAA;CAC7C;AAED,MAAM,CAAC,OAAO,UAAU,SAAS,CAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,EAAE,gBAAgB,GAAE,gBAAqB;WAkBpG,IAAI,aAAa,MAAM,mBAAmB,QAAQ;IA+GvE;;;;;;OAMG;eACyB,MAAM,QAAQ,QAAQ,SAAS,OAAO,MAAM,EAAE,GAAG,CAAC,gBAAgB,QAAQ;EAqCzG"}
+{"version":3,"file":"monad.d.ts","sourceRoot":"","sources":["../src/monad.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAU1C,UAAU,gBAAgB;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,CAAA;CAC7C;AAED,MAAM,CAAC,OAAO,UAAU,SAAS,CAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,EAAE,gBAAgB,GAAE,gBAAqB;WAkBpG,IAAI,aAAa,MAAM,mBAAmB,QAAQ,oBAAoB;QAAE,MAAM,EAAE,QAAQ,YAAY,CAAC,CAAA;KAAE;IAmH5H;;;;;;OAMG;eACyB,MAAM,QAAQ,QAAQ,SAAS,OAAO,MAAM,EAAE,GAAG,CAAC,gBAAgB,QAAQ;EA4CzG"}

package/build/monad.js

@@ -1,32 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = require("events");
-const logger_1 = __importDefault(require("@wdio/logger"));
-const utils_1 = require("./utils");
+import { EventEmitter } from 'node:events';
+import logger from '@wdio/logger';
+import { commandCallStructure, overwriteElementCommands } from './utils.js';
 const SCOPE_TYPES = {
     browser: /* istanbul ignore next */ function Browser() { },
     element: /* istanbul ignore next */ function Element() { }
 };
-function WebDriver(options, modifier, propertiesObject = {}) {
-    var _a;
+export default function WebDriver(options, modifier, propertiesObject = {}) {
     /**
      * In order to allow named scopes for elements we have to propagate that
      * info within the `propertiesObject` object. This doesn't have any functional
      * advantages just provides better description of objects when debugging them
      */
-    const scopeType = SCOPE_TYPES[((_a = propertiesObject.scope) === null || _a === void 0 ? void 0 : _a.value) || 'browser'];
+    const scopeType = SCOPE_TYPES[propertiesObject.scope?.value || 'browser'];
     delete propertiesObject.scope;
     const prototype = Object.create(scopeType.prototype);
-    const log = (0, logger_1.default)('webdriver');
-    const eventHandler = new events_1.EventEmitter();
+    const log = logger('webdriver');
+    const eventHandler = new EventEmitter();
     const EVENTHANDLER_FUNCTIONS = Object.getPrototypeOf(eventHandler);
     /**
      * WebDriver monad
      */
-    function unit(sessionId, commandWrapper) {
+    function unit(sessionId, commandWrapper, eventMiddleware) {
+        if (eventMiddleware) {
+            prototype.eventMiddleware = eventMiddleware;
+        }
         /**
          * capabilities attached to the instance prototype not being shown if
          * logging the instance
@@ -50,7 +47,7 @@ function WebDriver(options, modifier, propertiesObject = {}) {
         /**
          * overwrite native element commands with user defined
          */
-        utils_1.overwriteElementCommands.call(this, propertiesObject);
+        overwriteElementCommands.call(this, propertiesObject);
         /**
          * assign propertiesObject to itself so the client can be recreated
          */
@@ -138,7 +135,7 @@ function WebDriver(options, modifier, propertiesObject = {}) {
      */
     unit.lift = function (name, func, proto, origCommand) {
         (proto || prototype)[name] = function next(...args) {
-            log.info('COMMAND', (0, utils_1.commandCallStructure)(name, args));
+            log.info('COMMAND', commandCallStructure(name, args));
             /**
              * set name of function for better error stack
              */
@@ -163,9 +160,13 @@ function WebDriver(options, modifier, propertiesObject = {}) {
     for (let eventCommand in EVENTHANDLER_FUNCTIONS) {
         prototype[eventCommand] = function (...args) {
             eventHandler[eventCommand](...args);
+            if (prototype.eventMiddleware) {
+                if (typeof prototype.eventMiddleware[eventCommand] === 'function') {
+                    prototype.eventMiddleware.socket[eventCommand](...args);
+                }
+            }
             return this;
         };
     }
     return unit;
 }
-exports.default = WebDriver;