expect-webdriverio 3.3.1 → 4.0.0-alpha.0

package/lib/matchers/element/{toHaveElementClass.js → toHaveClass.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveClass = exports.toHaveElementClass = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils';
 async function condition(el, attribute, value, options) {
     const { ignoreCase = false, trim = false, containing = false } = options;
     let attr = await el.getAttribute(attribute);
@@ -27,33 +24,27 @@ async function condition(el, attribute, value, options) {
         result: valueInClasses
     };
 }
-function toHaveElementClassFn(received, className, options = {}) {
+export function toHaveElementClass(...args) {
+    return toHaveClass.call(this || {}, ...args);
+}
+export function toHaveClass(received, className, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'class', verb = 'have' } = this;
     const attribute = 'class';
     return browser.call(async () => {
         let el = await received;
         let attr;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, condition, options, [attribute, className, options]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, condition, options, [attribute, className, options]);
             el = result.el;
             attr = result.values;
             return result.success;
         }, isNot, options);
-        (0, utils_1.updateElementsArray)(pass, received, el);
-        const message = (0, utils_1.enhanceError)(el, (0, utils_1.wrapExpectedWithArray)(el, attr, className), attr, this, verb, expectation, '', options);
+        updateElementsArray(pass, received, el);
+        const message = enhanceError(el, wrapExpectedWithArray(el, attr, className), attr, this, verb, expectation, '', options);
         return {
             pass,
             message: () => message
         };
     });
 }
-function toHaveElementClass(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveElementClassFn, args);
-}
-exports.toHaveElementClass = toHaveElementClass;
-function toHaveClass(...args) {
-    console.warn('expect(...).toHaveClass is deprecated and will be removed in next release. Use toHaveElementClass instead.');
-    return expectAdapter_1.runExpect.call(this || {}, toHaveElementClassFn, args);
-}
-exports.toHaveClass = toHaveClass;

package/lib/matchers/element/toHaveClassContaining.js

@@ -0,0 +1,10 @@
+import { toHaveAttributeAndValueFn } from './toHaveAttribute';
+export function toHaveElementClassContaining(...args) {
+    return toHaveClassContaining.call(this, ...args);
+}
+export function toHaveClassContaining(el, className, options = {}) {
+    return toHaveAttributeAndValueFn.call(this, el, 'class', className, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveElementProperty = exports.toHaveElementPropertyFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils';
 async function condition(el, property, value, options = {}) {
     const { asString = false } = options;
     let prop = await el.getProperty(property);
@@ -16,28 +13,28 @@ async function condition(el, property, value, options = {}) {
         return { result: prop === value, value: prop };
     }
     prop = prop.toString();
-    return (0, utils_1.compareText)(prop, value, options);
+    return compareText(prop, value, options);
 }
-function toHaveElementPropertyFn(received, property, value, options = {}) {
+export function toHaveElementProperty(received, property, value, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'property', verb = 'have' } = this;
     return browser.call(async () => {
         let el = await received;
         let prop;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, condition, options, [property, value]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, condition, options, [property, value]);
             el = result.el;
             prop = result.values;
             return result.success;
         }, isNot, options);
-        (0, utils_1.updateElementsArray)(pass, received, el);
+        updateElementsArray(pass, received, el);
         let message;
         if (value === undefined) {
-            message = (0, utils_1.enhanceError)(el, !isNot, pass, this, verb, expectation, property, options);
+            message = enhanceError(el, !isNot, pass, this, verb, expectation, property, options);
         }
         else {
-            const expected = (0, utils_1.wrapExpectedWithArray)(el, prop, value);
-            message = (0, utils_1.enhanceError)(el, expected, prop, this, verb, expectation, property, options);
+            const expected = wrapExpectedWithArray(el, prop, value);
+            message = enhanceError(el, expected, prop, this, verb, expectation, property, options);
         }
         return {
             pass,
@@ -45,8 +42,3 @@ function toHaveElementPropertyFn(received, property, value, options = {}) {
         };
     });
 }
-exports.toHaveElementPropertyFn = toHaveElementPropertyFn;
-function toHaveElementProperty(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveElementPropertyFn, args);
-}
-exports.toHaveElementProperty = toHaveElementProperty;

package/lib/matchers/element/toHaveHref.js

@@ -1,14 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveLink = exports.toHaveHref = exports.toHaveHrefFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveAttribute_1 = require("./toHaveAttribute");
-function toHaveHrefFn(el, href, options = {}) {
-    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, 'href', href, options);
+import { toHaveAttributeAndValueFn } from './toHaveAttribute';
+export function toHaveHref(el, href, options = {}) {
+    return toHaveAttributeAndValueFn.call(this, el, 'href', href, options);
 }
-exports.toHaveHrefFn = toHaveHrefFn;
-function toHaveHref(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveHrefFn, args);
-}
-exports.toHaveHref = toHaveHref;
-exports.toHaveLink = toHaveHref;
+export const toHaveLink = toHaveHref;

package/lib/matchers/element/toHaveHrefContaining.js

@@ -1,16 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveLinkContaining = exports.toHaveHrefContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveHref_1 = require("./toHaveHref");
-function toHaveHrefContainingFn(el, href, options = {}) {
-    return toHaveHref_1.toHaveHrefFn.call(this, el, href, {
+import { toHaveHref } from './toHaveHref';
+export function toHaveHrefContaining(el, href, options = {}) {
+    return toHaveHref.call(this, el, href, {
         ...options,
         containing: true
     });
 }
-function toHaveHrefContaining(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveHrefContainingFn, args);
-}
-exports.toHaveHrefContaining = toHaveHrefContaining;
-exports.toHaveLinkContaining = toHaveHrefContaining;
+export const toHaveLinkContaining = toHaveHrefContaining;

package/lib/matchers/element/toHaveId.js

@@ -1,13 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveId = exports.toHaveIdFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveAttribute_1 = require("./toHaveAttribute");
-function toHaveIdFn(el, id, options = {}) {
-    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, 'id', id, options);
+import { toHaveAttributeAndValueFn } from './toHaveAttribute';
+export function toHaveId(el, id, options = {}) {
+    return toHaveAttributeAndValueFn.call(this, el, 'id', id, options);
 }
-exports.toHaveIdFn = toHaveIdFn;
-function toHaveId(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveIdFn, args);
-}
-exports.toHaveId = toHaveId;

package/lib/matchers/element/toHaveStyle.js

@@ -1,33 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveStyle = exports.toHaveStyleFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils';
 async function condition(el, style, options) {
-    return (0, utils_1.compareStyle)(el, style, options);
+    return compareStyle(el, style, options);
 }
-function toHaveStyleFn(received, style, options = {}) {
+export function toHaveStyle(received, style, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'style', verb = 'have' } = this;
     return browser.call(async () => {
         let el = await received;
         let actualStyle;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, condition, options, [style, options]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, condition, options, [style, options]);
             el = result.el;
             actualStyle = result.values;
             return result.success;
         }, isNot, options);
-        (0, utils_1.updateElementsArray)(pass, received, el);
-        const message = (0, utils_1.enhanceError)(el, (0, utils_1.wrapExpectedWithArray)(el, actualStyle, style), actualStyle, this, verb, expectation, '', options);
+        updateElementsArray(pass, received, el);
+        const message = enhanceError(el, wrapExpectedWithArray(el, actualStyle, style), actualStyle, this, verb, expectation, '', options);
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toHaveStyleFn = toHaveStyleFn;
-function toHaveStyle(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveStyleFn, args);
-}
-exports.toHaveStyle = toHaveStyle;

package/lib/matchers/element/toHaveText.js

@@ -1,37 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveText = exports.toHaveTextFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils';
 async function condition(el, text, options) {
     const actualText = await el.getText();
     if (Array.isArray(text)) {
-        return (0, utils_1.compareTextWithArray)(actualText, text, options);
+        return compareTextWithArray(actualText, text, options);
     }
-    return (0, utils_1.compareText)(actualText, text, options);
+    return compareText(actualText, text, options);
 }
-function toHaveTextFn(received, text, options = {}) {
+export function toHaveText(received, text, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'text', verb = 'have' } = this;
     return browser.call(async () => {
         let el = await received;
         let actualText;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, condition, options, [text, options]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, condition, options, [text, options]);
             el = result.el;
             actualText = result.values;
             return result.success;
         }, isNot, options);
-        (0, utils_1.updateElementsArray)(pass, received, el);
-        const message = (0, utils_1.enhanceError)(el, (0, utils_1.wrapExpectedWithArray)(el, actualText, text), actualText, this, verb, expectation, '', options);
+        updateElementsArray(pass, received, el);
+        const message = enhanceError(el, wrapExpectedWithArray(el, actualText, text), actualText, this, verb, expectation, '', options);
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toHaveTextFn = toHaveTextFn;
-function toHaveText(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveTextFn, args);
-}
-exports.toHaveText = toHaveText;

package/lib/matchers/element/toHaveTextContaining.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveTextContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveText_1 = require("./toHaveText");
-function toHaveTextContainingFn(el, text, options = {}) {
-    return toHaveText_1.toHaveTextFn.call(this, el, text, {
+import { toHaveText } from './toHaveText';
+export function toHaveTextContaining(el, text, options = {}) {
+    return toHaveText.call(this, el, text, {
         ...options,
         containing: true
     });
 }
-function toHaveTextContaining(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveTextContainingFn, args);
-}
-exports.toHaveTextContaining = toHaveTextContaining;

package/lib/matchers/element/toHaveValue.js

@@ -1,13 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveValue = exports.toHaveValueFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveElementProperty_1 = require("./toHaveElementProperty");
-function toHaveValueFn(el, value, options = {}) {
-    return toHaveElementProperty_1.toHaveElementPropertyFn.call(this, el, 'value', value, options);
+import { toHaveElementProperty } from './toHaveElementProperty';
+export function toHaveValue(el, value, options = {}) {
+    return toHaveElementProperty.call(this, el, 'value', value, options);
 }
-exports.toHaveValueFn = toHaveValueFn;
-function toHaveValue(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveValueFn, args);
-}
-exports.toHaveValue = toHaveValue;

package/lib/matchers/element/toHaveValueContaining.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveValueContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveValue_1 = require("./toHaveValue");
-function toHaveValueContainingFn(el, value, options = {}) {
-    return toHaveValue_1.toHaveValueFn.call(this, el, value, {
+import { toHaveValue } from './toHaveValue';
+export function toHaveValueContaining(el, value, options = {}) {
+    return toHaveValue.call(this, el, value, {
         ...options,
         containing: true
     });
 }
-function toHaveValueContaining(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveValueContainingFn, args);
-}
-exports.toHaveValueContaining = toHaveValueContaining;

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeElementsArrayOfSize = void 0;
-const utils_1 = require("../../utils");
-const refetchElements_1 = require("../../util/refetchElements");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeElementsArrayOfSizeFn(received, expected, options = {}) {
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareNumbers, numberError, updateElementsArray } from '../../utils';
+import { refetchElements } from '../../util/refetchElements';
+export function toBeElementsArrayOfSize(received, expected, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'elements array of size', verb = 'be' } = this;
     let numberOptions;
@@ -20,20 +17,16 @@ function toBeElementsArrayOfSizeFn(received, expected, options = {}) {
     return browser.call(async () => {
         let elements = await received;
         const arrLength = elements.length;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            elements = await (0, refetchElements_1.refetchElements)(elements, numberOptions.wait, true);
-            return (0, utils_1.compareNumbers)(elements.length, numberOptions);
+        const pass = await waitUntil(async () => {
+            elements = await refetchElements(elements, numberOptions.wait, true);
+            return compareNumbers(elements.length, numberOptions);
         }, isNot, { ...numberOptions, ...options });
-        (0, utils_1.updateElementsArray)(pass, received, elements, true);
-        const error = (0, utils_1.numberError)(numberOptions);
-        const message = (0, utils_1.enhanceError)(elements, error, arrLength, this, verb, expectation, '', numberOptions);
+        updateElementsArray(pass, received, elements, true);
+        const error = numberError(numberOptions);
+        const message = enhanceError(elements, error, arrLength, this, verb, expectation, '', numberOptions);
         return {
             pass,
             message: () => message
         };
     });
 }
-function toBeElementsArrayOfSize(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeElementsArrayOfSizeFn, args);
-}
-exports.toBeElementsArrayOfSize = toBeElementsArrayOfSize;

package/lib/matchers/mock/toBeRequested.js

@@ -1,12 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeRequested = void 0;
-const toBeRequestedTimes_1 = require("./toBeRequestedTimes");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeRequestedFn(received, options = {}) {
-    return toBeRequestedTimes_1.toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { ...options, gte: 1 });
+import { toBeRequestedTimes } from './toBeRequestedTimes';
+export function toBeRequested(received, options = {}) {
+    return toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { ...options, gte: 1 });
 }
-function toBeRequested(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeRequestedFn, args);
-}
-exports.toBeRequested = toBeRequested;

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeRequestedTimes = exports.toBeRequestedTimesFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-const formatMessage_1 = require("../../util/formatMessage");
-function toBeRequestedTimesFn(received, expected = {}, options = {}) {
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareNumbers } from '../../utils';
+import { numberError } from '../../util/formatMessage';
+export function toBeRequestedTimes(received, expected = {}, options = {}) {
     const isNot = this.isNot || false;
     const { expectation = `called${typeof expected === 'number' ? ' ' + expected : ''} time${expected !== 1 ? 's' : ''}`, verb = 'be' } = this;
     let numberOptions;
@@ -16,20 +13,15 @@ function toBeRequestedTimesFn(received, expected = {}, options = {}) {
     }
     return browser.call(async () => {
         let actual;
-        const pass = await (0, utils_1.waitUntil)(async () => {
+        const pass = await waitUntil(async () => {
             actual = received.calls.length;
-            return (0, utils_1.compareNumbers)(actual, numberOptions);
+            return compareNumbers(actual, numberOptions);
         }, isNot, { ...numberOptions, ...options });
-        const error = (0, formatMessage_1.numberError)(numberOptions);
-        const message = (0, utils_1.enhanceError)('mock', error, actual, this, verb, expectation, '', numberOptions);
+        const error = numberError(numberOptions);
+        const message = enhanceError('mock', error, actual, this, verb, expectation, '', numberOptions);
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toBeRequestedTimesFn = toBeRequestedTimesFn;
-function toBeRequestedTimes(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeRequestedTimesFn, args);
-}
-exports.toBeRequestedTimes = toBeRequestedTimes;

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,17 +1,14 @@
-"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 { browser } from '@wdio/globals';
+import { waitUntil, enhanceError } from '../../utils';
+import { equals } from '../../jasmineUtils';
 const STR_LIMIT = 80;
 const KEY_LIMIT = 12;
-function toBeRequestedWithFn(received, requestedWith = {}, options = {}) {
+export 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 (0, utils_1.waitUntil)(async () => {
+        const pass = await waitUntil(async () => {
             for (const call of received.calls) {
                 actual = call;
                 if (methodMatcher(call.method, requestedWith.method) &&
@@ -26,14 +23,13 @@ function toBeRequestedWithFn(received, requestedWith = {}, options = {}) {
             }
             return false;
         }, isNot, { ...options, wait: isNot ? 0 : options.wait });
-        const message = (0, utils_1.enhanceError)('mock', minifyRequestedWith(requestedWith), minifyRequestMock(actual, requestedWith) || 'was not called', this, verb, expectation, '', options);
+        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 +62,7 @@ const urlMatcher = (url, expected) => {
     if (typeof expected === 'function') {
         return expected(url);
     }
-    return (0, jasmineUtils_1.equals)(url, expected);
+    return equals(url, expected);
 };
 const headersMatcher = (headers, expected) => {
     if (typeof expected === 'undefined') {
@@ -75,7 +71,7 @@ const headersMatcher = (headers, expected) => {
     if (typeof expected === 'function') {
         return expected(headers);
     }
-    return (0, jasmineUtils_1.equals)(headers, expected);
+    return equals(headers, expected);
 };
 const bodyMatcher = (body, expected) => {
     if (typeof expected === 'undefined') {
@@ -97,7 +93,7 @@ const bodyMatcher = (body, expected) => {
             return false;
         }
     }
-    return (0, jasmineUtils_1.equals)(parsedBody, expected);
+    return equals(parsedBody, expected);
 };
 const isExpectedJsonLike = (expected) => {
     if (typeof expected === 'undefined') {
@@ -112,14 +108,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 +207,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 {};