@testspectra/matchers 1.1.10 → 1.1.11-rc.3

package/dist/matchers.js

@@ -5,31 +5,16 @@
  * @param target - Selector string or element instance.
  * @returns Resolved WebdriverIO.Element instance.
  */
-/**
- * Resolves an ElementTarget (selector string, WebdriverIO.Element, Playwright Locator, or ChainablePromiseElement)
- * to an actionable element instance.
- *
- * @param target - Selector string or element instance.
- * @returns Resolved element or locator instance.
- */
 export async function resolveElement(target) {
     if (typeof target === 'string') {
-        if (typeof globalThis.$ === 'function') {
-            const el = await globalThis.$(target);
-            return el;
-        }
-        const b = globalThis.browser;
-        if (b && typeof b.$ === 'function') {
-            const el = await b.$(target);
-            return el;
-        }
-        throw new Error(`Cannot resolve selector "${target}": No global '$' or browser context available.`);
+        const el = await $(target);
+        return el;
     }
     const el = await target;
     return el;
 }
 /**
- * Executes a single element matcher against the active runner context (Playwright or WebdriverIO).
+ * Executes a single element matcher against the WebdriverIO browser / element context.
  *
  * @param target - Optional element target (not required for browser-level assertions).
  * @param matcher - Single element matcher string.
@@ -37,531 +22,151 @@ export async function resolveElement(target) {
  */
 export async function executeSingleMatcher(target, matcher, args) {
     const isBrowserLevel = matcher === 'have.url' || matcher === 'contain.url' || matcher === 'have.title' || matcher === 'contain.title';
-    const b = typeof browser !== 'undefined' ? browser : globalThis.browser;
     if (isBrowserLevel) {
         const expected = args[0];
-        const exp = typeof expect !== 'undefined' ? expect : globalThis.expect;
-        if (exp && typeof exp(b)?.toHaveUrl === 'function') {
-            switch (matcher) {
-                case 'have.url':
-                    await exp(b).toHaveUrl(expected);
-                    break;
-                case 'contain.url':
-                    await exp(b).toHaveUrl(exp.stringContaining
-                        ? exp.stringContaining(expected)
-                        : new RegExp(String(expected).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                    break;
-                case 'have.title':
-                    await exp(b).toHaveTitle(expected);
-                    break;
-                case 'contain.title':
-                    await exp(b).toHaveTitle(exp.stringContaining
-                        ? exp.stringContaining(expected)
-                        : new RegExp(String(expected).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                    break;
-            }
-        }
-        else {
-            // Direct polling fallback (works with Playwright Page or generic browser)
-            const currentUrl = b?.getUrl
-                ? await b.getUrl()
-                : b?.url
-                    ? typeof b.url === 'function'
-                        ? await b.url()
-                        : b.url
-                    : '';
-            const currentTitle = b?.getTitle
-                ? await b.getTitle()
-                : b?.title
-                    ? typeof b.title === 'function'
-                        ? await b.title()
-                        : b.title
-                    : '';
-            if (matcher === 'have.url' && currentUrl !== expected) {
-                throw new Error(`Expected URL to be "${expected}", but got "${currentUrl}"`);
-            }
-            if (matcher === 'contain.url' && !currentUrl.includes(expected)) {
-                throw new Error(`Expected URL to contain "${expected}", but got "${currentUrl}"`);
-            }
-            if (matcher === 'have.title' && currentTitle !== expected) {
-                throw new Error(`Expected title to be "${expected}", but got "${currentTitle}"`);
-            }
-            if (matcher === 'contain.title' && !currentTitle.includes(expected)) {
-                throw new Error(`Expected title to contain "${expected}", but got "${currentTitle}"`);
-            }
-        }
-        return;
-    }
-    if (!target) {
-        throw new Error(`Assertion matcher '${matcher}' requires an element target.`);
-    }
-    const el = await resolveElement(target);
-    const exp = typeof expect !== 'undefined' ? expect : globalThis.expect;
-    // Branch 1: WebdriverIO expect-webdriverio
-    if (exp && typeof exp(el)?.toBeDisplayed === 'function') {
         switch (matcher) {
-            case 'be.visible':
-                await exp(el).toBeDisplayed();
-                break;
-            case 'not.be.visible':
-                await exp(el).not.toBeDisplayed();
-                break;
-            case 'exist':
-                await exp(el).toExist();
-                break;
-            case 'not.exist':
-                await exp(el).not.toExist();
-                break;
-            case 'be.clickable':
-                await exp(el).toBeClickable();
-                break;
-            case 'not.be.clickable':
-                await exp(el).not.toBeClickable();
-                break;
-            case 'be.enabled':
-                await exp(el).toBeEnabled();
-                break;
-            case 'be.disabled':
-                await exp(el).toBeDisabled();
-                break;
-            case 'be.checked':
-            case 'be.selected':
-                await exp(el).toBeSelected();
-                break;
-            case 'not.be.checked':
-            case 'not.be.selected':
-                await exp(el).not.toBeSelected();
-                break;
-            case 'be.focused':
-                await exp(el).toBeFocused();
-                break;
-            case 'not.be.focused':
-                await exp(el).not.toBeFocused();
-                break;
-            case 'have.value':
-                await exp(el).toHaveValue(args[0]);
-                break;
-            case 'not.have.value':
-                await exp(el).not.toHaveValue(args[0]);
-                break;
-            case 'contain.value':
-                await exp(el).toHaveValue(exp.stringContaining
-                    ? exp.stringContaining(args[0])
-                    : new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                break;
-            case 'not.contain.value':
-                await exp(el).not.toHaveValue(exp.stringContaining
-                    ? exp.stringContaining(args[0])
-                    : new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                break;
-            case 'have.text':
-                await exp(el).toHaveText(args[0]);
-                break;
-            case 'not.have.text':
-                await exp(el).not.toHaveText(args[0]);
-                break;
-            case 'contain.text':
-                await exp(el).toHaveText(exp.stringContaining
-                    ? exp.stringContaining(args[0])
-                    : new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                break;
-            case 'not.contain.text':
-                await exp(el).not.toHaveText(exp.stringContaining
-                    ? exp.stringContaining(args[0])
-                    : new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                break;
-            case 'have.class':
-                await exp(el).toHaveElementClass(args[0]);
-                break;
-            case 'not.have.class':
-                await exp(el).not.toHaveElementClass(args[0]);
-                break;
-            case 'have.attr':
-                if (args.length >= 2)
-                    await exp(el).toHaveAttribute(args[0], args[1]);
-                else
-                    await exp(el).toHaveAttribute(args[0]);
+            case 'have.url':
+                await expect(browser).toHaveUrl(expected);
                 break;
-            case 'not.have.attr':
-                await exp(el).not.toHaveAttribute(args[0]);
+            case 'contain.url':
+                await expect(browser).toHaveUrl(expect.stringContaining(expected));
                 break;
-            case 'have.css':
-                await exp(el).toHaveStyle({ [args[0]]: args[1] });
+            case 'have.title':
+                await expect(browser).toHaveTitle(expected);
                 break;
-            case 'not.have.css':
-                await exp(el).not.toHaveStyle({ [args[0]]: args[1] });
+            case 'contain.title':
+                await expect(browser).toHaveTitle(expect.stringContaining(expected));
                 break;
-            default:
-                throw new Error(`Unsupported matcher: ${matcher}`);
         }
         return;
     }
-    // Branch 2: Playwright expect(locator)
-    if (exp && typeof exp(el)?.toBeVisible === 'function') {
-        switch (matcher) {
-            case 'be.visible':
-                await exp(el).toBeVisible();
-                break;
-            case 'not.be.visible':
-                await exp(el).not.toBeVisible();
-                break;
-            case 'exist':
-                await exp(el).toBeAttached();
-                break;
-            case 'not.exist':
-                await exp(el).not.toBeAttached();
-                break;
-            case 'be.clickable':
-            case 'be.enabled':
-                await exp(el).toBeEnabled();
-                break;
-            case 'not.be.clickable':
-            case 'be.disabled':
-                await exp(el).toBeDisabled();
-                break;
-            case 'be.checked':
-            case 'be.selected':
-                await exp(el).toBeChecked();
-                break;
-            case 'not.be.checked':
-            case 'not.be.selected':
-                await exp(el).not.toBeChecked();
-                break;
-            case 'be.focused':
-                await exp(el).toBeFocused();
-                break;
-            case 'not.be.focused':
-                await exp(el).not.toBeFocused();
-                break;
-            case 'have.value':
-                await exp(el).toHaveValue(args[0]);
-                break;
-            case 'not.have.value':
-                await exp(el).not.toHaveValue(args[0]);
-                break;
-            case 'contain.value':
-                await exp(el).toHaveValue(new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                break;
-            case 'not.contain.value':
-                await exp(el).not.toHaveValue(new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-                break;
-            case 'have.text':
-                await exp(el).toHaveText(args[0]);
-                break;
-            case 'not.have.text':
-                await exp(el).not.toHaveText(args[0]);
-                break;
-            case 'contain.text':
-                await exp(el).toContainText(args[0]);
-                break;
-            case 'not.contain.text':
-                await exp(el).not.toContainText(args[0]);
-                break;
-            case 'have.class':
-                await exp(el).toHaveClass(new RegExp(`(^|\\s)${String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\s|$)`));
-                break;
-            case 'not.have.class':
-                await exp(el).not.toHaveClass(new RegExp(`(^|\\s)${String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\s|$)`));
-                break;
-            case 'have.attr':
-                if (args.length >= 2)
-                    await exp(el).toHaveAttribute(args[0], args[1]);
-                else
-                    await exp(el).toHaveAttribute(args[0], /.*/);
-                break;
-            case 'not.have.attr':
-                await exp(el).not.toHaveAttribute(args[0], /.*/);
-                break;
-            case 'have.css':
-                await exp(el).toHaveCSS(args[0], args[1]);
-                break;
-            case 'not.have.css':
-                await exp(el).not.toHaveCSS(args[0], args[1]);
-                break;
-            default:
-                throw new Error(`Unsupported matcher: ${matcher}`);
-        }
-        return;
+    if (!target) {
+        throw new Error(`Assertion matcher '${matcher}' requires an element target.`);
     }
-    // Branch 3: Universal fallback evaluation with auto-waiting polling
-    const passed = await pollUntil(async () => {
-        const currentEl = typeof target === 'string' ? await resolveElement(target) : el;
-        switch (matcher) {
-            case 'be.visible': {
-                return typeof currentEl.isDisplayed === 'function'
-                    ? await currentEl.isDisplayed()
-                    : typeof currentEl.isVisible === 'function'
-                        ? await currentEl.isVisible()
-                        : true;
-            }
-            case 'not.be.visible': {
-                const v = typeof currentEl.isDisplayed === 'function'
-                    ? await currentEl.isDisplayed()
-                    : typeof currentEl.isVisible === 'function'
-                        ? await currentEl.isVisible()
-                        : false;
-                return !v;
-            }
-            case 'exist': {
-                if (typeof currentEl.isExisting === 'function')
-                    return await currentEl.isExisting();
-                if (typeof currentEl.count === 'function')
-                    return (await currentEl.count()) > 0;
-                if (currentEl.locator?.count)
-                    return (await currentEl.locator.count()) > 0;
-                return true;
-            }
-            case 'not.exist': {
-                if (typeof currentEl.isExisting === 'function')
-                    return !(await currentEl.isExisting());
-                if (typeof currentEl.count === 'function')
-                    return (await currentEl.count()) === 0;
-                if (currentEl.locator?.count)
-                    return (await currentEl.locator.count()) === 0;
-                return false;
-            }
-            case 'be.clickable':
-            case 'be.enabled': {
-                return typeof currentEl.isEnabled === 'function' ? await currentEl.isEnabled() : true;
-            }
-            case 'not.be.clickable':
-            case 'be.disabled': {
-                return typeof currentEl.isEnabled === 'function' ? !(await currentEl.isEnabled()) : false;
-            }
-            case 'be.checked':
-            case 'be.selected': {
-                return typeof currentEl.isSelected === 'function'
-                    ? await currentEl.isSelected()
-                    : typeof currentEl.isChecked === 'function'
-                        ? await currentEl.isChecked()
-                        : false;
-            }
-            case 'not.be.checked':
-            case 'not.be.selected': {
-                const sel = typeof currentEl.isSelected === 'function'
-                    ? await currentEl.isSelected()
-                    : typeof currentEl.isChecked === 'function'
-                        ? await currentEl.isChecked()
-                        : true;
-                return !sel;
-            }
-            case 'be.focused': {
-                return typeof currentEl.isFocused === 'function' ? await currentEl.isFocused() : false;
-            }
-            case 'not.be.focused': {
-                return typeof currentEl.isFocused === 'function' ? !(await currentEl.isFocused()) : true;
-            }
-            case 'have.value': {
-                const val = typeof currentEl.getValue === 'function'
-                    ? await currentEl.getValue()
-                    : typeof currentEl.inputValue === 'function'
-                        ? await currentEl.inputValue()
-                        : '';
-                return val === args[0];
-            }
-            case 'not.have.value': {
-                const val = typeof currentEl.getValue === 'function'
-                    ? await currentEl.getValue()
-                    : typeof currentEl.inputValue === 'function'
-                        ? await currentEl.inputValue()
-                        : '';
-                return val !== args[0];
-            }
-            case 'contain.value': {
-                const val = typeof currentEl.getValue === 'function'
-                    ? await currentEl.getValue()
-                    : typeof currentEl.inputValue === 'function'
-                        ? await currentEl.inputValue()
-                        : '';
-                return String(val).includes(args[0]);
-            }
-            case 'not.contain.value': {
-                const val = typeof currentEl.getValue === 'function'
-                    ? await currentEl.getValue()
-                    : typeof currentEl.inputValue === 'function'
-                        ? await currentEl.inputValue()
-                        : '';
-                return !String(val).includes(args[0]);
-            }
-            case 'have.text': {
-                const text = typeof currentEl.getText === 'function'
-                    ? await currentEl.getText()
-                    : typeof currentEl.textContent === 'function'
-                        ? await currentEl.textContent()
-                        : '';
-                return text.trim() === String(args[0]).trim();
-            }
-            case 'not.have.text': {
-                const text = typeof currentEl.getText === 'function'
-                    ? await currentEl.getText()
-                    : typeof currentEl.textContent === 'function'
-                        ? await currentEl.textContent()
-                        : '';
-                return text.trim() !== String(args[0]).trim();
-            }
-            case 'contain.text': {
-                const text = typeof currentEl.getText === 'function'
-                    ? await currentEl.getText()
-                    : typeof currentEl.textContent === 'function'
-                        ? await currentEl.textContent()
-                        : '';
-                return text.includes(String(args[0]));
-            }
-            case 'not.contain.text': {
-                const text = typeof currentEl.getText === 'function'
-                    ? await currentEl.getText()
-                    : typeof currentEl.textContent === 'function'
-                        ? await currentEl.textContent()
-                        : '';
-                return !text.includes(String(args[0]));
-            }
-            case 'have.class': {
-                const cls = typeof currentEl.getAttribute === 'function' ? (await currentEl.getAttribute('class')) || '' : '';
-                return cls.split(/\s+/).includes(args[0]);
-            }
-            case 'not.have.class': {
-                const cls = typeof currentEl.getAttribute === 'function' ? (await currentEl.getAttribute('class')) || '' : '';
-                return !cls.split(/\s+/).includes(args[0]);
-            }
-            case 'have.attr': {
-                const attrVal = typeof currentEl.getAttribute === 'function' ? await currentEl.getAttribute(args[0]) : null;
-                if (args.length >= 2)
-                    return attrVal === args[1];
-                return attrVal !== null;
-            }
-            case 'not.have.attr': {
-                const attrVal = typeof currentEl.getAttribute === 'function' ? await currentEl.getAttribute(args[0]) : null;
-                if (args.length >= 2)
-                    return attrVal !== args[1];
-                return attrVal === null;
-            }
-            case 'have.css': {
-                const cssVal = typeof currentEl.getCSSProperty === 'function'
-                    ? (await currentEl.getCSSProperty(args[0]))?.value
-                    : typeof currentEl.evaluate === 'function'
-                        ? await currentEl.evaluate((node, prop) => window.getComputedStyle(node).getPropertyValue(prop), args[0])
-                        : null;
-                if (!cssVal)
-                    return false;
-                const norm = (v) => String(v ?? '')
-                    .replace(/\s+/g, '')
-                    .replace(/rgba\((.+?),1\)/, 'rgb($1)')
-                    .toLowerCase();
-                return norm(cssVal) === norm(args[1]);
+    const el = await resolveElement(target);
+    switch (matcher) {
+        case 'be.visible':
+            await expect(el).toBeDisplayed();
+            break;
+        case 'not.be.visible':
+            await expect(el).not.toBeDisplayed();
+            break;
+        case 'exist':
+            await expect(el).toExist();
+            break;
+        case 'not.exist':
+            await expect(el).not.toExist();
+            break;
+        case 'be.clickable':
+            await expect(el).toBeClickable();
+            break;
+        case 'not.be.clickable':
+            await expect(el).not.toBeClickable();
+            break;
+        case 'be.enabled':
+            await expect(el).toBeEnabled();
+            break;
+        case 'be.disabled':
+            await expect(el).toBeDisabled();
+            break;
+        case 'be.checked':
+        case 'be.selected':
+            await expect(el).toBeSelected();
+            break;
+        case 'not.be.checked':
+        case 'not.be.selected':
+            await expect(el).not.toBeSelected();
+            break;
+        case 'be.focused':
+            await expect(el).toBeFocused();
+            break;
+        case 'not.be.focused':
+            await expect(el).not.toBeFocused();
+            break;
+        case 'have.value':
+            await expect(el).toHaveValue(args[0]);
+            break;
+        case 'not.have.value':
+            await expect(el).not.toHaveValue(args[0]);
+            break;
+        case 'contain.value':
+            await expect(el).toHaveValue(expect.stringContaining(args[0]));
+            break;
+        case 'not.contain.value':
+            await expect(el).not.toHaveValue(expect.stringContaining(args[0]));
+            break;
+        case 'have.text':
+            await expect(el).toHaveText(args[0]);
+            break;
+        case 'not.have.text':
+            await expect(el).not.toHaveText(args[0]);
+            break;
+        case 'contain.text':
+            await expect(el).toHaveText(expect.stringContaining(args[0]));
+            break;
+        case 'not.contain.text':
+            await expect(el).not.toHaveText(expect.stringContaining(args[0]));
+            break;
+        case 'have.class':
+            await expect(el).toHaveElementClass(args[0]);
+            break;
+        case 'not.have.class':
+            await expect(el).not.toHaveElementClass(args[0]);
+            break;
+        case 'have.attr':
+            if (args.length >= 2) {
+                await expect(el).toHaveAttribute(args[0], args[1]);
             }
-            case 'not.have.css': {
-                const cssVal = typeof currentEl.getCSSProperty === 'function'
-                    ? (await currentEl.getCSSProperty(args[0]))?.value
-                    : typeof currentEl.evaluate === 'function'
-                        ? await currentEl.evaluate((node, prop) => window.getComputedStyle(node).getPropertyValue(prop), args[0])
-                        : null;
-                if (!cssVal)
-                    return true;
-                const norm = (v) => String(v ?? '')
-                    .replace(/\s+/g, '')
-                    .replace(/rgba\((.+?),1\)/, 'rgb($1)')
-                    .toLowerCase();
-                return norm(cssVal) !== norm(args[1]);
+            else {
+                await expect(el).toHaveAttribute(args[0]);
             }
-            default:
-                throw new Error(`Unsupported matcher: ${matcher}`);
-        }
-    }, 5000);
-    if (!passed) {
-        throw new Error(`Assertion matcher '${matcher}' failed for target within 5000ms timeout.`);
-    }
-}
-async function pollUntil(condition, timeout = 5000, interval = 50) {
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-        try {
-            if (await condition())
-                return true;
-        }
-        catch {
-            // ignore and retry
-        }
-        await new Promise((r) => setTimeout(r, interval));
-    }
-    try {
-        return await condition();
-    }
-    catch {
-        return false;
+            break;
+        case 'not.have.attr':
+            await expect(el).not.toHaveAttribute(args[0]);
+            break;
+        case 'have.css':
+            await expect(el).toHaveStyle({ [args[0]]: args[1] });
+            break;
+        case 'not.have.css':
+            await expect(el).not.toHaveStyle({ [args[0]]: args[1] });
+            break;
+        default:
+            throw new Error(`Unsupported matcher: ${matcher}`);
     }
 }
 /**
- * Executes a multi-element collection matcher against $$.
+ * Executes a multi-element collection matcher against WebdriverIO $$.
  *
  * @param selector - CSS/XPath selector for the collection.
  * @param matcher - Multi-element matcher string.
  * @param args - Expected values or count limits.
  */
 export async function executeMultiMatcher(selector, matcher, args) {
-    const elements = typeof globalThis.$$ === 'function' ? await globalThis.$$(selector) : [];
-    const exp = typeof expect !== 'undefined' ? expect : globalThis.expect;
-    if (exp && typeof exp(elements)?.toBeElementsArrayOfSize === 'function') {
-        switch (matcher) {
-            case 'have.length':
-                await exp(elements).toBeElementsArrayOfSize(args[0]);
-                break;
-            case 'not.have.length':
-                await exp(elements).not.toBeElementsArrayOfSize(args[0]);
-                break;
-            case 'have.length.greaterThan':
-                await exp(elements).toBeElementsArrayOfSize({ gte: args[0] + 1 });
-                break;
-            case 'have.length.lessThan':
-                await exp(elements).toBeElementsArrayOfSize({ lte: Math.max(0, args[0] - 1) });
-                break;
-            case 'be.empty':
-                await exp(elements).toBeElementsArrayOfSize(0);
-                break;
-            case 'not.be.empty':
-                await exp(elements).toBeElementsArrayOfSize({ gte: 1 });
-                break;
-            case 'exist':
-                await exp(elements).toBeElementsArrayOfSize({ gte: 1 });
-                break;
-            default:
-                throw new Error(`Unsupported multi-element matcher: ${matcher}`);
-        }
-        return;
-    }
-    // Playwright Locator / Array length fallback with polling
-    const passed = await pollUntil(async () => {
-        const currentElements = typeof globalThis.$$ === 'function' ? await globalThis.$$(selector) : [];
-        const count = Array.isArray(currentElements)
-            ? currentElements.length
-            : typeof currentElements.count === 'function'
-                ? await currentElements.count()
-                : 0;
-        switch (matcher) {
-            case 'have.length':
-                return count === args[0];
-            case 'not.have.length':
-                return count !== args[0];
-            case 'have.length.greaterThan':
-                return count > args[0];
-            case 'have.length.lessThan':
-                return count < args[0];
-            case 'be.empty':
-                return count === 0;
-            case 'not.be.empty':
-            case 'exist':
-                return count > 0;
-            default:
-                return false;
-        }
-    }, 5000);
-    if (!passed) {
-        const currentElements = typeof globalThis.$$ === 'function' ? await globalThis.$$(selector) : [];
-        const count = Array.isArray(currentElements)
-            ? currentElements.length
-            : typeof currentElements.count === 'function'
-                ? await currentElements.count()
-                : 0;
-        throw new Error(`Assertion '${matcher}' failed for collection '${selector}' within 5000ms. Current count: ${count}`);
+    const elements = await $$(selector);
+    switch (matcher) {
+        case 'have.length':
+            await expect(elements).toBeElementsArrayOfSize(args[0]);
+            break;
+        case 'not.have.length':
+            await expect(elements).not.toBeElementsArrayOfSize(args[0]);
+            break;
+        case 'have.length.greaterThan':
+            await expect(elements).toBeElementsArrayOfSize({ gte: args[0] + 1 });
+            break;
+        case 'have.length.lessThan':
+            await expect(elements).toBeElementsArrayOfSize({ lte: Math.max(0, args[0] - 1) });
+            break;
+        case 'be.empty':
+            await expect(elements).toBeElementsArrayOfSize(0);
+            break;
+        case 'not.be.empty':
+            await expect(elements).toBeElementsArrayOfSize({ gte: 1 });
+            break;
+        case 'exist':
+            await expect(elements).toBeElementsArrayOfSize({ gte: 1 });
+            break;
+        default:
+            throw new Error(`Unsupported multi-element matcher: ${matcher}`);
     }
 }
 /**
@@ -570,71 +175,25 @@ export async function executeMultiMatcher(selector, matcher, args) {
 export async function executeBrowserAssertion(assertion, args = []) {
     const b = typeof browser !== 'undefined' ? browser : globalThis.browser;
     if (!b)
-        throw new Error('Browser instance is not available.');
-    const exp = typeof expect !== 'undefined' ? expect : globalThis.expect;
+        throw new Error('WebdriverIO browser instance is not available.');
     switch (assertion) {
         case 'shouldHaveUrl':
-            if (exp && typeof exp(b)?.toHaveUrl === 'function') {
-                await exp(b).toHaveUrl(args[0]);
-            }
-            else {
-                const url = b.getUrl ? await b.getUrl() : b.url ? (typeof b.url === 'function' ? await b.url() : b.url) : '';
-                if (url !== args[0])
-                    throw new Error(`Expected URL to be "${args[0]}", but got "${url}"`);
-            }
+            await expect(b).toHaveUrl(args[0]);
             break;
         case 'shouldContainUrl':
-            if (exp && typeof exp(b)?.toHaveUrl === 'function') {
-                await exp(b).toHaveUrl(new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-            }
-            else {
-                const url = b.getUrl ? await b.getUrl() : b.url ? (typeof b.url === 'function' ? await b.url() : b.url) : '';
-                if (!url.includes(args[0]))
-                    throw new Error(`Expected URL to contain "${args[0]}", but got "${url}"`);
-            }
+            await expect(b).toHaveUrl(new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
             break;
         case 'shouldHaveTitle':
-            if (exp && typeof exp(b)?.toHaveTitle === 'function') {
-                await exp(b).toHaveTitle(args[0]);
-            }
-            else {
-                const title = b.getTitle
-                    ? await b.getTitle()
-                    : b.title
-                        ? typeof b.title === 'function'
-                            ? await b.title()
-                            : b.title
-                        : '';
-                if (title !== args[0])
-                    throw new Error(`Expected title to be "${args[0]}", but got "${title}"`);
-            }
+            await expect(b).toHaveTitle(args[0]);
             break;
         case 'shouldContainTitle':
-            if (exp && typeof exp(b)?.toHaveTitle === 'function') {
-                await exp(b).toHaveTitle(new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-            }
-            else {
-                const title = b.getTitle
-                    ? await b.getTitle()
-                    : b.title
-                        ? typeof b.title === 'function'
-                            ? await b.title()
-                            : b.title
-                        : '';
-                if (!title.includes(args[0]))
-                    throw new Error(`Expected title to contain "${args[0]}", but got "${title}"`);
-            }
+            await expect(b).toHaveTitle(new RegExp(String(args[0]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
             break;
         case 'shouldBePageLoaded':
-            if (b.waitUntil) {
-                await b.waitUntil(async () => {
-                    const state = await b.execute(() => document.readyState);
-                    return state === 'complete';
-                }, { timeout: 10000, timeoutMsg: 'Expected page to be fully loaded (document.readyState === "complete")' });
-            }
-            else if (b.waitForLoadState) {
-                await b.waitForLoadState('domcontentloaded');
-            }
+            await b.waitUntil(async () => {
+                const state = await b.execute(() => document.readyState);
+                return state === 'complete';
+            }, { timeout: 10000, timeoutMsg: 'Expected page to be fully loaded (document.readyState === "complete")' });
             break;
         case 'shouldHaveNoConsoleErrors':
             try {