@wdio/utils 7.17.0 → 7.19.0

package/build/constants.d.ts

@@ -0,0 +1,82 @@
+/**
+ * unicode characters
+ * 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;
+};
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4E9B,CAAA"}

package/build/constants.js

@@ -0,0 +1,84 @@
+"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 = {
+    'NULL': '\uE000',
+    'Unidentified': '\uE000',
+    'Cancel': '\uE001',
+    'Help': '\uE002',
+    'Backspace': '\uE003',
+    'Back space': '\uE003',
+    'Tab': '\uE004',
+    'Clear': '\uE005',
+    'Return': '\uE006',
+    'Enter': '\uE007',
+    'Shift': '\uE008',
+    'Control': '\uE009',
+    'Control Left': '\uE009',
+    'Control Right': '\uE051',
+    'Alt': '\uE00A',
+    'Pause': '\uE00B',
+    'Escape': '\uE00C',
+    'Space': '\uE00D',
+    ' ': '\uE00D',
+    'PageUp': '\uE00E',
+    'Pageup': '\uE00E',
+    'Page_Up': '\uE00E',
+    'PageDown': '\uE00F',
+    'Pagedown': '\uE00F',
+    'Page_Down': '\uE00F',
+    'End': '\uE010',
+    'Home': '\uE011',
+    'ArrowLeft': '\uE012',
+    'Left arrow': '\uE012',
+    'Arrow_Left': '\uE012',
+    'ArrowUp': '\uE013',
+    'Up arrow': '\uE013',
+    'Arrow_Up': '\uE013',
+    'ArrowRight': '\uE014',
+    'Right arrow': '\uE014',
+    'Arrow_Right': '\uE014',
+    'ArrowDown': '\uE015',
+    'Down arrow': '\uE015',
+    'Arrow_Down': '\uE015',
+    'Insert': '\uE016',
+    'Delete': '\uE017',
+    'Semicolon': '\uE018',
+    'Equals': '\uE019',
+    'Numpad 0': '\uE01A',
+    'Numpad 1': '\uE01B',
+    'Numpad 2': '\uE01C',
+    'Numpad 3': '\uE01D',
+    'Numpad 4': '\uE01E',
+    'Numpad 5': '\uE01F',
+    'Numpad 6': '\uE020',
+    'Numpad 7': '\uE021',
+    'Numpad 8': '\uE022',
+    'Numpad 9': '\uE023',
+    'Multiply': '\uE024',
+    'Add': '\uE025',
+    'Separator': '\uE026',
+    'Subtract': '\uE027',
+    'Decimal': '\uE028',
+    'Divide': '\uE029',
+    'F1': '\uE031',
+    'F2': '\uE032',
+    'F3': '\uE033',
+    'F4': '\uE034',
+    'F5': '\uE035',
+    'F6': '\uE036',
+    'F7': '\uE037',
+    'F8': '\uE038',
+    'F9': '\uE039',
+    'F10': '\uE03A',
+    'F11': '\uE03B',
+    'F12': '\uE03C',
+    'Command': '\uE03D',
+    'Meta': '\uE03D',
+    'ZenkakuHankaku': '\uE040',
+    'Zenkaku_Hankaku': '\uE040'
+};

package/build/envDetector.d.ts

@@ -0,0 +1,71 @@
+import type { Capabilities } from '@wdio/types';
+/**
+ * check if session is based on W3C protocol based on the /session response
+ * @param  {Object}  capabilities  caps of session response
+ * @return {Boolean}               true if W3C (browser)
+ */
+export declare function isW3C(capabilities?: Capabilities.DesiredCapabilities): boolean;
+/**
+ * returns information about the environment before the session is created
+ * @param  {Object}  capabilities           caps provided by user
+ * @param  {string=} automationProtocol     `devtools`
+ * @return {Object}                         object with environment flags
+ */
+export declare function capabilitiesEnvironmentDetector(capabilities: Capabilities.Capabilities, automationProtocol: string): {
+    isChrome: boolean;
+    isFirefox: boolean;
+    isMobile: boolean;
+    isIOS: boolean;
+    isAndroid: boolean;
+    isSauce: boolean;
+};
+/**
+ * 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
+ */
+export declare function sessionEnvironmentDetector({ capabilities, requestedCapabilities }: {
+    capabilities: Capabilities.DesiredCapabilities;
+    requestedCapabilities: Capabilities.DesiredCapabilities | Capabilities.W3CCapabilities;
+}): {
+    isW3C: boolean;
+    isChrome: boolean;
+    isFirefox: boolean;
+    isMobile: boolean;
+    isIOS: boolean;
+    isAndroid: boolean;
+    isSauce: boolean;
+    isSeleniumStandalone: boolean;
+};
+/**
+ * returns information about the environment when `devtools` protocol is used
+ * @param  {Object}  capabilities           caps of session response
+ * @return {Object}                         object with environment flags
+ */
+export declare function devtoolsEnvironmentDetector({ browserName }: Capabilities.Capabilities): {
+    isDevTools: boolean;
+    isW3C: boolean;
+    isMobile: boolean;
+    isIOS: boolean;
+    isAndroid: boolean;
+    isFirefox: boolean;
+    isChrome: boolean;
+    isSauce: boolean;
+    isSeleniumStandalone: boolean;
+};
+/**
+ * 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
+ */
+export declare function webdriverEnvironmentDetector(capabilities: Capabilities.Capabilities): {
+    isChrome: boolean;
+    isFirefox: boolean;
+    isMobile: boolean;
+    isIOS: boolean;
+    isAndroid: boolean;
+    isSauce: boolean;
+};
+//# sourceMappingURL=envDetector.d.ts.map

package/build/envDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envDetector.d.ts","sourceRoot":"","sources":["../src/envDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAQ/C;;;;GAIG;AACH,wBAAgB,KAAK,CAAE,YAAY,CAAC,EAAE,YAAY,CAAC,mBAAmB,WAiCrE;AA0ID;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAE,YAAY,EAAE,YAAY,CAAC,YAAY,EAAE,kBAAkB,EAAE,MAAM;;;;;;;EAInH;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAE,EAAE,YAAY,EAAE,qBAAqB,EAAE,EAAE;IAAE,YAAY,EAAE,YAAY,CAAC,mBAAmB,CAAC;IAAC,qBAAqB,EAAE,YAAY,CAAC,mBAAmB,GAAG,YAAY,CAAC,eAAe,CAAA;CAAE;;;;;;;;;EAW9N;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAE,EAAE,WAAW,EAAE,EAAE,YAAY,CAAC,YAAY;;;;;;;;;;EAYtF;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAE,YAAY,EAAE,YAAY,CAAC,YAAY;;;;;;;EASpF"}

package/build/envDetector.js

@@ -0,0 +1,223 @@
+"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',
+    'device-orientation', 'deviceOrientation', 'deviceName', 'automationName'
+];
+/**
+ * check if session is based on W3C protocol based on the /session response
+ * @param  {Object}  capabilities  caps of session response
+ * @return {Boolean}               true if W3C (browser)
+ */
+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.
+     */
+    if (!capabilities) {
+        return false;
+    }
+    /**
+     * assume session to be a WebDriver session when
+     * - capabilities are returned
+     *   (https://w3c.github.io/webdriver/#dfn-new-sessions)
+     * - it is an Appium session (since Appium is full W3C compliant)
+     */
+    const isAppium = Boolean(capabilities.automationName ||
+        capabilities.deviceName ||
+        capabilities.appiumVersion);
+    const hasW3CCaps = Boolean(
+    /**
+     * safari docker image may not provide a platformName therefore
+     * check one of the available "platformName" or "browserVersion"
+     */
+    (capabilities.platformName || capabilities.browserVersion) &&
+        /**
+         * local safari and BrowserStack don't provide platformVersion therefore
+         * check also if setWindowRect is provided
+         */
+        (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
+ * @return {Boolean}               true if run by Chromedriver
+ */
+function isChrome(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return Boolean(capabilities.chrome || capabilities['goog:chromeOptions']);
+}
+/**
+ * check if session is run by Chromedriver
+ * @param  {Object}  capabilities  caps of session response
+ * @return {Boolean}               true if run by Chromedriver
+ */
+function isFirefox(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return (capabilities.browserName === 'firefox' ||
+        Boolean(Object.keys(capabilities).find((cap) => cap.startsWith('moz:'))));
+}
+/**
+ * check if current platform is mobile device
+ *
+ * @param  {Object}  caps  capabilities
+ * @return {Boolean}       true if platform is mobile device
+ */
+function isMobile(capabilities) {
+    const browserName = (capabilities.browserName || '').toLowerCase();
+    /**
+     * we have mobile capabilities if
+     */
+    return Boolean(
+    /**
+     * there are any Appium vendor capabilties
+     */
+    Object.keys(capabilities).find((cap) => cap.startsWith('appium:')) ||
+        /**
+         * capabilities contain mobile only specific capabilities
+         */
+        Object.keys(capabilities).find((cap) => MOBILE_CAPABILITIES.includes(cap)) ||
+        /**
+         * browserName is empty (and eventually app is defined)
+         */
+        capabilities.browserName === '' ||
+        /**
+         * browserName is a mobile browser
+         */
+        MOBILE_BROWSER_NAMES.includes(browserName));
+}
+/**
+ * check if session is run on iOS device
+ * @param  {Object}  capabilities  of session response
+ * @return {Boolean}               true if run on iOS device
+ */
+function isIOS(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return Boolean((capabilities.platformName && capabilities.platformName.match(/iOS/i)) ||
+        (capabilities.deviceName && capabilities.deviceName.match(/(iPad|iPhone)/i)));
+}
+/**
+ * check if session is run on Android device
+ * @param  {Object}  capabilities  caps of session response
+ * @return {Boolean}               true if run on Android device
+ */
+function isAndroid(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return Boolean((capabilities.platformName && capabilities.platformName.match(/Android/i)) ||
+        (capabilities.browserName && capabilities.browserName.match(/Android/i)));
+}
+/**
+ * detects if session is run on Sauce with extended debugging enabled
+ * @param  {string}  hostname     hostname of session request
+ * @param  {object}  capabilities session capabilities
+ * @return {Boolean}              true if session is running on Sauce with extended debugging enabled
+ */
+function isSauce(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    const caps = capabilities.alwaysMatch
+        ? capabilities.alwaysMatch
+        : capabilities;
+    return Boolean(caps.extendedDebugging ||
+        (caps['sauce:options'] &&
+            caps['sauce:options'].extendedDebugging));
+}
+/**
+ * detects if session is run using Selenium Standalone server
+ * @param  {object}  capabilities session capabilities
+ * @return {Boolean}              true if session is run with Selenium Standalone Server
+ */
+function isSeleniumStandalone(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return (
+    /**
+     * Selenium v3 and below
+     */
+    Boolean(capabilities['webdriver.remote.sessionid']) ||
+        /**
+         * Selenium v4 and up
+         */
+        Boolean(capabilities['se:cdp']));
+}
+/**
+ * returns information about the environment before the session is created
+ * @param  {Object}  capabilities           caps provided by user
+ * @param  {string=} automationProtocol     `devtools`
+ * @return {Object}                         object with environment flags
+ */
+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 }) {
+    return {
+        isW3C: isW3C(capabilities),
+        isChrome: isChrome(capabilities),
+        isFirefox: isFirefox(capabilities),
+        isMobile: isMobile(capabilities),
+        isIOS: isIOS(capabilities),
+        isAndroid: isAndroid(capabilities),
+        isSauce: isSauce(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 }) {
+    return {
+        isDevTools: true,
+        isW3C: true,
+        isMobile: false,
+        isIOS: false,
+        isAndroid: false,
+        isFirefox: false,
+        isChrome: browserName === 'chrome',
+        isSauce: false,
+        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) {
+    return {
+        isChrome: isChrome(capabilities),
+        isFirefox: isFirefox(capabilities),
+        isMobile: isMobile(capabilities),
+        isIOS: isIOS(capabilities),
+        isAndroid: isAndroid(capabilities),
+        isSauce: isSauce(capabilities)
+    };
+}
+exports.webdriverEnvironmentDetector = webdriverEnvironmentDetector;

package/build/index.d.ts

@@ -0,0 +1,22 @@
+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, 
+/**
+ * wdio-sync shim
+ */
+wrapCommand, executeSync, executeAsync, runFnInFiberContext, runTestInFiberContext, testFnWrapper, executeHooksWithArgs, hasWdioSyncSupport, 
+/**
+ * environmentDetector
+ */
+isW3C, sessionEnvironmentDetector, capabilitiesEnvironmentDetector, devtoolsEnvironmentDetector, 
+/**
+ * constants
+ */
+UNICODE_CHARACTERS };
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +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"}

package/build/index.js

@@ -0,0 +1,40 @@
+"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; } });

package/build/initialisePlugin.d.ts

@@ -0,0 +1,9 @@
+import { 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;
+//# sourceMappingURL=initialisePlugin.d.ts.map

package/build/initialisePlugin.d.ts.map

@@ -0,0 +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"}

package/build/initialisePlugin.js

@@ -0,0 +1,45 @@
+"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");
+/**
+ * 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) {
+    /**
+     * 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 (service) {
+            return service;
+        }
+    }
+    if (typeof type !== 'string') {
+        throw new Error('No plugin type provided');
+    }
+    /**
+     * check for scoped version of plugin first (e.g. @wdio/sauce-service)
+     */
+    const scopedPlugin = (0, utils_1.safeRequire)(`@wdio/${name.toLowerCase()}-${type}`);
+    if (scopedPlugin) {
+        return scopedPlugin;
+    }
+    /**
+     * check for old type of
+     */
+    const plugin = (0, utils_1.safeRequire)(`wdio-${name.toLowerCase()}-${type}`);
+    if (plugin) {
+        return plugin;
+    }
+    throw new Error(`Couldn't find plugin "${name}" ${type}, neither as wdio scoped package ` +
+        `"@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

@@ -0,0 +1,23 @@
+import type { Capabilities, Services, Options } from '@wdio/types';
+/**
+ * initialise service for launcher process
+ * @param  {Object}   config  wdio config
+ * @param  {Object[]} caps    list of capabilities
+ * @return {Object}           containing a list of launcher services as well
+ *                            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): {
+    ignoredWorkerServices: string[];
+    launcherServices: Services.ServiceInstance[];
+};
+/**
+ * initialise services for worker instance
+ * @param  {Object} config                 wdio config
+ * @param  {Object} caps                   worker capabilities
+ * @param  {[type]} ignoredWorkerServices  list of services that don't need to be required in a worker
+ *                                         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[];
+//# sourceMappingURL=initialiseServices.d.ts.map

package/build/initialiseServices.d.ts.map

@@ -0,0 +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"}