expect-webdriverio 4.0.0 → 4.0.1

package/README.md

@@ -22,21 +22,41 @@ NOTE: [WebdriverIO](https://github.com/webdriverio/webdriverio) `v5.16.11` or hi
 
 ## Usage
 
-In your `wdio.conf.js`
-```js
-before () { // not needed in WebdriverIO v6
-    require('expect-webdriverio')
-},
-```
+### Using WebdriverIO Testrunner
+
+If you run your tests through the [WDIO testrunner](https://webdriver.io/docs/clioptions) no additional setup is needed. WebdriverIO initialises `expect-webdriverio` and makes `expect` available in the global scope. So you can use it directly in your tests:
 
-In your test
 ```js
-const $button = $('button')
-expect($button).toBeDisplayed()
+const $button = await $('button')
+await expect($button).toBeDisplayed()
 ```
 
 See more [Examples](docs/Examples.md)
 
+### Using in a standalone script
+
+If you embed WebdriverIO in a standalone script, make sure you import `expect-webdriverio` before you use it anywhere.
+
+```js
+import { remote } from 'webdriverio'
+import { expect } from 'expect-webdriverio'
+
+;(async () => {
+    const browser = await remote({
+        capabilities: {
+            browserName: 'chrome'
+        }
+    })
+
+    await browser.url('https://webdriver.io')
+
+    const $button = await browser.$('button')
+    await expect($button).toBeDisplayed()
+    
+    await browser.deleteSession()
+})().catch(console.error)
+```
+
 ## API
 
 Please see [API doc](docs/API.md)

package/jasmine.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="expect-webdriverio/types/expect-webdriverio"/>
 
 declare module jasmine {
-    interface Matchers<T> extends ExpectWebdriverIO.Matchers<any, T> {}
     interface AsyncMatchers<T, U> extends ExpectWebdriverIO.Matchers<Promise<void>, T> {}
 }

package/jest.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="expect-webdriverio/types/expect-webdriverio"/>
+/// <reference types="./types/expect-webdriverio"/>
 
 declare namespace jest {
     interface Matchers<R, T> extends ExpectWebdriverIO.Matchers<R, T> { }

package/lib/constants.js

@@ -0,0 +1,4 @@
+export const DEFAULT_OPTIONS = {
+    wait: 2000,
+    interval: 100,
+};

package/lib/index.js

@@ -1,6 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setOptions = void 0;
-const addMatchers_1 = require("./addMatchers");
-addMatchers_1.addMatchers();
-exports.setOptions = require('./options').setDefaultOptions;
+import { expect as expectLib } from 'expect';
+import matchers from './matchers.js';
+import { DEFAULT_OPTIONS } from './constants.js';
+expectLib.extend({ ...matchers });
+export const expect = expectLib;
+export const getConfig = () => DEFAULT_OPTIONS;
+export const setDefaultOptions = (options = {}) => {
+    Object.entries(options).forEach(([key, value]) => {
+        if (key in DEFAULT_OPTIONS) {
+            DEFAULT_OPTIONS[key] = value;
+        }
+    });
+};
+export const setOptions = setDefaultOptions;

package/lib/jasmineUtils.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImmutableUnorderedSet = exports.isImmutableUnorderedKeyed = exports.hasProperty = exports.isUndefined = exports.fnNameFor = exports.isA = exports.equals = void 0;
-function equals(a, b, customTesters, strictCheck) {
+export function equals(a, b, customTesters, strictCheck) {
     customTesters = customTesters || [];
     return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
 }
-exports.equals = equals;
 const functionToString = Function.prototype.toString;
 function isAsymmetric(obj) {
     return !!obj && isA('Function', obj.asymmetricMatch);
@@ -144,10 +140,9 @@ function hasDefinedKey(obj, key) {
 function hasKey(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key);
 }
-function isA(typeName, value) {
+export function isA(typeName, value) {
     return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
 }
-exports.isA = isA;
 function isDomNode(obj) {
     return (obj !== null &&
         typeof obj === 'object' &&
@@ -155,7 +150,7 @@ function isDomNode(obj) {
         typeof obj.nodeName === 'string' &&
         typeof obj.isEqualNode === 'function');
 }
-function fnNameFor(func) {
+export function fnNameFor(func) {
     if (func.name) {
         return func.name;
     }
@@ -164,11 +159,9 @@ function fnNameFor(func) {
         .match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
     return matches ? matches[1] : '<anonymous>';
 }
-exports.fnNameFor = fnNameFor;
-function isUndefined(obj) {
+export function isUndefined(obj) {
     return obj === void 0;
 }
-exports.isUndefined = isUndefined;
 function getPrototype(obj) {
     if (Object.getPrototypeOf) {
         return Object.getPrototypeOf(obj);
@@ -178,7 +171,7 @@ function getPrototype(obj) {
     }
     return obj.constructor.prototype;
 }
-function hasProperty(obj, property) {
+export function hasProperty(obj, property) {
     if (!obj) {
         return false;
     }
@@ -187,19 +180,16 @@ function hasProperty(obj, property) {
     }
     return hasProperty(getPrototype(obj), property);
 }
-exports.hasProperty = hasProperty;
 const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
 const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
 const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
-function isImmutableUnorderedKeyed(maybeKeyed) {
+export function isImmutableUnorderedKeyed(maybeKeyed) {
     return !!(maybeKeyed &&
         maybeKeyed[IS_KEYED_SENTINEL] &&
         !maybeKeyed[IS_ORDERED_SENTINEL]);
 }
-exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed;
-function isImmutableUnorderedSet(maybeSet) {
+export function isImmutableUnorderedSet(maybeSet) {
     return !!(maybeSet &&
         maybeSet[IS_SET_SENTINEL] &&
         !maybeSet[IS_ORDERED_SENTINEL]);
 }
-exports.isImmutableUnorderedSet = isImmutableUnorderedSet;

package/lib/matchers/browser/toHaveTitle.js

@@ -1,26 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveTitle = exports.toHaveTitleFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const utils_1 = require("../../utils");
-function toHaveTitleFn(browser, title, options = {}) {
+import { waitUntil, enhanceError, compareText } from '../../utils.js';
+export async function toHaveTitle(browser, title, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'title', verb = 'have' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await utils_1.waitUntil(async () => {
-            actual = await browser.getTitle();
-            return utils_1.compareText(actual, title, options).result;
-        }, isNot, options);
-        const message = utils_1.enhanceError('window', title, actual, this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let actual;
+    const pass = await waitUntil(async () => {
+        actual = await browser.getTitle();
+        return compareText(actual, title, options).result;
+    }, isNot, options);
+    const message = enhanceError('window', title, actual, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message
+    };
 }
-exports.toHaveTitleFn = toHaveTitleFn;
-function toHaveTitle(...args) {
-    return expectAdapter_1.runExpect.call(this, toHaveTitleFn, args);
-}
-exports.toHaveTitle = toHaveTitle;

package/lib/matchers/browser/toHaveTitleContaining.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveTitleContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveTitle_1 = require("./toHaveTitle");
-function toHaveTitleContainingFn(browser, title, options = {}) {
-    return toHaveTitle_1.toHaveTitleFn.call(this, browser, title, {
+import { toHaveTitle } from './toHaveTitle.js';
+export function toHaveTitleContaining(browser, title, options = {}) {
+    return toHaveTitle.call(this, browser, title, {
         ...options,
         containing: true
     });
 }
-function toHaveTitleContaining(...args) {
-    return expectAdapter_1.runExpect.call(this, toHaveTitleContainingFn, args);
-}
-exports.toHaveTitleContaining = toHaveTitleContaining;

package/lib/matchers/browser/toHaveUrl.js

@@ -1,26 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveUrl = exports.toHaveUrlFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const utils_1 = require("../../utils");
-function toHaveUrlFn(browser, url, options = {}) {
+import { waitUntil, enhanceError, compareText } from '../../utils.js';
+export async function toHaveUrl(browser, url, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'url', verb = 'have' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await utils_1.waitUntil(async () => {
-            actual = await browser.getUrl();
-            return utils_1.compareText(actual, url, options).result;
-        }, isNot, options);
-        const message = utils_1.enhanceError('window', url, actual, this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let actual;
+    const pass = await waitUntil(async () => {
+        actual = await browser.getUrl();
+        return compareText(actual, url, options).result;
+    }, isNot, options);
+    const message = enhanceError('window', url, actual, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message
+    };
 }
-exports.toHaveUrlFn = toHaveUrlFn;
-function toHaveUrl(...args) {
-    return expectAdapter_1.runExpect.call(this, toHaveUrlFn, args);
-}
-exports.toHaveUrl = toHaveUrl;

package/lib/matchers/browser/toHaveUrlContaining.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveUrlContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveUrl_1 = require("./toHaveUrl");
-function toHaveUrlContainingFn(browser, url, options = {}) {
-    return toHaveUrl_1.toHaveUrlFn.call(this, browser, url, {
+import { toHaveUrl } from './toHaveUrl.js';
+export function toHaveUrlContaining(browser, url, options = {}) {
+    return toHaveUrl.call(this, browser, url, {
         ...options,
         containing: true
     });
 }
-function toHaveUrlContaining(...args) {
-    return expectAdapter_1.runExpect.call(this, toHaveUrlContainingFn, args);
-}
-exports.toHaveUrlContaining = toHaveUrlContaining;

package/lib/matchers/element/toBeClickable.js

@@ -1,23 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeClickable = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeClickableFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export function toBeClickable(received, options = {}) {
     this.expectation = this.expectation || 'clickable';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isClickable();
-            }
-            catch (_a) {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isClickable();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }
-function toBeClickable(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeClickableFn, args);
-}
-exports.toBeClickable = toBeClickable;

package/lib/matchers/element/toBeDisabled.js

@@ -1,16 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDisabled = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeDisabledFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export function toBeDisabled(received, options = {}) {
     this.expectation = this.expectation || 'disabled';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
 }
-function toBeDisabled(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeDisabledFn, args);
-}
-exports.toBeDisabled = toBeDisabled;

package/lib/matchers/element/toBeDisplayed.js

@@ -1,23 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDisplayed = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeDisplayedFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export async function toBeDisplayed(received, options = {}) {
     this.expectation = this.expectation || 'displayed';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isDisplayed();
-            }
-            catch (_a) {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isDisplayed();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }
-function toBeDisplayed(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeDisplayedFn, args);
-}
-exports.toBeDisplayed = toBeDisplayed;

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -1,23 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDisplayedInViewport = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeDisplayedInViewportFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export function toBeDisplayedInViewport(received, options = {}) {
     this.expectation = this.expectation || 'displayed in viewport';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isDisplayedInViewport();
-            }
-            catch (_a) {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isDisplayedInViewport();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }
-function toBeDisplayedInViewport(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeDisplayedInViewportFn, args);
-}
-exports.toBeDisplayedInViewport = toBeDisplayedInViewport;

package/lib/matchers/element/toBeEnabled.js

@@ -1,16 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeEnabled = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeEnabledFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export function toBeEnabled(received, options = {}) {
     this.expectation = this.expectation || 'enabled';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, el => el.isEnabled(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, el => el.isEnabled(), options);
 }
-function toBeEnabled(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeEnabledFn, args);
-}
-exports.toBeEnabled = toBeEnabled;

package/lib/matchers/element/toBeExisting.js

@@ -1,32 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBePresent = exports.toBeExisting = exports.toExist = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toExistFn(received, options = {}) {
+import { executeCommandBe, aliasFn } from '../../utils.js';
+export function toExist(received, options = {}) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isExisting();
-            }
-            catch (_a) {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isExisting();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }
-function toExist(...args) {
-    return expectAdapter_1.runExpect.call(this, toExistFn, args);
+export function toBeExisting(el, options) {
+    return aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);
 }
-exports.toExist = toExist;
-function toBeExisting(el, options) {
-    return utils_1.aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);
+export function toBePresent(el, options) {
+    return aliasFn.call(this, toExist, { verb: 'be', expectation: 'present' }, el, options);
 }
-exports.toBeExisting = toBeExisting;
-function toBePresent(el, options) {
-    return utils_1.aliasFn.call(this, toExist, { verb: 'be', expectation: 'present' }, el, options);
-}
-exports.toBePresent = toBePresent;

package/lib/matchers/element/toBeFocused.js

@@ -1,16 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeFocused = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeFocusedFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export function toBeFocused(received, options = {}) {
     this.expectation = this.expectation || 'focused';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, el => el.isFocused(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, el => el.isFocused(), options);
 }
-function toBeFocused(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeFocusedFn, args);
-}
-exports.toBeFocused = toBeFocused;

package/lib/matchers/element/toBeSelected.js

@@ -1,22 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeChecked = exports.toBeSelected = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeSelectedFn(received, options = {}) {
+import { executeCommandBe } from '../../utils.js';
+export function toBeSelected(received, options = {}) {
     this.expectation = this.expectation || 'selected';
-    return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, el => el.isSelected(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, el => el.isSelected(), options);
 }
-function toBeSelected(...args) {
-    return expectAdapter_1.runExpect.call(this, toBeSelectedFn, args);
+export function toBeChecked(el, options) {
+    this.expectation = 'checked';
+    return toBeSelected.call(this, el, options);
 }
-exports.toBeSelected = toBeSelected;
-function toBeChecked(el, options) {
-    const context = expectAdapter_1.getContext(this);
-    context.expectation = 'checked';
-    return toBeSelected.call(context, el, options);
-}
-exports.toBeChecked = toBeChecked;

package/lib/matchers/element/toHaveAttribute.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveAttr = exports.toHaveAttribute = exports.toHaveAttributeFn = exports.toHaveAttributeAndValueFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function conditionAttr(el, attribute) {
     const attr = await el.getAttribute(attribute);
     if (typeof attr !== 'string') {
@@ -17,56 +13,49 @@ async function conditionAttrAndValue(el, attribute, value, options) {
     if (typeof attr !== 'string') {
         return { result: false, value: attr };
     }
-    return utils_1.compareText(attr, value, options);
+    return compareText(attr, value, options);
 }
-function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
+export async function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
-    return browser.call(async () => {
-        let el = await received;
-        let attr;
-        const pass = await utils_1.waitUntil(async () => {
-            const result = await utils_1.executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
-            el = result.el;
-            attr = result.values;
-            return result.success;
-        }, isNot, options);
-        utils_1.updateElementsArray(pass, received, el);
-        const expected = utils_1.wrapExpectedWithArray(el, attr, value);
-        const message = utils_1.enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let el = await received;
+    let attr;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
+        el = result.el;
+        attr = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const expected = wrapExpectedWithArray(el, attr, value);
+    const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
+    return {
+        pass,
+        message: () => message
+    };
 }
-exports.toHaveAttributeAndValueFn = toHaveAttributeAndValueFn;
-function toHaveAttributeFn(received, attribute) {
+export async function toHaveAttributeFn(received, attribute) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
-    return browser.call(async () => {
-        let el = await received;
-        const pass = await utils_1.waitUntil(async () => {
-            const result = await utils_1.executeCommand.call(this, el, conditionAttr, {}, [attribute]);
-            el = result.el;
-            return result.success;
-        }, isNot, {});
-        utils_1.updateElementsArray(pass, received, el);
-        const message = utils_1.enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let el = await received;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, conditionAttr, {}, [attribute]);
+        el = result.el;
+        return result.success;
+    }, isNot, {});
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
+    return {
+        pass,
+        message: () => message
+    };
 }
-exports.toHaveAttributeFn = toHaveAttributeFn;
-function toHaveAttribute(...args) {
+export function toHaveAttribute(...args) {
     if (args.length === 3 || args.length === 4) {
-        return expectAdapter_1.runExpect.call(this, toHaveAttributeAndValueFn, args);
+        return toHaveAttributeAndValueFn.call(this, ...args);
     }
     else {
-        return expectAdapter_1.runExpect.call(this, toHaveAttributeFn, args);
+        return toHaveAttributeFn.call(this, ...args);
     }
 }
-exports.toHaveAttribute = toHaveAttribute;
-exports.toHaveAttr = toHaveAttribute;
+export const toHaveAttr = toHaveAttribute;