expect-webdriverio 4.0.0 → 4.0.1

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,39 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeRequestedWith = exports.toBeRequestedWithFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-const jasmineUtils_1 = require("../../jasmineUtils");
+import { waitUntil, enhanceError } from '../../utils.js';
+import { equals } from '../../jasmineUtils.js';
 const STR_LIMIT = 80;
 const KEY_LIMIT = 12;
-function toBeRequestedWithFn(received, requestedWith = {}, options = {}) {
+export async function toBeRequestedWith(received, requestedWith = {}, options = {}) {
     const isNot = this.isNot || false;
     const { expectation = 'called with', verb = 'be' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await utils_1.waitUntil(async () => {
-            for (const call of received.calls) {
-                actual = call;
-                if (methodMatcher(call.method, requestedWith.method) &&
-                    statusCodeMatcher(call.statusCode, requestedWith.statusCode) &&
-                    urlMatcher(call.url, requestedWith.url) &&
-                    headersMatcher(call.headers, requestedWith.requestHeaders) &&
-                    headersMatcher(call.responseHeaders, requestedWith.responseHeaders) &&
-                    bodyMatcher(call.postData, requestedWith.postData) &&
-                    bodyMatcher(call.body, requestedWith.response)) {
-                    return true;
-                }
+    let actual;
+    const pass = await waitUntil(async () => {
+        for (const call of received.calls) {
+            actual = call;
+            if (methodMatcher(call.method, requestedWith.method) &&
+                statusCodeMatcher(call.statusCode, requestedWith.statusCode) &&
+                urlMatcher(call.url, requestedWith.url) &&
+                headersMatcher(call.headers, requestedWith.requestHeaders) &&
+                headersMatcher(call.responseHeaders, requestedWith.responseHeaders) &&
+                bodyMatcher(call.postData, requestedWith.postData) &&
+                bodyMatcher(call.body, requestedWith.response)) {
+                return true;
             }
-            return false;
-        }, isNot, { ...options, wait: isNot ? 0 : options.wait });
-        const message = utils_1.enhanceError('mock', minifyRequestedWith(requestedWith), minifyRequestMock(actual, requestedWith) || 'was not called', this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message,
-        };
-    });
+        }
+        return false;
+    }, isNot, { ...options, wait: isNot ? 0 : options.wait });
+    const message = enhanceError('mock', minifyRequestedWith(requestedWith), minifyRequestMock(actual, requestedWith) || 'was not called', this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
 }
-exports.toBeRequestedWithFn = toBeRequestedWithFn;
 const methodMatcher = (method, expected) => {
     if (typeof expected === 'undefined') {
         return true;
@@ -66,7 +59,7 @@ const urlMatcher = (url, expected) => {
     if (typeof expected === 'function') {
         return expected(url);
     }
-    return jasmineUtils_1.equals(url, expected);
+    return equals(url, expected);
 };
 const headersMatcher = (headers, expected) => {
     if (typeof expected === 'undefined') {
@@ -75,7 +68,7 @@ const headersMatcher = (headers, expected) => {
     if (typeof expected === 'function') {
         return expected(headers);
     }
-    return jasmineUtils_1.equals(headers, expected);
+    return equals(headers, expected);
 };
 const bodyMatcher = (body, expected) => {
     if (typeof expected === 'undefined') {
@@ -97,7 +90,7 @@ const bodyMatcher = (body, expected) => {
             return false;
         }
     }
-    return jasmineUtils_1.equals(parsedBody, expected);
+    return equals(parsedBody, expected);
 };
 const isExpectedJsonLike = (expected) => {
     if (typeof expected === 'undefined') {
@@ -112,14 +105,13 @@ const isExpectedJsonLike = (expected) => {
             actualSample instanceof RegExp === false));
 };
 const isMatcher = (filter) => {
-    var _a;
-    return typeof ((_a = filter.__proto__) === null || _a === void 0 ? void 0 : _a.asymmetricMatch) === 'function';
+    return typeof filter.__proto__?.asymmetricMatch === 'function';
 };
 const tryParseBody = (jsonString, fallback = null) => {
     try {
         return typeof jsonString === 'undefined' ? fallback : JSON.parse(jsonString);
     }
-    catch (_a) {
+    catch {
         return fallback;
     }
 };
@@ -212,7 +204,6 @@ const deleteUndefinedValues = (obj, baseline = obj) => {
         }
     });
 };
-function toBeRequestedWith(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeRequestedWithFn, args);
+export function toBeRequestedWithResponse(...args) {
+    return toBeRequestedWith.call(this, ...args);
 }
-exports.toBeRequestedWith = toBeRequestedWith;

package/lib/matchers.js

@@ -1,41 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+import * as toHaveTitle from './matchers/browser/toHaveTitle.js';
+import * as toHaveTitleContaining from './matchers/browser/toHaveTitleContaining.js';
+import * as toHaveUrl from './matchers/browser/toHaveUrl.js';
+import * as toHaveUrlContaining from './matchers/browser/toHaveUrlContaining.js';
+import * as toBeElementsArrayOfSize from './matchers/elements/toBeElementsArrayOfSize.js';
+import * as toBeClickable from './matchers/element/toBeClickable.js';
+import * as toBeDisabled from './matchers/element/toBeDisabled.js';
+import * as toBeDisplayed from './matchers/element/toBeDisplayed.js';
+import * as toBeDisplayedInViewport from './matchers/element/toBeDisplayedInViewport.js';
+import * as toBeEnabled from './matchers/element/toBeEnabled.js';
+import * as toBeExisting from './matchers/element/toBeExisting.js';
+import * as toBeFocused from './matchers/element/toBeFocused.js';
+import * as toBeSelected from './matchers/element/toBeSelected.js';
+import * as toHaveAttribute from './matchers/element/toHaveAttribute.js';
+import * as toHaveAttributeContaining from './matchers/element/toHaveAttributeContaining.js';
+import * as toHaveChildren from './matchers/element/toHaveChildren.js';
+import * as toHaveClass from './matchers/element/toHaveClass.js';
+import * as toHaveClassContaining from './matchers/element/toHaveClassContaining.js';
+import * as toHaveHref from './matchers/element/toHaveHref.js';
+import * as toHaveHrefContaining from './matchers/element/toHaveHrefContaining.js';
+import * as toHaveId from './matchers/element/toHaveId.js';
+import * as toHaveElementProperty from './matchers/element/toHaveElementProperty.js';
+import * as toHaveText from './matchers/element/toHaveText.js';
+import * as toHaveTextContaining from './matchers/element/toHaveTextContaining.js';
+import * as toHaveValue from './matchers/element/toHaveValue.js';
+import * as toHaveValueContaining from './matchers/element/toHaveValueContaining.js';
+import * as toHaveStyle from './matchers/element/toHaveStyle.js';
+import * as toBeRequested from './matchers/mock/toBeRequested.js';
+import * as toBeRequestedTimes from './matchers/mock/toBeRequestedTimes.js';
+import * as toBeRequestedWith from './matchers/mock/toBeRequestedWith.js';
 const matchers = {
-    ...require('./matchers/browser/toHaveTitle'),
-    ...require('./matchers/browser/toHaveTitleContaining'),
-    ...require('./matchers/browser/toHaveUrl'),
-    ...require('./matchers/browser/toHaveUrlContaining'),
-    ...require('./matchers/elements/toBeElementsArrayOfSize'),
-    ...require('./matchers/element/toBeClickable'),
-    ...require('./matchers/element/toBeDisabled'),
-    ...require('./matchers/element/toBeDisplayed'),
-    ...require('./matchers/element/toBeDisplayedInViewport'),
-    ...require('./matchers/element/toBeEnabled'),
-    ...require('./matchers/element/toBeExisting'),
-    ...require('./matchers/element/toBeFocused'),
-    ...require('./matchers/element/toBeSelected'),
-    ...require('./matchers/element/toHaveAttribute'),
-    ...require('./matchers/element/toHaveAttributeContaining'),
-    ...require('./matchers/element/toHaveChildren'),
-    ...require('./matchers/element/toHaveElementClass'),
-    ...require('./matchers/element/toHaveElementClassContaining'),
-    ...require('./matchers/element/toHaveHref'),
-    ...require('./matchers/element/toHaveHrefContaining'),
-    ...require('./matchers/element/toHaveId'),
-    ...require('./matchers/element/toHaveElementProperty'),
-    ...require('./matchers/element/toHaveText'),
-    ...require('./matchers/element/toHaveTextContaining'),
-    ...require('./matchers/element/toHaveValue'),
-    ...require('./matchers/element/toHaveValueContaining'),
-    ...require('./matchers/element/toHaveStyle'),
-    ...require('./matchers/mock/toBeRequested'),
-    ...require('./matchers/mock/toBeRequestedTimes'),
-    ...require('./matchers/mock/toBeRequestedWith'),
-    ...require('./matchers/mock/toBeRequestedWithResponse'),
+    ...toHaveTitle,
+    ...toHaveTitleContaining,
+    ...toHaveUrl,
+    ...toHaveUrlContaining,
+    ...toBeElementsArrayOfSize,
+    ...toBeClickable,
+    ...toBeDisabled,
+    ...toBeDisplayed,
+    ...toBeDisplayedInViewport,
+    ...toBeEnabled,
+    ...toBeExisting,
+    ...toBeFocused,
+    ...toBeSelected,
+    ...toHaveAttribute,
+    ...toHaveAttributeContaining,
+    ...toHaveChildren,
+    ...toHaveClass,
+    ...toHaveClassContaining,
+    ...toHaveHref,
+    ...toHaveHrefContaining,
+    ...toHaveId,
+    ...toHaveElementProperty,
+    ...toHaveText,
+    ...toHaveTextContaining,
+    ...toHaveValue,
+    ...toHaveValueContaining,
+    ...toHaveStyle,
+    ...toBeRequested,
+    ...toBeRequestedTimes,
+    ...toBeRequestedWith,
 };
-Object.keys(matchers).forEach(key => {
+Object.keys(matchers).forEach((key) => {
     if (key.endsWith('Fn')) {
         delete matchers[key];
     }
 });
-exports.default = matchers;
+export default matchers;

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/util/elementsUtil.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateElementsArray = exports.wrapExpectedWithArray = void 0;
-const wrapExpectedWithArray = (el, actual, expected) => {
+export const wrapExpectedWithArray = (el, actual, expected) => {
     if (Array.isArray(el) && el.length > 1 && Array.isArray(actual)) {
         expected = [expected];
     }
     return expected;
 };
-exports.wrapExpectedWithArray = wrapExpectedWithArray;
-const updateElementsArray = (success, received, refetched, full = false) => {
+export const updateElementsArray = (success, received, refetched, full = false) => {
     if (!success) {
         return;
     }
@@ -25,4 +21,3 @@ const updateElementsArray = (success, received, refetched, full = false) => {
         }
     }
 };
-exports.updateElementsArray = updateElementsArray;

package/lib/util/executeCommand.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeCommand = void 0;
-const refetchElements_1 = require("./refetchElements");
-async function executeCommand(el, condition, options = {}, params = [], fullRefetch = false) {
+import { refetchElements } from './refetchElements.js';
+export async function executeCommand(el, condition, options = {}, params = [], fullRefetch = false) {
     const { isNot = false } = this;
     let elements;
     if (Array.isArray(el)) {
-        elements = await refetchElements_1.refetchElements(el, options.wait, fullRefetch);
+        elements = await refetchElements(el, options.wait, fullRefetch);
     }
     else {
         elements = [el];
@@ -28,4 +25,3 @@ async function executeCommand(el, condition, options = {}, params = [], fullRefe
         values: values.length > 1 ? values : values[0]
     };
 }
-exports.executeCommand = executeCommand;

package/lib/util/formatMessage.js

@@ -1,46 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.numberError = exports.enhanceErrorBe = exports.enhanceError = exports.not = exports.getSelectors = exports.getSelector = void 0;
-const jest_matcher_utils_1 = require("jest-matcher-utils");
-const jasmineUtils_1 = require("../jasmineUtils");
+import { printExpected, printReceived, printDiffOrStringify } from 'jest-matcher-utils';
+import { equals } from '../jasmineUtils.js';
 const EXPECTED_LABEL = 'Expected';
 const RECEIVED_LABEL = 'Received';
 const NOT_SUFFIX = ' [not]';
 const NOT_EXPECTED_LABEL = EXPECTED_LABEL + NOT_SUFFIX;
-const getSelector = (el) => {
+export const getSelector = (el) => {
     let result = typeof el.selector === 'string' ? el.selector : '<fn>';
     if (Array.isArray(el) && el.props.length > 0) {
         result += ', <props>';
     }
     return result;
 };
-exports.getSelector = getSelector;
-const getSelectors = (el) => {
+export const getSelectors = (el) => {
     const selectors = [];
     let parent;
     if (Array.isArray(el)) {
-        selectors.push(`${el.foundWith}(\`${exports.getSelector(el)}\`)`);
+        selectors.push(`${el.foundWith}(\`${getSelector(el)}\`)`);
         parent = el.parent;
     }
     else {
         parent = el;
     }
     while (parent && 'selector' in parent) {
-        const selector = exports.getSelector(parent);
+        const selector = getSelector(parent);
         const index = parent.index ? `[${parent.index}]` : '';
         selectors.push(`${parent.index ? '$' : ''}$(\`${selector}\`)${index}`);
         parent = parent.parent;
     }
     return selectors.reverse().join('.');
 };
-exports.getSelectors = getSelectors;
-const not = (isNot) => {
+export const not = (isNot) => {
     return `${isNot ? 'not ' : ''}`;
 };
-exports.not = not;
-const enhanceError = (subject, expected, actual, context, verb, expectation, arg2 = '', { message = '', containing = false }) => {
+export const enhanceError = (subject, expected, actual, context, verb, expectation, arg2 = '', { message = '', containing = false }) => {
     const { isNot = false } = context;
-    subject = typeof subject === 'string' ? subject : exports.getSelectors(subject);
+    subject = typeof subject === 'string' ? subject : getSelectors(subject);
     let contain = '';
     if (containing) {
         contain = ' containing';
@@ -49,12 +43,12 @@ const enhanceError = (subject, expected, actual, context, verb, expectation, arg
         verb += ' ';
     }
     let diffString;
-    if (isNot && jasmineUtils_1.equals(actual, expected)) {
-        diffString = `${EXPECTED_LABEL}: ${jest_matcher_utils_1.printExpected(expected)}\n` +
-            `${RECEIVED_LABEL}: ${jest_matcher_utils_1.printReceived(actual)}`;
+    if (isNot && equals(actual, expected)) {
+        diffString = `${EXPECTED_LABEL}: ${printExpected(expected)}\n` +
+            `${RECEIVED_LABEL}: ${printReceived(actual)}`;
     }
     else {
-        diffString = jest_matcher_utils_1.printDiffOrStringify(expected, actual, EXPECTED_LABEL, RECEIVED_LABEL, true);
+        diffString = printDiffOrStringify(expected, actual, EXPECTED_LABEL, RECEIVED_LABEL, true);
     }
     if (isNot) {
         diffString = diffString
@@ -67,15 +61,13 @@ const enhanceError = (subject, expected, actual, context, verb, expectation, arg
     if (arg2) {
         arg2 = ` ${arg2}`;
     }
-    const msg = `${message}Expect ${subject} ${exports.not(isNot)}to ${verb}${expectation}${arg2}${contain}\n\n${diffString}`;
+    const msg = `${message}Expect ${subject} ${not(isNot)}to ${verb}${expectation}${arg2}${contain}\n\n${diffString}`;
     return msg;
 };
-exports.enhanceError = enhanceError;
-const enhanceErrorBe = (subject, pass, context, verb, expectation, options) => {
-    return exports.enhanceError(subject, exports.not(context.isNot) + expectation, exports.not(!pass) + expectation, context, verb, expectation, '', options);
+export const enhanceErrorBe = (subject, pass, context, verb, expectation, options) => {
+    return enhanceError(subject, not(context.isNot) + expectation, not(!pass) + expectation, context, verb, expectation, '', options);
 };
-exports.enhanceErrorBe = enhanceErrorBe;
-const numberError = (options = {}) => {
+export const numberError = (options = {}) => {
     if (options.eq) {
         return options.eq;
     }
@@ -90,4 +82,3 @@ const numberError = (options = {}) => {
     }
     return "no params";
 };
-exports.numberError = numberError;

package/lib/util/refetchElements.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.refetchElements = void 0;
-const options_1 = require("../options");
-const config = options_1.getConfig();
-const { options: DEFAULT_OPTIONS } = config;
-const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
+import { DEFAULT_OPTIONS } from '../constants.js';
+export const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
     if (elements) {
         if (wait > 0 && (elements.length === 0 || full)) {
             elements = await elements.parent[elements.foundWith](elements.selector, ...elements.props);
@@ -12,4 +7,3 @@ const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = fal
     }
     return elements;
 };
-exports.refetchElements = refetchElements;

package/lib/utils.js

@@ -1,37 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.aliasFn = exports.compareNumbers = exports.waitUntil = exports.executeCommandBe = exports.executeCommand = exports.numberError = exports.enhanceError = exports.wrapExpectedWithArray = exports.updateElementsArray = exports.compareStyle = exports.compareTextWithArray = exports.compareText = void 0;
-const options_1 = require("./options");
-const executeCommand_1 = require("./util/executeCommand");
-Object.defineProperty(exports, "executeCommand", { enumerable: true, get: function () { return executeCommand_1.executeCommand; } });
-const elementsUtil_1 = require("./util/elementsUtil");
-Object.defineProperty(exports, "wrapExpectedWithArray", { enumerable: true, get: function () { return elementsUtil_1.wrapExpectedWithArray; } });
-Object.defineProperty(exports, "updateElementsArray", { enumerable: true, get: function () { return elementsUtil_1.updateElementsArray; } });
-const formatMessage_1 = require("./util/formatMessage");
-Object.defineProperty(exports, "enhanceError", { enumerable: true, get: function () { return formatMessage_1.enhanceError; } });
-Object.defineProperty(exports, "numberError", { enumerable: true, get: function () { return formatMessage_1.numberError; } });
-const expectAdapter_1 = require("./util/expectAdapter");
-const config = options_1.getConfig();
-const { options: DEFAULT_OPTIONS } = config;
+import { executeCommand } from './util/executeCommand.js';
+import { wrapExpectedWithArray, updateElementsArray } from './util/elementsUtil.js';
+import { enhanceError, enhanceErrorBe, numberError } from './util/formatMessage.js';
+import { DEFAULT_OPTIONS } from './constants.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
     if (wait === 0) {
         return await condition();
     }
     try {
         let error;
-        await browser.waitUntil(async () => {
+        const start = Date.now();
+        while (true) {
+            if ((Date.now() - start) > wait) {
+                throw new Error('timeout');
+            }
             error = undefined;
             try {
-                return isNot !== await condition();
+                const result = isNot !== await condition();
+                if (result) {
+                    break;
+                }
+                await sleep(interval);
             }
             catch (err) {
                 error = err;
-                return false;
+                await sleep(interval);
             }
-        }, {
-            timeout: wait,
-            interval
-        });
+        }
         if (error) {
             throw error;
         }
@@ -41,24 +36,22 @@ const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait
         return isNot;
     }
 };
-exports.waitUntil = waitUntil;
 async function executeCommandBe(received, command, options) {
     const { isNot, expectation, verb = 'be' } = this;
     received = await received;
     let el = received;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand_1.executeCommand.call(this, el, async (element) => ({ result: await command(element) }), options);
+        const result = await executeCommand.call(this, el, async (element) => ({ result: await command(element) }), options);
         el = result.el;
         return result.success;
     }, isNot, options);
-    elementsUtil_1.updateElementsArray(pass, received, el);
-    const message = formatMessage_1.enhanceErrorBe(el, pass, this, verb, expectation, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceErrorBe(el, pass, this, verb, expectation, options);
     return {
         pass,
         message: () => message
     };
 }
-exports.executeCommandBe = executeCommandBe;
 const compareNumbers = (actual, options = {}) => {
     if (typeof options.eq === 'number') {
         return actual === options.eq;
@@ -74,8 +67,7 @@ const compareNumbers = (actual, options = {}) => {
     }
     return false;
 };
-exports.compareNumbers = compareNumbers;
-const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false }) => {
+export const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false }) => {
     if (typeof actual !== 'string') {
         return {
             value: actual,
@@ -87,7 +79,15 @@ const compareText = (actual, expected, { ignoreCase = false, trim = true, contai
     }
     if (ignoreCase) {
         actual = actual.toLowerCase();
-        expected = expected.toLowerCase();
+        if (!(expected instanceof RegExp)) {
+            expected = expected.toLowerCase();
+        }
+    }
+    if (expected instanceof RegExp) {
+        return {
+            value: actual,
+            result: !!actual.match(expected)
+        };
     }
     if (containing) {
         return {
@@ -100,8 +100,7 @@ const compareText = (actual, expected, { ignoreCase = false, trim = true, contai
         result: actual === expected
     };
 };
-exports.compareText = compareText;
-const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim = false, containing = false }) => {
+export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim = false, containing = false }) => {
     if (typeof actual !== 'string') {
         return {
             value: actual,
@@ -113,22 +112,17 @@ const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim
     }
     if (ignoreCase) {
         actual = actual.toLowerCase();
-        expectedArray = expectedArray.map(item => item.toLowerCase());
-    }
-    if (containing) {
-        const textInArray = expectedArray.some((t) => actual.includes(t));
-        return {
-            value: actual,
-            result: textInArray
-        };
+        expectedArray = expectedArray.map(item => (item instanceof RegExp) ? item : item.toLowerCase());
     }
+    const textInArray = expectedArray.some((expected) => {
+        return expected instanceof RegExp ? !!actual.match(expected) : containing ? actual.includes(expected) : actual === expected;
+    });
     return {
         value: actual,
-        result: expectedArray.includes(actual)
+        result: textInArray
     };
 };
-exports.compareTextWithArray = compareTextWithArray;
-const compareStyle = async (actualEl, style, { ignoreCase = true, trim = false }) => {
+export const compareStyle = async (actualEl, style, { ignoreCase = true, trim = false }) => {
     let result = true;
     const actual = {};
     for (const key in style) {
@@ -151,11 +145,9 @@ const compareStyle = async (actualEl, style, { ignoreCase = true, trim = false }
         result
     };
 };
-exports.compareStyle = compareStyle;
 function aliasFn(fn, { verb, expectation } = {}, ...args) {
-    const context = expectAdapter_1.getContext(this);
-    context.verb = verb;
-    context.expectation = expectation;
-    return fn.apply(context, args);
+    this.verb = verb;
+    this.expectation = expectation;
+    return fn.apply(this, args);
 }
-exports.aliasFn = aliasFn;
+export { updateElementsArray, wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn };