expect-webdriverio 5.6.0 → 5.6.2

package/lib/{matchers → src/matchers}/browser/toHaveClipboardText.js

@@ -3,7 +3,6 @@ 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 = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'clipboard text', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveClipboardText',
@@ -16,7 +15,7 @@ export async function toHaveClipboardText(browser, expectedValue, options = DEFA
             .catch((err) => log.warn(`Couldn't set clipboard permissions: ${err}`));
         actual = await browser.execute(() => window.navigator.clipboard.readText());
         return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
+    }, options);
     const message = enhanceError('browser', expectedValue, actual, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/browser/toHaveTitle.js

@@ -1,7 +1,6 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
 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?.({
         matcherName: 'toHaveTitle',
@@ -12,7 +11,7 @@ export async function toHaveTitle(browser, expectedValue, options = DEFAULT_OPTI
     const pass = await waitUntil(async () => {
         actual = await browser.getTitle();
         return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
+    }, options);
     const message = enhanceError('window', expectedValue, actual, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/browser/toHaveUrl.js

@@ -1,7 +1,6 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
 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?.({
         matcherName: 'toHaveUrl',
@@ -12,7 +11,7 @@ export async function toHaveUrl(browser, expectedValue, options = DEFAULT_OPTION
     const pass = await waitUntil(async () => {
         actual = await browser.getUrl();
         return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
+    }, options);
     const message = enhanceError('window', expectedValue, actual, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/src/matchers/element/toBeDisplayed.js

@@ -0,0 +1,29 @@
+import { executeCommandBe } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
+const DEFAULT_OPTIONS_DISPLAYED = {
+    ...DEFAULT_OPTIONS,
+    withinViewport: false,
+    contentVisibilityAuto: true,
+    opacityProperty: true,
+    visibilityProperty: true
+};
+export async function toBeDisplayed(received, options = DEFAULT_OPTIONS_DISPLAYED) {
+    this.expectation = this.expectation || 'displayed';
+    await options.beforeAssertion?.({
+        matcherName: 'toBeDisplayed',
+        options,
+    });
+    const { withinViewport, contentVisibilityAuto, opacityProperty, visibilityProperty, ...commandOptions } = { ...DEFAULT_OPTIONS_DISPLAYED, ...options };
+    const result = await executeCommandBe.call(this, received, el => el?.isDisplayed({
+        withinViewport,
+        contentVisibilityAuto,
+        opacityProperty,
+        visibilityProperty
+    }), commandOptions);
+    await options.afterAssertion?.({
+        matcherName: 'toBeDisplayed',
+        options,
+        result
+    });
+    return result;
+}

package/lib/{matchers → src/matchers}/element/toHaveAttribute.js

@@ -15,7 +15,6 @@ async function conditionAttrAndValue(el, attribute, value, options) {
     return compareText(attr, 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?.getElement();
     let attr;
@@ -24,7 +23,7 @@ export async function toHaveAttributeAndValue(received, attribute, value, option
         el = result.el;
         attr = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const expected = wrapExpectedWithArray(el, attr, value);
     const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
     return {
@@ -32,16 +31,15 @@ export async function toHaveAttributeAndValue(received, attribute, value, option
         message: () => message
     };
 }
-async function toHaveAttributeFn(received, attribute) {
-    const isNot = this.isNot;
-    const { expectation = 'attribute', verb = 'have' } = this;
+async function toHaveAttributeFn(received, attribute, options) {
+    const { expectation = 'attribute', verb = 'have', isNot } = this;
     let el = await received?.getElement();
     const pass = await waitUntil(async () => {
         const result = await executeCommand.call(this, el, conditionAttr, {}, [attribute]);
         el = result.el;
         return result.success;
-    }, isNot, {});
-    const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
+    }, options);
+    const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, options);
     return {
         pass,
         message: () => message
@@ -55,7 +53,7 @@ export async function toHaveAttribute(received, attribute, value, options = DEFA
     });
     const result = value !== undefined
         ? await toHaveAttributeAndValue.call(this, received, attribute, value, options)
-        : await toHaveAttributeFn.call(this, received, attribute);
+        : await toHaveAttributeFn.call(this, received, attribute, options);
     await options.afterAssertion?.({
         matcherName: 'toHaveAttribute',
         expectedValue: [attribute, value],

package/lib/{matchers → src/matchers}/element/toHaveChildren.js

@@ -16,7 +16,6 @@ async function condition(el, options) {
     };
 }
 export async function toHaveChildren(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'children', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveChildren',
@@ -33,7 +32,7 @@ export async function toHaveChildren(received, expectedValue, options = DEFAULT_
         el = result.el;
         children = result.values;
         return result.success;
-    }, isNot, { ...numberOptions, ...options });
+    }, { ...numberOptions, ...options });
     const error = numberError(numberOptions);
     const expectedArray = wrapExpectedWithArray(el, children, error);
     const message = enhanceError(el, expectedArray, children, this, verb, expectation, '', numberOptions);

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

@@ -24,7 +24,6 @@ export function toHaveClass(...args) {
     return toHaveElementClass.call(this || {}, ...args);
 }
 export async function toHaveElementClass(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'class', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveElementClass',
@@ -39,7 +38,7 @@ export async function toHaveElementClass(received, expectedValue, options = DEFA
         el = result.el;
         attr = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, attr, expectedValue), attr, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveComputedLabel.js

@@ -8,7 +8,6 @@ async function condition(el, label, options) {
     return compareText(actualLabel, label, options);
 }
 export async function toHaveComputedLabel(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'computed label', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveComputedLabel',
@@ -22,7 +21,7 @@ export async function toHaveComputedLabel(received, expectedValue, options = DEF
         el = result.el;
         actualLabel = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveComputedRole.js

@@ -8,7 +8,6 @@ async function condition(el, role, options) {
     return compareText(actualRole, role, options);
 }
 export async function toHaveComputedRole(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'computed role', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveComputedRole',
@@ -22,7 +21,7 @@ export async function toHaveComputedRole(received, expectedValue, options = DEFA
         el = result.el;
         actualRole = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveElementProperty.js

@@ -16,8 +16,7 @@ async function condition(el, property, value, options = DEFAULT_OPTIONS) {
     return compareText(prop, value, options);
 }
 export async function toHaveElementProperty(received, property, value, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'property', verb = 'have' } = this;
+    const { expectation = 'property', verb = 'have', isNot } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveElementProperty',
         expectedValue: [property, value],
@@ -30,7 +29,7 @@ export async function toHaveElementProperty(received, property, value, options =
         el = result.el;
         prop = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     let message;
     if (value === undefined) {
         message = enhanceError(el, !isNot, pass, this, verb, expectation, property, options);

package/lib/{matchers → src/matchers}/element/toHaveHTML.js

@@ -8,7 +8,6 @@ async function condition(el, html, options) {
     return compareText(actualHTML, html, options);
 }
 export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'HTML', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveHTML',
@@ -26,7 +25,7 @@ export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTI
         el = result.el;
         actualHTML = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, expectedValue), actualHTML, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveHeight.js

@@ -8,7 +8,6 @@ async function condition(el, height, options) {
     };
 }
 export async function toHaveHeight(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'height', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveHeight',
@@ -32,7 +31,7 @@ export async function toHaveHeight(received, expectedValue, options = DEFAULT_OP
         el = result.el;
         actualHeight = result.values;
         return result.success;
-    }, isNot, { ...numberOptions, ...options });
+    }, { ...numberOptions, ...options });
     const error = numberError(numberOptions);
     const message = enhanceError(el, error, actualHeight, this, verb, expectation, '', options);
     const result = {

package/lib/{matchers → src/matchers}/element/toHaveSize.js

@@ -5,7 +5,6 @@ async function condition(el, size) {
     return compareObject(actualSize, size);
 }
 export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'size', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveSize',
@@ -19,7 +18,7 @@ export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTI
         el = result.el;
         actualSize = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveStyle.js

@@ -4,7 +4,6 @@ async function condition(el, style, options) {
     return compareStyle(el, style, options);
 }
 export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'style', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveStyle',
@@ -18,7 +17,7 @@ export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPT
         el = result.el;
         actualStyle = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualStyle, expectedValue), actualStyle, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveText.js

@@ -28,7 +28,6 @@ async function condition(el, text, options) {
     };
 }
 export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'text', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveText',
@@ -46,7 +45,7 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
         el = result.el;
         actualText = result.values;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualText, expectedValue), actualText, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/element/toHaveWidth.js

@@ -8,7 +8,6 @@ async function condition(el, width, options) {
     };
 }
 export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
     const { expectation = 'width', verb = 'have' } = this;
     await options.beforeAssertion?.({
         matcherName: 'toHaveWidth',
@@ -32,7 +31,7 @@ export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPT
         el = result.el;
         actualWidth = result.values;
         return result.success;
-    }, isNot, { ...numberOptions, ...options });
+    }, { ...numberOptions, ...options });
     const error = numberError(numberOptions);
     const message = enhanceError(el, error, actualWidth, this, verb, expectation, '', options);
     const result = {

package/lib/{matchers → src/matchers}/elements/toBeElementsArrayOfSize.js

@@ -2,7 +2,6 @@ import { waitUntil, enhanceError, compareNumbers, numberError } from '../../util
 import { refetchElements } from '../../util/refetchElements.js';
 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?.({
         matcherName: 'toBeElementsArrayOfSize',
@@ -28,7 +27,7 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
         }
         elements = await refetchElements(elements, numberOptions.wait, true);
         return false;
-    }, isNot, { ...numberOptions, ...options });
+    }, { ...numberOptions, ...options });
     if (Array.isArray(received) && pass) {
         for (let index = originalLength; index < elements.length; index++) {
             received.push(elements[index]);

package/lib/{matchers → src/matchers}/mock/toBeRequestedTimes.js

@@ -2,7 +2,6 @@ import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
 import { numberError } from '../../util/formatMessage.js';
 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?.({
         matcherName: 'toBeRequestedTimes',
@@ -16,7 +15,7 @@ export async function toBeRequestedTimes(received, expectedValue = {}, options =
     const pass = await waitUntil(async () => {
         actual = received.calls.length;
         return compareNumbers(actual, numberOptions);
-    }, isNot, { ...numberOptions, ...options });
+    }, { ...numberOptions, ...options });
     const error = numberError(numberOptions);
     const message = enhanceError('mock', error, actual, this, verb, expectation, '', numberOptions);
     const result = {

package/lib/{matchers → src/matchers}/mock/toBeRequestedWith.js

@@ -10,8 +10,7 @@ function reduceHeaders(headers) {
     }, {});
 }
 export async function toBeRequestedWith(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot || false;
-    const { expectation = 'called with', verb = 'be' } = this;
+    const { expectation = 'called with', verb = 'be', isNot } = this;
     await options.beforeAssertion?.({
         matcherName: 'toBeRequestedWith',
         expectedValue,
@@ -30,7 +29,7 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
             }
         }
         return false;
-    }, isNot, { ...options, wait: isNot ? 0 : options.wait });
+    }, { ...options, wait: isNot ? 0 : options.wait });
     const message = enhanceError('mock', minifyRequestedWith(expectedValue), minifyRequestMock(actual, expectedValue) || 'was not called', this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/{matchers → src/matchers}/snapshot.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { expect } from 'expect';
 import { stripSnapshotIndentation } from '@vitest/snapshot';
-import { SnapshotService } from '../snapshot';
+import { SnapshotService } from '../snapshot.js';
 function returnSnapshotError(snapshotError) {
     try {
         expect(snapshotError.actual).toBe(snapshotError.expected);

package/lib/{softAssert.js → src/softAssert.js}

@@ -1,5 +1,6 @@
 export class SoftAssertService {
     static instance;
+    static GLOBAL_TEST_ID = '__global_soft_assert_context__';
     failureMap = new Map();
     currentTest = null;
     constructor() { }
@@ -22,9 +23,9 @@ export class SoftAssertService {
         return this.currentTest?.id || null;
     }
     addFailure(error, matcherName) {
-        const testId = this.getCurrentTestId();
-        if (!testId) {
-            throw error;
+        const testId = this.getCurrentTestId() || SoftAssertService.GLOBAL_TEST_ID;
+        if (!this.failureMap.has(testId)) {
+            this.failureMap.set(testId, []);
         }
         const stackLines = error.stack?.split('\n') || [];
         let location = '';
@@ -34,28 +35,18 @@ export class SoftAssertService {
                 break;
             }
         }
-        const failures = this.failureMap.get(testId) || [];
-        failures.push({ error, matcherName, location });
-        this.failureMap.set(testId, failures);
+        this.failureMap.get(testId).push({ error, matcherName, location });
     }
     getFailures(testId) {
-        const id = testId || this.getCurrentTestId();
-        if (!id) {
-            return [];
-        }
+        const id = testId || this.getCurrentTestId() || SoftAssertService.GLOBAL_TEST_ID;
         return this.failureMap.get(id) || [];
     }
     clearFailures(testId) {
-        const id = testId || this.getCurrentTestId();
-        if (id) {
-            this.failureMap.delete(id);
-        }
+        const id = testId || this.getCurrentTestId() || SoftAssertService.GLOBAL_TEST_ID;
+        this.failureMap.delete(id);
     }
     assertNoFailures(testId) {
-        const id = testId || this.getCurrentTestId();
-        if (!id) {
-            return;
-        }
+        const id = testId || this.getCurrentTestId() || SoftAssertService.GLOBAL_TEST_ID;
         const failures = this.getFailures(id);
         if (failures.length === 0) {
             return;

package/lib/{util → src/util}/elementsUtil.js

@@ -4,3 +4,6 @@ export const wrapExpectedWithArray = (el, actual, expected) => {
     }
     return expected;
 };
+export const isElementArray = (obj) => {
+    return obj !== null && typeof obj === 'object' && 'selector' in obj && 'foundWith' in obj && 'parent' in obj;
+};

package/lib/{util → src/util}/formatMessage.js

@@ -1,5 +1,6 @@
 import { printDiffOrStringify, printExpected, printReceived } from 'jest-matcher-utils';
 import { equals } from '../jasmineUtils.js';
+import { isElementArray } from './elementsUtil.js';
 const EXPECTED_LABEL = 'Expected';
 const RECEIVED_LABEL = 'Received';
 const NOT_SUFFIX = ' [not]';
@@ -14,11 +15,11 @@ export const getSelector = (el) => {
 export const getSelectors = (el) => {
     const selectors = [];
     let parent;
-    if (Array.isArray(el)) {
-        selectors.push(`${el.foundWith}(\`${getSelector(el)}\`)`);
+    if (isElementArray(el)) {
+        selectors.push(`${(el).foundWith}(\`${getSelector(el)}\`)`);
         parent = el.parent;
     }
-    else {
+    else if (!Array.isArray(el)) {
         parent = el;
     }
     while (parent && 'selector' in parent) {

package/lib/src/util/refetchElements.js

@@ -0,0 +1,9 @@
+import { DEFAULT_OPTIONS } from '../constants.js';
+import { isElementArray } from './elementsUtil.js';
+export const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
+    if (elements && wait > 0 && (elements.length === 0 || full) && isElementArray(elements) && elements.parent && elements.foundWith && elements.foundWith in elements.parent) {
+        const fetchFunction = elements.parent[elements.foundWith];
+        elements = await fetchFunction(elements.selector, ...elements.props);
+    }
+    return elements;
+};

package/lib/{utils.js → src/utils.js}

@@ -19,50 +19,38 @@ export function isAsymmetricMatcher(expected) {
 function isStringContainingMatcher(expected) {
     return isAsymmetricMatcher(expected) && ['StringContaining', 'StringNotContaining'].includes(expected.toString());
 }
-const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
-    if (wait === 0) {
-        return await condition();
-    }
+const waitUntil = async (condition, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
+    const start = Date.now();
     let error;
-    try {
-        const start = Date.now();
-        while (true) {
-            if (Date.now() - start > wait) {
-                throw new Error('timeout');
-            }
-            try {
-                const result = isNot !== (await condition());
-                error = undefined;
-                if (result) {
-                    break;
-                }
-                await sleep(interval);
-            }
-            catch (err) {
-                error = err;
-                await sleep(interval);
+    let result = false;
+    do {
+        try {
+            result = await condition();
+            error = undefined;
+            if (result) {
+                break;
             }
         }
-        if (error) {
-            throw error;
+        catch (err) {
+            error = err;
         }
-        return !isNot;
-    }
-    catch {
-        if (error) {
-            throw error;
+        if (Date.now() - start < wait) {
+            await sleep(interval);
         }
-        return isNot;
+    } while (Date.now() - start < wait);
+    if (error) {
+        throw error;
     }
+    return result;
 };
 async function executeCommandBe(received, command, options) {
-    const { isNot, expectation, verb = 'be' } = this;
+    const { expectation, verb = 'be' } = this;
     let el = await received?.getElement();
     const pass = await waitUntil(async () => {
         const result = await executeCommand.call(this, el, async (element) => ({ result: await command(element) }), options);
         el = result.el;
         return result.success;
-    }, isNot, options);
+    }, options);
     const message = enhanceErrorBe(el, pass, this, verb, expectation, options);
     return {
         pass,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "5.6.0",
+  "version": "5.6.2",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -63,6 +63,7 @@
     "ts:mocha": "cd test-types/mocha && tsc --project ./tsconfig.json",
     "ts:jasmine": "cd test-types/jasmine && tsc --project ./tsconfig.json",
     "ts:jasmine-async": "cd test-types/jasmine-async && tsc --project ./tsconfig.json",
+    "checks:all": "npm run build && npm run compile && npm run tsc:root-types && npm run test && npm run ts",
     "watch": "npm run compile -- --watch",
     "prepare": "husky install"
   },

package/types/expect-webdriverio.d.ts

@@ -54,7 +54,7 @@ type WdioOnlyMaybePromiseLike = ElementPromise | ElementArrayPromise | Chainable
  */
 type ElementOrArrayLike = ElementLike | ElementArrayLike
 type ElementLike = WebdriverIO.Element | ChainablePromiseElement
-type ElementArrayLike = WebdriverIO.ElementArray | ChainablePromiseArray
+type ElementArrayLike = WebdriverIO.ElementArray | ChainablePromiseArray | WebdriverIO.Element[]
 type MockPromise = Promise<WebdriverIO.Mock>
 
 /**
@@ -122,7 +122,7 @@ interface WdioElementOrArrayMatchers<_R, ActualT = unknown> {
     /**
      * `WebdriverIO.Element` -> `isDisplayed`
      */
-    toBeDisplayed: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+    toBeDisplayed: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.ToBeDisplayedOptions) => Promise<void>>
 
     /**
      * `WebdriverIO.Element` -> `isExisting`
@@ -188,11 +188,14 @@ interface WdioElementOrArrayMatchers<_R, ActualT = unknown> {
     /**
      * `WebdriverIO.Element` -> `getProperty`
      */
-    toHaveElementProperty: FnWhenElementOrArrayLike<ActualT, (
-        property: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
-        value?: unknown,
-        options?: ExpectWebdriverIO.StringOptions
-    ) => Promise<void>>
+    toHaveElementProperty: FnWhenElementOrArrayLike<
+        ActualT,
+        (
+            property: string,
+            value?: string | RegExp | WdioAsymmetricMatcher<string> | null,
+            options?: ExpectWebdriverIO.StringOptions,
+        ) => Promise<void>
+    >
 
     /**
      * `WebdriverIO.Element` -> `getProperty` value
@@ -702,6 +705,32 @@ declare namespace ExpectWebdriverIO {
         gte?: number
     }
 
+    interface ToBeDisplayedOptions extends CommandOptions {
+        /**
+         * `true` to check if the element is within the viewport. false by default.
+         */
+        withinViewport?: boolean
+
+        /**
+         * `true` to check if the element content-visibility property has (or inherits) the value auto,
+         * and it is currently skipping its rendering. `true` by default.
+         * @default true
+         */
+        contentVisibilityAuto?: boolean
+
+        /**
+         * `true` to check if the element opacity property has (or inherits) a value of 0. `true` by default.
+         * @default true
+         */
+        opacityProperty?: boolean
+
+        /**
+         * `true` to check if the element is invisible due to the value of its visibility property. `true` by default.
+         * @default true
+         */
+        visibilityProperty?: boolean
+    }
+
     type RequestedWith = {
         url?: string | ExpectWebdriverIO.PartialMatcher<string>| ((url: string) => boolean)
         method?: string | Array<string>

package/lib/matchers/element/toBeDisplayed.js

@@ -1,16 +0,0 @@
-import { executeCommandBe } from '../../utils.js';
-import { DEFAULT_OPTIONS } from '../../constants.js';
-export async function toBeDisplayed(received, { withinViewport = false, contentVisibilityAuto = true, opacityProperty = true, visibilityProperty = true } = {}, options = DEFAULT_OPTIONS) {
-    this.expectation = this.expectation || 'displayed';
-    await options.beforeAssertion?.({
-        matcherName: 'toBeDisplayed',
-        options,
-    });
-    const result = await executeCommandBe.call(this, received, el => el?.isDisplayed({ withinViewport, contentVisibilityAuto, opacityProperty, visibilityProperty }), options);
-    await options.afterAssertion?.({
-        matcherName: 'toBeDisplayed',
-        options,
-        result
-    });
-    return result;
-}

package/lib/util/refetchElements.js

@@ -1,9 +0,0 @@
-import { DEFAULT_OPTIONS } from '../constants.js';
-export const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
-    if (elements) {
-        if (wait > 0 && (elements.length === 0 || full)) {
-            elements = await elements.parent[elements.foundWith](elements.selector, ...elements.props);
-        }
-    }
-    return elements;
-};