expect-webdriverio 4.6.0 → 4.7.0

package/lib/index.js

@@ -1,7 +1,8 @@
-import { expect as expectLib } from 'expect';
+import { jestExpect as expectLib } from '@jest/expect';
 import wdioMatchers from './matchers.js';
 import * as expectUtils from './utils.js';
 import { DEFAULT_OPTIONS } from './constants.js';
+expectLib.setState({ suppressedErrors: [] });
 expectLib.extend({ ...wdioMatchers });
 export const expect = expectLib;
 export const matchers = wdioMatchers;

package/lib/matchers/browser/toHaveClipboardText.js

@@ -1,7 +1,8 @@
-import { waitUntil, enhanceError, compareText } from '../../utils.js';
 import logger from '@wdio/logger';
+import { waitUntil, enhanceError, compareText } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 const log = logger('expect-webdriverio');
-export async function toHaveClipboardText(browser, expectedValue, options = {}) {
+export async function toHaveClipboardText(browser, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'clipboard text', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/browser/toHaveTitle.js

@@ -1,5 +1,6 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
-export async function toHaveTitle(browser, expectedValue, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toHaveTitle(browser, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'title', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/browser/toHaveUrl.js

@@ -1,5 +1,6 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
-export async function toHaveUrl(browser, expectedValue, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toHaveUrl(browser, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'url', verb = 'have' } = this;
     await options.beforeAssertion?.({
@@ -25,7 +26,7 @@ export async function toHaveUrl(browser, expectedValue, options = {}) {
     });
     return result;
 }
-export function toHaveUrlContaining(browser, url, options = {}) {
+export function toHaveUrlContaining(browser, url, options = DEFAULT_OPTIONS) {
     return toHaveUrl.call(this, browser, url, {
         ...options,
         containing: true

package/lib/matchers/element/toBeClickable.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeClickable(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeClickable(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'clickable';
     await options.beforeAssertion?.({
         matcherName: 'toBeClickable',

package/lib/matchers/element/toBeDisabled.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeDisabled(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeDisabled(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'disabled';
     await options.beforeAssertion?.({
         matcherName: 'toBeDisabled',

package/lib/matchers/element/toBeDisplayed.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeDisplayed(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeDisplayed(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'displayed';
     await options.beforeAssertion?.({
         matcherName: 'toBeDisplayed',

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeDisplayedInViewport(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeDisplayedInViewport(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'displayed in viewport';
     await options.beforeAssertion?.({
         matcherName: 'toBeDisplayedInViewport',

package/lib/matchers/element/toBeEnabled.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeEnabled(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeEnabled(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'enabled';
     await options.beforeAssertion?.({
         matcherName: 'toBeEnabled',

package/lib/matchers/element/toBeExisting.js

@@ -1,5 +1,6 @@
 import { executeCommandBe, aliasFn } from '../../utils.js';
-export async function toExist(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toExist(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
     await options.beforeAssertion?.({

package/lib/matchers/element/toBeFocused.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeFocused(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeFocused(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'focused';
     await options.beforeAssertion?.({
         matcherName: 'toBeFocused',

package/lib/matchers/element/toBeSelected.js

@@ -1,5 +1,6 @@
 import { executeCommandBe } from '../../utils.js';
-export async function toBeSelected(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeSelected(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'selected';
     await options.beforeAssertion?.({
         matcherName: 'toBeSelected',
@@ -13,7 +14,7 @@ export async function toBeSelected(received, options = {}) {
     });
     return result;
 }
-export async function toBeChecked(el, options = {}) {
+export async function toBeChecked(el, options = DEFAULT_OPTIONS) {
     this.expectation = 'checked';
     await options.beforeAssertion?.({
         matcherName: 'toBeChecked',

package/lib/matchers/element/toHaveAttribute.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function conditionAttr(el, attribute) {
     const attr = await el.getAttribute(attribute);
     if (typeof attr !== 'string') {
@@ -15,7 +16,7 @@ async function conditionAttrAndValue(el, attribute, value, options) {
     }
     return compareText(attr, value, options);
 }
-export async function toHaveAttributeAndValue(received, attribute, value, options = {}) {
+export async function toHaveAttributeAndValue(received, attribute, value, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
     let el = await received;
@@ -50,7 +51,7 @@ async function toHaveAttributeFn(received, attribute) {
         message: () => message
     };
 }
-export async function toHaveAttribute(received, attribute, value, options = {}) {
+export async function toHaveAttribute(received, attribute, value, options = DEFAULT_OPTIONS) {
     await options.beforeAssertion?.({
         matcherName: 'toHaveAttribute',
         expectedValue: [attribute, value],
@@ -67,7 +68,7 @@ export async function toHaveAttribute(received, attribute, value, options = {})
     });
     return result;
 }
-export function toHaveAttributeContaining(el, attribute, value, options = {}) {
+export function toHaveAttributeContaining(el, attribute, value, options = DEFAULT_OPTIONS) {
     return toHaveAttributeAndValue.call(this, el, attribute, value, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveChildren.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareNumbers, numberError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, options) {
     const children = await el.$$('./*');
     if (typeof options.lte !== 'number' &&
@@ -14,7 +15,7 @@ async function condition(el, options) {
         value: children?.length
     };
 }
-export async function toHaveChildren(received, expectedValue, options = {}) {
+export async function toHaveChildren(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'children', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toHaveClass.js

@@ -1,5 +1,6 @@
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareText } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, attribute, value, options) {
     const { ignoreCase = false, trim = false, containing = false } = options;
     let attr = await el.getAttribute(attribute);
@@ -31,7 +32,7 @@ async function condition(el, attribute, value, options) {
 export function toHaveClass(...args) {
     return toHaveElementClass.call(this || {}, ...args);
 }
-export async function toHaveElementClass(received, expectedValue, options = {}) {
+export async function toHaveElementClass(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'class', verb = 'have' } = this;
     await options.beforeAssertion?.({
@@ -65,7 +66,7 @@ export async function toHaveElementClass(received, expectedValue, options = {})
 export function toHaveElementClassContaining(...args) {
     return toHaveClassContaining.call(this, ...args);
 }
-export function toHaveClassContaining(el, className, options = {}) {
+export function toHaveClassContaining(el, className, options = DEFAULT_OPTIONS) {
     return toHaveAttributeAndValue.call(this, el, 'class', className, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveComputedLabel.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, label, options) {
     const actualLabel = await el.getComputedLabel();
     if (Array.isArray(label)) {
@@ -6,7 +7,7 @@ async function condition(el, label, options) {
     }
     return compareText(actualLabel, label, options);
 }
-export async function toHaveComputedLabel(received, expectedValue, options = {}) {
+export async function toHaveComputedLabel(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'computed label', verb = 'have' } = this;
     await options.beforeAssertion?.({
@@ -36,7 +37,7 @@ export async function toHaveComputedLabel(received, expectedValue, options = {})
     });
     return result;
 }
-export function toHaveComputedLabelContaining(el, label, options = {}) {
+export function toHaveComputedLabelContaining(el, label, options = DEFAULT_OPTIONS) {
     return toHaveComputedLabel.call(this, el, label, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveComputedRole.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, role, options) {
     const actualRole = await el.getComputedRole();
     if (Array.isArray(role)) {
@@ -6,7 +7,7 @@ async function condition(el, role, options) {
     }
     return compareText(actualRole, role, options);
 }
-export async function toHaveComputedRole(received, expectedValue, options = {}) {
+export async function toHaveComputedRole(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'computed role', verb = 'have' } = this;
     await options.beforeAssertion?.({
@@ -36,7 +37,7 @@ export async function toHaveComputedRole(received, expectedValue, options = {})
     });
     return result;
 }
-export function toHaveComputedRoleContaining(el, role, options = {}) {
+export function toHaveComputedRoleContaining(el, role, options = DEFAULT_OPTIONS) {
     return toHaveComputedRole.call(this, el, role, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,5 +1,6 @@
 import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
-async function condition(el, property, value, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+async function condition(el, property, value, options = DEFAULT_OPTIONS) {
     const { asString = false } = options;
     let prop = await el.getProperty(property);
     if (prop === null || prop === undefined) {
@@ -14,7 +15,7 @@ async function condition(el, property, value, options = {}) {
     prop = prop.toString();
     return compareText(prop, value, options);
 }
-export async function toHaveElementProperty(received, property, value, options = {}) {
+export async function toHaveElementProperty(received, property, value, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'property', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toHaveHTML.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, html, options) {
     const actualHTML = await el.getHTML(options.includeSelectorTag);
     if (Array.isArray(html)) {
@@ -6,7 +7,7 @@ async function condition(el, html, options) {
     }
     return compareText(actualHTML, html, options);
 }
-export async function toHaveHTML(received, expectedValue, options = {}) {
+export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'HTML', verb = 'have' } = this;
     await options.beforeAssertion?.({
@@ -36,7 +37,7 @@ export async function toHaveHTML(received, expectedValue, options = {}) {
     });
     return result;
 }
-export function toHaveHTMLContaining(el, html, options = {}) {
+export function toHaveHTMLContaining(el, html, options = DEFAULT_OPTIONS) {
     return toHaveHTML.call(this, el, html, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveHeight.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, height) {
     const actualHeight = await el.getSize('height');
     return {
@@ -6,7 +7,7 @@ async function condition(el, height) {
         result: actualHeight === height,
     };
 }
-export async function toHaveHeight(received, expectedValue, options = {}) {
+export async function toHaveHeight(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'height', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toHaveHref.js

@@ -1,5 +1,6 @@
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
-export async function toHaveHref(el, expectedValue, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toHaveHref(el, expectedValue, options = DEFAULT_OPTIONS) {
     await options.beforeAssertion?.({
         matcherName: 'toHaveHref',
         expectedValue,
@@ -15,7 +16,7 @@ export async function toHaveHref(el, expectedValue, options = {}) {
     return result;
 }
 export const toHaveLink = toHaveHref;
-export function toHaveHrefContaining(el, href, options = {}) {
+export function toHaveHrefContaining(el, href, options = DEFAULT_OPTIONS) {
     return toHaveHref.call(this, el, href, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveId.js

@@ -1,5 +1,6 @@
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
-export async function toHaveId(el, expectedValue, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toHaveId(el, expectedValue, options = DEFAULT_OPTIONS) {
     await options.beforeAssertion?.({
         matcherName: 'toHaveId',
         expectedValue,

package/lib/matchers/element/toHaveSize.js

@@ -1,9 +1,10 @@
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareObject, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, size) {
     const actualSize = await el.getSize();
     return compareObject(actualSize, size);
 }
-export async function toHaveSize(received, expectedValue, options = {}) {
+export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'size', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toHaveStyle.js

@@ -1,8 +1,9 @@
 import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, style, options) {
     return compareStyle(el, style, options);
 }
-export async function toHaveStyle(received, expectedValue, options = {}) {
+export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'style', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toHaveText.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, text, options) {
     const actualText = await el.getText();
     if (Array.isArray(text)) {
@@ -6,7 +7,7 @@ async function condition(el, text, options) {
     }
     return compareText(actualText, text, options);
 }
-export async function toHaveText(received, expectedValue, options = {}) {
+export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'text', verb = 'have' } = this;
     await options.beforeAssertion?.({
@@ -36,7 +37,7 @@ export async function toHaveText(received, expectedValue, options = {}) {
     });
     return result;
 }
-export function toHaveTextContaining(el, text, options = {}) {
+export function toHaveTextContaining(el, text, options = DEFAULT_OPTIONS) {
     return toHaveText.call(this, el, text, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveValue.js

@@ -1,8 +1,9 @@
 import { toHaveElementProperty } from './toHaveElementProperty.js';
-export function toHaveValue(el, value, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export function toHaveValue(el, value, options = DEFAULT_OPTIONS) {
     return toHaveElementProperty.call(this, el, 'value', value, options);
 }
-export function toHaveValueContaining(el, value, options = {}) {
+export function toHaveValueContaining(el, value, options = DEFAULT_OPTIONS) {
     return toHaveValue.call(this, el, value, {
         ...options,
         containing: true

package/lib/matchers/element/toHaveWidth.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, width) {
     const actualWidth = await el.getSize('width');
     return {
@@ -6,7 +7,7 @@ async function condition(el, width) {
         result: actualWidth === width,
     };
 }
-export async function toHaveWidth(received, expectedValue, options = {}) {
+export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'width', verb = 'have' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toMatchElementSnapshot.js

@@ -0,0 +1,9 @@
+import { toMatchSnapshot as jestToMatchSnapshot, toMatchInlineSnapshot as jestToMatchInlineSnapshot } from 'jest-snapshot';
+export async function toMatchElementSnapshot(el, ...args) {
+    this.expectation = this.expectation || 'matchElementSnapshot';
+    return jestToMatchSnapshot.call(this, await el.getHTML(), ...args);
+}
+export async function toMatchElementInlineSnapshot(el, ...args) {
+    this.expectation = this.expectation || 'matchElementInlineSnapshot';
+    return jestToMatchInlineSnapshot.call(this, await el.getHTML(), ...args);
+}

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,6 +1,7 @@
 import { waitUntil, enhanceError, compareNumbers, numberError, updateElementsArray } from '../../utils.js';
 import { refetchElements } from '../../util/refetchElements.js';
-export async function toBeElementsArrayOfSize(received, expectedValue, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'elements array of size', verb = 'be' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/general/toMatchSnapshot.js

@@ -0,0 +1,9 @@
+import { toMatchSnapshot as jestToMatchSnapshot, toMatchInlineSnapshot as jestToMatchInlineSnapshot } from 'jest-snapshot';
+export async function toMatchSnapshot(received, ...args) {
+    this.expectation = this.expectation || 'matchSnapshot';
+    return jestToMatchSnapshot.call(this, await received, ...args);
+}
+export async function toMatchInlineSnapshot(received, ...args) {
+    this.expectation = this.expectation || 'matchInlineSnapshot';
+    return jestToMatchInlineSnapshot.call(this, await received, ...args);
+}

package/lib/matchers/mock/toBeRequested.js

@@ -1,4 +1,5 @@
 import { toBeRequestedTimes } from './toBeRequestedTimes.js';
-export function toBeRequested(received, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export function toBeRequested(received, options = DEFAULT_OPTIONS) {
     return toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { gte: 1 }, options);
 }

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,6 +1,7 @@
 import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
 import { numberError } from '../../util/formatMessage.js';
-export async function toBeRequestedTimes(received, expectedValue = {}, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeRequestedTimes(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot || false;
     const { expectation = `called${typeof expectedValue === 'number' ? ' ' + expectedValue : ''} time${expectedValue !== 1 ? 's' : ''}`, verb = 'be' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,8 +1,9 @@
 import { waitUntil, enhanceError } from '../../utils.js';
 import { equals } from '../../jasmineUtils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 const STR_LIMIT = 80;
 const KEY_LIMIT = 12;
-export async function toBeRequestedWith(received, expectedValue = {}, options = {}) {
+export async function toBeRequestedWith(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot || false;
     const { expectation = 'called with', verb = 'be' } = this;
     await options.beforeAssertion?.({

package/lib/matchers.js

@@ -16,6 +16,7 @@ import * as toHaveClass from './matchers/element/toHaveClass.js';
 import * as toHaveHref from './matchers/element/toHaveHref.js';
 import * as toHaveId from './matchers/element/toHaveId.js';
 import * as toHaveSize from './matchers/element/toHaveSize.js';
+import * as toMatchElementSnapshot from './matchers/element/toMatchElementSnapshot.js';
 import * as toHaveElementProperty from './matchers/element/toHaveElementProperty.js';
 import * as toHaveText from './matchers/element/toHaveText.js';
 import * as toHaveValue from './matchers/element/toHaveValue.js';
@@ -23,7 +24,9 @@ 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';
+import * as toMatchSnapshot from './matchers/general/toMatchSnapshot.js';
 const matchers = {
+    ...toMatchSnapshot,
     ...toHaveClipboardText,
     ...toHaveTitle,
     ...toHaveUrl,
@@ -46,6 +49,7 @@ const matchers = {
     ...toHaveText,
     ...toHaveValue,
     ...toHaveStyle,
+    ...toMatchElementSnapshot,
     ...toBeRequested,
     ...toBeRequestedTimes,
     ...toBeRequestedWith,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.6.0",
+  "version": "4.7.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -77,7 +77,7 @@
     "shelljs": "^0.8.5",
     "typescript": "^5.2.2",
     "vitest": "0.34.6",
-    "webdriverio": "8.23.1"
+    "webdriverio": "8.24.6"
   },
   "optionalDependencies": {
     "@wdio/globals": "^8.23.1",
@@ -85,7 +85,8 @@
     "webdriverio": "^8.23.1"
   },
   "dependencies": {
-    "expect": "^29.7.0",
+    "jest-snapshot": "^29.7.0",
+    "@jest/expect": "^29.7.0",
     "jest-matcher-utils": "^29.7.0",
     "lodash.isequal": "^4.5.0"
   }

package/types/expect-webdriverio.d.ts

@@ -1,7 +1,5 @@
 declare namespace ExpectWebdriverIO {
-    function expect<T = unknown, R extends void | Promise<void> = void | Promise<void>>(
-        actual: T
-    ): Matchers<R, T>
+    const expect: ExpectWebdriverIO.Expect
     function setOptions(options: DefaultOptions): void
     function getConfig(): any
 
@@ -145,6 +143,29 @@ declare namespace ExpectWebdriverIO {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     interface Matchers<R, T> {
         // ===== $ or $$ =====
+        /**
+          * This ensures that element html value matches the most recent snapshot with property matchers.
+          */
+        toMatchElementSnapshot(hint?: string): R;
+        /**
+         * This ensures that element html matches the most recent snapshot.
+         */
+        toMatchElementSnapshot<U extends Record<keyof T, unknown>>(
+            propertyMatchers: Partial<U>,
+            hint?: string,
+        ): R;
+        /**
+         * This ensures that element html matches the most recent snapshot with property matchers.
+         */
+        toMatchElementInlineSnapshot(snapshot?: string): R;
+        /**
+         * This ensures that element html matches the most recent snapshot with property matchers.
+         */
+        toMatchElementInlineSnapshot<U extends Record<keyof T, unknown>>(
+            propertyMatchers: Partial<U>,
+            snapshot?: string,
+        ): R;
+
         /**
          * `WebdriverIO.Element` -> `isDisplayed`
          */
@@ -487,23 +508,23 @@ declare namespace ExpectWebdriverIO {
         method?: string | Array<string>
         statusCode?: number | Array<number>
         requestHeaders?:
-            | Record<string, string>
-            | ExpectWebdriverIO.PartialMatcher
-            | ((headers: Record<string, string>) => boolean)
+        | Record<string, string>
+        | ExpectWebdriverIO.PartialMatcher
+        | ((headers: Record<string, string>) => boolean)
         responseHeaders?:
-            | Record<string, string>
-            | ExpectWebdriverIO.PartialMatcher
-            | ((headers: Record<string, string>) => boolean)
+        | Record<string, string>
+        | ExpectWebdriverIO.PartialMatcher
+        | ((headers: Record<string, string>) => boolean)
         postData?:
-            | string
-            | ExpectWebdriverIO.JsonCompatible
-            | ExpectWebdriverIO.PartialMatcher
-            | ((r: string | undefined) => boolean)
+        | string
+        | ExpectWebdriverIO.JsonCompatible
+        | ExpectWebdriverIO.PartialMatcher
+        | ((r: string | undefined) => boolean)
         response?:
-            | string
-            | ExpectWebdriverIO.JsonCompatible
-            | ExpectWebdriverIO.PartialMatcher
-            | ((r: string) => boolean)
+        | string
+        | ExpectWebdriverIO.JsonCompatible
+        | ExpectWebdriverIO.PartialMatcher
+        | ((r: string) => boolean)
     }
 
     type jsonPrimitive = string | number | boolean | null

package/types/jest-global.d.ts

@@ -1,7 +1,5 @@
 /// <reference types="./standalone.js"/>
 
-declare const expect: ExpectWebdriverIO.Expect
-
 declare namespace NodeJS {
     interface Global {
         expect: ExpectWebdriverIO.Expect;

package/types/standalone.d.ts

@@ -4,13 +4,13 @@ type ChainablePromiseElement = import('webdriverio').ChainablePromiseElement<Web
 type ChainablePromiseArray = import('webdriverio').ChainablePromiseArray<WebdriverIO.Element>
 
 declare namespace ExpectWebdriverIO {
-    interface Matchers<R extends void | Promise<void>, T> extends Readonly<import('expect').Matchers<R>> {
+    interface Matchers<R extends void | Promise<void>, T> extends Readonly<import('expect').Matchers<R, T>>, Readonly<import('jest-snapshot').SnapshotMatchers<R, T>> {
         not: Matchers<R, T>
         resolves: Matchers<R, T>
         rejects: Matchers<R, T>
     }
 
-    type Expect = {
+    type Expect = Readonly<import('@jest/expect').JestExpect> & {
         <T = unknown, R extends void | Promise<void> = void | Promise<void>>(actual: T): Matchers<R, T>
         extend(map: Record<string, Function>): void
     } & AsymmetricMatchers