pw-core 1.2.0 → 1.2.1

package/dist/page/assertions/verify-chain.d.ts

@@ -1,5 +1,5 @@
 import { Locator, expect as playwrightExpect } from '@playwright/test';
-import { ChainedKeys, PageKeys } from '../config';
+import { PageKeys, GetStrategyOfKey } from '../config';
 export type VerifyOptions = {
     timeout?: number;
     nth?: number;
@@ -11,64 +11,71 @@ type ModifyMatcherArgs<Args extends any[]> = Args extends [] ? [options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}] : Args extends [any, any?] ? [Args[0], (Exclude<Args[1], undefined> & {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-})?] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [(Exclude<Args[0], undefined> & {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-})?] : [Exclude<Args[0], undefined>, options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-}] : [options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-}];
-type DynamicallyModifiedMatchers<T> = {
-    [K in keyof PlaywrightLocatorMatchers]: K extends 'not' ? Omit<VerifyMatchers<T>, 'not'> : PlaywrightLocatorMatchers[K] extends (...args: infer Args) => any ? (...args: ModifyMatcherArgs<Args>) => Promise<void> : PlaywrightLocatorMatchers[K];
+}] : Args extends [any, any?] ? [
+    Args[0],
+    (Exclude<Args[1], undefined> & {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    })?
+] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [
+    (Exclude<Args[0], undefined> & {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    })?
+] : [
+    Exclude<Args[0], undefined>,
+    options?: {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    }
+] : [
+    options?: {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    }
+];
+type DynamicallyModifiedMatchers<T, Target> = {
+    [K in keyof PlaywrightLocatorMatchers]: K extends 'not' ? Omit<VerifyMatchers<T, Target>, 'not'> : K extends 'toBeChecked' ? Target extends Locator ? (...args: ModifyMatcherArgs<Parameters<PlaywrightLocatorMatchers[K]>>) => Promise<void> : Target extends string ? GetStrategyOfKey<T, Target> extends 'checkbox' | 'radio' ? (...args: ModifyMatcherArgs<Parameters<PlaywrightLocatorMatchers[K]>>) => Promise<void> : never : never : PlaywrightLocatorMatchers[K] extends (...args: infer Args) => any ? (...args: ModifyMatcherArgs<Args>) => Promise<void> : PlaywrightLocatorMatchers[K];
 };
-export type VerifyMatchers<T> = DynamicallyModifiedMatchers<T> & PromiseLike<void> & {
+export type VerifyMatchers<T, Target> = DynamicallyModifiedMatchers<T, Target> & PromiseLike<void> & {
     (options?: Parameters<PlaywrightLocatorMatchers['toBeVisible']>[0] & {
         nth?: number;
         hasText?: string | RegExp;
         message?: string;
     }): Promise<void>;
 };
-export type VerifyFn<T> = (target: PageKeys<T> | ChainedKeys<T> | Locator, options?: VerifyOptions) => VerifyMatchers<T>;
+export type VerifyFn<T> = <Target extends PageKeys<T> | Locator>(target: Target, options?: VerifyOptions) => VerifyMatchers<T, Target>;
 export type AssertionsMethod<T> = {
     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;
         hasText?: string | RegExp;
         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;
         hasText?: string | RegExp;
         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;
         hasText?: string | RegExp;
         message?: string;
     }): Promise<void>;
-    expect(target: PageKeys<T> | ChainedKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
-    locator(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+    expect(target: PageKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
+    locator(target: PageKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
         nth?: number;
     }): Locator;
 };
-export declare function createVerifyChain<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-}>(resolveLocator: (target: any, options?: {
+export declare function createVerifyChain<T>(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     raw?: boolean;
-}) => Locator, target: PageKeys<T> | ChainedKeys<T> | Locator, verifyOptions: VerifyOptions | undefined, isSoft: boolean): VerifyMatchers<T>;
+}) => Locator, target: PageKeys<T> | Locator, verifyOptions: VerifyOptions | undefined, isSoft: boolean): VerifyMatchers<T, any>;
 export {};

package/dist/page/assertions/verify-chain.js

@@ -36,7 +36,17 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                         return baseFn().then(onfulfilled, onrejected);
                     };
                 }
-                const skippedProps = new Set(['then', 'catch', 'finally', 'bind', 'call', 'apply', 'toString', 'valueOf', 'toLocaleString']);
+                const skippedProps = new Set([
+                    'then',
+                    'catch',
+                    'finally',
+                    'bind',
+                    'call',
+                    'apply',
+                    'toString',
+                    'valueOf',
+                    'toLocaleString'
+                ]);
                 if (skippedProps.has(prop)) {
                     return targetObj[prop];
                 }
@@ -45,12 +55,16 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                     const lastIsOptions = lastArg !== null && typeof lastArg === 'object' && !(lastArg instanceof RegExp) && !Array.isArray(lastArg);
                     const valueArgs = lastIsOptions ? args.slice(0, args.length - 1) : args;
                     const options = lastIsOptions ? lastArg : undefined;
-                    const nth = (options && 'nth' in options) ? options.nth : defaultNth;
-                    const hasText = (options && 'hasText' in options) ? options.hasText : defaultHasText;
+                    const nth = options && 'nth' in options ? options.nth : defaultNth;
+                    const hasText = options && 'hasText' in options ? options.hasText : defaultHasText;
                     const isHaveCount = prop === 'toHaveCount';
                     const stepName = options?.message ?? defaultMessage ?? (0, formatter_1.formatAssertionDescription)(target, String(prop), isNegated, valueArgs);
                     await test_1.test.step(stepName, async () => {
-                        const locator = resolveLocator(target, { nth, hasText, raw: isHaveCount });
+                        const locator = resolveLocator(target, {
+                            nth,
+                            hasText,
+                            raw: isHaveCount
+                        });
                         const expectation = expectFn(locator, stepName);
                         const match = isNegated ? expectation.not : expectation;
                         await match[prop](...args);

package/dist/page/assertions/verify-helpers.js

@@ -8,21 +8,30 @@ const formatter_1 = require("../utils/formatter");
 async function verifyHidden(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeHidden', false, [options]);
     await test_1.test.step(stepName, async () => {
-        const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
+        const locator = resolveLocator(target, {
+            nth: options?.nth,
+            hasText: options?.hasText
+        });
         await (0, test_1.expect)(locator, stepName).toBeHidden(options);
     }, { box: true, location });
 }
 async function verifyEnabled(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeEnabled', false, [options]);
     await test_1.test.step(stepName, async () => {
-        const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
+        const locator = resolveLocator(target, {
+            nth: options?.nth,
+            hasText: options?.hasText
+        });
         await (0, test_1.expect)(locator, stepName).toBeEnabled(options);
     }, { box: true, location });
 }
 async function verifyDisabled(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeDisabled', false, [options]);
     await test_1.test.step(stepName, async () => {
-        const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
+        const locator = resolveLocator(target, {
+            nth: options?.nth,
+            hasText: options?.hasText
+        });
         await (0, test_1.expect)(locator, stepName).toBeDisabled(options);
     }, { box: true, location });
 }

package/dist/page/config.d.ts

@@ -1,101 +1,139 @@
-import { Locator, Page } from '@playwright/test';
+import { Locator } from '@playwright/test';
 import type { DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver.js';
 export { ProxyLocatorMethods } from './types/proxy-methods.js';
 export type { DynamicLocatorEntry, DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver.js';
-export declare const zeroArgMethodsList: readonly ["click", "dblclick", "hover", "focus", "blur", "check", "uncheck", "clear", "waitFor", "isChecked", "isDisabled", "isVisible", "textContent", "innerText", "allInnerTexts", "allTextContents", "count", "scrollIntoViewIfNeeded", "boundingBox"];
-export declare const oneArgMethodsList: readonly ["fill", "press", "pressSequentially", "selectOption", "setInputFiles", "getAttribute", "dragTo"];
-export type AllowedZeroArgMethods = typeof zeroArgMethodsList[number];
-export type AllowedOneArgMethods = typeof oneArgMethodsList[number];
-export type AllowedMethodKeys = AllowedZeroArgMethods | AllowedOneArgMethods;
-import { ValidateDynamicEntryProperties, HasDuplicatePlaceholders } from './types/validation.js';
-/**
- * Replaces every `{Name}` placeholder in `Pattern` with `Capitalize<Value>`
- * where `Value` is drawn from the corresponding array in `Entry`.
- * Template-literal unions distribute automatically, producing the full cartesian product.
- */
-type ReplacePattern<Pattern extends string, Entry> = Pattern extends `${infer Before}{${infer Name}}${infer After}` ? Name extends keyof Entry ? Entry[Name] extends readonly string[] ? `${Before}${Capitalize<Entry[Name][number]>}${ReplacePattern<After, Entry> & string}` : never : never : Pattern;
-/**
- * Expands a dynamic key pattern into the union of all concrete (camelCased) keys.
- *
- * @example
- * ```ts
- * type Keys = ExpandDynamicKey<
- *   "{status}{id}Chart",
- *   { status: readonly ['active', 'inactive']; id: readonly ['line', 'bar']; testId: "status-id-chart" }
- * >;
- * // => "activeLineChart" | "activeBarChart" | "inactiveLineChart" | "inactiveBarChart"
- * ```
- */
-type ExpandDynamicKey<Pattern extends string, Entry> = Uncapitalize<ReplacePattern<Pattern, Entry>>;
-/**
- * Resolves every key in a testIds record:
- * - string values → the key itself (static locator)
- * - object values → the expanded dynamic key union
- */
-type ResolvedTestIdKeys<I> = {
-    [K in keyof I & string]: I[K] extends string ? K : ExpandDynamicKey<K, I[K]>;
-}[keyof I & string];
-/**
- * Validates all entries in a testIds or selectors record.
- * Static (string) entries pass through. Dynamic entries are checked via ValidateDynamicEntryProperties.
- */
-type ValidateTestIds<I, TargetKey extends 'testId' | 'selector'> = {
-    [K in keyof I & string]: I[K] extends string ? string : K extends `${string}{${string}}${string}` ? HasDuplicatePlaceholders<K> extends true ? "Error: Pattern contains duplicate placeholders" : ValidateDynamicEntryProperties<K, I[K], TargetKey> : I[K];
-};
+import { AllowedMethodKeys } from '../types/methods';
+import { StrategyType, LocatorStrategyOptions } from '../types/strategies';
+import { ResolvedTestIdKeys, ValidateTestIds } from './types/validation.js';
+export { zeroArgMethodsList, oneArgMethodsList } from '../constants/methods';
+export { rolesList, strategyList } from '../constants/strategies';
+export { AllowedZeroArgMethods, AllowedOneArgMethods, AllowedMethodKeys } from '../types/methods';
+export { RoleType, StrategyType, PlaywrightRoleOptions, PlaywrightTextOptions, LocatorStrategyOptions } from '../types/strategies';
+export type GetStrategyOfKey<T, K extends string> = K extends (T extends {
+    testId: infer I;
+} ? ResolvedTestIdKeys<I> : never) ? 'testId' : K extends (T extends {
+    testIds: infer I;
+} ? ResolvedTestIdKeys<I> : never) ? 'testId' : K extends (T extends {
+    selector: infer S;
+} ? ResolvedTestIdKeys<S> : never) ? 'selector' : K extends (T extends {
+    selectors: infer S;
+} ? ResolvedTestIdKeys<S> : never) ? 'selector' : {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]: K extends (T extends Record<S, readonly string[]> ? T[S][number] : never) ? S : never;
+}[Exclude<StrategyType, 'testId' | 'selector'>];
+export type ModifyOptionsForTarget<T, Target, Options> = Options & {
+    nth?: number;
+    hasText?: string | RegExp;
+} & (Target extends string ? LocatorStrategyOptions<GetStrategyOfKey<T, Target>> : {});
 export type PageKeys<T> = (T extends {
-    testIds?: infer I;
-} ? I extends Record<string, any> ? ResolvedTestIdKeys<I> : never : never) | (T extends {
-    selectors?: infer S;
-} ? S extends Record<string, any> ? ResolvedTestIdKeys<S> : never : never);
+    testId: infer I;
+} ? (I extends Record<string, any> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
+    testIds: infer I;
+} ? (I extends Record<string, any> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
+    selector: infer S;
+} ? (S extends Record<string, any> ? ResolvedTestIdKeys<S> : never) : never) | (T extends {
+    selectors: infer S;
+} ? (S extends Record<string, any> ? ResolvedTestIdKeys<S> : never) : never) | {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}[Exclude<StrategyType, 'testId' | 'selector'>];
+export type CheckableLocatorKeys<T> = {
+    [S in 'checkbox' | 'radio']: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}['checkbox' | 'radio'];
+export type CheckboxLocatorKeys<T> = T extends Record<'checkbox', readonly string[]> ? T['checkbox'][number] : never;
+export type EditableLocatorKeys<T> = {
+    [S in 'label' | 'placeholder' | 'textbox' | 'searchbox']: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}['label' | 'placeholder' | 'textbox' | 'searchbox'];
+export type SelectableLocatorKeys<T> = {
+    [S in 'combobox' | 'listbox' | 'option']: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}['combobox' | 'listbox' | 'option'];
 export type TypedLocators<T> = {
     [K in PageKeys<T>]: Locator;
 };
-export type ChainedKeys<T> = `${PageKeys<T>}.${PageKeys<T>}`;
+export type UniversalKeys<T> = (T extends {
+    testId: infer I;
+} ? ResolvedTestIdKeys<I> : never) | (T extends {
+    testIds: infer I;
+} ? ResolvedTestIdKeys<I> : never) | (T extends {
+    selector: infer S;
+} ? ResolvedTestIdKeys<S> : never) | (T extends {
+    selectors: infer S;
+} ? ResolvedTestIdKeys<S> : never);
+export type SemanticKeys<T> = Exclude<PageKeys<T>, UniversalKeys<T>>;
+export type ChainedKeys<T> = `${UniversalKeys<T>}.${PageKeys<T>}` | `${UniversalKeys<T>}.${SemanticKeys<T>}.${UniversalKeys<T>}` | `${UniversalKeys<T>}.${UniversalKeys<T>}.${PageKeys<T>}`;
 export type TargetKey<T> = PageKeys<T> | ChainedKeys<T> | Locator;
-export type ValidateTarget<K, T> = K extends Locator ? Locator : K extends (PageKeys<T> | ChainedKeys<T>) ? K : never;
+export type ValidateTarget<K, T> = K extends Locator ? Locator : K extends PageKeys<T> | ChainedKeys<T> ? K : never;
 export declare function getOptionsArgumentIndex(methodName: AllowedMethodKeys): number;
-/** Map type accepted by the `testIds` property in a page config. */
+/** Map type accepted by the `testId` property in a page config. */
 export type TestIdMap = Record<string, string | DynamicTestIdEntry>;
 export type SelectorMap = Record<string, string | DynamicSelectorEntry>;
 export type PageConfig = {
     url?: string;
+    testId?: TestIdMap;
+    selector?: SelectorMap;
     testIds?: TestIdMap;
     selectors?: SelectorMap;
-    Class?: new (page: Page, config?: any) => any;
+} & {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]?: readonly string[];
 };
+export type KeysOfStrategy<T, S extends StrategyType> = S extends 'testId' ? T extends {
+    testId: infer I;
+} ? ResolvedTestIdKeys<I> : T extends {
+    testIds: infer I;
+} ? ResolvedTestIdKeys<I> : never : S extends 'selector' ? T extends {
+    selector: infer I;
+} ? ResolvedTestIdKeys<I> : T extends {
+    selectors: infer S2;
+} ? ResolvedTestIdKeys<S2> : never : T extends Record<S, infer A> ? A extends readonly string[] ? A[number] : never : never;
+export type KeysOfOtherStrategies<T, S extends StrategyType> = {
+    [O in Exclude<StrategyType, S>]: KeysOfStrategy<T, O>;
+}[Exclude<StrategyType, S>];
+type GetTestIds<T> = T extends {
+    testId: infer I;
+} ? (I extends Record<string, any> ? I : {}) : T extends {
+    testIds: infer I;
+} ? (I extends Record<string, any> ? I : {}) : {};
+type GetSelectors<T> = T extends {
+    selector: infer S;
+} ? (S extends Record<string, any> ? S : {}) : T extends {
+    selectors: infer S;
+} ? (S extends Record<string, any> ? S : {}) : {};
 export type ValidatePageConfig<T> = {
     url?: string;
+    testId?: T extends {
+        testId: infer I;
+    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId', GetSelectors<T>> & {
+        [K in keyof I]: K extends KeysOfOtherStrategies<T, 'testId'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : TestIdMap : TestIdMap;
     testIds?: T extends {
         testIds: infer I;
-    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId'> : TestIdMap : TestIdMap;
+    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId', GetSelectors<T>> & {
+        [K in keyof I]: K extends KeysOfOtherStrategies<T, 'testId'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : TestIdMap : TestIdMap;
+    selector?: T extends {
+        selector: infer S;
+    } ? S extends Record<string, any> ? ValidateTestIds<S, 'selector', GetTestIds<T>> & {
+        [K in keyof S]: K extends KeysOfOtherStrategies<T, 'selector'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : SelectorMap : SelectorMap;
     selectors?: T extends {
-        testIds: infer I;
         selectors: infer S;
-    } ? S extends Record<string, any> ? {
-        [K in keyof S]: K extends keyof I ? `Duplicate key: ${K & string} already exists in testIds` : ValidateTestIds<S, 'selector'>[K & keyof S & string];
+    } ? S extends Record<string, any> ? ValidateTestIds<S, 'selector', GetTestIds<T>> & {
+        [K in keyof S]: K extends KeysOfOtherStrategies<T, 'selector'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
     } : SelectorMap : SelectorMap;
-    Class?: new (page: Page, config?: any) => any;
+} & {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]?: T extends Record<S, infer A> ? A extends readonly string[] ? {
+        [I in keyof A]: A[I] extends string ? A[I] extends KeysOfOtherStrategies<T, S> ? `Error: Duplicate key "${A[I]}" is defined in multiple strategies` : A[I] : A[I];
+    } : readonly string[] : readonly string[];
 } & {
     [K in Exclude<keyof T, keyof PageConfig>]: never;
 };
 /**
  * Creates a strongly-typed page configuration object containing URLs, testIds, and CSS selectors.
- *
- * @example
- * ```ts
- * import { createPageConfig } from 'pw-core/page';
- *
- * const config = createPageConfig({
- *   url: '/login',
- *   testIds: {
- *     username: 'username-input',
- *     password: 'password-input',
- *     submitBtn: 'login-button',
- *   },
- *   selectors: {
- *     errorAlert: '.alert-danger',
- *   }
- * });
- * ```
  */
 export declare function createPageConfig<const T extends PageConfig>(config: [T] extends [ValidatePageConfig<T>] ? T : ValidatePageConfig<T>): T;

package/dist/page/config.js

@@ -1,45 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oneArgMethodsList = exports.zeroArgMethodsList = void 0;
+exports.strategyList = exports.rolesList = exports.oneArgMethodsList = exports.zeroArgMethodsList = void 0;
 exports.getOptionsArgumentIndex = getOptionsArgumentIndex;
 exports.createPageConfig = createPageConfig;
-exports.zeroArgMethodsList = [
-    'click', 'dblclick', 'hover', 'focus', 'blur', 'check', 'uncheck', 'clear',
-    'waitFor', 'isChecked', 'isDisabled',
-    'isVisible', 'textContent', 'innerText',
-    'allInnerTexts', 'allTextContents', 'count',
-    'scrollIntoViewIfNeeded', 'boundingBox'
-];
-exports.oneArgMethodsList = [
-    'fill', 'press', 'pressSequentially', 'selectOption', 'setInputFiles',
-    'getAttribute', 'dragTo'
-];
+const methods_1 = require("../constants/methods");
+var methods_2 = require("../constants/methods");
+Object.defineProperty(exports, "zeroArgMethodsList", { enumerable: true, get: function () { return methods_2.zeroArgMethodsList; } });
+Object.defineProperty(exports, "oneArgMethodsList", { enumerable: true, get: function () { return methods_2.oneArgMethodsList; } });
+var strategies_1 = require("../constants/strategies");
+Object.defineProperty(exports, "rolesList", { enumerable: true, get: function () { return strategies_1.rolesList; } });
+Object.defineProperty(exports, "strategyList", { enumerable: true, get: function () { return strategies_1.strategyList; } });
 function getOptionsArgumentIndex(methodName) {
-    if (exports.zeroArgMethodsList.includes(methodName))
+    if (methods_1.zeroArgMethodsList.includes(methodName))
         return 0;
-    if (exports.oneArgMethodsList.includes(methodName))
+    if (methods_1.oneArgMethodsList.includes(methodName))
         return 1;
     return -1;
 }
 /**
  * Creates a strongly-typed page configuration object containing URLs, testIds, and CSS selectors.
- *
- * @example
- * ```ts
- * import { createPageConfig } from 'pw-core/page';
- *
- * const config = createPageConfig({
- *   url: '/login',
- *   testIds: {
- *     username: 'username-input',
- *     password: 'password-input',
- *     submitBtn: 'login-button',
- *   },
- *   selectors: {
- *     errorAlert: '.alert-danger',
- *   }
- * });
- * ```
  */
 function createPageConfig(config) {
     return config;

package/dist/page/locators/dynamic-locator-resolver.js

@@ -48,7 +48,7 @@ function capitalize(value) {
 function cartesianProduct(arrays) {
     if (arrays.length === 0)
         return [[]];
-    return arrays.reduce((acc, arr) => acc.flatMap(combo => arr.map(val => [...combo, val])), [[]]);
+    return arrays.reduce((acc, arr) => acc.flatMap((combo) => arr.map((val) => [...combo, val])), [[]]);
 }
 /**
  * Extract placeholder names from a pattern like `"{status}{id}Chart"`.
@@ -88,24 +88,24 @@ function expandSingleDynamic(pattern, entry) {
     }
     // 1. No unknown keys (only placeholder names + targetKey)
     const actualKeys = Object.keys(placeholders);
-    const unknownKeys = actualKeys.filter(k => !expectedNames.includes(k));
+    const unknownKeys = actualKeys.filter((k) => !expectedNames.includes(k));
     if (unknownKeys.length > 0) {
         throw new Error(`Dynamic locator "${pattern}": unknown key(s) [${unknownKeys.join(', ')}]. ` +
             `Only '${targetKey}' and placeholder keys [${expectedNames.join(', ')}] are allowed.`);
     }
     // 2. All placeholders from the pattern must have a key in the entry
-    const missingKeys = expectedNames.filter(name => !(name in placeholders));
+    const missingKeys = expectedNames.filter((name) => !(name in placeholders));
     if (missingKeys.length > 0) {
         throw new Error(`Dynamic locator "${pattern}": missing placeholder key(s) [${missingKeys.join(', ')}]. ` +
             `You must provide values for all placeholders defined in the pattern.`);
     }
     // 2.5. Placeholder values must be arrays
-    const nonArrayKeys = expectedNames.filter(name => !Array.isArray(placeholders[name]));
+    const nonArrayKeys = expectedNames.filter((name) => !Array.isArray(placeholders[name]));
     if (nonArrayKeys.length > 0) {
         throw new Error(`Dynamic locator "${pattern}": placeholder key(s) [${nonArrayKeys.join(', ')}] must be arrays.`);
     }
     // 3. All placeholder names must appear as substrings in the target pattern value
-    const missingInPattern = expectedNames.filter(name => !targetPattern.includes(name));
+    const missingInPattern = expectedNames.filter((name) => !targetPattern.includes(name));
     if (missingInPattern.length > 0) {
         throw new Error(`Dynamic locator "${pattern}": ${targetKey} "${targetPattern}" does not contain ` +
             `placeholder name(s) [${missingInPattern.join(', ')}]. ` +
@@ -114,7 +114,7 @@ function expandSingleDynamic(pattern, entry) {
     // ─── Expansion ───────────────────────────────────────────────────────
     // Sort placeholder names longest-first to avoid substring replacement issues
     const names = Object.keys(placeholders).sort((a, b) => b.length - a.length);
-    const values = names.map(name => {
+    const values = names.map((name) => {
         const v = placeholders[name];
         return v;
     });
@@ -123,11 +123,22 @@ function expandSingleDynamic(pattern, entry) {
         // Build the *key* — replace {name} with Capitalize(value), then uncapitalize the first char
         let expandedKey = pattern;
         let expandedValue = targetPattern;
+        const isPurePlaceholder = pattern === `{${names[0]}}` && names.length === 1;
         for (let i = 0; i < names.length; i++) {
             const name = names[i];
             const val = combo[i];
-            expandedKey = expandedKey.replace(`{${name}}`, capitalize(val));
-            expandedValue = expandedValue.replaceAll(name, targetKey === 'selector' ? val : val.toLowerCase());
+            let capValue = '';
+            if (isPurePlaceholder) {
+                capValue = val;
+            }
+            else {
+                const words = val.split(/[^a-zA-Z0-9]/).filter(Boolean);
+                capValue = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+            }
+            expandedKey = expandedKey.replace(`{${name}}`, capValue);
+            const replacement = targetKey === 'selector' ? val : val.toLowerCase();
+            expandedValue = expandedValue.replaceAll(`{${name}}`, replacement);
+            expandedValue = expandedValue.replaceAll(name, replacement);
         }
         // camelCase: uncapitalize the first character
         expandedKey = expandedKey.charAt(0).toLowerCase() + expandedKey.slice(1);
@@ -143,10 +154,19 @@ function expandDynamicLocators(testIds) {
     const result = {};
     for (const [key, value] of Object.entries(testIds)) {
         if (typeof value === 'string') {
+            if (key in result) {
+                throw new Error(`Duplicate key "${key}" defined in page object configuration.`);
+            }
             result[key] = value;
         }
         else {
-            Object.assign(result, expandSingleDynamic(key, value));
+            const expanded = expandSingleDynamic(key, value);
+            for (const k of Object.keys(expanded)) {
+                if (k in result) {
+                    throw new Error(`Duplicate key "${k}" defined in page object configuration.`);
+                }
+                result[k] = expanded[k];
+            }
         }
     }
     return result;

package/dist/page/locators/resolver.d.ts

@@ -1,25 +1,25 @@
 import { Page, Locator } from '@playwright/test';
-import { ChainedKeys, PageKeys, DynamicSelectorEntry } from '../config';
-import type { DynamicLocatorEntry } from './dynamic-locator-resolver';
-export declare function defineLocators<T extends {
-    testIds?: Record<string, string | DynamicLocatorEntry>;
-    selectors?: Record<string, string | DynamicSelectorEntry>;
-}>(instance: any, context: Page | Locator, config: T): void;
-export declare function resolveLocator<T extends {
-    testIds?: Record<string, string | DynamicLocatorEntry>;
-    selectors?: Record<string, string | DynamicSelectorEntry>;
-}>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: {
+export declare const locatorStrategies: Record<string, {
+    resolver: string;
+    role?: string;
+}>;
+export interface LocatorMetadata {
+    strategy: string;
+    value: any;
+}
+export declare function cleanKey(s: string): string;
+export declare const lookupIndexCache: WeakMap<object, Map<string, LocatorMetadata>>;
+export declare function buildLookupIndex(config: any): Map<string, LocatorMetadata>;
+export declare function defineLocators(instance: any, context: Page | Locator, config: any): void;
+export declare function resolveLocator(context: Page | Locator, config: any, target: any, options?: {
     nth?: number;
     raw?: boolean;
     hasText?: string | RegExp;
-}): Locator;
+} & Record<string, any>): Locator;
 /**
  * Resolve a config key to a proxied Locator with step-wrapped Playwright methods.
  */
-export declare function locator<T extends {
-    testIds?: Record<string, string | DynamicLocatorEntry>;
-    selectors?: Record<string, string | DynamicSelectorEntry>;
-}>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+export declare function locator(context: Page | Locator, config: any, target: any, options?: Parameters<Locator['filter']>[0] & {
     nth?: number;
 }): Locator;
 export declare function wrapLocatorWithProxy(loc: Locator): Locator;