pw-core 1.2.1 → 1.3.1

package/dist/page/config.d.ts

@@ -1,14 +1,14 @@
-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';
-import { AllowedMethodKeys } from '../types/methods';
-import { StrategyType, LocatorStrategyOptions } from '../types/strategies';
-import { ResolvedTestIdKeys, ValidateTestIds } from './types/validation.js';
+import type { Locator } from '@playwright/test';
+import type { DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver';
+export { ProxyLocatorMethods } from './types/proxy-methods';
+export type { DynamicLocatorEntry, DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver';
+import type { AllowedMethodKeys } from '../types/methods';
+import type { StrategyType, LocatorStrategyOptions } from '../types/strategies';
+import type { ResolvedTestIdKeys, ValidateTestIds } from './types/validation';
 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 { AllowedZeroArgMethods, AllowedOneArgMethods, AllowedMethodKeys } from '../types/methods';
+export type { 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 {
@@ -26,13 +26,13 @@ export type ModifyOptionsForTarget<T, Target, Options> = Options & {
 } & (Target extends string ? LocatorStrategyOptions<GetStrategyOfKey<T, Target>> : {});
 export type PageKeys<T> = (T extends {
     testId: infer I;
-} ? (I extends Record<string, any> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
+} ? (I extends Record<string, unknown> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
     testIds: infer I;
-} ? (I extends Record<string, any> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
+} ? (I extends Record<string, unknown> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
     selector: infer S;
-} ? (S extends Record<string, any> ? ResolvedTestIdKeys<S> : never) : never) | (T extends {
+} ? (S extends Record<string, unknown> ? ResolvedTestIdKeys<S> : never) : never) | (T extends {
     selectors: infer S;
-} ? (S extends Record<string, any> ? ResolvedTestIdKeys<S> : never) : never) | {
+} ? (S extends Record<string, unknown> ? 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> = {
@@ -88,43 +88,43 @@ export type KeysOfOtherStrategies<T, S extends StrategyType> = {
 }[Exclude<StrategyType, S>];
 type GetTestIds<T> = T extends {
     testId: infer I;
-} ? (I extends Record<string, any> ? I : {}) : T extends {
+} ? (I extends Record<string, unknown> ? I : {}) : T extends {
     testIds: infer I;
-} ? (I extends Record<string, any> ? I : {}) : {};
+} ? (I extends Record<string, unknown> ? I : {}) : {};
 type GetSelectors<T> = T extends {
     selector: infer S;
-} ? (S extends Record<string, any> ? S : {}) : T extends {
+} ? (S extends Record<string, unknown> ? S : {}) : T extends {
     selectors: infer S;
-} ? (S extends Record<string, any> ? S : {}) : {};
+} ? (S extends Record<string, unknown> ? S : {}) : {};
 export type ValidatePageConfig<T> = {
     url?: string;
     testId?: T extends {
         testId: infer I;
-    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId', GetSelectors<T>> & {
+    } ? I extends Record<string, unknown> ? 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;
+        } : unknown;
     } : TestIdMap : TestIdMap;
     testIds?: T extends {
         testIds: infer I;
-    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId', GetSelectors<T>> & {
+    } ? I extends Record<string, unknown> ? 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;
+        } : unknown;
     } : TestIdMap : TestIdMap;
     selector?: T extends {
         selector: infer S;
-    } ? S extends Record<string, any> ? ValidateTestIds<S, 'selector', GetTestIds<T>> & {
+    } ? S extends Record<string, unknown> ? 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;
+        } : unknown;
     } : SelectorMap : SelectorMap;
     selectors?: T extends {
         selectors: infer S;
-    } ? S extends Record<string, any> ? ValidateTestIds<S, 'selector', GetTestIds<T>> & {
+    } ? S extends Record<string, unknown> ? 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;
+        } : unknown;
     } : SelectorMap : SelectorMap;
 } & {
     [S in Exclude<StrategyType, 'testId' | 'selector'>]?: T extends Record<S, infer A> ? A extends readonly string[] ? {

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

@@ -63,6 +63,24 @@ function extractPlaceholders(pattern) {
     }
     return names;
 }
+function getPlaceholderValues(entry) {
+    const placeholders = {};
+    for (const [key, value] of Object.entries(entry)) {
+        if (key !== 'testId' && key !== 'selector') {
+            placeholders[key] = value;
+        }
+    }
+    return placeholders;
+}
+function collectPlaceholderArrays(placeholders, names) {
+    return names.map((name) => {
+        const value = placeholders[name];
+        if (!Array.isArray(value)) {
+            throw new Error(`Dynamic locator placeholder "${name}" must be an array.`);
+        }
+        return value;
+    });
+}
 /**
  * Expand a single dynamic key pattern + entry into flat key → locator-value pairs.
  * Validates the entry at runtime before expansion.
@@ -71,14 +89,12 @@ function extractPlaceholders(pattern) {
 function expandSingleDynamic(pattern, entry) {
     const testIdPattern = entry.testId;
     const selectorPattern = entry.selector;
-    const targetPattern = (testIdPattern !== undefined ? testIdPattern : selectorPattern);
-    const targetKey = testIdPattern !== undefined ? 'testId' : 'selector';
+    const targetPattern = (testIdPattern ?? selectorPattern);
     if (targetPattern === undefined) {
         throw new Error(`Dynamic locator "${pattern}": entry must contain either 'testId' or 'selector' property.`);
     }
-    const placeholders = { ...entry };
-    delete placeholders.testId;
-    delete placeholders.selector;
+    const targetKey = testIdPattern !== undefined ? 'testId' : 'selector';
+    const placeholders = getPlaceholderValues(entry);
     // ─── Validation ──────────────────────────────────────────────────────
     const expectedNames = extractPlaceholders(pattern);
     // 0.5. No duplicate placeholders in the pattern
@@ -114,10 +130,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 v = placeholders[name];
-        return v;
-    });
+    const values = collectPlaceholderArrays(placeholders, names);
     const result = {};
     for (const combo of cartesianProduct(values)) {
         // Build the *key* — replace {name} with Capitalize(value), then uncapitalize the first char

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

@@ -1,25 +1,31 @@
 import { Page, Locator } from '@playwright/test';
-export declare const locatorStrategies: Record<string, {
+import { PageConfig, StrategyType } from '../config';
+export interface LocatorStrategyDefinition {
     resolver: string;
     role?: string;
-}>;
+}
+export declare const locatorStrategies: Record<string, LocatorStrategyDefinition>;
 export interface LocatorMetadata {
-    strategy: string;
-    value: any;
+    strategy: StrategyType;
+    value: string;
 }
-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?: {
+/** A configured locator key or a raw Playwright locator. */
+export type LocatorTarget = string | Locator;
+/** Shared internal options understood by locator resolution. */
+export type LocatorResolutionOptions = {
     nth?: number;
     raw?: boolean;
     hasText?: string | RegExp;
-} & Record<string, any>): Locator;
+} & Record<string, unknown>;
+export declare function cleanKey(s: string): string;
+export declare const lookupIndexCache: WeakMap<object, Map<string, LocatorMetadata>>;
+export declare function buildLookupIndex(config: PageConfig): Map<string, LocatorMetadata>;
+export declare function defineLocators(instance: object, context: Page | Locator, config: PageConfig): void;
+export declare function resolveLocator(context: Page | Locator, config: PageConfig, target: LocatorTarget, options?: LocatorResolutionOptions): Locator;
 /**
  * Resolve a config key to a proxied Locator with step-wrapped Playwright methods.
  */
-export declare function locator(context: Page | Locator, config: any, target: any, options?: Parameters<Locator['filter']>[0] & {
+export declare function locator(context: Page | Locator, config: PageConfig, target: LocatorTarget, options?: Parameters<Locator['filter']>[0] & {
     nth?: number;
 }): Locator;
 export declare function wrapLocatorWithProxy(loc: Locator): Locator;

package/dist/page/locators/resolver.js

@@ -21,13 +21,27 @@ exports.locatorStrategies = {
     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'];
+    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'), '');
     }
@@ -36,6 +50,14 @@ function cleanKey(s) {
     return clean;
 }
 exports.lookupIndexCache = new WeakMap();
+function getLookupIndex(config) {
+    let index = exports.lookupIndexCache.get(config);
+    if (!index) {
+        index = buildLookupIndex(config);
+        exports.lookupIndexCache.set(config, index);
+    }
+    return index;
+}
 function buildLookupIndex(config) {
     const index = new Map();
     const seenInStrategies = new Map();
@@ -90,11 +112,7 @@ function buildLookupIndex(config) {
     return index;
 }
 function defineLocators(instance, context, config) {
-    let index = exports.lookupIndexCache.get(config);
-    if (!index) {
-        index = buildLookupIndex(config);
-        exports.lookupIndexCache.set(config, index);
-    }
+    const index = getLookupIndex(config);
     for (const key of index.keys()) {
         Object.defineProperty(instance, key, {
             get: () => {
@@ -105,19 +123,63 @@ function defineLocators(instance, context, config) {
         });
     }
 }
-function resolveLocator(context, config, target, options) {
-    if (typeof target !== 'string')
-        return target;
-    const targetStr = target;
-    let index = exports.lookupIndexCache.get(config);
-    if (!index) {
-        index = buildLookupIndex(config);
-        exports.lookupIndexCache.set(config, index);
-    }
+function resolvePlaywrightLocator(ctx, resolver, role, value, options) {
     const toRegex = (val) => {
         const escaped = val.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
         return new RegExp(escaped.replace(/\s+/g, '\\s+'), 'i');
     };
+    if (resolver === 'getByRole') {
+        const val = typeof value === 'string' ? toRegex(value) : 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 && options[opt] !== undefined) {
+                    roleOptions[opt] = options[opt];
+                }
+            }
+        }
+        return ctx.getByRole(role, roleOptions);
+    }
+    if (resolver === 'locator') {
+        return ctx.locator(value);
+    }
+    const opt = {};
+    if (options && 'exact' in options && typeof options.exact === 'boolean') {
+        opt.exact = options.exact;
+    }
+    const val = typeof value === 'string' ? toRegex(value) : value;
+    switch (resolver) {
+        case 'getByTestId':
+            return ctx.getByTestId(val);
+        case 'getByLabel':
+            return ctx.getByLabel(val, opt);
+        case 'getByPlaceholder':
+            return ctx.getByPlaceholder(val, opt);
+        case 'getByAltText':
+            return ctx.getByAltText(val, opt);
+        case 'getByTitle':
+            return ctx.getByTitle(val, opt);
+        case 'getByText':
+            return ctx.getByText(val, opt);
+        default:
+            return typeof val === 'string' ? ctx.locator(val) : ctx.getByText(val, opt);
+    }
+}
+function resolveLocator(context, config, target, options) {
+    if (typeof target !== 'string')
+        return target;
+    const targetStr = target;
+    const index = getLookupIndex(config);
     const resolveSingle = (key, ctx) => {
         const cleaned = cleanKey(key);
         const meta = index.get(cleaned);
@@ -129,30 +191,7 @@ function resolveLocator(context, config, target, options) {
             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);
-        }
-        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);
-        }
+        return resolvePlaywrightLocator(ctx, resolver, role, meta.value, options);
     };
     let loc;
     const cleanedTarget = cleanKey(targetStr);
@@ -192,50 +231,17 @@ function locator(context, config, target, options) {
         : filtered;
     return wrapLocatorWithProxy(loc);
 }
+const ACTION_METHODS = new Set([...config_1.zeroArgMethodsList, ...config_1.oneArgMethodsList]);
 function wrapLocatorWithProxy(loc) {
-    const actionMethods = [...config_1.zeroArgMethodsList, ...config_1.oneArgMethodsList];
     return new Proxy(loc, {
         get: (targetLoc, propKey, receiver) => {
             const val = Reflect.get(targetLoc, propKey, receiver);
-            if (typeof val === 'function' && actionMethods.includes(propKey)) {
+            if (typeof val === 'function' && typeof propKey === 'string' && ACTION_METHODS.has(propKey)) {
                 return (...args) => {
                     const stepName = (0, formatter_1.formatStepDescription)(propKey, targetLoc, args);
-                    if (propKey === 'fill') {
-                        const options = args[1];
-                        let shouldMask = false;
-                        if (options && typeof options === 'object' && options.mask !== undefined) {
-                            shouldMask = options.mask === true;
-                        }
-                        else {
-                            const targetStr = (0, formatter_1.formatTarget)(targetLoc);
-                            const targetStrLower = targetStr.toLowerCase();
-                            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
-                        }
-                        if (shouldMask) {
-                            return test_1.test.step(stepName, async () => {
-                                await targetLoc.focus();
-                                await targetLoc.evaluate((el, val) => {
-                                    const inputEl = el;
-                                    const prototype = el.tagName === 'TEXTAREA'
-                                        ? window.HTMLTextAreaElement.prototype
-                                        : window.HTMLInputElement.prototype;
-                                    const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
-                                    if (descriptor && descriptor.set) {
-                                        descriptor.set.call(inputEl, val);
-                                    }
-                                    else {
-                                        inputEl.value = val;
-                                    }
-                                    inputEl.dispatchEvent(new Event('input', { bubbles: true }));
-                                    inputEl.dispatchEvent(new Event('change', { bubbles: true }));
-                                }, args[0]);
-                            }, { 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, async () => {
+                        return await targetLoc[propKey](...args);
+                    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
                 };
             }
             return val;

package/dist/page/registry.d.ts

@@ -5,12 +5,12 @@ export type PageRegistry = Record<string, PageConfig>;
 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 : TypedPage<T[K]> : TypedPage<T[K]>;
+export type PageRegistryTest<T extends Record<string, PageConfig>, P extends {}, W extends {}, O = {}> = TestType<P & {
+    [K in keyof T]: K extends keyof O ? O[K] extends new (page: Page, ...args: unknown[]) => 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]>;
+    [K in keyof T as K extends `worker${infer R}` ? Uncapitalize<R> : never]: K extends keyof O ? O[K] extends new (page: Page, ...args: unknown[]) => infer R ? R : TypedPage<T[K]> : TypedPage<T[K]>;
 }, W & {
-    [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]>;
+    [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: unknown[]) => infer R ? R : TypedPage<T[K]> : TypedPage<T[K]>;
 } & {
     workerPage: Page;
 }> & {
@@ -29,8 +29,8 @@ export type PageRegistryTest<T extends Record<string, PageConfig>, P, W, O = {}>
         [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;
-    }>, B extends TestType<any, any> = typeof test>(overrides: O2, base?: B): B extends TestType<infer BaseP, infer BaseW> ? PageRegistryTest<T, BaseP, BaseW, O2> : never;
+        [K in keyof T]: new (page: Page, ...args: unknown[]) => unknown;
+    }>, CustomP extends {} = typeof test extends TestType<infer DefaultP, infer _DefaultW> ? DefaultP : {}, CustomW extends {} = typeof test extends TestType<infer _DefaultP, infer DefaultW> ? DefaultW : {}>(overrides: O2, base?: TestType<CustomP, CustomW>): PageRegistryTest<T, CustomP, CustomW, O2>;
 };
 /**
  * Creates a page registry that registers page objects as Playwright fixtures,
@@ -43,35 +43,35 @@ export type PageRegistryTest<T extends Record<string, PageConfig>, P, W, O = {}>
  *
  * // returns the extended test runner directly
  * const test = createPageRegistry({
-    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"]'
-      }
-    }
-  });
+     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({