expect-webdriverio 2.0.0 → 2.0.1

package/lib/matchers/element/toHaveElementClass.js

@@ -0,0 +1,60 @@
+"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");
+async function condition(el, attribute, value, options) {
+    const { ignoreCase = false, trim = false, containing = false } = options;
+    let attr = await el.getAttribute(attribute);
+    if (typeof attr !== 'string') {
+        return { result: false };
+    }
+    if (trim) {
+        attr = attr.trim();
+    }
+    if (ignoreCase) {
+        attr = attr.toLowerCase();
+        value = value.toLowerCase();
+    }
+    if (containing) {
+        return {
+            result: attr.includes(value),
+            value: attr
+        };
+    }
+    const classes = attr.split(' ');
+    return {
+        result: classes.includes(value),
+        value: attr
+    };
+}
+function toHaveElementClassFn(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 utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [attribute, className, options]);
+            el = result.el;
+            attr = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        const message = utils_1.enhanceError(el, utils_1.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/toHaveElementClassContaining.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveClassContaining = exports.toHaveElementClassContaining = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveAttribute_1 = require("./toHaveAttribute");
+function toHaveElementClassContainingFn(el, className, options = {}) {
+    return toHaveAttribute_1.toHaveAttributeFn.call(this, el, 'class', className, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveElementClassContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveElementClassContainingFn, args);
+}
+exports.toHaveElementClassContaining = toHaveElementClassContaining;
+function toHaveClassContaining(...args) {
+    console.warn('expect(...).toHaveClassContaining is deprecated and will be removed in next release. Use toHaveElementClassContaining instead.');
+    return expectAdapter_1.runExpect.call(this, toHaveElementClassContainingFn, args);
+}
+exports.toHaveClassContaining = toHaveClassContaining;

package/lib/matchers/element/toHaveElementProperty.js

@@ -0,0 +1,52 @@
+"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");
+async function condition(el, property, value, options = {}) {
+    const { asString = false } = options;
+    let prop = await el.getProperty(property);
+    if (prop === null || prop === undefined) {
+        return { result: false, value: prop };
+    }
+    if (value === null) {
+        return { result: true, value: prop };
+    }
+    if (typeof value !== 'string' || (typeof prop !== 'string' && !asString)) {
+        return { result: prop === value, value: prop };
+    }
+    prop = prop.toString();
+    return utils_1.compareText(prop, value, options);
+}
+function toHaveElementPropertyFn(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 utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [property, value]);
+            el = result.el;
+            prop = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        let message;
+        if (value === undefined) {
+            message = utils_1.enhanceError(el, !isNot, pass, this, verb, expectation, property, options);
+        }
+        else {
+            const expected = utils_1.wrapExpectedWithArray(el, prop, value);
+            message = utils_1.enhanceError(el, expected, prop, this, verb, expectation, property, options);
+        }
+        return {
+            pass,
+            message: () => message,
+        };
+    });
+}
+exports.toHaveElementPropertyFn = toHaveElementPropertyFn;
+function toHaveElementProperty(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveElementPropertyFn, args);
+}
+exports.toHaveElementProperty = toHaveElementProperty;

package/lib/matchers/element/toHaveHref.js

@@ -0,0 +1,14 @@
+"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.toHaveAttributeFn.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;

package/lib/matchers/element/toHaveHrefContaining.js

@@ -0,0 +1,16 @@
+"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, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveHrefContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveHrefContainingFn, args);
+}
+exports.toHaveHrefContaining = toHaveHrefContaining;
+exports.toHaveLinkContaining = toHaveHrefContaining;

package/lib/matchers/element/toHaveId.js

@@ -0,0 +1,13 @@
+"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.toHaveAttributeFn.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/toHaveText.js

@@ -0,0 +1,37 @@
+"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");
+async function condition(el, text, options) {
+    const actualText = await el.getText();
+    if (Array.isArray(text)) {
+        return utils_1.compareTextWithArray(actualText, text, options);
+    }
+    return utils_1.compareText(actualText, text, options);
+}
+function toHaveTextFn(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 utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [text, options]);
+            el = result.el;
+            actualText = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        const message = utils_1.enhanceError(el, utils_1.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

@@ -0,0 +1,15 @@
+"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, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveTextContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveTextContainingFn, args);
+}
+exports.toHaveTextContaining = toHaveTextContaining;

package/lib/matchers/element/toHaveValue.js

@@ -0,0 +1,13 @@
+"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);
+}
+exports.toHaveValueFn = toHaveValueFn;
+function toHaveValue(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveValueFn, args);
+}
+exports.toHaveValue = toHaveValue;

package/lib/matchers/element/toHaveValueContaining.js

@@ -0,0 +1,15 @@
+"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, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveValueContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveValueContainingFn, args);
+}
+exports.toHaveValueContaining = toHaveValueContaining;

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -0,0 +1,41 @@
+"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, size, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'elements array of size', verb = 'be' } = this;
+    if (typeof size === 'number') {
+        options.eq = size;
+    }
+    else if (!size || (typeof size.eq !== 'number' && typeof size.gte !== 'number' && typeof size.lte !== 'number')) {
+        throw new Error('Invalid params passed to toBeElementsArrayOfSize.');
+    }
+    else {
+        options = size;
+    }
+    const eq = options.eq;
+    const gte = options.gte || 1;
+    const lte = options.lte || 0;
+    return browser.call(async () => {
+        let elements = await received;
+        const arrLength = elements.length;
+        const pass = await utils_1.waitUntil(async () => {
+            elements = await refetchElements_1.refetchElements(elements, options.wait, true);
+            return utils_1.compareNumbers(elements.length, gte, lte, eq);
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, elements, true);
+        const error = utils_1.numberError(gte, lte, eq);
+        const message = utils_1.enhanceError(elements, error, arrLength, this, verb, expectation, '', options);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+function toBeElementsArrayOfSize(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeElementsArrayOfSizeFn, args);
+}
+exports.toBeElementsArrayOfSize = toBeElementsArrayOfSize;

package/lib/matchers/mock/toBeRequested.js

@@ -0,0 +1,12 @@
+"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 });
+}
+function toBeRequested(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeRequestedFn, args);
+}
+exports.toBeRequested = toBeRequested;

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -0,0 +1,37 @@
+"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, times = {}, options = {}) {
+    const isNot = this.isNot || false;
+    const { expectation = `called${typeof times === 'number' ? ' ' + times : ''} time${times !== 1 ? 's' : ''}`, verb = 'be' } = this;
+    if (typeof times === 'number') {
+        options.eq = times;
+    }
+    else if (typeof times === 'object') {
+        options = { ...options, ...times };
+    }
+    const eq = options.eq;
+    const gte = options.gte || 1;
+    const lte = options.lte || 0;
+    return browser.call(async () => {
+        let actual;
+        const pass = await utils_1.waitUntil(async () => {
+            actual = received.calls.length;
+            return utils_1.compareNumbers(actual, gte, lte, eq);
+        }, isNot, { ...options, wait: isNot ? 0 : options.wait });
+        const error = formatMessage_1.numberError(gte, lte, eq);
+        const message = utils_1.enhanceError('mock', error, actual, this, verb, expectation, '', options);
+        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

@@ -0,0 +1,218 @@
+"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");
+const STR_LIMIT = 80;
+const KEY_LIMIT = 12;
+function toBeRequestedWithFn(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;
+                }
+            }
+            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,
+        };
+    });
+}
+exports.toBeRequestedWithFn = toBeRequestedWithFn;
+const methodMatcher = (method, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (!Array.isArray(expected)) {
+        expected = [expected];
+    }
+    return expected
+        .map((m) => {
+        if (typeof m !== 'string') {
+            return console.error('expect.toBeRequestedWith: unsupported value passed to method ' + m);
+        }
+        return m.toUpperCase();
+    })
+        .includes(method);
+};
+const statusCodeMatcher = (statusCode, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (!Array.isArray(expected)) {
+        expected = [expected];
+    }
+    return expected.includes(statusCode);
+};
+const urlMatcher = (url, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(url);
+    }
+    return jasmineUtils_1.equals(url, expected);
+};
+const headersMatcher = (headers, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(headers);
+    }
+    return jasmineUtils_1.equals(headers, expected);
+};
+const bodyMatcher = (body, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(body);
+    }
+    if (typeof body === 'undefined') {
+        return false;
+    }
+    let parsedBody = body;
+    if (body instanceof Buffer) {
+        parsedBody = body.toString();
+    }
+    if (typeof (body) === 'string' && isExpectedJsonLike(expected)) {
+        parsedBody = tryParseBody(body);
+        if (parsedBody === null) {
+            return false;
+        }
+    }
+    return jasmineUtils_1.equals(parsedBody, expected);
+};
+const isExpectedJsonLike = (expected) => {
+    if (typeof expected === 'undefined') {
+        return false;
+    }
+    const actualSample = isMatcher(expected)
+        ? expected.sample
+        : expected;
+    return (Array.isArray(actualSample) ||
+        (typeof actualSample === 'object' &&
+            actualSample !== null &&
+            actualSample instanceof RegExp === false));
+};
+const isMatcher = (filter) => {
+    var _a;
+    return typeof ((_a = filter.__proto__) === null || _a === void 0 ? void 0 : _a.asymmetricMatch) === 'function';
+};
+const tryParseBody = (jsonString, fallback = null) => {
+    try {
+        return typeof jsonString === 'undefined' ? fallback : JSON.parse(jsonString);
+    }
+    catch (_a) {
+        return fallback;
+    }
+};
+const minifyRequestMock = (requestMock, requestedWith) => {
+    if (typeof requestMock === 'undefined') {
+        return requestMock;
+    }
+    const r = {
+        url: requestMock.url,
+        method: requestMock.method,
+        requestHeaders: requestMock.headers,
+        responseHeaders: requestMock.responseHeaders,
+        postData: typeof requestMock.postData === 'string' && isExpectedJsonLike(requestedWith.postData)
+            ? tryParseBody(requestMock.postData, requestMock.postData)
+            : requestMock.postData,
+        response: typeof requestMock.body === 'string' && isExpectedJsonLike(requestedWith.response)
+            ? tryParseBody(requestMock.body, requestMock.body)
+            : requestMock.body,
+    };
+    deleteUndefinedValues(r, requestedWith);
+    return minifyRequestedWith(r);
+};
+const minifyRequestedWith = (r) => {
+    const result = {
+        url: requestedWithParamToString(r.url),
+        method: r.method,
+        requestHeaders: requestedWithParamToString(r.requestHeaders, shortenJson),
+        responseHeaders: requestedWithParamToString(r.responseHeaders, shortenJson),
+        postData: requestedWithParamToString(r.postData, shortenJson),
+        response: requestedWithParamToString(r.response, shortenJson),
+    };
+    deleteUndefinedValues(result);
+    return result;
+};
+const requestedWithParamToString = (param, transformFn) => {
+    if (typeof param === 'undefined') {
+        return;
+    }
+    if (typeof param === 'function') {
+        param = param.toString();
+    }
+    else if (isMatcher(param)) {
+        return (param.constructor.name +
+            ' ' +
+            (JSON.stringify(param.sample) || ''));
+    }
+    else if (transformFn && typeof param === 'object' && param !== null) {
+        param = transformFn(param);
+    }
+    if (typeof param === 'string') {
+        param = shortenString(param);
+    }
+    return param;
+};
+const shortenJson = (obj, lengthLimit = STR_LIMIT * 2, keyLimit = KEY_LIMIT) => {
+    if (JSON.stringify(obj).length < lengthLimit) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const firstItem = typeof obj[0] === 'object' && obj[0] !== null
+            ? shortenJson(obj[0], lengthLimit / 2, keyLimit / 4)
+            : shortenString(JSON.stringify(obj[0]));
+        return [firstItem, `... ${obj.length - 1} more items`];
+    }
+    const minifiedObject = {};
+    const entries = Object.entries(obj);
+    if (keyLimit >= 4) {
+        entries.slice(0, keyLimit).forEach(([k, v]) => {
+            if (typeof v === 'object' && v !== null) {
+                v = shortenJson(v, lengthLimit / 2, keyLimit / 4);
+            }
+            else if (typeof v === 'string') {
+                v = shortenString(v, 16);
+            }
+            minifiedObject[shortenString(k, 24)] = v;
+        });
+    }
+    if (entries.length > keyLimit) {
+        minifiedObject['...'] = `${entries.length} items in total`;
+    }
+    return minifiedObject;
+};
+const shortenString = (str, limit = STR_LIMIT) => {
+    return str.length > limit ? str.substring(0, limit / 2 - 1) + '..' + str.substr(1 - limit / 2) : str;
+};
+const deleteUndefinedValues = (obj, baseline = obj) => {
+    Object.keys(obj).forEach((k) => {
+        if (typeof baseline[k] === 'undefined') {
+            delete obj[k];
+        }
+    });
+};
+function toBeRequestedWith(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeRequestedWithFn, args);
+}
+exports.toBeRequestedWith = toBeRequestedWith;

package/lib/matchers/mock/toBeRequestedWithResponse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeRequestedWithResponse = void 0;
+const toBeRequestedWith_1 = require("./toBeRequestedWith");
+const expectAdapter_1 = require("../../util/expectAdapter");
+function toBeRequestedWithResponseFn(received, response, options = {}) {
+    return toBeRequestedWith_1.toBeRequestedWithFn.call(this, received, { response }, options);
+}
+function toBeRequestedWithResponse(...args) {
+    console.warn('expect(...).toBeRequestedWithResponse is deprecated and will be removed in next release. Use toBeRequestedWith instead.');
+    return expectAdapter_1.runExpect.call(this, toBeRequestedWithResponseFn, args);
+}
+exports.toBeRequestedWithResponse = toBeRequestedWithResponse;

package/lib/matchers.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/mock/toBeRequested'),
+    ...require('./matchers/mock/toBeRequestedTimes'),
+    ...require('./matchers/mock/toBeRequestedWith'),
+    ...require('./matchers/mock/toBeRequestedWithResponse'),
+};
+Object.keys(matchers).forEach(key => {
+    if (key.endsWith('Fn')) {
+        delete matchers[key];
+    }
+});
+exports.default = matchers;

package/lib/options.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDefaultOptions = exports.getConfig = void 0;
+const DEFAULT_OPTIONS = {
+    wait: 2000,
+    interval: 100,
+};
+let mode = 'jest';
+let expectLib;
+if (global.expectWdio) {
+    expectLib = global.expectWdio;
+}
+else if (global.jasmine && !((_a = global.expect) === null || _a === void 0 ? void 0 : _a.extend)) {
+    expectLib = global.jasmine;
+    mode = 'jasmine';
+}
+else {
+    expectLib = global.expect;
+}
+if (!expectLib._expectWebdriverio) {
+    expectLib._expectWebdriverio = { options: { ...DEFAULT_OPTIONS }, mode };
+}
+const getConfig = () => expectLib._expectWebdriverio;
+exports.getConfig = getConfig;
+const setDefaultOptions = (options = {}) => {
+    Object.entries(options).forEach(([key, value]) => {
+        if (key in DEFAULT_OPTIONS) {
+            expectLib._expectWebdriverio.options[key] = value;
+        }
+    });
+};
+exports.setDefaultOptions = setDefaultOptions;