@allwright.dev/vitest 0.1.24 → 0.1.25

package/README.md

@@ -289,13 +289,18 @@ await expect(page.locator('select')).toHaveSelectedOptions(['a', 'b']);
 await expect(page.locator('select')).toHaveSelectedOptions([{ value: 'a', label: /Alpha/ }]);
 await expect(page.locator('textarea')).toHaveSelectedText('selected words');
 await expect(page.locator('input[type=checkbox]')).toBeChecked();
+await expect(page.locator('button[type=submit]')).toBeEnabled();
+await expect(page.locator('input')).toBeEditable();
+await expect(page.locator('input')).toBeFocused();
+await expect(page.locator('.spinner')).toBeHidden();
+await expect(page.locator('main')).toBeAttached();
 await expect(page.locator('h1')).toHaveText('Welcome');
 await expect(page.locator('a')).toHaveAttribute('href', /dashboard/);
 await expect(page.locator('button')).toHaveBoundingBox({ width: 100, height: 40 });
 await expect(page.locator('input[type=radio]')).not().toBeChecked();
 ```
 
-Every element matcher also has a page form, such as `expect(page).toHaveValue('#name', 'Alice')` or `expect(page).toHaveAttribute('a', 'href', '/home')`. These state matchers are web-only; Android retains its text/count/visibility matchers.
+Every element matcher also has a page/app form, such as `expect(page).toHaveValue('#name', 'Alice')` or `expect(androidApp).toBeEnabled('text="Continue"')`. Value, checked-state, attribute, bounding-box, attached/hidden, enabled/disabled, focused, and editable matchers work across web, Android, iOS, macOS, and Windows. URL, selected-option, and selected-text matchers remain web-only.
 
 All Allwright page/app/locator expectations retry until they match or the timeout expires, including `.not` and `.not()`. Defaults come from the shared assertion configuration, falling back to 5 seconds and a 100 ms interval. Override these with `{ timeoutMs, intervalMs }`. In-flight reads and nested command timeout hints are bounded by the remaining assertion budget; `timeoutMs: 0` makes one observation without polling. Ordinary assertions on already captured values, such as `expect(await page.url()).toBe(...)`, use standard Vitest behavior and do not re-read the page.
 

package/dist/expectations.d.ts

@@ -15,6 +15,16 @@ export interface MobilePageExpectMatchers {
     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>;
+    toBeHidden(selector: string, options?: VisibleExpectationOptions): Promise<void>;
+    toBeAttached(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeEnabled(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeDisabled(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeFocused(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toBeEditable(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toHaveValue(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toBeChecked(selector: string, options?: TextExpectationOptions): Promise<void>;
+    toHaveAttribute(selector: string, name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
+    toHaveBoundingBox(selector: string, expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 export interface MobileLocatorExpectMatchers {
     readonly not: MobileLocatorExpectMatchers & (() => MobileLocatorExpectMatchers);
@@ -22,6 +32,16 @@ export interface MobileLocatorExpectMatchers {
     toContainText(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveCount(expected: number, options?: RetryExpectationOptions): Promise<void>;
     toBeVisible(options?: VisibleExpectationOptions): Promise<void>;
+    toBeHidden(options?: VisibleExpectationOptions): Promise<void>;
+    toBeAttached(options?: TextExpectationOptions): Promise<void>;
+    toBeEnabled(options?: TextExpectationOptions): Promise<void>;
+    toBeDisabled(options?: TextExpectationOptions): Promise<void>;
+    toBeFocused(options?: TextExpectationOptions): Promise<void>;
+    toBeEditable(options?: TextExpectationOptions): Promise<void>;
+    toHaveValue(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toBeChecked(options?: TextExpectationOptions): Promise<void>;
+    toHaveAttribute(name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
+    toHaveBoundingBox(expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 export type SelectedOptionExpectation = string | RegExp | {
     value?: string | RegExp;
@@ -30,22 +50,14 @@ export type SelectedOptionExpectation = string | RegExp | {
 };
 export interface LocatorExpectMatchers extends MobileLocatorExpectMatchers {
     readonly not: LocatorExpectMatchers & (() => LocatorExpectMatchers);
-    toHaveValue(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedOptions(expected: SelectedOptionExpectation[], options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedText(expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toBeChecked(options?: TextExpectationOptions): Promise<void>;
-    toHaveAttribute(name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toHaveBoundingBox(expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 export interface PageExpectMatchers extends MobilePageExpectMatchers {
     readonly not: PageExpectMatchers & (() => PageExpectMatchers);
     toHaveURL(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
-    toHaveValue(selector: string, expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedOptions(selector: string, expected: SelectedOptionExpectation[], options?: TextExpectationOptions): Promise<void>;
     toHaveSelectedText(selector: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toBeChecked(selector: string, options?: TextExpectationOptions): Promise<void>;
-    toHaveAttribute(selector: string, name: string, expected: string | RegExp | null, options?: TextExpectationOptions): Promise<void>;
-    toHaveBoundingBox(selector: string, expected: Partial<BoundingBox> | null, options?: TextExpectationOptions): Promise<void>;
 }
 type Defaults = () => RetryExpectationOptions;
 type AnyLocator = Locator | NativeAppLocator;

package/dist/expectations.js

@@ -57,11 +57,20 @@ async function isVisible(locator, command) {
         return true;
     }
     catch (error) {
-        if (error instanceof Error && error.message.startsWith("selector found but not visible: "))
+        if (error instanceof Error && (error.message.startsWith("selector found but not visible: ")
+            || error.message.includes("did not become visible")))
             return false;
         throw error;
     }
 }
+async function nativeOrWebState(locator, state, command) {
+    const attribute = "filter" in locator ? `__allwright_state_${state}` : state;
+    const value = await locator.getAttribute(attribute, command);
+    if (value !== "true" && value !== "false") {
+        throw new Error(`Element did not expose a ${state} state`);
+    }
+    return value === "true";
+}
 export function createLocatorExpect(locator, defaults, negated = false) {
     const assertion = (value) => negated ? vitestExpect(value).not : vitestExpect(value);
     const common = {
@@ -94,18 +103,64 @@ export function createLocatorExpect(locator, defaults, negated = false) {
                 assertion(await isVisible(locator, command)).toBe(true);
             }, options, defaults());
         },
+        async toBeHidden(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await isVisible(locator, command)).toBe(false);
+            }, options, defaults());
+        },
+        async toBeAttached(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion((await locator.count(command)) > 0).toBe(true);
+            }, options, defaults());
+        },
+        async toBeEnabled(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "enabled", command)).toBe(true);
+            }, options, defaults());
+        },
+        async toBeDisabled(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "enabled", command)).toBe(false);
+            }, options, defaults());
+        },
+        async toBeFocused(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "focused", command)).toBe(true);
+            }, options, defaults());
+        },
+        async toBeEditable(options = {}) {
+            await retryExpectation(async (command) => {
+                assertion(await nativeOrWebState(locator, "editable", command)).toBe(true);
+            }, options, defaults());
+        },
+        async toHaveValue(expected, options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.inputValue(command)).toEqual(expectedText(expected)), options, defaults());
+        },
+        async toBeChecked(options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.isChecked(command)).toBe(true), options, defaults());
+        },
+        async toHaveAttribute(name, expected, options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.getAttribute(name, command)).toEqual(expectedText(expected)), options, defaults());
+        },
+        async toHaveBoundingBox(expected, options = {}) {
+            await retryExpectation(async (command) => assertion(await locator.boundingBox(command)).toEqual(expected === null ? null : vitestExpect.objectContaining(expected)), options, defaults());
+        },
     };
-    if (!("inputValue" in locator))
+    if (!("selectedOptions" in locator))
         return common;
     const web = {
         toHaveText: common.toHaveText,
         toContainText: common.toContainText,
         toHaveCount: common.toHaveCount,
         toBeVisible: common.toBeVisible,
+        toBeHidden: common.toBeHidden,
+        toBeAttached: common.toBeAttached,
+        toBeEnabled: common.toBeEnabled,
+        toBeDisabled: common.toBeDisabled,
+        toBeFocused: common.toBeFocused,
+        toBeEditable: common.toBeEditable,
         get not() { return callableMatchers(createLocatorExpect(locator, defaults, !negated)); },
-        async toHaveValue(expected, options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.inputValue(command)).toEqual(expectedText(expected)), options, defaults());
-        },
+        toHaveValue: common.toHaveValue,
         async toHaveSelectedOptions(expected, options = {}) {
             await retryExpectation(async (command) => {
                 const wanted = expected.map(option => {
@@ -123,15 +178,9 @@ export function createLocatorExpect(locator, defaults, negated = false) {
         async toHaveSelectedText(expected, options = {}) {
             await retryExpectation(async (command) => assertion(await locator.selectedText(command)).toEqual(expectedText(expected)), options, defaults());
         },
-        async toBeChecked(options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.isChecked(command)).toBe(true), options, defaults());
-        },
-        async toHaveAttribute(name, expected, options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.getAttribute(name, command)).toEqual(expectedText(expected)), options, defaults());
-        },
-        async toHaveBoundingBox(expected, options = {}) {
-            await retryExpectation(async (command) => assertion(await locator.boundingBox(command)).toEqual(expected === null ? null : vitestExpect.objectContaining(expected)), options, defaults());
-        },
+        toBeChecked: common.toBeChecked,
+        toHaveAttribute: common.toHaveAttribute,
+        toHaveBoundingBox: common.toHaveBoundingBox,
     };
     return web;
 }
@@ -143,6 +192,16 @@ export function createPageExpect(page, defaults, negated = false) {
         toContainText: (selector, expected, options) => matcher(selector).toContainText(expected, options),
         toHaveCount: (selector, expected, options) => matcher(selector).toHaveCount(expected, options),
         toBeVisible: (selector, options) => matcher(selector).toBeVisible(options),
+        toBeHidden: (selector, options) => matcher(selector).toBeHidden(options),
+        toBeAttached: (selector, options) => matcher(selector).toBeAttached(options),
+        toBeEnabled: (selector, options) => matcher(selector).toBeEnabled(options),
+        toBeDisabled: (selector, options) => matcher(selector).toBeDisabled(options),
+        toBeFocused: (selector, options) => matcher(selector).toBeFocused(options),
+        toBeEditable: (selector, options) => matcher(selector).toBeEditable(options),
+        toHaveValue: (selector, expected, options) => matcher(selector).toHaveValue(expected, options),
+        toBeChecked: (selector, options) => matcher(selector).toBeChecked(options),
+        toHaveAttribute: (selector, name, expected, options) => matcher(selector).toHaveAttribute(name, expected, options),
+        toHaveBoundingBox: (selector, expected, options) => matcher(selector).toHaveBoundingBox(expected, options),
     };
     if (!("url" in page))
         return common;
@@ -152,6 +211,12 @@ export function createPageExpect(page, defaults, negated = false) {
         toContainText: common.toContainText,
         toHaveCount: common.toHaveCount,
         toBeVisible: common.toBeVisible,
+        toBeHidden: common.toBeHidden,
+        toBeAttached: common.toBeAttached,
+        toBeEnabled: common.toBeEnabled,
+        toBeDisabled: common.toBeDisabled,
+        toBeFocused: common.toBeFocused,
+        toBeEditable: common.toBeEditable,
         get not() { return callableMatchers(createPageExpect(page, defaults, !negated)); },
         async toHaveURL(expected, options = {}) {
             await retryExpectation(async (command) => {
@@ -159,12 +224,12 @@ export function createPageExpect(page, defaults, negated = false) {
                 (negated ? vitestExpect(url).not : vitestExpect(url)).toEqual(expectedText(expected));
             }, options, defaults());
         },
-        toHaveValue: (selector, expected, options) => webMatcher(selector).toHaveValue(expected, options),
+        toHaveValue: common.toHaveValue,
         toHaveSelectedOptions: (selector, expected, options) => webMatcher(selector).toHaveSelectedOptions(expected, options),
         toHaveSelectedText: (selector, expected, options) => webMatcher(selector).toHaveSelectedText(expected, options),
-        toBeChecked: (selector, options) => webMatcher(selector).toBeChecked(options),
-        toHaveAttribute: (selector, name, expected, options) => webMatcher(selector).toHaveAttribute(name, expected, options),
-        toHaveBoundingBox: (selector, expected, options) => webMatcher(selector).toHaveBoundingBox(expected, options),
+        toBeChecked: common.toBeChecked,
+        toHaveAttribute: common.toHaveAttribute,
+        toHaveBoundingBox: common.toHaveBoundingBox,
     };
     return web;
 }

package/dist/index.js

@@ -68,6 +68,9 @@ function createLazyLocator(pageResource, selectorFactory) {
         async click(options) {
             return (await pageResource.get()).locator(await selectorFactory()).click(options);
         },
+        async dblclick(options) {
+            return (await pageResource.get()).locator(await selectorFactory()).dblclick(options);
+        },
         async count(options) {
             return (await pageResource.get()).locator(await selectorFactory()).count(options);
         },
@@ -178,6 +181,9 @@ function createLazyPage(pageResource) {
         async click(selector, options) {
             return (await pageResource.get()).click(selector, options);
         },
+        async dblclick(selector, options) {
+            return (await pageResource.get()).dblclick(selector, options);
+        },
         async count(selector, options) {
             return (await pageResource.get()).count(selector, options);
         },
@@ -386,6 +392,18 @@ function createLazyMobileApp(appResource) {
         async innerText(selector, options) {
             return (await appResource.get()).innerText(selector, options);
         },
+        async inputValue(selector, options) {
+            return (await appResource.get()).inputValue(selector, options);
+        },
+        async isChecked(selector, options) {
+            return (await appResource.get()).isChecked(selector, options);
+        },
+        async getAttribute(selector, name, options) {
+            return (await appResource.get()).getAttribute(selector, name, options);
+        },
+        async boundingBox(selector, options) {
+            return (await appResource.get()).boundingBox(selector, options);
+        },
         async waitForSelector(selector, options) {
             return (await appResource.get()).waitForSelector(selector, options);
         },
@@ -427,6 +445,18 @@ function createLazyMobileLocator(appResource, selectorFactory) {
         async innerText(options) {
             return (await appResource.get()).locator(await selectorFactory()).innerText(options);
         },
+        async inputValue(options) {
+            return (await appResource.get()).locator(await selectorFactory()).inputValue(options);
+        },
+        async isChecked(options) {
+            return (await appResource.get()).locator(await selectorFactory()).isChecked(options);
+        },
+        async getAttribute(name, options) {
+            return (await appResource.get()).locator(await selectorFactory()).getAttribute(name, options);
+        },
+        async boundingBox(options) {
+            return (await appResource.get()).locator(await selectorFactory()).boundingBox(options);
+        },
         async waitFor(options) {
             return (await appResource.get()).locator(await selectorFactory()).waitFor(options);
         },

package/package.json

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