pw-core 0.0.1

package/dist/page/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./utils/formatter"), exports);
+__exportStar(require("./assertions/verify-chain"), exports);
+__exportStar(require("./assertions/verify-helpers"), exports);
+__exportStar(require("./assertions/expect"), exports);
+__exportStar(require("./actions/page-actions"), exports);
+__exportStar(require("./actions/locator-actions"), exports);
+__exportStar(require("./locators/resolver"), exports);
+__exportStar(require("./typed-page"), exports);
+__exportStar(require("./registry"), exports);

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

@@ -0,0 +1,23 @@
+import { Page, Locator } from '@playwright/test';
+import { ChainedKeys, PageKeys } from '../config';
+export declare function defineLocators<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+}>(instance: any, context: Page | Locator, config: T): void;
+export declare function resolveLocator<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+}>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: {
+    nth?: number;
+    raw?: boolean;
+}): Locator;
+/**
+ * Resolve a config key to a proxied Locator with step-wrapped Playwright methods.
+ */
+export declare function locator<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+}>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+    nth?: number;
+}): Locator;
+export declare function wrapLocatorWithProxy(loc: Locator): Locator;

package/dist/page/locators/resolver.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineLocators = defineLocators;
+exports.resolveLocator = resolveLocator;
+exports.locator = locator;
+exports.wrapLocatorWithProxy = wrapLocatorWithProxy;
+const test_1 = require("@playwright/test");
+const config_1 = require("../config");
+const formatter_1 = require("../utils/formatter");
+function defineLocators(instance, context, config) {
+    if (config.testIds) {
+        for (const key of Object.keys(config.testIds)) {
+            Object.defineProperty(instance, key, {
+                get: () => {
+                    return context.getByTestId(config.testIds[key]);
+                },
+                enumerable: true,
+                configurable: true,
+            });
+        }
+    }
+    if (config.selectors) {
+        for (const key of Object.keys(config.selectors)) {
+            Object.defineProperty(instance, key, {
+                get: () => {
+                    return context.locator(config.selectors[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 resolveSingle = (key, ctx) => {
+        if (config.testIds && key in config.testIds) {
+            return ctx.getByTestId(config.testIds[key]);
+        }
+        if (config.selectors && key in config.selectors) {
+            return ctx.locator(config.selectors[key]);
+        }
+        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);
+    }
+    if (options?.raw) {
+        return loc;
+    }
+    if (options?.nth !== undefined) {
+        return loc.nth(options.nth);
+    }
+    return loc.first();
+}
+/**
+ * Resolve a config key to a proxied Locator with step-wrapped Playwright methods.
+ */
+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;
+    return wrapLocatorWithProxy(loc);
+}
+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)) {
+                return (...args) => {
+                    const stepName = (0, formatter_1.formatStepDescription)(propKey, targetLoc, args);
+                    return test_1.test.step(stepName, () => val.apply(targetLoc, args));
+                };
+            }
+            return val;
+        }
+    });
+}

package/dist/page/registry.d.ts

@@ -0,0 +1,20 @@
+import test, { Page, TestType } from '@playwright/test';
+import { PageConfig } from './config';
+import { TypedPage } from './typed-page';
+export type PageRegistry = Record<string, PageConfig>;
+export interface PageConstructor<C extends PageConfig<any>> {
+    new (page: Page): TypedPage<C>;
+}
+export interface PageRegistryObject<T extends Record<string, PageConfig<any>>> {
+    classes: {
+        [K in keyof T]: PageConstructor<T[K]>;
+    };
+    extend<O extends Partial<{
+        [K in keyof T]: new (page: Page, ...args: any[]) => any;
+    }>, B extends TestType<any, any> = typeof test>(overrides: O, base?: B): B extends TestType<infer P, infer W> ? TestType<P & {
+        [K in keyof T]: K extends keyof O ? O[K] extends new (...args: any[]) => infer R ? R : TypedPage<T[K]> : TypedPage<T[K]>;
+    }, W> : never;
+}
+export declare function createPageRegistry<T extends {
+    [K in keyof T]: PageConfig<T[K]>;
+} & Record<string, PageConfig<any>>>(registry: T): PageRegistryObject<T>;

package/dist/page/registry.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageRegistry = createPageRegistry;
+const test_1 = __importDefault(require("@playwright/test"));
+const typed_page_1 = require("./typed-page");
+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);
+            }
+        });
+    }
+    return {
+        classes,
+        extend(overrides, base = test_1.default) {
+            const fixtures = {};
+            for (const key of Object.keys(registry)) {
+                fixtures[key] = async ({ page }, use) => {
+                    const config = registry[key];
+                    const PageClass = overrides[key] || classes[key];
+                    const instance = new PageClass(page);
+                    await use(instance);
+                };
+            }
+            return base.extend(fixtures);
+        }
+    };
+}

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

@@ -0,0 +1,78 @@
+import { Page, Locator, expect as playwrightExpect } from '@playwright/test';
+import { TypedLocators, ProxyLocatorMethods, PageKeys, ChainedKeys } from './config';
+import { VerifyFn, AssertionsMethod } from './assertions/verify-chain';
+declare class TypedPageClass<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+    url?: string;
+}> {
+    readonly page: Page;
+    readonly context: Page | Locator;
+    protected readonly config: T;
+    readonly url?: string;
+    timeout?: number;
+    constructor(context: Page | Locator, config: T, options?: {
+        timeout?: number;
+    });
+    /** Navigate to the URL from page config. */
+    goto(options?: {
+        referrer?: string;
+        timeout?: number;
+        waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
+    }): Promise<void>;
+    /** Assert the current URL matches the page config URL or a custom pattern. */
+    verifyURL(urlOrOptions?: string | RegExp | Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveURL']>[1], options?: Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveURL']>[1]): Promise<void>;
+    /** Assert the page title matches the expected value. */
+    verifyTitle(title: string | RegExp, options?: Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveTitle']>[1]): Promise<void>;
+    /** Reload the current page. */
+    reload(options?: Parameters<Page['reload']>[0]): Promise<void>;
+    /** Wait for the page to reach a load state. */
+    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?: {
+        nth?: number;
+        raw?: boolean;
+    }): 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] & {
+        nth?: number;
+    }): 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] & {
+        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>>;
+}
+export type TypedPageType<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+    url?: string;
+}> = TypedPageClass<T> & TypedLocators<T> & ProxyLocatorMethods<T> & AssertionsMethod<T>;
+export declare const TypedPage: {
+    new <T extends {
+        testIds?: Record<string, string>;
+        selectors?: Record<string, string>;
+        url?: string;
+    }>(context: Page | Locator, config: T, options?: {
+        timeout?: number;
+    }): TypedPageType<T>;
+};
+export type TypedPage<T extends {
+    testIds?: Record<string, string>;
+    selectors?: Record<string, string>;
+    url?: string;
+}> = TypedPageType<T>;
+export {};

package/dist/page/typed-page.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedPage = void 0;
+const verify_chain_1 = require("./assertions/verify-chain");
+const verify_helpers_1 = require("./assertions/verify-helpers");
+const expect_1 = require("./assertions/expect");
+const page_actions_1 = require("./actions/page-actions");
+const locator_actions_1 = require("./actions/locator-actions");
+const resolver_1 = require("./locators/resolver");
+class TypedPageClass {
+    page;
+    context;
+    config;
+    url;
+    timeout;
+    constructor(context, config, options) {
+        this.context = context;
+        this.page = typeof context.page === 'function'
+            ? context.page()
+            : context;
+        this.config = config;
+        this.url = config.url;
+        this.timeout = options?.timeout;
+        (0, resolver_1.defineLocators)(this, this.context, this.config);
+        (0, locator_actions_1.defineActionMethods)(this, this.resolveLocator.bind(this), this.timeout);
+    }
+    /** Navigate to the URL from page config. */
+    async goto(options) {
+        return (0, page_actions_1.goto)(this.page, this.url, this.constructor.name, options);
+    }
+    /** Assert the current URL matches the page config URL or a custom pattern. */
+    async verifyURL(urlOrOptions, options) {
+        return (0, page_actions_1.verifyURL)(this.page, this.url, this.constructor.name, urlOrOptions, options);
+    }
+    /** Assert the page title matches the expected value. */
+    async verifyTitle(title, options) {
+        return (0, page_actions_1.verifyTitle)(this.page, title, options);
+    }
+    /** Reload the current page. */
+    async reload(options) {
+        return (0, page_actions_1.reload)(this.page, options);
+    }
+    /** Wait for the page to reach a load state. */
+    async waitForLoadState(state, options) {
+        return (0, page_actions_1.waitForLoadState)(this.page, state, options);
+    }
+    /** Wait for navigation to a URL. Defaults to the page config URL. */
+    async waitForURL(urlOrOptions, options) {
+        return (0, page_actions_1.waitForURL)(this.page, this.url, this.constructor.name, urlOrOptions, options);
+    }
+    resolveLocator(target, options) {
+        return (0, resolver_1.resolveLocator)(this.context, this.config, target, options);
+    }
+    /** Resolve a config key to a proxied Locator with step-wrapped methods. */
+    locator(target, options) {
+        return (0, resolver_1.locator)(this.context, this.config, target, options);
+    }
+    /** 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);
+        fn.soft = (target, opts) => (0, verify_chain_1.createVerifyChain)(this.resolveLocator.bind(this), target, opts, true);
+        return fn;
+    }
+    async verifyHidden(target, options) {
+        return (0, verify_helpers_1.verifyHidden)(this.resolveLocator.bind(this), target, options);
+    }
+    async verifyEnabled(target, options) {
+        return (0, verify_helpers_1.verifyEnabled)(this.resolveLocator.bind(this), target, options);
+    }
+    async verifyDisabled(target, options) {
+        return (0, verify_helpers_1.verifyDisabled)(this.resolveLocator.bind(this), target, options);
+    }
+    expect(target, message) {
+        const resolved = typeof target !== 'string' ? target : this.resolveLocator(target);
+        return (0, expect_1.typedExpect)(resolved, message);
+    }
+}
+exports.TypedPage = TypedPageClass;

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

@@ -0,0 +1,53 @@
+import { Locator } from '@playwright/test';
+import type { PageKeys, ChainedKeys } from '../config';
+/**
+ * Playwright Locator methods proxied onto the page object.
+ * Each method resolves a config key (or Locator) as the first argument.
+ *
+ * @example
+ * ```ts
+ * await page.click('submit');
+ * await page.fill('username', 'alice', { nth: 1 });
+ * ```
+ *
+ * pw-core adds `nth` to options — targets a specific match when multiple elements resolve.
+ */
+type ProxyKeys = 'click' | 'dblclick' | 'hover' | 'focus' | 'blur' | 'check' | 'uncheck' | 'clear' | 'waitFor' | 'isChecked' | 'isDisabled' | 'isVisible' | 'textContent' | 'innerText' | 'allInnerTexts' | 'allTextContents' | 'count' | 'scrollIntoViewIfNeeded' | 'boundingBox' | 'press' | 'pressSequentially' | 'selectOption' | 'setInputFiles' | 'getAttribute';
+type ModifyProxyArgs<Args extends any[]> = Args extends [] ? [options?: {
+    nth?: number;
+}] : Args extends [any, any?] ? [Args[0], (Exclude<Args[1], undefined> & {
+    nth?: number;
+})?] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [(Exclude<Args[0], undefined> & {
+    nth?: number;
+})?] : [Exclude<Args[0], undefined>, options?: {
+    nth?: number;
+}] : [options?: {
+    nth?: number;
+}];
+type BaseProxyLocatorMethods<T> = {
+    [K in keyof Locator as K extends ProxyKeys ? K : never]: (target: PageKeys<T> | ChainedKeys<T> | Locator, ...args: ModifyProxyArgs<Parameters<Locator[K]>>) => ReturnType<Locator[K]>;
+};
+/**
+ * Playwright Locator methods proxied onto the page object.
+ * Each method resolves a config key (or Locator) as the first argument.
+ *
+ * @example
+ * ```ts
+ * await page.click('submit');
+ * await page.fill('username', 'alice', { nth: 1 });
+ * ```
+ *
+ * pw-core adds `nth` to options — targets a specific match when multiple elements resolve.
+ */
+export interface ProxyLocatorMethods<T> extends BaseProxyLocatorMethods<T> {
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-fill Locator.fill} */
+    fill(target: PageKeys<T> | ChainedKeys<T> | Locator, value: string, options?: Parameters<Locator['fill']>[1] & {
+        nth?: number;
+        mask?: boolean;
+    }): Promise<void>;
+    /** @see {@link https://playwright.dev/docs/api/class-locator#locator-drag-to Locator.dragTo} */
+    dragTo(target: PageKeys<T> | ChainedKeys<T> | Locator, destination: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['dragTo']>[1] & {
+        nth?: number;
+    }): Promise<void>;
+}
+export {};

package/dist/page/types/proxy-methods.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/page/utils/formatter.d.ts

@@ -0,0 +1,3 @@
+export declare function formatTarget(target: any): string;
+export declare function formatStepDescription(methodName: string, target: any, args: any[]): string;
+export declare function formatAssertionDescription(target: any, matcherName: string, isNegated: boolean, args: any[]): string;

package/dist/page/utils/formatter.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTarget = formatTarget;
+exports.formatStepDescription = formatStepDescription;
+exports.formatAssertionDescription = formatAssertionDescription;
+function formatTarget(target) {
+    if (typeof target === 'string')
+        return target;
+    if (target && typeof target.toString === 'function') {
+        return target.toString().replace(/^Locator@/, '');
+    }
+    return 'locator';
+}
+function formatStepDescription(methodName, target, args) {
+    const targetStr = formatTarget(target);
+    if (methodName === 'fill' && args[0] !== undefined) {
+        const options = args[1];
+        const shouldMask = !(options && typeof options === 'object' && options.mask === false);
+        const displayValue = shouldMask ? '*'.repeat(String(args[0]).length) : args[0];
+        return `Fill "${targetStr}" with "${displayValue}"`;
+    }
+    if (methodName === 'click')
+        return `Click "${targetStr}"`;
+    if (methodName === 'dblclick')
+        return `Double-click "${targetStr}"`;
+    if (methodName === 'dragTo')
+        return `Drag "${targetStr}" to "${formatTarget(args[0])}"`;
+    if (methodName === 'check')
+        return `Check "${targetStr}"`;
+    if (methodName === 'uncheck')
+        return `Uncheck "${targetStr}"`;
+    const formattedMethod = methodName.charAt(0).toUpperCase() + methodName.slice(1);
+    const cleanArgs = args.filter(a => typeof a === 'string' || typeof a === 'number').map(a => `"${a}"`).join(', ');
+    return `${formattedMethod} "${targetStr}"${cleanArgs ? ' with ' + cleanArgs : ''}`;
+}
+function formatAssertionDescription(target, matcherName, isNegated, args) {
+    const targetStr = formatTarget(target);
+    const prefix = `Verify "${targetStr}"`;
+    const matcherMap = {
+        toBeVisible: isNegated ? 'is not visible' : 'is visible',
+        toBeHidden: isNegated ? 'is not hidden' : 'is hidden',
+        toBeEnabled: isNegated ? 'is not enabled' : 'is enabled',
+        toBeDisabled: isNegated ? 'is not disabled' : 'is disabled',
+        toBeChecked: isNegated ? 'is not checked' : 'is checked',
+        toHaveText: (isNegated ? 'does not have text "' : 'has text "') + args.map(a => String(a)).join(', ') + '"',
+        toContainText: (isNegated ? 'does not contain "' : 'contains "') + args.map(a => String(a)).join(', ') + '"',
+        toHaveCount: (isNegated ? 'does not have count of "' : 'has count of "') + args[0] + '"'
+    };
+    return `${prefix} ${matcherMap[matcherName] || `${isNegated ? 'not ' : ''}${matcherName}`}`;
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "pw-core",
+  "version": "0.0.1",
+  "description": "Developer-first Playwright framework with typed page objects, components, assertions, and reusable automation utilities.",
+  "author": {
+    "name": "Shanmuka Chandra Teja Anem",
+    "url": "https://github.com/shanmukaanem"
+  },
+  "license": "MIT",
+  "keywords": [
+    "playwright",
+    "automation",
+    "testing",
+    "e2e",
+    "qa",
+    "sdet",
+    "page-object",
+    "framework",
+    "typescript"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./page": {
+      "types": "./dist/page/index.d.ts",
+      "default": "./dist/page/index.js"
+    },
+    "./component/table": {
+      "types": "./dist/component/table.d.ts",
+      "default": "./dist/component/table.js"
+    },
+    "./helpers": {
+      "types": "./dist/helpers.d.ts",
+      "default": "./dist/helpers.js"
+    }
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "prepare": "npm run build"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.40.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.60.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}