pw-core 1.1.0 → 1.2.1

package/dist/page/registry.d.ts

@@ -1,22 +1,32 @@
 import test, { Page, TestType } from '@playwright/test';
-import { PageConfig } from './config';
+import { PageConfig, ValidatePageConfig } from './config';
 import { TypedPage } from './typed-page';
 export type PageRegistry = Record<string, PageConfig>;
-export interface PageConstructor<C extends PageConfig<any>> {
+export interface PageConstructor<C extends PageConfig> {
     new (page: Page): TypedPage<C>;
 }
-export type PageRegistryTest<T extends Record<string, PageConfig<any>>, P, W, O = {}> = TestType<P & {
-    [K in keyof T]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R2 ? R2 : TypedPage<T[K]> : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]>;
+export type PageRegistryTest<T extends Record<string, PageConfig>, P, W, O = {}> = TestType<P & {
+    [K in keyof T]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]> : TypedPage<T[K]>;
+} & {
+    [K in keyof T as K extends `worker${infer R}` ? Uncapitalize<R> : never]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]> : TypedPage<T[K]>;
 }, W & {
-    [K in keyof T as `worker${Capitalize<K & string>}`]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R2 ? R2 : TypedPage<T[K]> : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]>;
+    [K in keyof T as K extends `worker${string}` ? K : `worker${Capitalize<K & string>}`]: K extends keyof O ? O[K] extends new (page: Page, ...args: any[]) => infer R ? R : TypedPage<T[K]> : TypedPage<T[K]>;
 } & {
     workerPage: Page;
 }> & {
     pages: {
-        [K in keyof T]: K extends keyof O ? O[K] : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => any ? NonNullable<T[K]['Class']> : PageConstructor<T[K]>;
+        [K in keyof T]: K extends keyof O ? O[K] : PageConstructor<T[K]>;
+    } & {
+        [K in keyof T as K extends `worker${infer R}` ? Uncapitalize<R> : never]: K extends keyof O ? O[K] : PageConstructor<T[K]>;
+    } & {
+        [K in keyof T as K extends `worker${string}` ? K : `worker${Capitalize<K & string>}`]: K extends keyof O ? O[K] : PageConstructor<T[K]>;
     };
     classes: {
-        [K in keyof T]: K extends keyof O ? O[K] : NonNullable<T[K]['Class']> extends new (page: Page, ...args: any[]) => any ? NonNullable<T[K]['Class']> : PageConstructor<T[K]>;
+        [K in keyof T]: K extends keyof O ? O[K] : PageConstructor<T[K]>;
+    } & {
+        [K in keyof T as K extends `worker${infer R}` ? Uncapitalize<R> : never]: K extends keyof O ? O[K] : PageConstructor<T[K]>;
+    } & {
+        [K in keyof T as K extends `worker${string}` ? K : `worker${Capitalize<K & string>}`]: K extends keyof O ? O[K] : PageConstructor<T[K]>;
     };
     extend<O2 extends Partial<{
         [K in keyof T]: new (page: Page, ...args: any[]) => any;
@@ -33,8 +43,35 @@ export type PageRegistryTest<T extends Record<string, PageConfig<any>>, P, W, O
  *
  * // returns the extended test runner directly
  * const test = createPageRegistry({
- *   login: { ...config, Class: LoginPage },
- * });
+    codegenPage: {
+      url: '/',
+      selectors: {
+        '{item}': {
+          item: ['why-pw-core', 'why-not-playwright', 'registry', 'typed-page', 'features'],
+          selector: '[data-parent-id="{item}"]'
+        },
+        copyToClipboardBtn: '.page',
+        dynamicLocators: 'text="Dynamic Locators" >> nth=0',
+        rootrailthumbright: '#rootRailThumbRight',
+        'text{item}': {
+          item: ['Auto Steps', 'Capabilities >> nth=0', 'Secret Masking'],
+          selector: 'text="{item}"'
+        },
+        tshirts: '.title-title',
+        tShirts: 'internal:role=link[name="T-Shirts"s]'
+      },
+      testIds: {
+        qaWorkspaceBtn: 'active-workspace-btn',
+        wsOptionApp: 'ws-option-app'
+      }
+    },
+    blankPage: {
+      url: '/',
+      selectors: {
+        element: '[data-pw-cursor="pointer"]'
+      }
+    }
+  });
  *
  * // returns page classes only when accessing .pages
  * const pages = createPageRegistry({
@@ -51,6 +88,8 @@ export type PageRegistryTest<T extends Record<string, PageConfig<any>>, P, W, O
  * });
  * ```
  */
-export declare function createPageRegistry<T extends {
-    [K in keyof T]: PageConfig<T[K]>;
-} & Record<string, PageConfig<any>>>(registry: T): typeof test extends TestType<infer P, infer W> ? PageRegistryTest<T, P, W> : never;
+export declare function createPageRegistry<const T extends Record<string, PageConfig>>(registry: [T] extends [{
+    [K in keyof T]: ValidatePageConfig<T[K]>;
+}] ? T : {
+    [K in keyof T]: ValidatePageConfig<T[K]>;
+}): typeof test extends TestType<infer P, infer W> ? PageRegistryTest<T, P, W> : never;

package/dist/page/registry.js

@@ -6,43 +6,86 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageRegistry = createPageRegistry;
 const test_1 = __importDefault(require("@playwright/test"));
 const typed_page_1 = require("./typed-page");
+const resolver_1 = require("./locators/resolver");
 function createPageRegistryWithClasses(registry, classes, base) {
     const fixtures = {
         // Shared worker context and page
-        workerContext: [async ({ browser }, use) => {
+        workerContext: [
+            async ({ browser }, use) => {
                 const context = await browser.newContext();
                 await use(context);
                 await context.close();
-            }, { scope: 'worker' }],
-        workerPage: [async ({ workerContext }, use) => {
+            },
+            { scope: 'worker' }
+        ],
+        workerPage: [
+            async ({ workerContext }, use) => {
                 const page = await workerContext.newPage();
                 await use(page);
-            }, { scope: 'worker' }]
+            },
+            { scope: 'worker' }
+        ]
     };
     for (const key of Object.keys(registry)) {
+        // Page fixture for key
         fixtures[key] = async ({ page }, use) => {
             const PageClass = classes[key];
             const instance = new PageClass(page);
             await use(instance);
         };
-        const workerKey = `worker${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-        fixtures[workerKey] = [async ({ workerPage }, use) => {
+        // Page fixture for un-prefixed key (if key starts with worker)
+        if (key.startsWith('worker')) {
+            const unPrefixed = key.slice(6).charAt(0).toLowerCase() + key.slice(7);
+            if (unPrefixed && !fixtures[unPrefixed]) {
+                fixtures[unPrefixed] = async ({ page }, use) => {
+                    const PageClass = classes[key];
+                    const instance = new PageClass(page);
+                    await use(instance);
+                };
+            }
+        }
+        // Worker fixture for worker-prefixed key
+        const workerKey = key.startsWith('worker') ? key : `worker${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+        fixtures[workerKey] = [
+            async ({ workerPage }, use) => {
                 const PageClass = classes[key];
                 const instance = new PageClass(workerPage);
                 await use(instance);
-            }, { scope: 'worker' }];
+            },
+            { scope: 'worker' }
+        ];
+    }
+    // Copy worker and non-worker aliases in pages and classes dictionaries
+    const extendedClasses = { ...classes };
+    for (const key of Object.keys(classes)) {
+        if (key.startsWith('worker')) {
+            const unPrefixed = key.slice(6).charAt(0).toLowerCase() + key.slice(7);
+            if (unPrefixed && !extendedClasses[unPrefixed]) {
+                extendedClasses[unPrefixed] = classes[key];
+            }
+        }
+        else {
+            const workerKey = `worker${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+            if (!extendedClasses[workerKey]) {
+                extendedClasses[workerKey] = classes[key];
+            }
+        }
     }
     const testRunner = base.extend(fixtures);
-    testRunner.pages = classes;
-    testRunner.classes = classes;
+    testRunner.pages = extendedClasses;
+    testRunner.classes = extendedClasses;
     const originalExtend = testRunner.extend.bind(testRunner);
     testRunner.extend = (overrides, customBase = test_1.default) => {
         if (!overrides) {
             return originalExtend();
         }
-        const isPlaywrightFixtures = Object.values(overrides).every(val => (typeof val === 'function' && !val.toString().startsWith('class')) || Array.isArray(val));
+        const isPlaywrightFixtures = Object.values(overrides).every((val) => (typeof val === 'function' && !val.toString().startsWith('class')) || Array.isArray(val));
         if (isPlaywrightFixtures) {
-            return originalExtend(overrides);
+            const runner = originalExtend(overrides);
+            runner.pages = extendedClasses;
+            runner.classes = extendedClasses;
+            runner.extend = testRunner.extend;
+            return runner;
         }
         const newClasses = { ...classes };
         for (const key of Object.keys(overrides)) {
@@ -65,8 +108,35 @@ function createPageRegistryWithClasses(registry, classes, base) {
  *
  * // returns the extended test runner directly
  * const test = createPageRegistry({
- *   login: { ...config, Class: LoginPage },
- * });
+    codegenPage: {
+      url: '/',
+      selectors: {
+        '{item}': {
+          item: ['why-pw-core', 'why-not-playwright', 'registry', 'typed-page', 'features'],
+          selector: '[data-parent-id="{item}"]'
+        },
+        copyToClipboardBtn: '.page',
+        dynamicLocators: 'text="Dynamic Locators" >> nth=0',
+        rootrailthumbright: '#rootRailThumbRight',
+        'text{item}': {
+          item: ['Auto Steps', 'Capabilities >> nth=0', 'Secret Masking'],
+          selector: 'text="{item}"'
+        },
+        tshirts: '.title-title',
+        tShirts: 'internal:role=link[name="T-Shirts"s]'
+      },
+      testIds: {
+        qaWorkspaceBtn: 'active-workspace-btn',
+        wsOptionApp: 'ws-option-app'
+      }
+    },
+    blankPage: {
+      url: '/',
+      selectors: {
+        element: '[data-pw-cursor="pointer"]'
+      }
+    }
+  });
  *
  * // returns page classes only when accessing .pages
  * const pages = createPageRegistry({
@@ -87,11 +157,13 @@ function createPageRegistry(registry) {
     const classes = {};
     for (const key of Object.keys(registry)) {
         const config = registry[key];
-        classes[key] = config.Class || (class extends typed_page_1.TypedPage {
-            constructor(page) {
-                super(page, config);
-            }
-        });
+        (0, resolver_1.buildLookupIndex)(config);
+        classes[key] =
+            class extends typed_page_1.TypedPage {
+                constructor(page) {
+                    super(page, config);
+                }
+            };
     }
     return createPageRegistryWithClasses(registry, classes, test_1.default);
 }

package/dist/page/typed-page.d.ts

@@ -1,11 +1,7 @@
 import { Page, Locator, expect as playwrightExpect } from '@playwright/test';
-import { TypedLocators, ProxyLocatorMethods, PageKeys, ChainedKeys } from './config';
+import { PageConfig, TypedLocators, ProxyLocatorMethods, PageKeys, ChainedKeys, ModifyOptionsForTarget, UniversalKeys, SemanticKeys } from './config';
 import { VerifyFn, AssertionsMethod } from './assertions/verify-chain';
-declare class TypedPageClass<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-    url?: string;
-}> {
+declare class TypedPageClass<T extends PageConfig> {
     readonly page: Page;
     readonly context: Page | Locator;
     protected readonly config: T;
@@ -30,50 +26,59 @@ declare class TypedPageClass<T extends {
     waitForLoadState(state?: Parameters<Page['waitForLoadState']>[0], options?: Parameters<Page['waitForLoadState']>[1]): Promise<void>;
     /** Wait for navigation to a URL. Defaults to the page config URL. */
     waitForURL(urlOrOptions?: string | RegExp | Parameters<Page['waitForURL']>[1], options?: Parameters<Page['waitForURL']>[1]): Promise<void>;
-    resolveLocator(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: {
+    resolveLocator<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, {
         nth?: number;
         raw?: boolean;
         hasText?: string | RegExp;
-    }): Locator;
+    }>): Locator;
     /** Resolve a config key to a proxied Locator with step-wrapped methods. */
-    locator(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+    locator(target: PageKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+        nth?: number;
+    }): Locator;
+    /** Chain multiple locators sequentially up to depth 3. */
+    chain<P1 extends UniversalKeys<T>, P2 extends PageKeys<T>>(p1: P1, p2: P2, options?: {
         nth?: number;
+        raw?: boolean;
+        hasText?: string | RegExp;
+    }): Locator;
+    chain<P1 extends UniversalKeys<T>, P2 extends SemanticKeys<T>, P3 extends UniversalKeys<T>>(p1: P1, p2: P2, p3: P3, options?: {
+        nth?: number;
+        raw?: boolean;
+        hasText?: string | RegExp;
+    }): Locator;
+    chain<P1 extends UniversalKeys<T>, P2 extends UniversalKeys<T>, P3 extends PageKeys<T>>(p1: P1, p2: P2, p3: P3, options?: {
+        nth?: number;
+        raw?: boolean;
+        hasText?: string | RegExp;
+    }): Locator;
+    chain(path: ChainedKeys<T>, options?: {
+        nth?: number;
+        raw?: boolean;
+        hasText?: string | RegExp;
     }): Locator;
     /** Chainable assertions on config keys. Supports `.soft` for soft assertions. */
     get verify(): VerifyFn<T> & {
         soft: VerifyFn<T>;
     };
-    verifyHidden(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeHidden']>[0] & {
+    verifyHidden(target: PageKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeHidden']>[0] & {
         nth?: number;
         message?: string;
     }): Promise<void>;
-    verifyEnabled(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeEnabled']>[0] & {
+    verifyEnabled(target: PageKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeEnabled']>[0] & {
         nth?: number;
         message?: string;
     }): Promise<void>;
-    verifyDisabled(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeDisabled']>[0] & {
+    verifyDisabled(target: PageKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeDisabled']>[0] & {
         nth?: number;
         message?: string;
     }): Promise<void>;
-    expect(target: PageKeys<T> | ChainedKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
+    expect(target: PageKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
 }
-export type TypedPageType<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-    url?: string;
-}> = TypedPageClass<T> & TypedLocators<T> & ProxyLocatorMethods<T> & AssertionsMethod<T>;
+export type TypedPageType<T extends PageConfig> = TypedPageClass<T> & TypedLocators<T> & ProxyLocatorMethods<T> & AssertionsMethod<T>;
 export declare const TypedPage: {
-    new <T extends {
-        testIds?: Record<string, string>;
-        selectors?: Record<string, string>;
-        url?: string;
-    }>(context: Page | Locator, config: T, options?: {
+    new <T extends PageConfig>(context: Page | Locator, config: T, options?: {
         timeout?: number;
     }): TypedPageType<T>;
 };
-export type TypedPage<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-    url?: string;
-}> = TypedPageType<T>;
+export type TypedPage<T extends PageConfig> = TypedPageType<T>;
 export {};

package/dist/page/typed-page.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedPage = void 0;
+const test_1 = require("@playwright/test");
 const verify_chain_1 = require("./assertions/verify-chain");
 const verify_helpers_1 = require("./assertions/verify-helpers");
 const expect_1 = require("./assertions/expect");
 const page_actions_1 = require("./actions/page-actions");
 const locator_actions_1 = require("./actions/locator-actions");
 const resolver_1 = require("./locators/resolver");
+const caller_location_1 = require("./utils/caller-location");
 class TypedPageClass {
     page;
     context;
@@ -15,38 +17,91 @@ class TypedPageClass {
     timeout;
     constructor(context, config, options) {
         this.context = context;
-        this.page = typeof context.page === 'function'
-            ? context.page()
-            : context;
+        this.page = typeof context.page === 'function' ? context.page() : context;
         this.config = config;
         this.url = config.url;
         this.timeout = options?.timeout;
         (0, resolver_1.defineLocators)(this, this.context, this.config);
         (0, locator_actions_1.defineActionMethods)(this, this.resolveLocator.bind(this), this.timeout);
+        // Auto-wrap subclass methods with Playwright test.step
+        const builtInMethods = new Set([
+            'constructor',
+            'goto',
+            'verifyURL',
+            'verifyTitle',
+            'reload',
+            'waitForLoadState',
+            'waitForURL',
+            'resolveLocator',
+            'locator',
+            'verify',
+            'verifyHidden',
+            'verifyEnabled',
+            'verifyDisabled',
+            'expect'
+        ]);
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Object.prototype && proto !== TypedPageClass.prototype) {
+            const propNames = Object.getOwnPropertyNames(proto);
+            for (const prop of propNames) {
+                const desc = Object.getOwnPropertyDescriptor(proto, prop);
+                if (desc && typeof desc.value === 'function' && !builtInMethods.has(prop) && !prop.startsWith('_')) {
+                    const originalFn = desc.value;
+                    Object.defineProperty(this, prop, {
+                        value: function (...args) {
+                            const words = prop.split(/(?=[A-Z])/).map((w) => w.toLowerCase());
+                            if (words.length > 0) {
+                                words[0] = words[0].charAt(0).toUpperCase() + words[0].slice(1);
+                            }
+                            const sentence = words.join(' ');
+                            const formattedArgs = args.map((arg) => {
+                                if (typeof arg === 'object' && arg !== null) {
+                                    try {
+                                        return JSON.stringify(arg);
+                                    }
+                                    catch {
+                                        return String(arg);
+                                    }
+                                }
+                                return String(arg);
+                            });
+                            const stepName = formattedArgs.length > 0 ? `${sentence} - ${formattedArgs.join(' - ')}` : sentence;
+                            return test_1.test.step(stepName, () => {
+                                return originalFn.apply(this, args);
+                            });
+                        },
+                        writable: true,
+                        configurable: true,
+                        enumerable: true
+                    });
+                }
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
     }
     /** Navigate to the URL from page config. */
     async goto(options) {
-        return (0, page_actions_1.goto)(this.page, this.url, this.constructor.name, options);
+        return (0, page_actions_1.goto)(this.page, this.url, this.constructor.name, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Assert the current URL matches the page config URL or a custom pattern. */
     async verifyURL(urlOrOptions, options) {
-        return (0, page_actions_1.verifyURL)(this.page, this.url, this.constructor.name, urlOrOptions, options);
+        return (0, page_actions_1.verifyURL)(this.page, this.url, this.constructor.name, urlOrOptions, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Assert the page title matches the expected value. */
     async verifyTitle(title, options) {
-        return (0, page_actions_1.verifyTitle)(this.page, title, options);
+        return (0, page_actions_1.verifyTitle)(this.page, title, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Reload the current page. */
     async reload(options) {
-        return (0, page_actions_1.reload)(this.page, options);
+        return (0, page_actions_1.reload)(this.page, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Wait for the page to reach a load state. */
     async waitForLoadState(state, options) {
-        return (0, page_actions_1.waitForLoadState)(this.page, state, options);
+        return (0, page_actions_1.waitForLoadState)(this.page, state, options, (0, caller_location_1.getCallerLocation)());
     }
     /** Wait for navigation to a URL. Defaults to the page config URL. */
     async waitForURL(urlOrOptions, options) {
-        return (0, page_actions_1.waitForURL)(this.page, this.url, this.constructor.name, urlOrOptions, options);
+        return (0, page_actions_1.waitForURL)(this.page, this.url, this.constructor.name, urlOrOptions, options, (0, caller_location_1.getCallerLocation)());
     }
     resolveLocator(target, options) {
         return (0, resolver_1.resolveLocator)(this.context, this.config, target, options);
@@ -55,6 +110,28 @@ class TypedPageClass {
     locator(target, options) {
         return (0, resolver_1.locator)(this.context, this.config, target, options);
     }
+    chain(...args) {
+        let options = undefined;
+        const keys = [];
+        for (const arg of args) {
+            if (typeof arg === 'string') {
+                if (arg.includes('.')) {
+                    keys.push(...arg.split('.'));
+                }
+                else {
+                    keys.push(arg);
+                }
+            }
+            else if (typeof arg === 'object' && arg !== null) {
+                options = arg;
+            }
+        }
+        let loc = (0, resolver_1.resolveLocator)(this.context, this.config, keys[0], options);
+        for (let i = 1; i < keys.length; i++) {
+            loc = (0, resolver_1.resolveLocator)(loc, this.config, keys[i], options);
+        }
+        return loc;
+    }
     /** Chainable assertions on config keys. Supports `.soft` for soft assertions. */
     get verify() {
         const fn = (target, opts) => (0, verify_chain_1.createVerifyChain)(this.resolveLocator.bind(this), target, opts, false);
@@ -62,13 +139,13 @@ class TypedPageClass {
         return fn;
     }
     async verifyHidden(target, options) {
-        return (0, verify_helpers_1.verifyHidden)(this.resolveLocator.bind(this), target, options);
+        return (0, verify_helpers_1.verifyHidden)(this.resolveLocator.bind(this), target, options, (0, caller_location_1.getCallerLocation)());
     }
     async verifyEnabled(target, options) {
-        return (0, verify_helpers_1.verifyEnabled)(this.resolveLocator.bind(this), target, options);
+        return (0, verify_helpers_1.verifyEnabled)(this.resolveLocator.bind(this), target, options, (0, caller_location_1.getCallerLocation)());
     }
     async verifyDisabled(target, options) {
-        return (0, verify_helpers_1.verifyDisabled)(this.resolveLocator.bind(this), target, options);
+        return (0, verify_helpers_1.verifyDisabled)(this.resolveLocator.bind(this), target, options, (0, caller_location_1.getCallerLocation)());
     }
     expect(target, message) {
         const resolved = typeof target !== 'string' ? target : this.resolveLocator(target);

package/dist/page/types/proxy-methods.d.ts

@@ -1,60 +1,75 @@
 import { Locator } from '@playwright/test';
-import type { PageKeys, ChainedKeys } from '../config';
-/**
- * Playwright Locator methods proxied onto the page object.
- * Each method resolves a config key (or Locator) as the first argument.
- *
- * @example
- * ```ts
- * await page.click('submit');
- * await page.fill('username', 'alice', { nth: 1 });
- * ```
- *
- * pw-core adds `nth` to options — targets a specific match when multiple elements resolve.
- */
-type ProxyKeys = 'click' | 'dblclick' | 'hover' | 'focus' | 'blur' | 'check' | 'uncheck' | 'clear' | 'waitFor' | 'isChecked' | 'isDisabled' | 'isVisible' | 'textContent' | 'innerText' | 'allInnerTexts' | 'allTextContents' | 'count' | 'scrollIntoViewIfNeeded' | 'boundingBox' | 'press' | 'pressSequentially' | 'selectOption' | 'setInputFiles' | 'getAttribute';
-type ModifyProxyArgs<Args extends any[]> = Args extends [] ? [options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-}] : Args extends [any, any?] ? [Args[0], (Exclude<Args[1], undefined> & {
-    nth?: number;
-    hasText?: string | RegExp;
-})?] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [(Exclude<Args[0], undefined> & {
-    nth?: number;
-    hasText?: string | RegExp;
-})?] : [Exclude<Args[0], undefined>, options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-}] : [options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-}];
-type BaseProxyLocatorMethods<T> = {
-    [K in keyof Locator as K extends ProxyKeys ? K : never]: (target: PageKeys<T> | ChainedKeys<T> | Locator, ...args: ModifyProxyArgs<Parameters<Locator[K]>>) => ReturnType<Locator[K]>;
-};
-/**
- * Playwright Locator methods proxied onto the page object.
- * Each method resolves a config key (or Locator) as the first argument.
- *
- * @example
- * ```ts
- * await page.click('submit');
- * await page.fill('username', 'alice', { nth: 1 });
- * ```
- *
- * pw-core adds `nth` and `hasText` to options — targets a specific match when multiple elements resolve.
- */
-export interface ProxyLocatorMethods<T> extends BaseProxyLocatorMethods<T> {
+import type { PageKeys, CheckableLocatorKeys, CheckboxLocatorKeys, EditableLocatorKeys, SelectableLocatorKeys, ModifyOptionsForTarget } from '../config';
+export interface ProxyLocatorMethods<T> {
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-click Locator.click} */
+    click<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['click']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-dblclick Locator.dblclick} */
+    dblclick<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['dblclick']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-hover Locator.hover} */
+    hover<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['hover']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-focus Locator.focus} */
+    focus<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['focus']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-blur Locator.blur} */
+    blur<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['blur']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-check Locator.check} */
+    check<Target extends CheckableLocatorKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['check']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-uncheck Locator.uncheck} */
+    uncheck<Target extends CheckboxLocatorKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['uncheck']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-clear Locator.clear} */
+    clear<Target extends EditableLocatorKeys<T> | (string & {}) | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['clear']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-wait-for Locator.waitFor} */
+    waitFor<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['waitFor']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-is-checked Locator.isChecked} */
+    isChecked<Target extends CheckableLocatorKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['isChecked']>[0]>): Promise<boolean>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-is-disabled Locator.isDisabled} */
+    isDisabled<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['isDisabled']>[0]>): Promise<boolean>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-is-visible Locator.isVisible} */
+    isVisible<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['isVisible']>[0]>): Promise<boolean>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-text-content Locator.textContent} */
+    textContent<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['textContent']>[0]>): Promise<string | null>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-inner-text Locator.innerText} */
+    innerText<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['innerText']>[0]>): Promise<string>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-all-inner-texts Locator.allInnerTexts} */
+    allInnerTexts<Target extends PageKeys<T> | Locator>(target: Target): Promise<string[]>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-all-text-contents Locator.allTextContents} */
+    allTextContents<Target extends PageKeys<T> | Locator>(target: Target): Promise<string[]>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-count Locator.count} */
+    count<Target extends PageKeys<T> | Locator>(target: Target): Promise<number>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-scroll-into-view-if-needed Locator.scrollIntoViewIfNeeded} */
+    scrollIntoViewIfNeeded<Target extends PageKeys<T> | Locator>(target: Target, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['scrollIntoViewIfNeeded']>[0]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-bounding-box Locator.boundingBox} */
+    boundingBox<Target extends PageKeys<T> | Locator>(target: Target): Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-press Locator.press} */
+    press<Target extends EditableLocatorKeys<T> | (string & {}) | Locator>(target: Target, key: string, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['press']>[1]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-press-sequentially Locator.pressSequentially} */
+    pressSequentially<Target extends EditableLocatorKeys<T> | (string & {}) | Locator>(target: Target, value: string, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['pressSequentially']>[1]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-select-option Locator.selectOption} */
+    selectOption<Target extends SelectableLocatorKeys<T> | (string & {}) | Locator>(target: Target, values: string | string[] | {
+        value?: string;
+        label?: string;
+        index?: number;
+    } | null, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['selectOption']>[1]>): Promise<string[]>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-set-input-files Locator.setInputFiles} */
+    setInputFiles<Target extends PageKeys<T> | Locator>(target: Target, files: string | string[] | {
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    } | {
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    }[], options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['setInputFiles']>[1]>): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-get-attribute Locator.getAttribute} */
+    getAttribute<Target extends PageKeys<T> | Locator>(target: Target, name: string, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['getAttribute']>[1]>): Promise<string | null>;
     /** @see {@link https://playwright.dev/docs/api/class-locator#locator-fill Locator.fill} */
-    fill(target: PageKeys<T> | ChainedKeys<T> | Locator, value: string, options?: Parameters<Locator['fill']>[1] & {
-        nth?: number;
-        hasText?: string | RegExp;
+    fill<Target extends EditableLocatorKeys<T> | (string & {}) | Locator>(target: Target, value: string, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['fill']>[1]> & {
         mask?: boolean;
     }): Promise<void>;
     /** @see {@link https://playwright.dev/docs/api/class-locator#locator-drag-to Locator.dragTo} */
-    dragTo(target: PageKeys<T> | ChainedKeys<T> | Locator, destination: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['dragTo']>[1] & {
-        nth?: number;
-        hasText?: string | RegExp;
-    }): Promise<void>;
+    dragTo<Target extends PageKeys<T> | Locator>(target: Target, destination: PageKeys<T> | Locator, options?: ModifyOptionsForTarget<T, Target, Parameters<Locator['dragTo']>[1]>): Promise<void>;
 }
-export {};