feat: adding webview support

packages/mobilewright-core/src/expect.ts

@@ -1,5 +1,7 @@
-import type { Locator } from './locator.js';
+import type { Locator, StepFn } from './locator.js';
 import { LocatorError } from './locator.js';
+import { Page } from './page.js';
+import { WebLocator } from './web-locator.js';
 import { retryUntil } from './poll.js';
 import { filterStack, captureLocation } from './stackTrace.js';
 
@@ -10,38 +12,56 @@ export interface ExpectOptions {
 }
 
 /**
- * Playwright-style expect for mobile locators and plain values.
+ * Playwright-style expect for mobile locators, web locators, pages, and plain values.
  *
  * Usage:
  *   expect(locator).toBeVisible()
- *   expect(locator).not.toBeVisible()
- *   expect(locator).toHaveText('Hello')
+ *   expect(page).toHaveURL(/dashboard/)
+ *   expect(webLocator).toHaveText('Hello')
  *   expect(42).toBe(42)
  */
+export function expect(actual: Page): PageAssertions;
+export function expect(actual: WebLocator): WebLocatorAssertions;
 export function expect(actual: Locator): LocatorAssertions;
 export function expect<T>(actual: T): ValueAssertions<T>;
 export function expect(actual: unknown): any {
+  if (actual instanceof Page) return new PageAssertions(actual, false);
+  if (actual instanceof WebLocator) return new WebLocatorAssertions(actual, false);
   if (actual && typeof actual === 'object' && 'tap' in actual && 'getText' in actual) {
     return new LocatorAssertions(actual as Locator, false);
   }
   return new ValueAssertions(actual, false);
 }
 
+// Minimal interface satisfied by both Locator and WebLocator (after getText/getValue aliases).
+interface LocatorLike {
+  isVisible(opts?: { timeout?: number }): Promise<boolean>;
+  isEnabled(opts?: { timeout?: number }): Promise<boolean>;
+  isChecked(opts?: { timeout?: number }): Promise<boolean>;
+  isSelected?(opts?: { timeout?: number }): Promise<boolean>;
+  isFocused?(opts?: { timeout?: number }): Promise<boolean>;
+  getText(opts?: { timeout?: number }): Promise<string>;
+  getValue(opts?: { timeout?: number }): Promise<string>;
+  count(): Promise<number>;
+  expectTimeout?: number;
+  _stepFn?: StepFn | null;
+}
+
 class LocatorAssertions {
   constructor(
-    private readonly locator: Locator,
-    private readonly negated: boolean,
+    protected readonly locator: LocatorLike,
+    protected readonly negated: boolean,
   ) {}
 
-  get not(): LocatorAssertions {
-    return new LocatorAssertions(this.locator, !this.negated);
+  get not(): this {
+    return new (this.constructor as any)(this.locator, !this.negated) as this;
   }
 
   private assertionTimeout(opts?: ExpectOptions): number {
     return opts?.timeout ?? this.locator.expectTimeout ?? DEFAULT_TIMEOUT;
   }
 
-  private _wrapAssertion<T>(method: string, fn: () => Promise<T>): Promise<T> {
+  protected _wrapAssertion<T>(method: string, fn: () => Promise<T>): Promise<T> {
     const stepFn = this.locator._stepFn;
     const title = this.negated ? `expect.not.${method}()` : `expect.${method}()`;
     if (stepFn) {
@@ -83,13 +103,13 @@ class LocatorAssertions {
 
   async toBeSelected(opts?: ExpectOptions): Promise<void> {
     return this._wrapAssertion('toBeSelected', async () => {
-      await this.assertBoolean('selected', () => this.locator.isSelected({ timeout: 0 }), opts);
+      await this.assertBoolean('selected', () => this.locator.isSelected!({ timeout: 0 }), opts);
     });
   }
 
   async toBeFocused(opts?: ExpectOptions): Promise<void> {
     return this._wrapAssertion('toBeFocused', async () => {
-      await this.assertBoolean('focused', () => this.locator.isFocused({ timeout: 0 }), opts);
+      await this.assertBoolean('focused', () => this.locator.isFocused!({ timeout: 0 }), opts);
     });
   }
 
@@ -194,7 +214,7 @@ class LocatorAssertions {
     });
   }
 
-  private async assertBoolean(
+  protected async assertBoolean(
     name: string,
     poll: () => Promise<boolean>,
     opts?: ExpectOptions,
@@ -209,7 +229,7 @@ class LocatorAssertions {
     );
   }
 
-  private async assertText(
+  protected async assertText(
     predicate: (text: string) => boolean,
     expected: string | RegExp,
     opts?: ExpectOptions,
@@ -241,7 +261,7 @@ class LocatorAssertions {
     );
   }
 
-  private async retryAssertion<T>(
+  protected async retryAssertion<T>(
     poll: () => Promise<T>,
     predicate: (value: T) => boolean,
     timeout: number,
@@ -401,6 +421,94 @@ class ValueAssertions<T> {
   }
 }
 
+// ─── PageAssertions ───────────────────────────────────────────
+
+class PageAssertions {
+  constructor(
+    private readonly page: Page,
+    private readonly negated: boolean,
+  ) {}
+
+  get not(): PageAssertions {
+    return new PageAssertions(this.page, !this.negated);
+  }
+
+  private _wrapAssertion<T>(method: string, fn: () => Promise<T>): Promise<T> {
+    const stepFn = this.page._stepFn;
+    const title = this.negated ? `expect.not.${method}()` : `expect.${method}()`;
+    if (stepFn) {
+      const location = captureLocation();
+      return stepFn(title, fn as () => Promise<unknown>, location) as Promise<T>;
+    }
+    return fn();
+  }
+
+  async toHaveURL(url: string | RegExp, opts?: ExpectOptions): Promise<void> {
+    return this._wrapAssertion('toHaveURL', async () => {
+      let last = '';
+      await this.retryAssertion(
+        async () => { try { last = await this.page.url(); } catch { last = ''; } return last; },
+        (current) => url instanceof RegExp ? url.test(current) : current === url,
+        opts?.timeout ?? DEFAULT_TIMEOUT,
+        () => `Expected page URL to ${this.negated ? 'not ' : ''}match "${url}", but got "${last}"`,
+      );
+    });
+  }
+
+  async toHaveTitle(title: string | RegExp, opts?: ExpectOptions): Promise<void> {
+    return this._wrapAssertion('toHaveTitle', async () => {
+      let last = '';
+      await this.retryAssertion(
+        async () => { try { last = await this.page.title(); } catch { last = ''; } return last; },
+        (current) => title instanceof RegExp ? title.test(current) : current === title,
+        opts?.timeout ?? DEFAULT_TIMEOUT,
+        () => `Expected page title to ${this.negated ? 'not ' : ''}match "${title}", but got "${last}"`,
+      );
+    });
+  }
+
+  private async retryAssertion<T>(
+    poll: () => Promise<T>,
+    predicate: (value: T) => boolean,
+    timeout: number,
+    failMessage: string | (() => string),
+  ): Promise<void> {
+    try {
+      await retryUntil(poll, (v) => this.negated ? !predicate(v) : predicate(v), timeout, failMessage);
+    } catch (e) {
+      throw new ExpectError(e instanceof Error ? e.message : String(e));
+    }
+  }
+}
+
+// ─── WebLocatorAssertions ─────────────────────────────────────
+// Extends LocatorAssertions — only adds toHaveAttribute (web-only).
+// All other matchers (toBeVisible, toHaveText, toHaveCount, etc.) are inherited.
+
+class WebLocatorAssertions extends LocatorAssertions {
+  constructor(private readonly webLocator: WebLocator, negated: boolean) {
+    super(webLocator, negated);
+  }
+
+  async toHaveAttribute(name: string, expected: string | RegExp, opts?: ExpectOptions): Promise<void> {
+    return this._wrapAssertion('toHaveAttribute', async () => {
+      let last: string | null = null;
+      await this.retryAssertion(
+        async () => {
+          try { last = await this.webLocator.getAttribute(name, { timeout: 0 }); } catch { last = null; }
+          return last;
+        },
+        (value) => {
+          if (value === null) { return false; }
+          return expected instanceof RegExp ? expected.test(value) : value === expected;
+        },
+        opts?.timeout ?? DEFAULT_TIMEOUT,
+        () => `Expected element to ${this.negated ? 'not ' : ''}have attribute "${name}" = "${expected}", but got "${last}"`,
+      );
+    });
+  }
+}
+
 function fmt(value: unknown): string {
   return typeof value === 'string' ? `"${value}"` : String(value);
 }

packages/mobilewright-core/src/index.ts

@@ -1,6 +1,9 @@
 export { Locator, LocatorError, type LocatorOptions, type ScrollIntoViewOptions } from './locator.js';
+export { WebViewLocator } from './webview-locator.js';
 export { Screen } from './screen.js';
 export { Device, type DeviceOptions } from './device.js';
+export { Page } from './page.js';
+export { WebLocator, type WebLocatorStrategy } from './web-locator.js';
 export { expect, ExpectError, type ExpectOptions } from './expect.js';
 export { queryAll, type LocatorStrategy } from './query-engine.js';
 export { sleep } from './sleep.js';

packages/mobilewright-core/src/locator.ts

@@ -34,16 +34,16 @@ export class Locator {
   _stepFn: StepFn | null = null;
 
   constructor(
-    private readonly driver: MobilewrightDriver,
-    private readonly strategy: LocatorStrategy,
-    private readonly options: LocatorOptions = {},
+    protected readonly driver: MobilewrightDriver,
+    protected readonly strategy: LocatorStrategy,
+    protected readonly options: LocatorOptions = {},
   ) {}
 
   get expectTimeout(): number | undefined {
     return this.options.expectTimeout;
   }
 
-  private async _step<T>(title: string, fn: () => Promise<T>): Promise<T> {
+  protected async _step<T>(title: string, fn: () => Promise<T>): Promise<T> {
     if (this._stepFn) {
       const location = captureLocation();
       return this._stepFn(title, fn as () => Promise<unknown>, location) as Promise<T>;
@@ -77,7 +77,7 @@ export class Locator {
     return this.child({ kind: 'placeholder', value: placeholder, exact: opts?.exact });
   }
 
-  private child(childStrategy: LocatorStrategy): Locator {
+  protected child(childStrategy: LocatorStrategy): Locator {
     const loc = new Locator(
       this.driver,
       { kind: 'chain', parent: this.strategy, child: childStrategy },