pw-core 1.2.0 → 1.3.0

package/dist/page/locators/resolver.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupIndexCache = exports.locatorStrategies = void 0;
+exports.cleanKey = cleanKey;
+exports.buildLookupIndex = buildLookupIndex;
 exports.defineLocators = defineLocators;
 exports.resolveLocator = resolveLocator;
 exports.locator = locator;
@@ -9,51 +12,162 @@ const config_1 = require("../config");
 const formatter_1 = require("../utils/formatter");
 const dynamic_locator_resolver_1 = require("./dynamic-locator-resolver");
 const caller_location_1 = require("../utils/caller-location");
-function defineLocators(instance, context, config) {
-    if (config.testIds) {
-        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.testIds);
+exports.locatorStrategies = {
+    testId: { resolver: 'getByTestId' },
+    selector: { resolver: 'locator' },
+    text: { resolver: 'getByText' },
+    label: { resolver: 'getByLabel' },
+    title: { resolver: 'getByTitle' },
+    placeholder: { resolver: 'getByPlaceholder' },
+    altText: { resolver: 'getByAltText' }
+};
+// Add all roles dynamically
+for (const role of config_1.rolesList) {
+    exports.locatorStrategies[role] = { resolver: 'getByRole', role };
+}
+function cleanKey(s) {
+    let clean = s;
+    const suffixes = ['Btn', 'Button', 'Link', 'Input', 'Checkbox', 'Option', 'Title', 'Label', 'Value', 'Text', 'Wrapper', 'Container', 'Card', 'Item'];
+    for (const suffix of suffixes) {
+        clean = clean.replace(new RegExp(`[-_]?${suffix}$`, 'i'), '');
+    }
+    clean = clean.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+    clean = clean.replace(/^\d+/, '').replace(/\d+$/, '');
+    return clean;
+}
+exports.lookupIndexCache = new WeakMap();
+function buildLookupIndex(config) {
+    const index = new Map();
+    const seenInStrategies = new Map();
+    const addKey = (key, strategy, value) => {
+        const cleanedKey = cleanKey(key);
+        if (seenInStrategies.has(cleanedKey)) {
+            const existing = seenInStrategies.get(cleanedKey);
+            if (!existing.includes(strategy)) {
+                existing.push(strategy);
+            }
+        }
+        else {
+            seenInStrategies.set(cleanedKey, [strategy]);
+        }
+        index.set(cleanedKey, { strategy, value });
+    };
+    // 1. Process testId / testIds (backward compatibility)
+    const testIdConfig = config.testId || config.testIds;
+    if (testIdConfig) {
+        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(testIdConfig);
         for (const key of Object.keys(expanded)) {
-            Object.defineProperty(instance, key, {
-                get: () => {
-                    return context.getByTestId(expanded[key]);
-                },
-                enumerable: true,
-                configurable: true,
-            });
+            addKey(key, 'testId', expanded[key]);
         }
     }
-    if (config.selectors) {
-        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.selectors);
+    // 2. Process selector / selectors (backward compatibility)
+    const selectorConfig = config.selector || config.selectors;
+    if (selectorConfig) {
+        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(selectorConfig);
         for (const key of Object.keys(expanded)) {
-            Object.defineProperty(instance, key, {
-                get: () => {
-                    return context.locator(expanded[key]);
-                },
-                enumerable: true,
-                configurable: true,
-            });
+            addKey(key, 'selector', expanded[key]);
+        }
+    }
+    // 3. Process all other strategies
+    for (const strategy of config_1.strategyList) {
+        if (strategy === 'testId' || strategy === 'selector')
+            continue;
+        const items = config[strategy];
+        if (Array.isArray(items)) {
+            for (const item of items) {
+                if (typeof item === 'string') {
+                    addKey(item, strategy, item);
+                }
+            }
         }
     }
+    // 4. Duplicate Check & Validation
+    for (const [key, strategies] of seenInStrategies.entries()) {
+        if (strategies.length > 1) {
+            throw new Error(`Duplicate locator value "${key}"\n\nFound in\n\n${strategies.join('\n\n')}\n\nLocator values must be globally unique.`);
+        }
+    }
+    return index;
+}
+function defineLocators(instance, context, config) {
+    let index = exports.lookupIndexCache.get(config);
+    if (!index) {
+        index = buildLookupIndex(config);
+        exports.lookupIndexCache.set(config, index);
+    }
+    for (const key of index.keys()) {
+        Object.defineProperty(instance, key, {
+            get: () => {
+                return resolveLocator(context, config, key);
+            },
+            enumerable: true,
+            configurable: true
+        });
+    }
 }
 function resolveLocator(context, config, target, options) {
     if (typeof target !== 'string')
         return target;
     const targetStr = target;
-    const parts = targetStr.split('.');
-    const expandedTestIds = config.testIds ? (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.testIds) : undefined;
-    const expandedSelectors = config.selectors ? (0, dynamic_locator_resolver_1.getExpandedTestIds)(config.selectors) : undefined;
+    let index = exports.lookupIndexCache.get(config);
+    if (!index) {
+        index = buildLookupIndex(config);
+        exports.lookupIndexCache.set(config, index);
+    }
+    const toRegex = (val) => {
+        const escaped = val.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+        return new RegExp(escaped.replace(/\s+/g, '\\s+'), 'i');
+    };
     const resolveSingle = (key, ctx) => {
-        if (expandedTestIds && key in expandedTestIds) {
-            return ctx.getByTestId(expandedTestIds[key]);
+        const cleaned = cleanKey(key);
+        const meta = index.get(cleaned);
+        if (!meta) {
+            throw new Error(`Locator key '${key}' is not defined in page object configuration.`);
+        }
+        const strategy = exports.locatorStrategies[meta.strategy];
+        if (!strategy) {
+            throw new Error(`Unknown locator strategy '${meta.strategy}' for key '${key}'.`);
+        }
+        const { resolver, role } = strategy;
+        if (resolver === 'getByRole') {
+            const val = typeof meta.value === 'string' ? toRegex(meta.value) : meta.value;
+            const roleOptions = { name: val };
+            if (options) {
+                const allowedOptions = ['exact', 'checked', 'disabled', 'expanded', 'includeHidden', 'level', 'pressed', 'selected'];
+                for (const opt of allowedOptions) {
+                    if (opt in options) {
+                        roleOptions[opt] = options[opt];
+                    }
+                }
+            }
+            return ctx[resolver](role, roleOptions);
         }
-        if (expandedSelectors && key in expandedSelectors) {
-            return ctx.locator(expandedSelectors[key]);
+        else if (resolver === 'locator') {
+            return ctx[resolver](meta.value);
+        }
+        else {
+            const opt = {};
+            if (options && 'exact' in options) {
+                opt.exact = options.exact;
+            }
+            const val = typeof meta.value === 'string' ? toRegex(meta.value) : meta.value;
+            return ctx[resolver](val, opt);
         }
-        throw new Error(`Locator key '${key}' is not defined in testIds or selectors.`);
     };
-    let loc = resolveSingle(parts[0], context);
-    for (let i = 1; i < parts.length; i++) {
-        loc = resolveSingle(parts[i], loc);
+    let loc;
+    const cleanedTarget = cleanKey(targetStr);
+    if (index.has(cleanedTarget)) {
+        loc = resolveSingle(targetStr, context);
+    }
+    else if (targetStr.includes('.')) {
+        const parts = targetStr.split('.');
+        loc = resolveSingle(parts[0], context);
+        for (let i = 1; i < parts.length; i++) {
+            loc = resolveSingle(parts[i], loc);
+        }
+    }
+    else {
+        loc = resolveSingle(targetStr, context);
     }
     let resolved = loc;
     if (options?.hasText !== undefined) {
@@ -73,7 +187,9 @@ function resolveLocator(context, config, target, options) {
 function locator(context, config, target, options) {
     const resolved = resolveLocator(context, config, target, { raw: true });
     const filtered = options ? resolved.filter(options) : resolved;
-    const loc = (options && typeof options === 'object' && 'nth' in options && options.nth !== undefined) ? filtered.nth(options.nth) : filtered;
+    const loc = options && typeof options === 'object' && 'nth' in options && options.nth !== undefined
+        ? filtered.nth(options.nth)
+        : filtered;
     return wrapLocatorWithProxy(loc);
 }
 function wrapLocatorWithProxy(loc) {
@@ -116,7 +232,10 @@ function wrapLocatorWithProxy(loc) {
                             }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
                         }
                     }
-                    return test_1.test.step(stepName, () => val.apply(targetLoc, args), { box: true, location: (0, caller_location_1.getCallerLocation)() });
+                    return test_1.test.step(stepName, () => val.apply(targetLoc, args), {
+                        box: true,
+                        location: (0, caller_location_1.getCallerLocation)()
+                    });
                 };
             }
             return val;

package/dist/page/registry.d.ts

@@ -6,17 +6,27 @@ export interface PageConstructor<C extends PageConfig> {
     new (page: Page): TypedPage<C>;
 }
 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 : 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]: 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>, 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({

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,12 +1,7 @@
 import { Page, Locator, expect as playwrightExpect } from '@playwright/test';
-import { TypedLocators, ProxyLocatorMethods, PageKeys, ChainedKeys, DynamicSelectorEntry } from './config';
-import type { DynamicLocatorEntry } from './locators/dynamic-locator-resolver';
+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 | DynamicLocatorEntry>;
-    selectors?: Record<string, string | DynamicSelectorEntry>;
-    url?: string;
-}> {
+declare class TypedPageClass<T extends PageConfig> {
     readonly page: Page;
     readonly context: Page | Locator;
     protected readonly config: T;
@@ -31,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 | DynamicLocatorEntry>;
-    selectors?: Record<string, string | DynamicSelectorEntry>;
-    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 | DynamicLocatorEntry>;
-        selectors?: Record<string, string | DynamicSelectorEntry>;
-        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 | DynamicLocatorEntry>;
-    selectors?: Record<string, string | DynamicSelectorEntry>;
-    url?: string;
-}> = TypedPageType<T>;
+export type TypedPage<T extends PageConfig> = TypedPageType<T>;
 export {};

package/dist/page/typed-page.js

@@ -17,9 +17,7 @@ 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;
@@ -27,9 +25,20 @@ class TypedPageClass {
         (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'
+            '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) {
@@ -40,12 +49,12 @@ class TypedPageClass {
                     const originalFn = desc.value;
                     Object.defineProperty(this, prop, {
                         value: function (...args) {
-                            const words = prop.split(/(?=[A-Z])/).map(w => w.toLowerCase());
+                            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 => {
+                            const formattedArgs = args.map((arg) => {
                                 if (typeof arg === 'object' && arg !== null) {
                                     try {
                                         return JSON.stringify(arg);
@@ -56,9 +65,7 @@ class TypedPageClass {
                                 }
                                 return String(arg);
                             });
-                            const stepName = formattedArgs.length > 0
-                                ? `${sentence} - ${formattedArgs.join(' - ')}`
-                                : sentence;
+                            const stepName = formattedArgs.length > 0 ? `${sentence} - ${formattedArgs.join(' - ')}` : sentence;
                             return test_1.test.step(stepName, () => {
                                 return originalFn.apply(this, args);
                             });
@@ -103,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);