@testspectra/matchers 1.0.70 → 1.1.0-rc.0

package/dist/matchers.js

@@ -5,125 +5,653 @@
  * @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") {
-        const el = await $(target);
-        return el;
+    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;
 }
 /**
- * Executes a single element matcher against the WebdriverIO browser / element context.
+ * Executes a single element matcher against the active runner context (Playwright or WebdriverIO).
  *
  * @param target - Optional element target (not required for browser-level assertions).
  * @param matcher - Single element matcher string.
  * @param args - Arguments passed to the matcher.
  */
 export async function executeSingleMatcher(target, matcher, args) {
-    const isBrowserLevel = matcher === "have.url" ||
-        matcher === "contain.url" ||
-        matcher === "have.title" ||
-        matcher === "contain.title";
+    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 "have.url":
-                await expect(browser).toHaveUrl(expected);
+            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 "contain.url":
-                await expect(browser).toHaveUrl(expect.stringContaining(expected));
+            case 'have.class':
+                await exp(el).toHaveElementClass(args[0]);
                 break;
-            case "have.title":
-                await expect(browser).toHaveTitle(expected);
+            case 'not.have.class':
+                await exp(el).not.toHaveElementClass(args[0]);
                 break;
-            case "contain.title":
-                await expect(browser).toHaveTitle(expect.stringContaining(expected));
+            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).toHaveStyle({ [args[0]]: args[1] });
+                break;
+            case 'not.have.css':
+                await exp(el).not.toHaveStyle({ [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 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;
     }
-    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.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 "have.value":
-            await expect(el).toHaveValue(args[0]);
-            break;
-        case "contain.value":
-            await expect(el).toHaveValue(expect.stringContaining(args[0]));
-            break;
-        case "have.text":
-            await expect(el).toHaveText(args[0]);
-            break;
-        case "contain.text":
-            await expect(el).toHaveText(expect.stringContaining(args[0]));
-            break;
-        case "have.class":
-            await expect(el).toHaveElementClass(args[0]);
-            break;
-        case "have.attr":
-            if (args.length >= 2) {
-                await expect(el).toHaveAttribute(args[0], args[1]);
+    // 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;
             }
-            else {
-                await expect(el).toHaveAttribute(args[0]);
+            case 'not.be.visible': {
+                const v = typeof currentEl.isDisplayed === 'function'
+                    ? await currentEl.isDisplayed()
+                    : typeof currentEl.isVisible === 'function'
+                        ? await currentEl.isVisible()
+                        : false;
+                return !v;
             }
-            break;
-        default:
-            throw new Error(`Unsupported matcher: ${matcher}`);
+            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]);
+            }
+            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]);
+            }
+            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;
     }
 }
 /**
- * Executes a multi-element collection matcher against WebdriverIO $$.
+ * Executes a multi-element collection matcher against $$.
  *
  * @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 = await $$(selector);
-    switch (matcher) {
-        case "have.length":
-            await expect(elements).toBeElementsArrayOfSize(args[0]);
+    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}`);
+    }
+}
+/**
+ * Executes browser-level context assertions.
+ */
+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;
+    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}"`);
+            }
             break;
-        case "have.length.greaterThan":
-            await expect(elements).toBeElementsArrayOfSize({ gte: args[0] + 1 });
+        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}"`);
+            }
             break;
-        case "be.empty":
-            await expect(elements).toBeElementsArrayOfSize(0);
+        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}"`);
+            }
             break;
-        case "exist":
-            await expect(elements).toBeElementsArrayOfSize({ gte: 1 });
+        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}"`);
+            }
+            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');
+            }
+            break;
+        case 'shouldHaveNoConsoleErrors':
+            try {
+                const logs = await b.getLogs?.('browser');
+                if (Array.isArray(logs)) {
+                    const severeLogs = logs.filter((log) => log.level === 'SEVERE');
+                    if (severeLogs.length > 0) {
+                        throw new Error(`Browser console has errors: ${severeLogs.map((l) => l.message).join('; ')}`);
+                    }
+                }
+            }
+            catch (err) {
+                if (err.message && err.message.includes('Browser console has errors'))
+                    throw err;
+            }
             break;
         default:
-            throw new Error(`Unsupported multi-element matcher: ${matcher}`);
+            throw new Error(`Unsupported browser assertion: ${assertion}`);
     }
 }