@wdio/utils 8.12.1 → 8.14.0

package/build/envDetector.js

@@ -57,9 +57,9 @@ function isChrome(capabilities) {
     return Boolean(capabilities.chrome || capabilities['goog:chromeOptions']);
 }
 /**
- * check if session is run by Chromedriver
+ * check if session is run by Geckodriver
  * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run by Chromedriver
+ * @return {Boolean}               true if run by Geckodriver
  */
 function isFirefox(capabilities) {
     if (!capabilities) {

package/build/pIteration.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Implements ES5 [`Array#forEach()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) method.<br><br>
+ * Executes the provided callback once for each element.<br>
+ * Callbacks are run concurrently,
+ * and are only invoked for properties of the array that have been initialized (including those initialized with *undefined*), for unassigned ones `callback` is not run.<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with undefined value.
+ */
+export declare const forEach: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<void>;
+/**
+ * Same functionality as [`forEach()`](global.html#forEach), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with undefined value.
+ */
+export declare const forEachSeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<void>;
+/**
+ * Implements ES5 [`Array#map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) method.<br><br>
+ * Creates a new array with the results of calling the provided callback once for each element.<br>
+ * Callbacks are run concurrently,
+ * and are only invoked for properties of the array that have been initialized (including those initialized with *undefined*), for unassigned ones`callback` is not run.<br>
+ * Resultant *Array* is always the same *length* as the original one.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the resultant *Array* as value.
+ */
+export declare const map: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<any[]>;
+/**
+ * Same functionality as [`map()`](global.html#map), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the resultant *Array* as value.
+ */
+export declare const mapSeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<any[]>;
+/**
+ * Implements ES5 [`Array#find()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) method.<br><br>
+ * Returns the value of the element that satisfies the provided `callback`. The value returned is the one found first.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if the returned value is found in one of the first elements of `array`,
+ * depending on the async calls you are going to use, consider using instead [`findSeries()`](global.html#findSeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the element that passed the test as value, otherwise *undefined*.
+ */
+export declare const find: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown>;
+/**
+ * Same functionality as [`find()`](global.html#find), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the element that passed the test as value, otherwise *undefined*.
+ */
+export declare const findSeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown>;
+/**
+ * Implements ES5 [`Array#findIndex()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex) method.<br><br>
+ * Returns the index of the element that satisfies the provided `callback`. The index returned is the one found first.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if the returned index is found in one of the first elements of `array`,
+ * depending on the async calls you are going to use, consider using instead [`findSeries()`](global.html#findSeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the index that passed the test as value, otherwise *-1*.
+ */
+export declare const findIndex: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown>;
+/**
+ * Same functionality as [`findIndex()`](global.html#findIndex), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the index that passed the test, otherwise *-1*.
+ */
+export declare const findIndexSeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<number | undefined>;
+/**
+ * Implements ES5 [`Array#some()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some) method.<br><br>
+ * Test if some element in `array` passes the test implemented in `callback`.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if some of the first elements pass the test,
+ * depending on the async calls you are going to use, consider using instead [`someSeries()`](global.html#someSeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if some element passed the test, otherwise *false*.
+ */
+export declare const some: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown>;
+/**
+ * Same functionality as [`some()`](global.html#some), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if some element passed the test, otherwise *false*.
+ */
+export declare const someSeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<boolean>;
+/**
+ * Implements ES5 [`Array#every()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) method.<br><br>
+ * Test if all elements in `array` pass the test implemented in `callback`.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if any of the first elements do not pass the test,
+ * depending on the async calls you are going to use, consider using instead [`everySeries()`](global.html#everySeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if all elements passed the test, otherwise *false*.
+ */
+export declare const every: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown>;
+/**
+ * Same functionality as [`every()`](global.html#every), but runs only one callback at a time.<br><br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if all elements passed the test, otherwise *false*.
+ */
+export declare const everySeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<boolean>;
+/**
+ * Implements ES5 [`Array#filter()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) method.<br><br>
+ * Creates a new array with the elements that passed the test implemented in `callback`.<br>
+ * Callbacks are run concurrently.<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the resultant filtered *Array* as value.
+ */
+export declare const filter: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown>;
+/**
+ * Same functionality as [`filter()`](global.html#filter), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @return {Promise} - Returns a Promise with the resultant filtered *Array* as value.
+ */
+export declare const filterSeries: (array: unknown[], callback: Function, thisArg?: unknown) => Promise<unknown[]>;
+/**
+ * Implements ES5 [`Array#reduce()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) method.<br><br>
+ * Applies a `callback` against an accumulator and each element in `array`.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts four arguments: `accumulator`, `currentValue`, `currentIndex` and `array`.
+ * @param {Object} [initialValue] - Used as first argument to the first call of `callback`.
+ * @return {Promise} - Returns a Promise with the resultant value from the reduction.
+ */
+export declare const reduce: (array: unknown[], callback: Function, initialValue?: unknown) => Promise<any>;
+//# sourceMappingURL=pIteration.d.ts.map

package/build/pIteration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pIteration.d.ts","sourceRoot":"","sources":["../src/pIteration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,kBAWpF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,kBAM1F,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,mBAUhF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,mBAQtF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,UAAW,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAqB3E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAMvF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,UAAW,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAqBhF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,gCAM5F,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,UAAW,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAyB3E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAOvF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,UAAW,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAyB5E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAOxF,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,UAAW,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,qBAwB7E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAiB,OAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,uBAQzF,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,UAAiB,OAAO,EAAE,YAAY,QAAQ,iBAAiB,OAAO,iBAmBxF,CAAA"}

package/build/pIteration.js

@@ -0,0 +1,347 @@
+/**
+ * Implements ES5 [`Array#forEach()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) method.<br><br>
+ * Executes the provided callback once for each element.<br>
+ * Callbacks are run concurrently,
+ * and are only invoked for properties of the array that have been initialized (including those initialized with *undefined*), for unassigned ones `callback` is not run.<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with undefined value.
+ */
+export const forEach = async (array, callback, thisArg) => {
+    const promiseArray = [];
+    for (let i = 0; i < array.length; i++) {
+        if (i in array) {
+            const p = Promise.resolve(array[i]).then((currentValue) => {
+                return callback.call(thisArg || this, currentValue, i, array);
+            });
+            promiseArray.push(p);
+        }
+    }
+    await Promise.all(promiseArray);
+};
+/**
+ * Same functionality as [`forEach()`](global.html#forEach), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with undefined value.
+ */
+export const forEachSeries = async (array, callback, thisArg) => {
+    for (let i = 0; i < array.length; i++) {
+        if (i in array) {
+            await callback.call(thisArg || this, await array[i], i, array);
+        }
+    }
+};
+/**
+ * Implements ES5 [`Array#map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) method.<br><br>
+ * Creates a new array with the results of calling the provided callback once for each element.<br>
+ * Callbacks are run concurrently,
+ * and are only invoked for properties of the array that have been initialized (including those initialized with *undefined*), for unassigned ones`callback` is not run.<br>
+ * Resultant *Array* is always the same *length* as the original one.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the resultant *Array* as value.
+ */
+export const map = async (array, callback, thisArg) => {
+    const promiseArray = [];
+    for (let i = 0; i < array.length; i++) {
+        if (i in array) {
+            promiseArray[i] = Promise.resolve(array[i]).then((currentValue) => {
+                return callback.call(thisArg || this, currentValue, i, array);
+            });
+        }
+    }
+    return Promise.all(promiseArray);
+};
+/**
+ * Same functionality as [`map()`](global.html#map), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the resultant *Array* as value.
+ */
+export const mapSeries = async (array, callback, thisArg) => {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        if (i in array) {
+            result[i] = await callback.call(thisArg || this, await array[i], i, array);
+        }
+    }
+    return result;
+};
+/**
+ * Implements ES5 [`Array#find()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) method.<br><br>
+ * Returns the value of the element that satisfies the provided `callback`. The value returned is the one found first.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if the returned value is found in one of the first elements of `array`,
+ * depending on the async calls you are going to use, consider using instead [`findSeries()`](global.html#findSeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the element that passed the test as value, otherwise *undefined*.
+ */
+export const find = (array, callback, thisArg) => {
+    return new Promise((resolve, reject) => {
+        if (array.length === 0) {
+            return resolve(undefined);
+        }
+        let counter = 1;
+        for (let i = 0; i < array.length; i++) {
+            const check = (found) => {
+                if (found) {
+                    resolve(array[i]);
+                }
+                else if (counter === array.length) {
+                    resolve(undefined);
+                }
+                counter++;
+            };
+            Promise.resolve(array[i])
+                .then((elem) => callback.call(thisArg || this, elem, i, array))
+                .then(check)
+                .catch(reject);
+        }
+    });
+};
+/**
+ * Same functionality as [`find()`](global.html#find), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the element that passed the test as value, otherwise *undefined*.
+ */
+export const findSeries = async (array, callback, thisArg) => {
+    for (let i = 0; i < array.length; i++) {
+        if (await callback.call(thisArg || this, await array[i], i, array)) {
+            return array[i];
+        }
+    }
+};
+/**
+ * Implements ES5 [`Array#findIndex()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex) method.<br><br>
+ * Returns the index of the element that satisfies the provided `callback`. The index returned is the one found first.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if the returned index is found in one of the first elements of `array`,
+ * depending on the async calls you are going to use, consider using instead [`findSeries()`](global.html#findSeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the index that passed the test as value, otherwise *-1*.
+ */
+export const findIndex = (array, callback, thisArg) => {
+    return new Promise((resolve, reject) => {
+        if (array.length === 0) {
+            return resolve(-1);
+        }
+        let counter = 1;
+        for (let i = 0; i < array.length; i++) {
+            const check = (found) => {
+                if (found) {
+                    resolve(i);
+                }
+                else if (counter === array.length) {
+                    resolve(-1);
+                }
+                counter++;
+            };
+            Promise.resolve(array[i])
+                .then((elem) => callback.call(thisArg || this, elem, i, array))
+                .then(check)
+                .catch(reject);
+        }
+    });
+};
+/**
+ * Same functionality as [`findIndex()`](global.html#findIndex), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the index that passed the test, otherwise *-1*.
+ */
+export const findIndexSeries = async (array, callback, thisArg) => {
+    for (let i = 0; i < array.length; i++) {
+        if (await callback.call(thisArg || this, await array[i], i, array)) {
+            return i;
+        }
+    }
+};
+/**
+ * Implements ES5 [`Array#some()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some) method.<br><br>
+ * Test if some element in `array` passes the test implemented in `callback`.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if some of the first elements pass the test,
+ * depending on the async calls you are going to use, consider using instead [`someSeries()`](global.html#someSeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if some element passed the test, otherwise *false*.
+ */
+export const some = (array, callback, thisArg) => {
+    return new Promise((resolve, reject) => {
+        if (array.length === 0) {
+            return resolve(false);
+        }
+        let counter = 1;
+        for (let i = 0; i < array.length; i++) {
+            if (!(i in array)) {
+                counter++;
+                continue;
+            }
+            const check = (found) => {
+                if (found) {
+                    resolve(true);
+                }
+                else if (counter === array.length) {
+                    resolve(false);
+                }
+                counter++;
+            };
+            Promise.resolve(array[i])
+                .then((elem) => callback.call(thisArg || this, elem, i, array))
+                .then(check)
+                .catch(reject);
+        }
+    });
+};
+/**
+ * Same functionality as [`some()`](global.html#some), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if some element passed the test, otherwise *false*.
+ */
+export const someSeries = async (array, callback, thisArg) => {
+    for (let i = 0; i < array.length; i++) {
+        if (i in array && await callback.call(thisArg || this, await array[i], i, array)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Implements ES5 [`Array#every()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) method.<br><br>
+ * Test if all elements in `array` pass the test implemented in `callback`.<br>
+ * Callbacks are run concurrently, meaning that all the callbacks are going to run even if any of the first elements do not pass the test,
+ * depending on the async calls you are going to use, consider using instead [`everySeries()`](global.html#everySeries).<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if all elements passed the test, otherwise *false*.
+ */
+export const every = (array, callback, thisArg) => {
+    return new Promise((resolve, reject) => {
+        if (array.length === 0) {
+            return resolve(true);
+        }
+        let counter = 1;
+        for (let i = 0; i < array.length; i++) {
+            if (!(i in array)) {
+                counter++;
+                continue;
+            }
+            const check = (found) => {
+                if (!found) {
+                    resolve(false);
+                }
+                else if (counter === array.length) {
+                    resolve(true);
+                }
+                counter++;
+            };
+            Promise.resolve(array[i])
+                .then((elem) => callback.call(thisArg || this, elem, i, array))
+                .then(check)
+                .catch(reject);
+        }
+    });
+};
+/**
+ * Same functionality as [`every()`](global.html#every), but runs only one callback at a time.<br><br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with *true* as value if all elements passed the test, otherwise *false*.
+ */
+export const everySeries = async (array, callback, thisArg) => {
+    for (let i = 0; i < array.length; i++) {
+        if (i in array && !await callback.call(thisArg || this, await array[i], i, array)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Implements ES5 [`Array#filter()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) method.<br><br>
+ * Creates a new array with the elements that passed the test implemented in `callback`.<br>
+ * Callbacks are run concurrently.<br>
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
+ * @return {Promise} - Returns a Promise with the resultant filtered *Array* as value.
+ */
+export const filter = (array, callback, thisArg) => {
+    /* two loops are necessary in order to do the filtering concurrently
+     * while keeping the order of the elements
+     * (if you find a better way to do it please send a PR!)
+     */
+    return new Promise((resolve, reject) => {
+        const promiseArray = [];
+        for (let i = 0; i < array.length; i++) {
+            if (i in array) {
+                promiseArray[i] = Promise.resolve(array[i]).then((currentValue) => {
+                    return callback.call(thisArg || this, currentValue, i, array);
+                }).catch(reject);
+            }
+        }
+        return Promise.all(promiseArray.map(async (p, i) => {
+            if (await p) {
+                return await array[i];
+            }
+            return undefined;
+        })).then((result) => result.filter((val) => typeof val !== 'undefined')).then(resolve, reject);
+    });
+};
+/**
+ * Same functionality as [`filter()`](global.html#filter), but runs only one callback at a time.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
+ * @return {Promise} - Returns a Promise with the resultant filtered *Array* as value.
+ */
+export const filterSeries = async (array, callback, thisArg) => {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        if (i in array && await callback.call(thisArg || this, await array[i], i, array)) {
+            result.push(await array[i]);
+        }
+    }
+    return result;
+};
+/**
+ * Implements ES5 [`Array#reduce()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) method.<br><br>
+ * Applies a `callback` against an accumulator and each element in `array`.
+ * @param {Array} array - Array to iterate over.
+ * @param {Function} callback - Function to apply each item in `array`. Accepts four arguments: `accumulator`, `currentValue`, `currentIndex` and `array`.
+ * @param {Object} [initialValue] - Used as first argument to the first call of `callback`.
+ * @return {Promise} - Returns a Promise with the resultant value from the reduction.
+ */
+export const reduce = async (array, callback, initialValue) => {
+    if (array.length === 0 && initialValue === undefined) {
+        throw TypeError('Reduce of empty array with no initial value');
+    }
+    let i;
+    let previousValue;
+    if (initialValue !== undefined) {
+        previousValue = initialValue;
+        i = 0;
+    }
+    else {
+        previousValue = array[0];
+        i = 1;
+    }
+    for (i; i < array.length; i++) {
+        if (i in array) {
+            previousValue = await callback(await previousValue, await array[i], i, array);
+        }
+    }
+    return previousValue;
+};

package/build/shim.js

@@ -1,4 +1,4 @@
-import iterators from 'p-iteration';
+import * as iterators from './pIteration.js';
 import logger from '@wdio/logger';
 const log = logger('@wdio/utils:shim');
 let inCommandHook = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/utils",
-  "version": "8.12.1",
+  "version": "8.14.0",
   "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",
@@ -31,12 +31,11 @@
   },
   "dependencies": {
     "@wdio/logger": "8.11.0",
-    "@wdio/types": "8.10.4",
-    "import-meta-resolve": "^3.0.0",
-    "p-iteration": "^1.1.8"
+    "@wdio/types": "8.14.0",
+    "import-meta-resolve": "^3.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "be1e7959a7599e2afe33e60856be9a7ca16eb3aa"
+  "gitHead": "cb2092b007e6d2ac23a49aa30dae67d70e45906d"
 }