pw-core 0.0.1

package/dist/component/table.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = exports.TableRows = void 0;
+const test_1 = require("@playwright/test");
+/**
+ * A custom Array subclass representing a list of table rows.
+ * Inherits all standard Array methods while adding type-safe get and getAll capabilities.
+ */
+class TableRows extends Array {
+    constructor(...items) {
+        // Call the base Array constructor
+        super(...items);
+        // Explicitly set the prototype for correct inheritance in ES6 environment
+        Object.setPrototypeOf(this, TableRows.prototype);
+    }
+    get(key, value) {
+        if (arguments.length === 1) {
+            // Return the value of the key from the first row
+            return this[0] ? this[0][key] : undefined;
+        }
+        // Return the first matching row
+        return this.find(row => row[key] === value);
+    }
+    getAll(key, value) {
+        if (arguments.length === 1) {
+            // Return the values of the key from all rows
+            return this.map(row => row[key]);
+        }
+        // Return all matching rows
+        return this.filter(row => row[key] === value);
+    }
+}
+exports.TableRows = TableRows;
+class Table {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    /**
+     * Retrieves all the headers from the table as lowercase strings.
+     */
+    async getHeaders() {
+        return test_1.test.step(`Get headers of table`, async () => {
+            const headers = await this.root.locator('th').evaluateAll(ths => ths.map(th => th.textContent?.trim().toLowerCase() || ''));
+            return headers;
+        });
+    }
+    /**
+     * Retrieves all the rows of the table as typed objects.
+     * Dynamically maps table headers to object keys.
+     */
+    async getRows() {
+        return test_1.test.step('Get table rows', async () => {
+            const headers = await this.getHeaders();
+            const rowsData = await this.root.locator('tbody tr, tr[data-testid="transaction-row"]').evaluateAll((trs, headers) => {
+                return trs.map(tr => {
+                    const cells = Array.from(tr.querySelectorAll('td')).map(td => td.textContent?.trim() || '');
+                    if (cells.length === 0)
+                        return null; // Skip header or empty rows
+                    const rowData = {};
+                    headers.forEach((header, index) => {
+                        if (index < cells.length && header) {
+                            rowData[header] = cells[index];
+                        }
+                    });
+                    return rowData;
+                });
+            }, headers);
+            return rowsData.filter((r) => r !== null);
+        });
+    }
+    /**
+     * Retrieves all rows from the table, returned as a custom TableRows collection
+     * with type-safe finder helper methods.
+     */
+    async get() {
+        const rows = await this.getRows();
+        return new TableRows(...rows);
+    }
+    /**
+     * Gets the total count of data rows in the table.
+     */
+    async getRowCount() {
+        return test_1.test.step('Get table row count', async () => {
+            return await this.root.locator('tbody tr, tr[data-testid="transaction-row"]').evaluateAll(trs => {
+                return trs.filter(tr => tr.querySelectorAll('td').length > 0).length;
+            });
+        });
+    }
+    /**
+     * Retrieves the value of a specific cell by row index and column key.
+     */
+    async getCellValue(rowIndex, column) {
+        return test_1.test.step(`Get table cell value at row ${rowIndex}, column "${String(column)}"`, async () => {
+            const headers = await this.getHeaders();
+            const columnIndex = headers.indexOf(String(column).toLowerCase());
+            if (columnIndex === -1) {
+                throw new Error(`Column "${String(column)}" not found in table headers: ${headers.join(', ')}`);
+            }
+            return await this.root.evaluate((tableEl, { rowIndex, columnIndex }) => {
+                const trs = Array.from(tableEl.querySelectorAll('tbody tr, tr[data-testid="transaction-row"]'));
+                const dataRows = trs.filter(tr => tr.querySelectorAll('td').length > 0);
+                if (rowIndex < 0 || rowIndex >= dataRows.length) {
+                    throw new Error(`Row index ${rowIndex} is out of bounds (0 to ${dataRows.length - 1})`);
+                }
+                const cell = dataRows[rowIndex].querySelectorAll('td')[columnIndex];
+                return cell?.textContent?.trim() ?? '';
+            }, { rowIndex, columnIndex });
+        });
+    }
+}
+exports.Table = Table;

package/dist/helpers.d.ts

@@ -0,0 +1,15 @@
+import type { Page } from '@playwright/test';
+/** Read a value from the browser's localStorage. Returns null if the key is absent. */
+export declare function getLocalStorage(page: Page, key: string): Promise<string | null>;
+/** Write a value to the browser's localStorage. */
+export declare function setLocalStorage(page: Page, key: string, value: string): Promise<void>;
+/** Read a value from the browser's sessionStorage. Returns null if the key is absent. */
+export declare function getSessionStorage(page: Page, key: string): Promise<string | null>;
+/** Write a value to the browser's sessionStorage. */
+export declare function setSessionStorage(page: Page, key: string, value: string): Promise<void>;
+/**
+ * Seeds sessionStorage entries via addInitScript before any navigation.
+ * Only runs when authenticated cookies are present (loaded from storageState),
+ * so unauthenticated tests that clear storageState are unaffected.
+ */
+export declare function seedSessionStorage(page: Page, entries: Record<string, string>): Promise<void>;

package/dist/helpers.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalStorage = getLocalStorage;
+exports.setLocalStorage = setLocalStorage;
+exports.getSessionStorage = getSessionStorage;
+exports.setSessionStorage = setSessionStorage;
+exports.seedSessionStorage = seedSessionStorage;
+/** Read a value from the browser's localStorage. Returns null if the key is absent. */
+async function getLocalStorage(page, key) {
+    return page.evaluate((k) => localStorage.getItem(k), key);
+}
+/** Write a value to the browser's localStorage. */
+async function setLocalStorage(page, key, value) {
+    await page.evaluate(([k, v]) => localStorage.setItem(k, v), [key, value]);
+}
+/** Read a value from the browser's sessionStorage. Returns null if the key is absent. */
+async function getSessionStorage(page, key) {
+    return page.evaluate((k) => sessionStorage.getItem(k), key);
+}
+/** Write a value to the browser's sessionStorage. */
+async function setSessionStorage(page, key, value) {
+    await page.evaluate(([k, v]) => sessionStorage.setItem(k, v), [key, value]);
+}
+/**
+ * Seeds sessionStorage entries via addInitScript before any navigation.
+ * Only runs when authenticated cookies are present (loaded from storageState),
+ * so unauthenticated tests that clear storageState are unaffected.
+ */
+async function seedSessionStorage(page, entries) {
+    const cookies = await page.context().cookies();
+    if (cookies.length > 0) {
+        const pairs = Object.entries(entries);
+        await page.addInitScript((items) => {
+            for (const [key, value] of items) {
+                sessionStorage.setItem(key, value);
+            }
+        }, pairs);
+    }
+}

package/dist/page/actions/locator-actions.d.ts

@@ -0,0 +1,10 @@
+import { Locator } from '@playwright/test';
+import { AllowedMethodKeys } from '../config';
+export declare function executeAction(prop: AllowedMethodKeys, resolveLocatorFn: (target: any, options?: {
+    nth?: number;
+    raw?: boolean;
+}) => Locator, timeout: number | undefined, args: any[]): Promise<any>;
+export declare function defineActionMethods(instance: any, resolveLocatorFn: (target: any, options?: {
+    nth?: number;
+    raw?: boolean;
+}) => Locator, timeout: number | undefined): void;

package/dist/page/actions/locator-actions.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAction = executeAction;
+exports.defineActionMethods = defineActionMethods;
+const test_1 = require("@playwright/test");
+const config_1 = require("../config");
+const formatter_1 = require("../utils/formatter");
+function executeAction(prop, resolveLocatorFn, timeout, args) {
+    const [locatorKey, ...methodArgs] = args;
+    let optNth = undefined;
+    const optionsIndex = (0, config_1.getOptionsArgumentIndex)(prop);
+    if (optionsIndex !== -1 && methodArgs.length > optionsIndex) {
+        const opts = methodArgs[optionsIndex];
+        if (opts && typeof opts === 'object' && 'nth' in opts) {
+            optNth = opts.nth;
+        }
+    }
+    const isCount = prop === 'count';
+    const locator = resolveLocatorFn(locatorKey, { nth: optNth, raw: isCount });
+    const method = locator[prop];
+    if (typeof method !== 'function') {
+        throw new Error(`Property '${prop}' does not exist on Locator.`);
+    }
+    if (prop === 'dragTo' && methodArgs.length > 0) {
+        methodArgs[0] = resolveLocatorFn(methodArgs[0]);
+    }
+    if (timeout !== undefined) {
+        if (optionsIndex !== -1) {
+            while (methodArgs.length < optionsIndex) {
+                methodArgs.push(undefined);
+            }
+            const existingOptions = methodArgs[optionsIndex] || {};
+            methodArgs[optionsIndex] = { timeout, ...existingOptions };
+        }
+    }
+    const stepName = (0, formatter_1.formatStepDescription)(prop, locatorKey, methodArgs);
+    if (prop === 'fill' && methodArgs.length > 1) {
+        const opts = methodArgs[1];
+        if (opts && typeof opts === 'object' && 'mask' in opts) {
+            const { mask, ...playwrightOpts } = opts;
+            methodArgs[1] = playwrightOpts;
+        }
+    }
+    return test_1.test.step(stepName, () => {
+        return method.apply(locator, methodArgs);
+    });
+}
+function defineActionMethods(instance, resolveLocatorFn, timeout) {
+    const locatorMethods = [...config_1.zeroArgMethodsList, ...config_1.oneArgMethodsList];
+    for (const prop of locatorMethods) {
+        Object.defineProperty(instance, prop, {
+            value: (...args) => {
+                return executeAction(prop, resolveLocatorFn, timeout, args);
+            },
+            writable: true,
+            configurable: true,
+            enumerable: false
+        });
+    }
+}

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

@@ -0,0 +1,39 @@
+import { Page, expect as playwrightExpect } from '@playwright/test';
+type GotoOptions = {
+    referrer?: string;
+    timeout?: number;
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
+};
+type ToHaveURLOptions = Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveURL']>[1];
+type ToHaveTitleOptions = Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveTitle']>[1];
+/**
+ * Navigate to the page URL defined in the page config.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-goto Page.goto} in a test step.
+ */
+export declare function goto(page: Page, url: string | undefined, constructorName: string, options?: GotoOptions): Promise<void>;
+/**
+ * Assert the current URL matches the page config URL or a custom pattern.
+ * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-url expect(page).toHaveURL}.
+ */
+export declare function verifyURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | ToHaveURLOptions, options?: ToHaveURLOptions): Promise<void>;
+/**
+ * Assert the page title matches the expected value.
+ * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-title expect(page).toHaveTitle}.
+ */
+export declare function verifyTitle(page: Page, title: string | RegExp, options?: ToHaveTitleOptions): Promise<void>;
+/**
+ * Reload the page.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-reload Page.reload} in a test step.
+ */
+export declare function reload(page: Page, options?: Parameters<Page['reload']>[0]): Promise<void>;
+/**
+ * Wait for the page to reach a load state.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-load-state Page.waitForLoadState} in a test step.
+ */
+export declare function waitForLoadState(page: Page, state?: Parameters<Page['waitForLoadState']>[0], options?: Parameters<Page['waitForLoadState']>[1]): Promise<void>;
+/**
+ * Wait for navigation to a URL. Defaults to the page config URL when no pattern is given.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-url Page.waitForURL} in a test step.
+ */
+export declare function waitForURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | Parameters<Page['waitForURL']>[1], options?: Parameters<Page['waitForURL']>[1]): Promise<void>;
+export {};

package/dist/page/actions/page-actions.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goto = goto;
+exports.verifyURL = verifyURL;
+exports.verifyTitle = verifyTitle;
+exports.reload = reload;
+exports.waitForLoadState = waitForLoadState;
+exports.waitForURL = waitForURL;
+const test_1 = require("@playwright/test");
+function resolveUrlPattern(url, constructorName, urlOrOptions, options) {
+    let targetUrl;
+    let actualOptions = options;
+    if (urlOrOptions !== undefined && (typeof urlOrOptions === 'string' || urlOrOptions instanceof RegExp)) {
+        if (typeof urlOrOptions === 'string') {
+            targetUrl = new RegExp('.*' + urlOrOptions.replace('/#', ''));
+        }
+        else {
+            targetUrl = urlOrOptions;
+        }
+    }
+    else {
+        if (!url) {
+            throw new Error(`URL is not defined on ${constructorName}`);
+        }
+        targetUrl = new RegExp('.*' + url.replace('/#', ''));
+        if (typeof urlOrOptions === 'object') {
+            actualOptions = urlOrOptions;
+        }
+    }
+    return { targetUrl, actualOptions };
+}
+/**
+ * Navigate to the page URL defined in the page config.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-goto Page.goto} in a test step.
+ */
+async function goto(page, url, constructorName, options) {
+    await test_1.test.step(`Goto "${url || ''}"`, async () => {
+        if (!url) {
+            throw new Error(`URL is not defined on ${constructorName}`);
+        }
+        await page.goto(url, options);
+    });
+}
+/**
+ * Assert the current URL matches the page config URL or a custom pattern.
+ * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-url expect(page).toHaveURL}.
+ */
+async function verifyURL(page, url, constructorName, urlOrOptions, options) {
+    const { targetUrl, actualOptions } = resolveUrlPattern(url, constructorName, urlOrOptions, options);
+    const stepName = `Verify URL matches "${targetUrl.toString()}"`;
+    await test_1.test.step(stepName, async () => {
+        await (0, test_1.expect)(page).toHaveURL(targetUrl, actualOptions);
+    });
+}
+/**
+ * Assert the page title matches the expected value.
+ * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-title expect(page).toHaveTitle}.
+ */
+async function verifyTitle(page, title, options) {
+    const stepName = `Verify title matches "${title}"`;
+    await test_1.test.step(stepName, async () => {
+        await (0, test_1.expect)(page).toHaveTitle(title, options);
+    });
+}
+/**
+ * Reload the page.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-reload Page.reload} in a test step.
+ */
+async function reload(page, options) {
+    await test_1.test.step('Reload page', async () => {
+        await page.reload(options);
+    });
+}
+/**
+ * Wait for the page to reach a load state.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-load-state Page.waitForLoadState} in a test step.
+ */
+async function waitForLoadState(page, state, options) {
+    const stepName = `Wait for load state "${state ?? 'load'}"`;
+    await test_1.test.step(stepName, async () => {
+        await page.waitForLoadState(state, options);
+    });
+}
+/**
+ * Wait for navigation to a URL. Defaults to the page config URL when no pattern is given.
+ * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-url Page.waitForURL} in a test step.
+ */
+async function waitForURL(page, url, constructorName, urlOrOptions, options) {
+    let targetUrl;
+    let actualOptions = options;
+    if (urlOrOptions !== undefined && (typeof urlOrOptions === 'string' || urlOrOptions instanceof RegExp)) {
+        targetUrl = urlOrOptions;
+    }
+    else {
+        if (!url) {
+            throw new Error(`URL is not defined on ${constructorName}`);
+        }
+        targetUrl = url;
+        if (typeof urlOrOptions === 'object') {
+            actualOptions = urlOrOptions;
+        }
+    }
+    const stepName = `Wait for URL "${targetUrl.toString()}"`;
+    await test_1.test.step(stepName, async () => {
+        await page.waitForURL(targetUrl, actualOptions);
+    });
+}

package/dist/page/assertions/expect.d.ts

@@ -0,0 +1,2 @@
+import { Locator, expect as playwrightExpect } from '@playwright/test';
+export declare function typedExpect(resolved: Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;

package/dist/page/assertions/expect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedExpect = typedExpect;
+const test_1 = require("@playwright/test");
+function typedExpect(resolved, message) {
+    return (0, test_1.expect)(resolved, message);
+}

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

@@ -0,0 +1,63 @@
+import { Locator, expect as playwrightExpect } from '@playwright/test';
+import { ChainedKeys, PageKeys } from '../config';
+export type VerifyOptions = {
+    timeout?: number;
+    nth?: number;
+    message?: string;
+};
+type PlaywrightLocatorMatchers = ReturnType<typeof playwrightExpect<Locator>>;
+type ModifyMatcherArgs<Args extends any[]> = Args extends [] ? [options?: {
+    nth?: number;
+    message?: string;
+}] : Args extends [any, any?] ? [Args[0], (Exclude<Args[1], undefined> & {
+    nth?: number;
+    message?: string;
+})?] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [(Exclude<Args[0], undefined> & {
+    nth?: number;
+    message?: string;
+})?] : [Exclude<Args[0], undefined>, options?: {
+    nth?: number;
+    message?: string;
+}] : [options?: {
+    nth?: number;
+    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];
+};
+export type VerifyMatchers<T> = DynamicallyModifiedMatchers<T> & PromiseLike<void> & {
+    (options?: Parameters<PlaywrightLocatorMatchers['toBeVisible']>[0] & {
+        nth?: number;
+        message?: string;
+    }): Promise<void>;
+};
+export type VerifyFn<T> = (target: PageKeys<T> | ChainedKeys<T> | Locator, options?: VerifyOptions) => VerifyMatchers<T>;
+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] & {
+        nth?: number;
+        message?: string;
+    }): Promise<void>;
+    verifyEnabled(target: PageKeys<T> | ChainedKeys<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] & {
+        nth?: number;
+        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] & {
+        nth?: number;
+    }): Locator;
+};
+export declare function createVerifyChain<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+}>(resolveLocator: (target: any, options?: {
+    nth?: number;
+    raw?: boolean;
+}) => Locator, target: PageKeys<T> | ChainedKeys<T> | Locator, verifyOptions: VerifyOptions | undefined, isSoft: boolean): VerifyMatchers<T>;
+export {};

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVerifyChain = createVerifyChain;
+const test_1 = require("@playwright/test");
+const formatter_1 = require("../utils/formatter");
+function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
+    const defaultNth = verifyOptions?.nth;
+    const defaultMessage = verifyOptions?.message;
+    const expectFn = isSoft ? test_1.expect.soft : test_1.expect;
+    const createMatcher = (isNegated) => {
+        const baseFn = async (options) => {
+            const nth = options?.nth !== undefined ? options.nth : defaultNth;
+            const stepName = options?.message ?? defaultMessage ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeVisible', isNegated, [options]);
+            await test_1.test.step(stepName, async () => {
+                const locator = resolveLocator(target, { nth });
+                const expectation = expectFn(locator, stepName);
+                const match = isNegated ? expectation.not : expectation;
+                await match.toBeVisible(options);
+            });
+        };
+        return new Proxy(baseFn, {
+            get(targetObj, prop) {
+                if (typeof prop === 'symbol') {
+                    return targetObj[prop];
+                }
+                if (prop === 'not') {
+                    if (isNegated)
+                        return undefined;
+                    return createMatcher(true);
+                }
+                if (prop === 'then') {
+                    return (onfulfilled, onrejected) => {
+                        return baseFn().then(onfulfilled, onrejected);
+                    };
+                }
+                const skippedProps = new Set(['then', 'catch', 'finally', 'bind', 'call', 'apply', 'toString', 'valueOf', 'toLocaleString']);
+                if (skippedProps.has(prop)) {
+                    return targetObj[prop];
+                }
+                return async (...args) => {
+                    const lastArg = args[args.length - 1];
+                    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 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, raw: isHaveCount });
+                        const expectation = expectFn(locator, stepName);
+                        const match = isNegated ? expectation.not : expectation;
+                        await match[prop](...args);
+                    });
+                };
+            }
+        });
+    };
+    return createMatcher(false);
+}

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

@@ -0,0 +1,22 @@
+import { Locator, expect as playwrightExpect } from '@playwright/test';
+export declare function verifyHidden(resolveLocator: (target: any, options?: {
+    nth?: number;
+    raw?: boolean;
+}) => Locator, target: any, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeHidden']>[0] & {
+    nth?: number;
+    message?: string;
+}): Promise<void>;
+export declare function verifyEnabled(resolveLocator: (target: any, options?: {
+    nth?: number;
+    raw?: boolean;
+}) => Locator, target: any, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeEnabled']>[0] & {
+    nth?: number;
+    message?: string;
+}): Promise<void>;
+export declare function verifyDisabled(resolveLocator: (target: any, options?: {
+    nth?: number;
+    raw?: boolean;
+}) => Locator, target: any, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeDisabled']>[0] & {
+    nth?: number;
+    message?: string;
+}): Promise<void>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyHidden = verifyHidden;
+exports.verifyEnabled = verifyEnabled;
+exports.verifyDisabled = verifyDisabled;
+const test_1 = require("@playwright/test");
+const formatter_1 = require("../utils/formatter");
+async function verifyHidden(resolveLocator, target, options) {
+    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 });
+        await (0, test_1.expect)(locator, stepName).toBeHidden(options);
+    });
+}
+async function verifyEnabled(resolveLocator, target, options) {
+    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 });
+        await (0, test_1.expect)(locator, stepName).toBeEnabled(options);
+    });
+}
+async function verifyDisabled(resolveLocator, target, options) {
+    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 });
+        await (0, test_1.expect)(locator, stepName).toBeDisabled(options);
+    });
+}

package/dist/page/config.d.ts

@@ -0,0 +1,31 @@
+import { Locator, Page } from '@playwright/test';
+export { ProxyLocatorMethods } from './types/proxy-methods';
+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;
+export type PageKeys<T> = (T extends {
+    testIds?: infer I;
+} ? keyof I & string : never) | (T extends {
+    selectors?: infer S;
+} ? keyof S & string : never);
+export type TypedLocators<T> = {
+    [K in PageKeys<T>]: Locator;
+};
+export type ChainedKeys<T> = `${PageKeys<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 declare function getOptionsArgumentIndex(methodName: AllowedMethodKeys): number;
+export type PageConfig<T = any> = {
+    url?: string;
+    testIds?: Record<string, string>;
+    selectors?: T extends {
+        testIds: infer I;
+        selectors: infer S;
+    } ? {
+        [K in keyof S]: K extends keyof I ? `Duplicate key: ${K & string} already exists in testIds` : S[K];
+    } : Record<string, string>;
+    Class?: new (page: Page, config?: any) => any;
+};
+export declare function createPageConfig<T extends PageConfig<T>>(config: T): T;

package/dist/page/config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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'
+];
+function getOptionsArgumentIndex(methodName) {
+    if (exports.zeroArgMethodsList.includes(methodName))
+        return 0;
+    if (exports.oneArgMethodsList.includes(methodName))
+        return 1;
+    return -1;
+}
+function createPageConfig(config) {
+    return config;
+}

package/dist/page/index.d.ts

@@ -0,0 +1,10 @@
+export * from './config';
+export * from './utils/formatter';
+export * from './assertions/verify-chain';
+export * from './assertions/verify-helpers';
+export * from './assertions/expect';
+export * from './actions/page-actions';
+export * from './actions/locator-actions';
+export * from './locators/resolver';
+export * from './typed-page';
+export * from './registry';