@wdio/utils 9.0.0-alpha.9 → 9.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/utils",
-  "version": "9.0.0-alpha.9+9220932b7",
+  "version": "9.0.4",
   "description": "A WDIO helper utility to provide several utility functions used across the project.",
   "author": "Christian Bromann <mail@bromann.dev>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-utils",
@@ -12,10 +12,9 @@
       "types": "./build/index.d.ts"
     },
     "./node": {
-      "import": "./build/node/index.js",
-      "types": "./build/node/index.d.ts"
-    },
-    "./package.json": "./package.json"
+      "source": "./src/node/index.ts",
+      "import": "./build/node.js"
+    }
   },
   "types": "./build/index.d.ts",
   "typeScriptVersion": "3.8.3",
@@ -24,7 +23,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/webdriverio/webdriverio.git",
+    "url": "git+https://github.com/webdriverio/webdriverio.git",
     "directory": "packages/wdio-utils"
   },
   "keywords": [
@@ -38,11 +37,11 @@
   },
   "dependencies": {
     "@puppeteer/browsers": "^2.2.0",
-    "@wdio/logger": "9.0.0-alpha.9+9220932b7",
-    "@wdio/types": "9.0.0-alpha.9+9220932b7",
+    "@wdio/logger": "9.0.4",
+    "@wdio/types": "9.0.4",
     "decamelize": "^6.0.0",
-    "deepmerge-ts": "^5.1.0",
-    "edgedriver": "^5.3.10",
+    "deepmerge-ts": "^7.0.3",
+    "edgedriver": "^5.6.1",
     "geckodriver": "^4.3.3",
     "get-port": "^7.0.0",
     "import-meta-resolve": "^4.0.0",
@@ -54,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9220932b7048d9b5b6c8397dda54842625be7ef2"
+  "gitHead": "1f3d6f781391548e8672e768e72b3d5c499a3aa7"
 }

package/build/constants.js

@@ -1,114 +0,0 @@
-/**
- * unicode characters
- * https://w3c.github.io/webdriver/webdriver-spec.html#character-types
- */
-export const 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'
-};
-export const SUPPORTED_BROWSERNAMES = {
-    chrome: ['chrome', 'googlechrome', 'chromium', 'chromium-browser'],
-    firefox: ['firefox', 'ff', 'mozilla', 'mozilla firefox'],
-    edge: ['edge', 'microsoftedge', 'msedge'],
-    safari: ['safari', 'safari technology preview']
-};
-export const DEFAULT_HOSTNAME = 'localhost';
-export const DEFAULT_PROTOCOL = 'http';
-export const DEFAULT_PATH = '/';
-/* istanbul ignore next */
-export const HOOK_DEFINITION = {
-    type: 'object',
-    validate: (param) => {
-        /**
-         * option must be an array
-         */
-        if (!Array.isArray(param)) {
-            throw new Error('a hook option needs to be a list of functions');
-        }
-        /**
-         * array elements must be functions
-         */
-        for (const option of param) {
-            /**
-             * either a string
-             */
-            if (typeof option === 'function') {
-                continue;
-            }
-            throw new Error('expected hook to be type of function');
-        }
-    }
-};

package/build/envDetector.js

@@ -1,251 +0,0 @@
-import { SUPPORTED_BROWSERNAMES } from './constants.js';
-const MOBILE_BROWSER_NAMES = ['ipad', 'iphone', 'android'];
-const MOBILE_CAPABILITIES = [
-    'appium-version', 'appiumVersion', 'device-type', 'deviceType', 'app', 'appArguments',
-    '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)
- */
-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.
-     */
-    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(
-    // @ts-expect-error outdated jsonwp cap
-    capabilities.automationName ||
-        capabilities['appium: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 ||
-            capabilities['appium:platformVersion'] ||
-            Object.prototype.hasOwnProperty.call(capabilities, 'setWindowRect')));
-    const hasWebdriverFlag = Boolean(capabilities['ms:experimental-webdriver']);
-    return Boolean(hasW3CCaps || isAppium || hasWebdriverFlag);
-}
-/**
- * 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 Edgedriver
- * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run by Edgedriver
- */
-function isEdge(capabilities) {
-    if (!capabilities) {
-        return false;
-    }
-    return (Boolean(capabilities.browserName && SUPPORTED_BROWSERNAMES.edge.includes(capabilities.browserName.toLowerCase()) ||
-        capabilities['ms:edgeOptions']));
-}
-/**
- * check if session is run by Geckodriver
- * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run by Geckodriver
- */
-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();
-    const bsOptions = capabilities['bstack:options'] || {};
-    const browserstackBrowserName = (bsOptions.browserName || '').toLowerCase();
-    /**
-     * we have mobile capabilities if
-     */
-    return Boolean(
-    /**
-     * If the device is ios, tvos or android, the device might be mobile.
-     */
-    capabilities.platformName && capabilities.platformName.match(/ios/i) ||
-        capabilities.platformName && capabilities.platformName.match(/tvos/i) ||
-        capabilities.platformName && capabilities.platformName.match(/android/i) ||
-        /ios/i.test(bsOptions.platformName || '') ||
-        /tvos/i.test(bsOptions.platformName || '') ||
-        /android/i.test(bsOptions.platformName || '') ||
-        /**
-         * capabilities contain mobile only specific capabilities
-         */
-        Object.keys(capabilities).find((cap) => (MOBILE_CAPABILITIES.includes(cap) ||
-            MOBILE_CAPABILITIES.map((c) => `appium:${c}`).includes(cap))) ||
-        /**
-         * browserName is empty (and eventually app is defined)
-         */
-        capabilities.browserName === '' ||
-        bsOptions.browserName === '' ||
-        /**
-         * browserName is a mobile browser
-         */
-        MOBILE_BROWSER_NAMES.includes(browserName) ||
-        MOBILE_BROWSER_NAMES.includes(browserstackBrowserName));
-}
-/**
- * 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) {
-    const bsOptions = capabilities?.['bstack:options'] || {};
-    if (!capabilities) {
-        return false;
-    }
-    return Boolean((capabilities.platformName && capabilities.platformName.match(/iOS/i)) ||
-        (capabilities.deviceName && capabilities.deviceName.match(/(iPad|iPhone)/i)) ||
-        (/iOS/i.test(bsOptions.platformName || '')) ||
-        (/(iPad|iPhone)/i.test(bsOptions.deviceName || '')));
-}
-/**
- * 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) {
-    const bsOptions = capabilities?.['bstack:options'] || {};
-    if (!capabilities) {
-        return false;
-    }
-    return Boolean((capabilities.platformName && capabilities.platformName.match(/Android/i)) ||
-        (/Android/i.test(bsOptions.platformName || '')) ||
-        (/Android/i.test(bsOptions.browserName || '')) ||
-        (capabilities.browserName && capabilities.browserName.match(/Android/i)));
-}
-/**
- * detects if session is run on Sauce with extended debugging enabled
- * @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 has support for WebDriver Bidi
- * @param  {object}  capabilities session capabilities
- * @return {Boolean}              true if session has WebDriver Bidi support
- */
-function isBidi(capabilities) {
-    if (!capabilities) {
-        return false;
-    }
-    const caps = capabilities.alwaysMatch
-        ? capabilities.alwaysMatch
-        : capabilities;
-    return Boolean(caps.webSocketUrl);
-}
-/**
- * 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']));
-}
-/**
- * detects if session is run using Chromium protocol
- * @param  {object}  capabilities session capabilities
- * @return {Boolean}              true if session is run with Chromium protocol
- */
-function isChromium(capabilities) {
-    if (!capabilities) {
-        return false;
-    }
-    return (isChrome(capabilities) || isEdge(capabilities));
-}
-/**
- * returns information about the environment before the session is created
- * @param  {Object}  capabilities           caps provided by user
- * @return {Object}                         object with environment flags
- */
-export function capabilitiesEnvironmentDetector(capabilities) {
-    return {
-        isChrome: isChrome(capabilities),
-        isFirefox: isFirefox(capabilities),
-        isMobile: isMobile(capabilities),
-        isIOS: isIOS(capabilities),
-        isAndroid: isAndroid(capabilities),
-        isSauce: isSauce(capabilities),
-        isBidi: isBidi(capabilities),
-        isChromium: isChromium(capabilities)
-    };
-}
-/**
- * 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 function sessionEnvironmentDetector({ capabilities, requestedCapabilities }) {
-    const cap = 'alwaysMatch' in capabilities
-        ? capabilities.alwaysMatch
-        : capabilities;
-    return {
-        isW3C: isW3C(cap),
-        isChrome: isChrome(cap),
-        isFirefox: isFirefox(cap),
-        isMobile: isMobile(cap),
-        isIOS: isIOS(cap),
-        isAndroid: isAndroid(cap),
-        isSauce: isSauce(requestedCapabilities),
-        isSeleniumStandalone: isSeleniumStandalone(cap),
-        isBidi: isBidi(capabilities),
-        isChromium: isChromium(cap)
-    };
-}

package/build/initializePlugin.js

@@ -1,38 +0,0 @@
-import { safeImport, isAbsolute } from './utils.js';
-/**
- * initialize 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 async function initializePlugin(name, type) {
-    /**
-     * directly import packages that are scoped or start with an absolute path
-     */
-    if (name[0] === '@' || isAbsolute(name)) {
-        const service = await safeImport(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 = await safeImport(`@wdio/${name.toLowerCase()}-${type}`);
-    if (scopedPlugin) {
-        return scopedPlugin;
-    }
-    /**
-     * check for old type of
-     */
-    const plugin = await safeImport(`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!`);
-}

package/build/initializeServices.js

@@ -1,159 +0,0 @@
-import logger from '@wdio/logger';
-import initializePlugin from './initializePlugin.js';
-const log = logger('@wdio/utils:initializeServices');
-/**
- * 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
- */
-async function initializeServices(services) {
-    const initializedServices = [];
-    for (const [serviceName, serviceConfig = {}] of services) {
-        /**
-         * allow custom services that are already initialized, e.g.
-         *
-         * ```
-         * services: [
-         *     [{ beforeTest: () => { ... } }]
-         * ]
-         * ```
-         */
-        if (typeof serviceName === 'object') {
-            log.debug('initialize custom initiated service');
-            initializedServices.push([serviceName, {}]);
-            continue;
-        }
-        /**
-         * allow custom service classes, e.g.
-         *
-         * ```
-         * class MyService { ... }
-         * ```
-         *
-         * in wdio.conf.js:
-         *
-         * ```
-         * services: [MyService]
-         * ```
-         */
-        if (typeof serviceName === 'function') {
-            log.debug(`initialize custom service "${serviceName.name}"`);
-            initializedServices.push([serviceName, serviceConfig]);
-            continue;
-        }
-        /**
-         * services as NPM packages
-         *
-         * ```
-         * services: ['@wdio/devtools-service']
-         * ```
-         */
-        log.debug(`initialize service "${serviceName}" as NPM package`);
-        const service = await initializePlugin(serviceName, 'service');
-        initializedServices.push([service, serviceConfig, serviceName]);
-    }
-    return initializedServices;
-}
-/**
- * formats service array into proper structure which is an array with
- * the service object as first parameter and the service option as
- * second parameter
- * @param  {[Any]} service               list of services from config file
- * @return {[service, serviceConfig][]}  formatted list of services
- */
-function sanitizeServiceArray(service) {
-    return Array.isArray(service) ? service : [service, {}];
-}
-/**
- * initialize 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 async function initializeLauncherService(config, caps) {
-    const ignoredWorkerServices = [];
-    const launcherServices = [];
-    let serviceLabelToBeInitialised = 'unknown';
-    try {
-        const services = await initializeServices(config.services.map(sanitizeServiceArray));
-        for (const [service, serviceConfig, serviceName] of services) {
-            /**
-             * add custom services as object or function
-             */
-            if (typeof service === 'object' && !serviceName) {
-                serviceLabelToBeInitialised = 'object';
-                launcherServices.push(service);
-                continue;
-            }
-            /**
-             * add class service from imported package
-             */
-            const Launcher = service.launcher;
-            if (typeof Launcher === 'function' && serviceName) {
-                serviceLabelToBeInitialised = `"${serviceName}"`;
-                launcherServices.push(new Launcher(serviceConfig, caps, config));
-            }
-            /**
-             * add class service from passed in class
-             */
-            if (typeof service === 'function' && !serviceName) {
-                serviceLabelToBeInitialised = `"${service.constructor?.name || service.toString()}"`;
-                launcherServices.push(new service(serviceConfig, caps, config));
-            }
-            /**
-             * check if service has a default export, if not we can later filter it out so the
-             * service module is not even loaded in the worker process
-             */
-            if (serviceName &&
-                typeof service.default !== 'function' &&
-                typeof service !== 'function') {
-                ignoredWorkerServices.push(serviceName);
-            }
-        }
-    }
-    catch (err) {
-        throw new Error(`Failed to initilialise launcher service ${serviceLabelToBeInitialised}: ${err.stack}`);
-    }
-    return { ignoredWorkerServices, launcherServices };
-}
-/**
- * initialize services for worker instance
- * @param  {Object} config                 wdio config
- * @param  {Object} caps                   worker capabilities
- * @param  {object} 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 async function initializeWorkerService(config, caps, ignoredWorkerServices = []) {
-    let serviceLabelToBeInitialised = 'unknown';
-    const initializedServices = [];
-    const workerServices = config.services
-        .map(sanitizeServiceArray)
-        .filter(([serviceName]) => !ignoredWorkerServices.includes(serviceName));
-    try {
-        const services = await initializeServices(workerServices);
-        for (const [service, serviceConfig, serviceName] of services) {
-            /**
-             * add object service
-             */
-            if (typeof service === 'object' && !serviceName) {
-                serviceLabelToBeInitialised = 'object';
-                initializedServices.push(service);
-                continue;
-            }
-            const Service = service.default || service;
-            if (typeof Service === 'function') {
-                serviceLabelToBeInitialised = serviceName || Service.constructor?.name || Service.toString();
-                initializedServices.push(new Service(serviceConfig, caps, config));
-                continue;
-            }
-        }
-        return initializedServices;
-    }
-    catch (err) {
-        throw new Error(`Failed to initilialise service ${serviceLabelToBeInitialised}: ${err.stack}`);
-    }
-}