@allwright.dev/vitest 0.0.24 → 0.0.26

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { type Browser, type LaunchOptions, type Page } from "@allwright.dev/core";
-import { expect } from "vitest";
+import { Locator, Page, type Browser, type LaunchOptions, type WaitForSelectorOptions } from "@allwright.dev/core";
+import { expect as vitestExpect } from "vitest";
 export interface AllwrightVitestOptions {
     launchOptions?: LaunchOptions;
     serverAddr?: string;
@@ -8,10 +8,42 @@ export interface AllwrightVitestFixtures {
     browser: Browser;
     page: Page;
 }
+export interface RetryExpectationOptions {
+    timeoutMs?: number;
+    intervalMs?: number;
+}
+export interface TextExpectationOptions extends RetryExpectationOptions {
+    command?: {
+        timeoutMs?: number;
+    };
+}
+export interface VisibleExpectationOptions extends RetryExpectationOptions {
+    command?: WaitForSelectorOptions;
+}
+export interface PageExpectMatchers {
+    toHaveText(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toContainText(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toHaveCount(selector: string, expected: number, options?: RetryExpectationOptions): Promise<void>;
+    toBeVisible(selector: string, options?: VisibleExpectationOptions): Promise<void>;
+}
+export interface LocatorExpectMatchers {
+    toHaveText(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toContainText(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toHaveCount(expected: number, options?: RetryExpectationOptions): Promise<void>;
+    toBeVisible(options?: VisibleExpectationOptions): Promise<void>;
+}
 export declare const test: import("vitest").TestAPI<{
     browser: Browser;
     page: Page;
     allwright: AllwrightVitestOptions;
 }>;
-export { expect };
-export type { Browser, LaunchOptions, Page };
+type VitestExpect = typeof vitestExpect;
+type VitestMatcherReturn = ReturnType<VitestExpect>;
+interface AllwrightExpect extends VitestExpect {
+    (actual: Page): PageExpectMatchers;
+    (actual: Locator): LocatorExpectMatchers;
+    <T>(actual: T): VitestMatcherReturn;
+}
+export declare const expect: AllwrightExpect;
+export { vitestExpect };
+export type { Browser, LaunchOptions, Locator, Page };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { chromium, setServerAddr, shutdown, } from "@allwright.dev/core";
-import { expect, test as base } from "vitest";
+import { chromium, setServerAddr, shutdown, Locator, Page, } from "@allwright.dev/core";
+import { expect as vitestExpect, test as base } from "vitest";
 export const test = base.extend({
     allwright: async ({}, use) => {
         await use({});
@@ -21,4 +21,124 @@ export const test = base.extend({
         await use(browser.page());
     },
 });
-export { expect };
+const DEFAULT_EXPECT_TIMEOUT_MS = 5_000;
+const DEFAULT_EXPECT_INTERVAL_MS = 100;
+function isPage(value) {
+    return value instanceof Page;
+}
+function isLocator(value) {
+    return value instanceof Locator;
+}
+async function retryExpectation(callback, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_EXPECT_TIMEOUT_MS;
+    const intervalMs = options.intervalMs ?? DEFAULT_EXPECT_INTERVAL_MS;
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() <= deadline) {
+        try {
+            await callback();
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (Date.now() + intervalMs > deadline) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function createPageExpect(page) {
+    return {
+        async toHaveText(selector, expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await page.textContent(selector, options.command ?? {});
+                if (expected instanceof RegExp) {
+                    vitestExpect(result.text).toMatch(expected);
+                    return;
+                }
+                vitestExpect(result.text).toBe(expected);
+            }, options);
+        },
+        async toContainText(selector, expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await page.textContent(selector, options.command ?? {});
+                if (expected instanceof RegExp) {
+                    vitestExpect(result.text).toMatch(expected);
+                    return;
+                }
+                vitestExpect(result.text).toContain(expected);
+            }, options);
+        },
+        async toHaveCount(selector, expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await page.count(selector, {});
+                vitestExpect(result.count).toBe(expected);
+            }, options);
+        },
+        async toBeVisible(selector, options = {}) {
+            await retryExpectation(async () => {
+                const result = await page.waitForSelector(selector, {
+                    visible: true,
+                    ...(options.command ?? {}),
+                });
+                vitestExpect(result.visible).toBe(true);
+            }, options);
+        },
+    };
+}
+function createLocatorExpect(locator) {
+    return {
+        async toHaveText(expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.textContent(options.command ?? {});
+                if (expected instanceof RegExp) {
+                    vitestExpect(result.text).toMatch(expected);
+                    return;
+                }
+                vitestExpect(result.text).toBe(expected);
+            }, options);
+        },
+        async toContainText(expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.textContent(options.command ?? {});
+                if (expected instanceof RegExp) {
+                    vitestExpect(result.text).toMatch(expected);
+                    return;
+                }
+                vitestExpect(result.text).toContain(expected);
+            }, options);
+        },
+        async toHaveCount(expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.count({});
+                vitestExpect(result.count).toBe(expected);
+            }, options);
+        },
+        async toBeVisible(options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.waitFor({
+                    visible: true,
+                    ...(options.command ?? {}),
+                });
+                vitestExpect(result.visible).toBe(true);
+            }, options);
+        },
+    };
+}
+const expectImpl = ((actual) => {
+    if (isLocator(actual)) {
+        return createLocatorExpect(actual);
+    }
+    if (isPage(actual)) {
+        return createPageExpect(actual);
+    }
+    return vitestExpect(actual);
+});
+const vitestExpectDescriptors = Object.getOwnPropertyDescriptors(vitestExpect);
+for (const [key, descriptor] of Object.entries(vitestExpectDescriptors)) {
+    Object.defineProperty(expectImpl, key, descriptor);
+}
+export const expect = expectImpl;
+export { vitestExpect };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allwright.dev/vitest",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Vitest fixtures for the allwright TypeScript client.",
   "license": "MIT",
   "type": "module",
@@ -39,7 +39,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@allwright.dev/core": "0.0.24"
+    "@allwright.dev/core": "0.0.26"
   },
   "devDependencies": {
     "typescript": "^5.9.2",