@wdio/utils 7.20.3 → 7.20.8-alpha.504

package/build/shim.d.ts

@@ -1,12 +1,8 @@
-declare let hasWdioSyncSupport: boolean;
-declare let runSync: (this: unknown, fn: Function, repeatTest: any, args: unknown[]) => (resolve: Function, reject: Function) => unknown;
 interface Retries {
     limit: number;
     attempts: number;
 }
 declare global {
-    var _HAS_FIBER_CONTEXT: boolean;
-    var browser: any;
     var expectAsync: any;
 }
 declare global {
@@ -17,26 +13,13 @@ declare global {
         }
     }
 }
-export declare function expectAsyncShim(actual?: any, syncMatcher?: Function): any;
-export declare let runAsync: boolean;
-export declare let asyncSpec: boolean;
 declare let executeHooksWithArgs: <T>(hookName: string, hooks?: Function | Function[], args?: any[]) => Promise<(Error | T)[]>;
-declare let runFnInFiberContext: (fn: Function) => (this: any, ...args: any[]) => Promise<any>;
 /**
  * wrap command to enable before and after command to be executed
  * @param commandName name of the command (e.g. getTitle)
  * @param fn          command function
  */
 declare let wrapCommand: <T>(commandName: string, fn: Function) => (...args: any) => Promise<T>;
-/**
- * execute test or hook synchronously
- *
- * @param  {Function} fn         spec or hook method
- * @param  {Number}   retries    { limit: number, attempts: number }
- * @param  {Array}    args       arguments passed to hook
- * @return {Promise}             that gets resolved once test/hook is done or was retried enough
- */
-declare function executeSyncFn(this: any, fn: Function, retries: Retries, args?: any[]): Promise<unknown>;
 /**
  * execute test or hook asynchronously
  *
@@ -46,14 +29,5 @@ declare function executeSyncFn(this: any, fn: Function, retries: Retries, args?:
  * @return {Promise}             that gets resolved once test/hook is done or was retried enough
  */
 declare function executeAsync(this: any, fn: Function, retries: Retries, args?: any[]): Promise<unknown>;
-declare let executeSync: typeof executeSyncFn;
-/**
- * Method to switch between sync and async execution. It allows to have async
- * tests in between synchronous tests. `fn` can either return a promise (e.g. for `executeSync`)
- * or a function (e.g. for `runSync`). In both cases we need to make sure that
- * we flip `runAsync` flag to true to that commands are wrapped with the @wdio/sync
- * wrapper.
- */
-export declare function switchSyncFlag(fn: Function): (this: unknown, ...args: any[]) => any;
-export { executeHooksWithArgs, runFnInFiberContext, wrapCommand, hasWdioSyncSupport, executeSync, executeAsync, runSync };
+export { executeHooksWithArgs, wrapCommand, executeAsync, };
 //# sourceMappingURL=shim.d.ts.map

package/build/shim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shim.d.ts","sourceRoot":"","sources":["../src/shim.ts"],"names":[],"mappings":"AAOA,QAAA,IAAI,kBAAkB,SAAQ,CAAA;AAC9B,QAAA,IAAI,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,KAAK,OAAO,CAAA;AAEhI,UAAU,OAAO;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB;AAUD,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,kBAAkB,EAAE,OAAO,CAAA;IAC/B,IAAI,OAAO,EAAE,GAAG,CAAA;IAChB,IAAI,WAAW,EAAE,GAAG,CAAA;CACvB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM,CAAC;QACb,UAAU,MAAM;YACZ,MAAM,EAAE,GAAG,CAAA;YACX,WAAW,EAAE,GAAG,CAAA;SACnB;KACJ;CACJ;AAeD,wBAAgB,eAAe,CAAE,MAAM,CAAC,EAAE,GAAG,EAAE,WAAW,WAAa,OAgBtE;AAgBD,eAAO,IAAI,QAAQ,SAAQ,CAAA;AAC3B,eAAO,IAAI,SAAS,SAAQ,CAAA;AAoB5B,QAAA,IAAI,oBAAoB,gBAAyD,MAAM,UAAS,QAAQ,GAAG,QAAQ,EAAE,SAAa,GAAG,EAAE,2BA+CtI,CAAA;AAED,QAAA,IAAI,mBAAmB,OAAiB,QAAQ,YACrB,GAAG,WAAW,GAAG,EAAE,iBAI7C,CAAA;AAED;;;;GAIG;AACH,QAAA,IAAI,WAAW,mBAAwC,MAAM,MAAM,QAAQ,eAAa,GAAG,eAmL1F,CAAA;AAED;;;;;;;GAOG;AACH,iBAAe,aAAa,CAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAwB3G;AAED;;;;;;;GAOG;AACH,iBAAe,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAyCzG;AAED,QAAA,IAAI,WAAW,sBAAgB,CAAA;AAE/B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAE,EAAE,EAAE,QAAQ,UACjB,OAAO,WAAW,GAAG,EAAE,SA0BjD;AAeD,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,OAAO,EACV,CAAA"}
+{"version":3,"file":"shim.d.ts","sourceRoot":"","sources":["../src/shim.ts"],"names":[],"mappings":"AAQA,UAAU,OAAO;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,WAAW,EAAE,GAAG,CAAA;CACvB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM,CAAC;QACb,UAAU,MAAM;YACZ,MAAM,EAAE,GAAG,CAAA;YACX,WAAW,EAAE,GAAG,CAAA;SACnB;KACJ;CACJ;AAaD,QAAA,IAAI,oBAAoB,gBAAyD,MAAM,UAAS,QAAQ,GAAG,QAAQ,EAAE,SAAa,GAAG,EAAE,2BA6CtI,CAAA;AAED;;;;GAIG;AACH,QAAA,IAAI,WAAW,mBAAwC,MAAM,MAAM,QAAQ,eAAa,GAAG,eAkL1F,CAAA;AAED;;;;;;;GAOG;AACH,iBAAe,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBzG;AAED,OAAO,EACH,oBAAoB,EACpB,WAAW,EACX,YAAY,GACf,CAAA"}

package/build/shim.js

@@ -1,42 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSync = exports.executeAsync = exports.executeSync = exports.hasWdioSyncSupport = exports.wrapCommand = exports.runFnInFiberContext = exports.executeHooksWithArgs = exports.switchSyncFlag = exports.asyncSpec = exports.runAsync = exports.expectAsyncShim = void 0;
-const p_iteration_1 = __importDefault(require("p-iteration"));
-const logger_1 = __importDefault(require("@wdio/logger"));
-const log = (0, logger_1.default)('@wdio/utils:shim');
+import * as iterators from 'p-iteration';
+import logger from '@wdio/logger';
+const log = logger('@wdio/utils:shim');
 let inCommandHook = false;
-let hasWdioSyncSupport = false;
-exports.hasWdioSyncSupport = hasWdioSyncSupport;
-let runSync;
-exports.runSync = runSync;
-/**
- * Jasmine differentiates between sync and async matchers.
- * In order to offer a consistent experience WebdriverIO is
- * replacing `expect` with `expectAsync` in every spec file
- * that is async. Now to also allow assertions of literal values
- * like string, numbers etc. in an async function we overwrite expect
- * with this shim to check the input value. If we assert a promise,
- * a browser or element object we use `expectAsync` otherwise the
- * normal sync `expect`.
- *
- * Note: `syncMatcher` as parameter is only for testing purposes
- */
-let expectSync;
-function expectAsyncShim(actual, syncMatcher = expectSync) {
-    const expectAsync = global.expectAsync;
-    const useSync = (!actual ||
-        (typeof actual.then !== 'function' &&
-            !actual.sessionId &&
-            !actual.elementId));
-    if (useSync) {
-        return syncMatcher(actual);
-    }
-    return expectAsync(actual);
-}
-exports.expectAsyncShim = expectAsyncShim;
 const ELEMENT_QUERY_COMMANDS = [
     '$', '$$', 'custom$', 'custom$$', 'shadow$', 'shadow$$', 'react$',
     'react$$', 'nextElement', 'previousElement', 'parentElement'
@@ -45,31 +10,9 @@ const ELEMENT_PROPS = [
     'elementId', 'error', 'selector', 'parent', 'index', 'isReactElement',
     'length'
 ];
+const ACTION_COMMANDS = ['action', 'actions'];
 const PROMISE_METHODS = ['then', 'catch', 'finally'];
-/**
- * shim to make sure that we only wrap commands if wdio-sync is installed as dependency
- */
-let wdioSync;
-exports.runAsync = false;
-exports.asyncSpec = false;
-try {
-    const packageName = '@wdio/sync';
-    wdioSync = require(packageName);
-    exports.hasWdioSyncSupport = hasWdioSyncSupport = true;
-    /**
-     * only print within worker process
-     */
-    if (process.send) {
-        log.warn('You are running tests with @wdio/sync which will be discontinued starting Node.js v16.' +
-            'Read more on https://github.com/webdriverio/webdriverio/discussions/6702');
-    }
-}
-catch (err) {
-    exports.runAsync = true;
-    exports.asyncSpec = true;
-}
 let executeHooksWithArgs = async function executeHooksWithArgsShim(hookName, hooks = [], args = []) {
-    exports.runAsync = true;
     /**
      * make sure hooks are an array of functions
      */
@@ -110,14 +53,6 @@ let executeHooksWithArgs = async function executeHooksWithArgsShim(hookName, hoo
     }
     return result;
 };
-exports.executeHooksWithArgs = executeHooksWithArgs;
-let runFnInFiberContext = function (fn) {
-    return function (...args) {
-        exports.runAsync = true;
-        return Promise.resolve(fn.apply(this, args));
-    };
-};
-exports.runFnInFiberContext = runFnInFiberContext;
 /**
  * wrap command to enable before and after command to be executed
  * @param commandName name of the command (e.g. getTitle)
@@ -210,10 +145,10 @@ let wrapCommand = function wrapCommand(commandName, fn) {
                  * await $('body').$('header').$$('div').map((elem) => elem.getLocation())
                  * ```
                  */
-                if (commandName.endsWith('$$') && typeof p_iteration_1.default[prop] === 'function') {
+                if (commandName.endsWith('$$') && typeof iterators[prop] === 'function') {
                     return (mapIterator) => wrapElementFn(target, function (mapIterator) {
                         // @ts-ignore
-                        return p_iteration_1.default[prop](this, mapIterator);
+                        return iterators[prop](this, mapIterator);
                     }, [mapIterator]);
                 }
                 /**
@@ -260,53 +195,21 @@ let wrapCommand = function wrapCommand(commandName, fn) {
     }
     return function (...args) {
         /**
-         * use sync mode if:
-         * - @wdio/sync package is installed and can be resolved
-         * - if a global.browser is define so we run with wdio testrunner
-         * - we are in a fiber context (flag is set when outer function is wrapped into fibers context)
-         *
-         * also if we run command asynchronous and the command suppose to return an element, we
-         * apply `chainElementQuery` to allow chaining of these promises.
+         * if the command suppose to return an element, we apply `chainElementQuery` to allow
+         * chaining of these promises.
          */
-        const command = hasWdioSyncSupport && wdioSync && Boolean(global.browser) && !exports.runAsync && !exports.asyncSpec
-            ? wdioSync.wrapCommand(commandName, fn)
-            : ELEMENT_QUERY_COMMANDS.includes(commandName) || commandName.endsWith('$')
-                ? chainElementQuery
+        const command = ELEMENT_QUERY_COMMANDS.includes(commandName) || commandName.endsWith('$')
+            ? chainElementQuery
+            : ACTION_COMMANDS.includes(commandName)
+                /**
+                 * actions commands are a bit special as they return their own
+                 * sync interface
+                 */
+                ? fn
                 : wrapCommandFn;
         return command.apply(this, args);
     };
 };
-exports.wrapCommand = wrapCommand;
-/**
- * execute test or hook synchronously
- *
- * @param  {Function} fn         spec or hook method
- * @param  {Number}   retries    { limit: number, attempts: number }
- * @param  {Array}    args       arguments passed to hook
- * @return {Promise}             that gets resolved once test/hook is done or was retried enough
- */
-async function executeSyncFn(fn, retries, args = []) {
-    this.wdioRetries = retries.attempts;
-    try {
-        exports.runAsync = true;
-        let res = fn.apply(this, args);
-        /**
-         * sometimes function result is Promise,
-         * we need to await result before proceeding
-         */
-        if (res instanceof Promise) {
-            return await res;
-        }
-        return res;
-    }
-    catch (err) {
-        if (retries.limit > retries.attempts) {
-            retries.attempts++;
-            return await executeSyncFn.call(this, fn, retries, args);
-        }
-        return Promise.reject(err);
-    }
-}
 /**
  * execute test or hook asynchronously
  *
@@ -316,28 +219,11 @@ async function executeSyncFn(fn, retries, args = []) {
  * @return {Promise}             that gets resolved once test/hook is done or was retried enough
  */
 async function executeAsync(fn, retries, args = []) {
-    const isJasmine = global.jasmine && global.expectAsync;
-    const asyncSpecBefore = exports.asyncSpec;
     this.wdioRetries = retries.attempts;
-    if (!expectSync) {
-        // @ts-ignore
-        expectSync = global.expect.bind({});
-    }
-    if (isJasmine) {
-        // @ts-ignore
-        global.expect = expectAsyncShim;
-    }
     try {
-        exports.runAsync = true;
-        exports.asyncSpec = true;
         const result = fn.apply(this, args);
         if (result && typeof result.finally === 'function') {
-            result
-                .finally(() => (exports.asyncSpec = asyncSpecBefore))
-                .catch((err) => err);
-        }
-        else {
-            exports.asyncSpec = asyncSpecBefore;
+            result.catch((err) => err);
         }
         return await result;
     }
@@ -348,57 +234,5 @@ async function executeAsync(fn, retries, args = []) {
         }
         throw err;
     }
-    finally {
-        if (isJasmine) {
-            // @ts-ignore
-            global.expect = expectSync;
-        }
-    }
-}
-exports.executeAsync = executeAsync;
-let executeSync = executeSyncFn;
-exports.executeSync = executeSync;
-/**
- * Method to switch between sync and async execution. It allows to have async
- * tests in between synchronous tests. `fn` can either return a promise (e.g. for `executeSync`)
- * or a function (e.g. for `runSync`). In both cases we need to make sure that
- * we flip `runAsync` flag to true to that commands are wrapped with the @wdio/sync
- * wrapper.
- */
-function switchSyncFlag(fn) {
-    return function (...args) {
-        const switchFlag = exports.runAsync;
-        exports.runAsync = false;
-        const result = fn.apply(this, args);
-        if (typeof result.finally === 'function') {
-            exports.runAsync = switchFlag;
-            return result;
-        }
-        if (typeof result === 'function') {
-            return function (...args) {
-                const switchFlagWithinFn = exports.runAsync;
-                const res = result.apply(this, args);
-                if (typeof result.finally === 'function') {
-                    return result.finally(() => (exports.runAsync = switchFlagWithinFn));
-                }
-                exports.runAsync = switchFlagWithinFn;
-                return res;
-            };
-        }
-        exports.runAsync = switchFlag;
-        return result;
-    };
-}
-exports.switchSyncFlag = switchSyncFlag;
-/**
- * only require `@wdio/sync` if `WDIO_NO_SYNC_SUPPORT` which allows us to
- * create a smoke test scenario to test actual absence of the package
- * (internal use only)
- */
-/* istanbul ignore if */
-if (!process.env.WDIO_NO_SYNC_SUPPORT && hasWdioSyncSupport && wdioSync) {
-    exports.runFnInFiberContext = runFnInFiberContext = switchSyncFlag(wdioSync.runFnInFiberContext);
-    exports.executeHooksWithArgs = executeHooksWithArgs = switchSyncFlag(wdioSync.executeHooksWithArgs);
-    exports.executeSync = executeSync = switchSyncFlag(wdioSync.executeSync);
-    exports.runSync = runSync = switchSyncFlag(wdioSync.runSync);
 }
+export { executeHooksWithArgs, wrapCommand, executeAsync, };

package/build/test-framework/errorHandler.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logHookError = void 0;
 /**
  * notify `WDIOCLInterface` about failure in hook
  * we need to do it this way because `beforeFn` and `afterFn` are not real hooks.
@@ -10,7 +7,7 @@ exports.logHookError = void 0;
  * @param {Array}   hookResults hook functions results array
  * @param {string}  cid         cid
  */
-const logHookError = (hookName, hookResults = [], cid) => {
+export const logHookError = (hookName, hookResults = [], cid) => {
     const result = hookResults.find(result => result instanceof Error);
     if (typeof result === 'undefined') {
         return;
@@ -32,4 +29,3 @@ const logHookError = (hookName, hookResults = [], cid) => {
         content
     });
 };
-exports.logHookError = logHookError;

package/build/test-framework/index.d.ts

@@ -1,4 +1,4 @@
-import { testFnWrapper } from './testFnWrapper';
-import { runTestInFiberContext } from './testInterfaceWrapper';
+import { testFnWrapper } from './testFnWrapper.js';
+import { runTestInFiberContext } from './testInterfaceWrapper.js';
 export { testFnWrapper, runTestInFiberContext };
 //# sourceMappingURL=index.d.ts.map

package/build/test-framework/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-framework/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAE9D,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-framework/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,CAAA"}

package/build/test-framework/index.js

@@ -1,8 +1,4 @@
-"use strict";
 /* istanbul ignore file */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTestInFiberContext = exports.testFnWrapper = void 0;
-const testFnWrapper_1 = require("./testFnWrapper");
-Object.defineProperty(exports, "testFnWrapper", { enumerable: true, get: function () { return testFnWrapper_1.testFnWrapper; } });
-const testInterfaceWrapper_1 = require("./testInterfaceWrapper");
-Object.defineProperty(exports, "runTestInFiberContext", { enumerable: true, get: function () { return testInterfaceWrapper_1.runTestInFiberContext; } });
+import { testFnWrapper } from './testFnWrapper.js';
+import { runTestInFiberContext } from './testInterfaceWrapper.js';
+export { testFnWrapper, runTestInFiberContext };

package/build/test-framework/testFnWrapper.d.ts

@@ -23,7 +23,7 @@ export declare const testFnWrapper: (this: unknown, args_0: string, args_1: Spec
  * @param   {number} repeatTest     number of retries if test fails
  * @return  {*}                     specFn result
  */
-export declare const testFrameworkFnWrapper: (this: unknown, { executeHooksWithArgs, executeAsync, runSync }: WrapperMethods, type: string, { specFn, specFnArgs }: SpecFunction, { beforeFn, beforeFnArgs }: BeforeHookParam<unknown>, { afterFn, afterFnArgs }: AfterHookParam<unknown>, cid: string, repeatTest?: number) => Promise<unknown>;
+export declare const testFrameworkFnWrapper: (this: unknown, { executeHooksWithArgs, executeAsync }: WrapperMethods, type: string, { specFn, specFnArgs }: SpecFunction, { beforeFn, beforeFnArgs }: BeforeHookParam<unknown>, { afterFn, afterFnArgs }: AfterHookParam<unknown>, cid: string, repeatTest?: number) => Promise<unknown>;
 /**
  * Filter out internal stacktraces. exporting to allow testing of the function
  * @param   {string} stack Stacktrace

package/build/test-framework/testFnWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testFnWrapper.d.ts","sourceRoot":"","sources":["../../src/test-framework/testFnWrapper.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACR,cAAc,EACd,YAAY,EACZ,eAAe,EACf,cAAc,EAEjB,MAAM,SAAS,CAAA;AAShB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,SAChB,OAAO,8JAWhB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,SACzB,OAAO,mDACoC,cAAc,QACzD,MAAM,0BACY,YAAY,8BACR,gBAAgB,OAAO,CAAC,4BAC1B,eAAe,OAAO,CAAC,OAC5C,MAAM,0CAuDd,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,UAAW,MAAM,KAAG,MAKhD,CAAA"}
+{"version":3,"file":"testFnWrapper.d.ts","sourceRoot":"","sources":["../../src/test-framework/testFnWrapper.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,cAAc,EACd,YAAY,EACZ,eAAe,EACf,cAAc,EAEjB,MAAM,SAAS,CAAA;AAShB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,SAChB,OAAO,8JAWhB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,SACzB,OAAO,0CAC2B,cAAc,QAChD,MAAM,0BACY,YAAY,8BACR,gBAAgB,OAAO,CAAC,4BAC1B,eAAe,OAAO,CAAC,OAC5C,MAAM,0CA8Cd,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,UAAW,MAAM,KAAG,MAKhD,CAAA"}

package/build/test-framework/testFnWrapper.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterStackTrace = exports.testFrameworkFnWrapper = exports.testFnWrapper = void 0;
-const utils_1 = require("../utils");
-const errorHandler_1 = require("./errorHandler");
-const shim_1 = require("../shim");
+import { logHookError } from './errorHandler.js';
+import { executeHooksWithArgs, executeAsync } from '../shim.js';
 const STACKTRACE_FILTER = [
     'node_modules/webdriver/',
     'node_modules/webdriverio/',
@@ -21,10 +17,9 @@ const STACKTRACE_FILTER = [
  * @param   {number} repeatTest     number of retries if test fails
  * @return  {*}                     specFn result
  */
-const testFnWrapper = function (...args) {
-    return exports.testFrameworkFnWrapper.call(this, { executeHooksWithArgs: shim_1.executeHooksWithArgs, executeAsync: shim_1.executeAsync, runSync: shim_1.runSync }, ...args);
+export const testFnWrapper = function (...args) {
+    return testFrameworkFnWrapper.call(this, { executeHooksWithArgs, executeAsync }, ...args);
 };
-exports.testFnWrapper = testFnWrapper;
 /**
  * wraps test framework spec/hook function with WebdriverIO before/after hooks
  *
@@ -37,29 +32,19 @@ exports.testFnWrapper = testFnWrapper;
  * @param   {number} repeatTest     number of retries if test fails
  * @return  {*}                     specFn result
  */
-const testFrameworkFnWrapper = async function ({ executeHooksWithArgs, executeAsync, runSync }, type, { specFn, specFnArgs }, { beforeFn, beforeFnArgs }, { afterFn, afterFnArgs }, cid, repeatTest = 0) {
+export const testFrameworkFnWrapper = async function ({ executeHooksWithArgs, executeAsync }, type, { specFn, specFnArgs }, { beforeFn, beforeFnArgs }, { afterFn, afterFnArgs }, cid, repeatTest = 0) {
     const retries = { attempts: 0, limit: repeatTest };
     const beforeArgs = beforeFnArgs(this);
-    await (0, errorHandler_1.logHookError)(`Before${type}`, await executeHooksWithArgs(`before${type}`, beforeFn, beforeArgs), cid);
-    let promise;
+    await logHookError(`Before${type}`, await executeHooksWithArgs(`before${type}`, beforeFn, beforeArgs), cid);
     let result;
     let error;
-    /**
-     * user wants handle async command using promises, no need to wrap in fiber context
-     */
-    if ((0, utils_1.isFunctionAsync)(specFn) || !runSync) {
-        promise = executeAsync.call(this, specFn, retries, specFnArgs);
-    }
-    else {
-        promise = new Promise(runSync.call(this, specFn, retries, specFnArgs));
-    }
     const testStart = Date.now();
     try {
-        result = await promise;
+        result = await executeAsync.call(this, specFn, retries, specFnArgs);
     }
     catch (err) {
         if (err.stack) {
-            err.stack = (0, exports.filterStackTrace)(err.stack);
+            err.stack = filterStackTrace(err.stack);
         }
         error = err;
     }
@@ -80,22 +65,20 @@ const testFrameworkFnWrapper = async function ({ executeHooksWithArgs, executeAs
         duration,
         passed: !error
     });
-    await (0, errorHandler_1.logHookError)(`After${type}`, await executeHooksWithArgs(`after${type}`, afterFn, [...afterArgs]), cid);
+    await logHookError(`After${type}`, await executeHooksWithArgs(`after${type}`, afterFn, [...afterArgs]), cid);
     if (error && !error.matcherName) {
         throw error;
     }
     return result;
 };
-exports.testFrameworkFnWrapper = testFrameworkFnWrapper;
 /**
  * Filter out internal stacktraces. exporting to allow testing of the function
  * @param   {string} stack Stacktrace
  * @returns {string}
  */
-const filterStackTrace = (stack) => {
+export const filterStackTrace = (stack) => {
     return stack
         .split('\n')
         .filter(line => !STACKTRACE_FILTER.some(l => line.includes(l)))
         .join('\n');
 };
-exports.filterStackTrace = filterStackTrace;

package/build/test-framework/testInterfaceWrapper.d.ts

@@ -7,8 +7,7 @@
  */
 import type { HookFnArgs, SpecArguments } from './types';
 /**
- * runs a hook within fibers context (if function name is not async)
- * it also executes before/after hook
+ * runs a hook and execute before/after hook
  *
  * @param  {Function} hookFn        function that was passed to the framework hook
  * @param  {Function} origFn        original framework hook function
@@ -22,7 +21,7 @@ import type { HookFnArgs, SpecArguments } from './types';
  */
 export declare const runHook: (this: unknown, hookFn: Function, origFn: Function, beforeFn: Function | Function[], beforeFnArgs: HookFnArgs<unknown>, afterFn: Function | Function[], afterFnArgs: HookFnArgs<unknown>, cid: string, repeatTest: number, timeout: number) => any;
 /**
- * runs a spec function (test function) within the fibers context
+ * runs a spec function (test function)
  *
  * @param  {string}   specTitle     test description
  * @param  {Function} specFn        test function that got passed in from the user
@@ -51,7 +50,7 @@ export declare const runSpec: (this: unknown, specTitle: string, specFn: Functio
  */
 export declare const wrapTestFunction: (this: unknown, origFn: Function, isSpec: boolean, beforeFn: Function | Function[], beforeArgsFn: HookFnArgs<unknown>, afterFn: Function | Function[], afterArgsFn: HookFnArgs<unknown>, cid: string) => (...specArguments: SpecArguments) => any;
 /**
- * Wraps global test function like `it` so that commands can run synchronouse
+ * Wraps global test function like `it`.
  *
  * The scope parameter is used in the qunit framework since all functions are bound to global.QUnit instead of global
  *

package/build/test-framework/testInterfaceWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testInterfaceWrapper.d.ts","sourceRoot":"","sources":["../../src/test-framework/testInterfaceWrapper.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EACR,UAAU,EAIV,aAAa,EAChB,MAAM,SAAS,CAAA;AAIhB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,SACV,OAAO,UACL,QAAQ,UACR,QAAQ,YACN,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,OAC3B,MAAM,cACC,MAAM,WACT,MAAM,QAgClB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,SACV,OAAO,aACF,MAAM,UACT,QAAQ,UACR,QAAQ,YACN,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,OAC3B,MAAM,cACC,MAAM,WACT,MAAM,QAgClB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,SACnB,OAAO,UACL,QAAQ,UACR,OAAO,YACL,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,OAC3B,MAAM,wBAEwB,aAAa,QAgEnD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,SACxB,OAAO,UACL,OAAO,YACL,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,UACxB,MAAM,OACT,MAAM,oCAcd,CAAA"}
+{"version":3,"file":"testInterfaceWrapper.d.ts","sourceRoot":"","sources":["../../src/test-framework/testInterfaceWrapper.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EACR,UAAU,EAIV,aAAa,EAChB,MAAM,SAAS,CAAA;AAIhB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,SACV,OAAO,UACL,QAAQ,UACR,QAAQ,YACN,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,OAC3B,MAAM,cACC,MAAM,WACT,MAAM,QAgClB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,SACV,OAAO,aACF,MAAM,UACT,QAAQ,UACR,QAAQ,YACN,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,OAC3B,MAAM,cACC,MAAM,WACT,MAAM,QAgClB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,SACnB,OAAO,UACL,QAAQ,UACR,OAAO,YACL,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,OAC3B,MAAM,wBAEwB,aAAa,QAkEnD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,SACxB,OAAO,UACL,OAAO,YACL,QAAQ,GAAG,QAAQ,EAAE,gBACjB,WAAW,OAAO,CAAC,WACxB,QAAQ,GAAG,QAAQ,EAAE,eACjB,WAAW,OAAO,CAAC,UACxB,MAAM,OACT,MAAM,oCAcd,CAAA"}

package/build/test-framework/testInterfaceWrapper.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * used to wrap mocha, jasmine test frameworks functions (`it`, `beforeEach` and other)
  * with WebdriverIO before/after Test/Hook hooks.
@@ -6,14 +5,11 @@
  *
  * NOTE: not used by cucumber test framework. `testFnWrapper` is called directly there
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTestInFiberContext = exports.wrapTestFunction = exports.runSpec = exports.runHook = void 0;
-const utils_1 = require("../utils");
-const testFnWrapper_1 = require("./testFnWrapper");
+import { filterSpecArgs } from '../utils.js';
+import { testFnWrapper } from './testFnWrapper.js';
 const MOCHA_COMMANDS = ['skip', 'only'];
 /**
- * runs a hook within fibers context (if function name is not async)
- * it also executes before/after hook
+ * runs a hook and execute before/after hook
  *
  * @param  {Function} hookFn        function that was passed to the framework hook
  * @param  {Function} origFn        original framework hook function
@@ -25,11 +21,11 @@ const MOCHA_COMMANDS = ['skip', 'only'];
  * @param  {Number}   repeatTest    number of retries if hook fails
  * @return {Function}               wrapped framework hook function
  */
-const runHook = function (hookFn, origFn, beforeFn, beforeFnArgs, afterFn, afterFnArgs, cid, repeatTest, timeout) {
+export const runHook = function (hookFn, origFn, beforeFn, beforeFnArgs, afterFn, afterFnArgs, cid, repeatTest, timeout) {
     return origFn(function (...hookFnArgs) {
-        return testFnWrapper_1.testFnWrapper.call(this, 'Hook', {
+        return testFnWrapper.call(this, 'Hook', {
             specFn: hookFn,
-            specFnArgs: (0, utils_1.filterSpecArgs)(hookFnArgs)
+            specFnArgs: filterSpecArgs(hookFnArgs)
         }, {
             beforeFn,
             beforeFnArgs
@@ -39,9 +35,8 @@ const runHook = function (hookFn, origFn, beforeFn, beforeFnArgs, afterFn, after
         }, cid, repeatTest);
     }, timeout);
 };
-exports.runHook = runHook;
 /**
- * runs a spec function (test function) within the fibers context
+ * runs a spec function (test function)
  *
  * @param  {string}   specTitle     test description
  * @param  {Function} specFn        test function that got passed in from the user
@@ -54,11 +49,11 @@ exports.runHook = runHook;
  * @param  {Number}   repeatTest    number of retries if test fails
  * @return {Function}               wrapped test function
  */
-const runSpec = function (specTitle, specFn, origFn, beforeFn, beforeFnArgs, afterFn, afterFnArgs, cid, repeatTest, timeout) {
+export const runSpec = function (specTitle, specFn, origFn, beforeFn, beforeFnArgs, afterFn, afterFnArgs, cid, repeatTest, timeout) {
     return origFn(specTitle, function (...specFnArgs) {
-        return testFnWrapper_1.testFnWrapper.call(this, 'Test', {
+        return testFnWrapper.call(this, 'Test', {
             specFn,
-            specFnArgs: (0, utils_1.filterSpecArgs)(specFnArgs)
+            specFnArgs: filterSpecArgs(specFnArgs)
         }, {
             beforeFn,
             beforeFnArgs
@@ -68,7 +63,6 @@ const runSpec = function (specTitle, specFn, origFn, beforeFn, beforeFnArgs, aft
         }, cid, repeatTest);
     }, timeout);
 };
-exports.runSpec = runSpec;
 /**
  * wraps hooks and test function of a framework within a fiber context
  *
@@ -82,9 +76,8 @@ exports.runSpec = runSpec;
  * @param  {String}   cid                  cid
  * @return {Function}                      wrapped test/hook function
  */
-const wrapTestFunction = function (origFn, isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid) {
+export const wrapTestFunction = function (origFn, isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid) {
     return function (...specArguments) {
-        var _a;
         /**
          * Variadic arguments:
          * [title, fn], [title], [fn]
@@ -97,7 +90,9 @@ const wrapTestFunction = function (origFn, isSpec, beforeFn, beforeArgsFn, after
          * Jasmine uses a timeout value as last parameter, in this case the arguments
          * should be [title, fn, timeout, retryCnt]
          */
-        let timeout = (_a = global.jasmine) === null || _a === void 0 ? void 0 : _a.DEFAULT_TIMEOUT_INTERVAL;
+        // @ts-expect-error
+        let timeout = global.jasmine?.DEFAULT_TIMEOUT_INTERVAL;
+        // @ts-expect-error
         if (global.jasmine) {
             // if we have [title, fn, timeout, retryCnt]
             if (typeof specArguments[specArguments.length - 1] === 'number') {
@@ -114,19 +109,18 @@ const wrapTestFunction = function (origFn, isSpec, beforeFn, beforeArgsFn, after
         const specTitle = specArguments[0];
         if (isSpec) {
             if (specFn) {
-                return (0, exports.runSpec)(specTitle, specFn, origFn, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid, retryCnt, timeout);
+                return runSpec(specTitle, specFn, origFn, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid, retryCnt, timeout);
             }
             /**
              * if specFn is undefined we are dealing with a pending function
              */
             return origFn(specTitle);
         }
-        return (0, exports.runHook)(specFn, origFn, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid, retryCnt, timeout);
+        return runHook(specFn, origFn, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid, retryCnt, timeout);
     };
 };
-exports.wrapTestFunction = wrapTestFunction;
 /**
- * Wraps global test function like `it` so that commands can run synchronouse
+ * Wraps global test function like `it`.
  *
  * The scope parameter is used in the qunit framework since all functions are bound to global.QUnit instead of global
  *
@@ -139,12 +133,11 @@ exports.wrapTestFunction = wrapTestFunction;
  * @param  {String}   cid           cid
  * @param  {Object}   scope         the scope to run command from, defaults to global
  */
-const runTestInFiberContext = function (isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, fnName, cid, scope = global) {
+export const runTestInFiberContext = function (isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, fnName, cid, scope = global) {
     const origFn = scope[fnName];
-    scope[fnName] = (0, exports.wrapTestFunction)(origFn, isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid);
+    scope[fnName] = wrapTestFunction(origFn, isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid);
     addMochaCommands(origFn, scope[fnName]);
 };
-exports.runTestInFiberContext = runTestInFiberContext;
 /**
  * support `it.skip` and `it.only` for the Mocha framework
  * @param {Function} origFn original function

package/build/test-framework/types.d.ts

@@ -1,9 +1,8 @@
-import type { executeHooksWithArgs, executeAsync, runSync } from '../shim';
+import type { executeHooksWithArgs, executeAsync } from '../shim';
 export declare type HookFnArgs<T> = (ctx: T) => [unknown, T];
 export interface WrapperMethods {
     executeHooksWithArgs: typeof executeHooksWithArgs;
     executeAsync: typeof executeAsync;
-    runSync: typeof runSync;
 }
 export interface SpecFunction {
     specFn: Function;

package/build/test-framework/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/test-framework/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAE1E,oBAAY,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;AAEpD,MAAM,WAAW,cAAc;IAC3B,oBAAoB,EAAE,OAAO,oBAAoB,CAAA;IACjD,YAAY,EAAE,OAAO,YAAY,CAAA;IACjC,OAAO,EAAE,OAAO,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,QAAQ,CAAA;IAChB,UAAU,EAAE,GAAG,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAC9B,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;IAC/B,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAC9B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC;IAC7B,OAAO,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;IAC9B,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAC7B;AAED,MAAM,WAAW,cAAc;IAC3B,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACrD;AAED,oBAAY,aAAa,GAAG;AACxB;;GAEG;AACH;IAAC,QAAQ;CAAC;AACV;;GAEG;AACH;IAAC,QAAQ;IAAE,MAAM;CAAC;AAClB;;GAEG;AACH;IAAC,MAAM;IAAE,QAAQ;CAAC;AAClB;;GAEG;AACH;IAAC,MAAM;IAAE,QAAQ;IAAE,MAAM;CAAC,CAC7B,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/test-framework/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEjE,oBAAY,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;AAEpD,MAAM,WAAW,cAAc;IAC3B,oBAAoB,EAAE,OAAO,oBAAoB,CAAA;IACjD,YAAY,EAAE,OAAO,YAAY,CAAA;CACpC;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,QAAQ,CAAA;IAChB,UAAU,EAAE,GAAG,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAC9B,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;IAC/B,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAC9B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC;IAC7B,OAAO,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;IAC9B,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAC7B;AAED,MAAM,WAAW,cAAc;IAC3B,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACrD;AAED,oBAAY,aAAa,GAAG;AACxB;;GAEG;AACH;IAAC,QAAQ;CAAC;AACV;;GAEG;AACH;IAAC,QAAQ;IAAE,MAAM;CAAC;AAClB;;GAEG;AACH;IAAC,MAAM;IAAE,QAAQ;CAAC;AAClB;;GAEG;AACH;IAAC,MAAM;IAAE,QAAQ;IAAE,MAAM;CAAC,CAC7B,CAAA"}