pw-automation-framework 2.0.1

package/dist/core/handlers/AllHandlers.js

@@ -0,0 +1,648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableHandler = exports.CheckboxHandler = exports.KeyboardHandler = exports.WaitHandler = exports.AssertionHandler = void 0;
+const response_1 = require("../../utils/response");
+const locatorHelper_1 = require("../../utils/locatorHelper");
+const BaseHandler_1 = require("./BaseHandler");
+// ─── AssertionHandler ─────────────────────────────────────────────────────────
+class AssertionHandler extends BaseHandler_1.BaseHandler {
+    constructor(tConfig, page) { super(tConfig, page); }
+    getActions() {
+        return {
+            verifytext: this.verifyText.bind(this),
+            verifytextcontains: this.verifyTextContains.bind(this),
+            verifytextnotequal: this.verifyTextNotEqual.bind(this),
+            verifyvalue: this.verifyValue.bind(this),
+            verifyvisible: this.verifyVisible.bind(this),
+            verifyhidden: this.verifyHidden.bind(this),
+            verifyenabled: this.verifyEnabled.bind(this),
+            verifydisabled: this.verifyDisabled.bind(this),
+            verifyurl: this.verifyURL.bind(this),
+            verifypartialurl: this.verifyPartialURL.bind(this),
+            verifyelementcount: this.verifyElementCount.bind(this),
+            verifyattribute: this.verifyAttribute.bind(this),
+            verifychecked: this.verifyChecked.bind(this),
+            verifyunchecked: this.verifyUnchecked.bind(this),
+            gettext: this.getText.bind(this),
+            getattribute: this.getAttribute.bind(this),
+            assertequal: this.assertEqual.bind(this),
+            assertnotequal: this.assertNotEqual.bind(this),
+        };
+    }
+    async verifyText(args) {
+        const [strategy, locator, expected] = args;
+        if (!strategy || !locator || expected === undefined)
+            return (0, response_1.fail)("verifyText needs: strategy, locator, expectedText");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const actual = (await el.innerText()).trim();
+            const ok = actual === expected.trim();
+            const msg = ok ? `Text matches: "${expected}"` : `Text mismatch. Expected: "${expected}", Got: "${actual}"`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyText [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyTextContains(args) {
+        const [strategy, locator, partial] = args;
+        if (!strategy || !locator || partial === undefined)
+            return (0, response_1.fail)("verifyTextContains needs: strategy, locator, partialText");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const actual = (await el.innerText()).trim();
+            const ok = actual.toLowerCase().includes(partial.toLowerCase());
+            const msg = ok ? `Text contains: "${partial}"` : `Text "${actual}" does not contain "${partial}"`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyTextContains [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyTextNotEqual(args) {
+        const [strategy, locator, notExpected] = args;
+        if (!strategy || !locator || notExpected === undefined)
+            return (0, response_1.fail)("verifyTextNotEqual needs: strategy, locator, text");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const actual = (await el.innerText()).trim();
+            const ok = actual !== notExpected.trim();
+            const msg = ok ? `Text is not "${notExpected}" ✓` : `Text should not equal "${notExpected}"`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyTextNotEqual [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyValue(args) {
+        const [strategy, locator, expected] = args;
+        if (!strategy || !locator || expected === undefined)
+            return (0, response_1.fail)("verifyValue needs: strategy, locator, expected");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "attached", timeout: this.timeout });
+            const actual = await el.inputValue();
+            const ok = actual === expected;
+            const msg = ok ? `Value matches: "${expected}"` : `Value mismatch. Expected: "${expected}", Got: "${actual}"`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyValue [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyVisible(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("verifyVisible needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            const visible = await el.isVisible();
+            const msg = visible ? "Element is visible ✓" : "Element is NOT visible";
+            const sc = visible ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return visible ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyVisible [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyHidden(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("verifyHidden needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            const hidden = await el.isHidden();
+            const msg = hidden ? "Element is hidden ✓" : "Element is visible (expected hidden)";
+            const sc = hidden ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return hidden ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyHidden [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyEnabled(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("verifyEnabled needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            const enabled = await el.isEnabled();
+            const sc = enabled ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return enabled ? (0, response_1.pass)("Element is enabled ✓", sc) : (0, response_1.fail)("Element is NOT enabled", undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyEnabled [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyDisabled(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("verifyDisabled needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            const disabled = await el.isDisabled();
+            const sc = disabled ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return disabled ? (0, response_1.pass)("Element is disabled ✓", sc) : (0, response_1.fail)("Element is NOT disabled", undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyDisabled [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyURL(args) {
+        const [expected] = args;
+        const actual = this.page.url();
+        const ok = actual === expected;
+        const msg = ok ? `URL matches ✓` : `URL mismatch. Expected: "${expected}", Got: "${actual}"`;
+        const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+        return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+    }
+    async verifyPartialURL(args) {
+        const [partial] = args;
+        const actual = this.page.url();
+        const ok = actual.includes(partial);
+        const msg = ok ? `URL contains: "${partial}" ✓` : `URL "${actual}" does not contain "${partial}"`;
+        const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+        return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+    }
+    async verifyElementCount(args) {
+        const [strategy, locator, expectedStr] = args;
+        const expected = parseInt(expectedStr, 10);
+        if (!strategy || !locator || isNaN(expected))
+            return (0, response_1.fail)("verifyElementCount needs: strategy, locator, expectedCount");
+        try {
+            const actual = await this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).count();
+            const ok = actual === expected;
+            const msg = ok ? `Count: ${actual} ✓` : `Count mismatch. Expected: ${expected}, Got: ${actual}`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyElementCount [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyAttribute(args) {
+        const [strategy, locator, attribute, expected] = args;
+        if (!strategy || !locator || !attribute || expected === undefined)
+            return (0, response_1.fail)("verifyAttribute needs: strategy, locator, attribute, expectedValue");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "attached", timeout: this.timeout });
+            const actual = await el.getAttribute(attribute);
+            const ok = actual === expected;
+            const msg = ok ? `Attribute "${attribute}" = "${expected}" ✓` : `Attr "${attribute}" mismatch. Expected: "${expected}", Got: "${actual}"`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyAttribute [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyChecked(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("verifyChecked needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            const checked = await el.isChecked();
+            const sc = checked ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return checked ? (0, response_1.pass)("Checkbox is checked ✓", sc) : (0, response_1.fail)("Checkbox is NOT checked", undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyChecked [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async verifyUnchecked(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("verifyUnchecked needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            const unchecked = !(await el.isChecked());
+            const sc = unchecked ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return unchecked ? (0, response_1.pass)("Checkbox is unchecked ✓", sc) : (0, response_1.fail)("Checkbox IS checked (expected unchecked)", undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyUnchecked [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async getText(args) {
+        const [strategy, locator, storeKey] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("getText needs: strategy, locator, [storeKey]");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const text = (await el.innerText()).trim();
+            if (storeKey)
+                this.testData.set(storeKey, text);
+            return (0, response_1.pass)(`Text: "${text}"`, await this.shots.onPass(this.page), { text });
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed getText [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async getAttribute(args) {
+        const [strategy, locator, attribute, storeKey] = args;
+        if (!strategy || !locator || !attribute)
+            return (0, response_1.fail)("getAttribute needs: strategy, locator, attribute, [storeKey]");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "attached", timeout: this.timeout });
+            const value = await el.getAttribute(attribute);
+            if (storeKey)
+                this.testData.set(storeKey, value);
+            return (0, response_1.pass)(`Attribute "${attribute}": "${value}"`, await this.shots.onPass(this.page), { value });
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed getAttribute [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async assertEqual(args) {
+        const [actual, expected, label] = args;
+        const ok = actual === expected;
+        const tag = label || "Value";
+        const msg = ok ? `${tag} matches: "${expected}" ✓` : `${tag} mismatch. Expected: "${expected}", Got: "${actual}"`;
+        return ok ? (0, response_1.pass)(msg) : (0, response_1.fail)(msg);
+    }
+    async assertNotEqual(args) {
+        const [actual, notExpected, label] = args;
+        const ok = actual !== notExpected;
+        const tag = label || "Value";
+        const msg = ok ? `${tag} is not "${notExpected}" ✓` : `${tag} should not equal "${notExpected}"`;
+        return ok ? (0, response_1.pass)(msg) : (0, response_1.fail)(msg);
+    }
+}
+exports.AssertionHandler = AssertionHandler;
+// ─── WaitHandler ─────────────────────────────────────────────────────────────
+class WaitHandler extends BaseHandler_1.BaseHandler {
+    constructor(tConfig, page) { super(tConfig, page); }
+    getActions() {
+        return {
+            waitforelement: this.waitForElement.bind(this),
+            waitforelementhidden: this.waitForElementHidden.bind(this),
+            waitforurl: this.waitForURL.bind(this),
+            waitfortitle: this.waitForTitle.bind(this),
+            waitforpageload: this.waitForPageLoad.bind(this),
+            waitfornetworkidle: this.waitForNetworkIdle.bind(this),
+            waitfortextpresent: this.waitForTextPresent.bind(this),
+            sleep: this.sleep.bind(this),
+        };
+    }
+    async waitForElement(args) {
+        const [strategy, locator, timeoutStr] = args;
+        const timeout = parseInt(timeoutStr || String(this.timeout), 10);
+        if (!strategy || !locator)
+            return (0, response_1.fail)("waitForElement needs: strategy, locator, [timeoutMs]");
+        try {
+            await this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).waitFor({ state: "visible", timeout });
+            return (0, response_1.pass)(`Element visible: [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Element not visible in ${timeout}ms [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async waitForElementHidden(args) {
+        const [strategy, locator, timeoutStr] = args;
+        const timeout = parseInt(timeoutStr || String(this.timeout), 10);
+        if (!strategy || !locator)
+            return (0, response_1.fail)("waitForElementHidden needs: strategy, locator, [timeoutMs]");
+        try {
+            await this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).waitFor({ state: "hidden", timeout });
+            return (0, response_1.pass)(`Element hidden: [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Element still visible after ${timeout}ms [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async waitForURL(args) {
+        const [urlPattern, timeoutStr] = args;
+        const timeout = parseInt(timeoutStr || String(this.timeout), 10);
+        if (!urlPattern)
+            return (0, response_1.fail)("waitForURL needs: urlPattern, [timeoutMs]");
+        try {
+            await this.page.waitForURL(new RegExp(urlPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), { timeout });
+            return (0, response_1.pass)(`URL matches: "${urlPattern}"`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`URL not reached in ${timeout}ms: "${urlPattern}"`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async waitForTitle(args) {
+        const [titlePart, timeoutStr] = args;
+        const timeout = parseInt(timeoutStr || String(this.timeout), 10);
+        if (!titlePart)
+            return (0, response_1.fail)("waitForTitle needs: titlePart, [timeoutMs]");
+        try {
+            await this.page.waitForFunction((t) => document.title.includes(t), titlePart, { timeout });
+            return (0, response_1.pass)(`Title contains: "${titlePart}"`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Title not found in ${timeout}ms: "${titlePart}"`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async waitForPageLoad(args) {
+        const timeout = parseInt(args[0] || String(this.timeout), 10);
+        try {
+            await this.page.waitForLoadState("domcontentloaded", { timeout });
+            return (0, response_1.pass)("Page loaded", await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Page did not load in ${timeout}ms`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async waitForNetworkIdle(args) {
+        const timeout = parseInt(args[0] || String(this.timeout), 10);
+        try {
+            await this.page.waitForLoadState("networkidle", { timeout });
+            return (0, response_1.pass)("Network is idle", await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Network not idle in ${timeout}ms`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async waitForTextPresent(args) {
+        const [strategy, locator, text, timeoutStr] = args;
+        const timeout = parseInt(timeoutStr || String(this.timeout), 10);
+        if (!strategy || !locator || !text)
+            return (0, response_1.fail)("waitForTextPresent needs: strategy, locator, text, [timeoutMs]");
+        try {
+            await this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).filter({ hasText: text }).waitFor({ state: "visible", timeout });
+            return (0, response_1.pass)(`Text "${text}" is present`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Text "${text}" not found in ${timeout}ms`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async sleep(args) {
+        const ms = parseInt(args[0] || "1000", 10);
+        await this.page.waitForTimeout(ms);
+        return (0, response_1.pass)(`Waited ${ms}ms`);
+    }
+}
+exports.WaitHandler = WaitHandler;
+// ─── KeyboardHandler ──────────────────────────────────────────────────────────
+class KeyboardHandler extends BaseHandler_1.BaseHandler {
+    constructor(tConfig, page) { super(tConfig, page); }
+    getActions() {
+        return {
+            presskey: this.pressKey.bind(this),
+            presskeyon: this.pressKeyOn.bind(this),
+            keysendenter: this.sendEnter.bind(this),
+            keysendtab: this.sendTab.bind(this),
+            keysendesc: this.sendEsc.bind(this),
+            keycombo: this.keyCombo.bind(this),
+            selectall: this.selectAll.bind(this),
+            copytext: this.copyText.bind(this),
+            pastetext: this.pasteText.bind(this),
+        };
+    }
+    async pressKey(args) {
+        const [key] = args;
+        if (!key)
+            return (0, response_1.fail)("pressKey needs: keyName (e.g. Enter, Tab, F5, ArrowDown)");
+        try {
+            await this.page.keyboard.press(key);
+            return (0, response_1.pass)(`Pressed: ${key}`);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed pressKey: ${key}`, error.message);
+        }
+    }
+    async pressKeyOn(args) {
+        const [strategy, locator, key] = args;
+        if (!strategy || !locator || !key)
+            return (0, response_1.fail)("pressKeyOn needs: strategy, locator, keyName");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            await el.press(key, { timeout: this.timeout });
+            return (0, response_1.pass)(`Pressed ${key} on [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed pressKeyOn [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async sendEnter(args) { return this.pressKeyOn([args[0], args[1], "Enter"]); }
+    async sendTab(args) { return this.pressKeyOn([args[0], args[1], "Tab"]); }
+    async sendEsc(args) { return this.pressKeyOn([args[0], args[1], "Escape"]); }
+    // tSetup.keyCombo('Control+A')
+    async keyCombo(args) {
+        const [combo] = args;
+        if (!combo)
+            return (0, response_1.fail)("keyCombo needs: combo (e.g. Control+A, Control+Shift+T)");
+        try {
+            await this.page.keyboard.press(combo);
+            return (0, response_1.pass)(`Key combo: ${combo}`);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed keyCombo: ${combo}`, error.message);
+        }
+    }
+    async selectAll(args) {
+        const [strategy, locator] = args;
+        try {
+            if (strategy && locator) {
+                const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+                await el.focus();
+            }
+            await this.page.keyboard.press("Control+A");
+            return (0, response_1.pass)("Select All (Ctrl+A)");
+        }
+        catch (error) {
+            return (0, response_1.fail)("Failed selectAll", error.message);
+        }
+    }
+    async copyText(args) {
+        try {
+            await this.page.keyboard.press("Control+C");
+            return (0, response_1.pass)("Copied selection");
+        }
+        catch (error) {
+            return (0, response_1.fail)("Failed copyText", error.message);
+        }
+    }
+    async pasteText(args) {
+        try {
+            await this.page.keyboard.press("Control+V");
+            return (0, response_1.pass)("Pasted");
+        }
+        catch (error) {
+            return (0, response_1.fail)("Failed pasteText", error.message);
+        }
+    }
+}
+exports.KeyboardHandler = KeyboardHandler;
+// ─── CheckboxHandler ──────────────────────────────────────────────────────────
+class CheckboxHandler extends BaseHandler_1.BaseHandler {
+    constructor(tConfig, page) { super(tConfig, page); }
+    getActions() {
+        return {
+            checkcheckbox: this.check.bind(this),
+            uncheckcheckbox: this.uncheck.bind(this),
+            togglecheckbox: this.toggle.bind(this),
+            selectradio: this.selectRadio.bind(this),
+        };
+    }
+    async check(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("checkCheckbox needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            await el.check({ timeout: this.timeout });
+            return (0, response_1.pass)(`Checked [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed check [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async uncheck(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("uncheckCheckbox needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            await el.uncheck({ timeout: this.timeout });
+            return (0, response_1.pass)(`Unchecked [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed uncheck [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async toggle(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("toggleCheckbox needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const checked = await el.isChecked();
+            checked ? await el.uncheck() : await el.check();
+            return (0, response_1.pass)(`Toggled (now ${!checked}) [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed toggle [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    async selectRadio(args) {
+        const [strategy, locator] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("selectRadio needs: strategy, locator");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            await el.click({ timeout: this.timeout });
+            return (0, response_1.pass)(`Radio selected [${strategy}=${locator}]`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed selectRadio [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+}
+exports.CheckboxHandler = CheckboxHandler;
+// ─── TableHandler ─────────────────────────────────────────────────────────────
+class TableHandler extends BaseHandler_1.BaseHandler {
+    constructor(tConfig, page) { super(tConfig, page); }
+    getActions() {
+        return {
+            gettablerowcount: this.getTableRowCount.bind(this),
+            gettablecellvalue: this.getTableCellValue.bind(this),
+            verifytablecell: this.verifyTableCell.bind(this),
+            clicktablerow: this.clickTableRow.bind(this),
+            gettablecolumnvalues: this.getTableColumnValues.bind(this),
+        };
+    }
+    // tSetup.getTableRowCount('xpath', '//table/tbody/tr', 'storeKey')
+    async getTableRowCount(args) {
+        const [strategy, locator, storeKey] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("getTableRowCount needs: strategy, locator, [storeKey]");
+        try {
+            const count = await this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).count();
+            if (storeKey)
+                this.testData.set(storeKey, count);
+            return (0, response_1.pass)(`Row count: ${count}`, await this.shots.onPass(this.page), { count });
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed getTableRowCount [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    // tSetup.getTableCellValue('xpath', '//table/tbody/tr[2]/td[3]', 'storeKey')
+    async getTableCellValue(args) {
+        const [strategy, locator, storeKey] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("getTableCellValue needs: strategy, locator, [storeKey]");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const text = (await el.innerText()).trim();
+            if (storeKey)
+                this.testData.set(storeKey, text);
+            return (0, response_1.pass)(`Cell value: "${text}"`, await this.shots.onPass(this.page), { text });
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed getTableCellValue [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    // tSetup.verifyTableCell('xpath', '//table/tbody/tr[1]/td[2]', 'Expected Value')
+    async verifyTableCell(args) {
+        const [strategy, locator, expected] = args;
+        if (!strategy || !locator || !expected)
+            return (0, response_1.fail)("verifyTableCell needs: strategy, locator, expectedValue");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            const actual = (await el.innerText()).trim();
+            const ok = actual === expected.trim();
+            const msg = ok ? `Cell matches: "${expected}" ✓` : `Cell mismatch. Expected: "${expected}", Got: "${actual}"`;
+            const sc = ok ? await this.shots.onPass(this.page) : await this.shots.onFail(this.page);
+            return ok ? (0, response_1.pass)(msg, sc) : (0, response_1.fail)(msg, undefined, sc);
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed verifyTableCell [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    // tSetup.clickTableRow('xpath', '//table/tbody/tr', '3')
+    async clickTableRow(args) {
+        const [strategy, locator, rowStr] = args;
+        const row = parseInt(rowStr || "1", 10) - 1;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("clickTableRow needs: strategy, locator, rowNumber");
+        try {
+            const el = this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).nth(row);
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            await el.click({ timeout: this.timeout });
+            return (0, response_1.pass)(`Clicked row ${row + 1}`, await this.shots.onPass(this.page));
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed clickTableRow row=${row + 1}`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+    // tSetup.getTableColumnValues('xpath', '//table/tbody/tr/td[2]', 'storeKey')
+    async getTableColumnValues(args) {
+        const [strategy, locator, storeKey] = args;
+        if (!strategy || !locator)
+            return (0, response_1.fail)("getTableColumnValues needs: strategy, locator, [storeKey]");
+        try {
+            const values = await this.page.locator((0, locatorHelper_1.buildLocatorString)(strategy, locator)).allInnerTexts();
+            const trimmed = values.map(v => v.trim());
+            if (storeKey)
+                this.testData.set(storeKey, trimmed);
+            return (0, response_1.pass)(`Column values: [${trimmed.join(", ")}]`, await this.shots.onPass(this.page), { values: trimmed });
+        }
+        catch (error) {
+            return (0, response_1.fail)(`Failed getTableColumnValues [${strategy}=${locator}]`, error.message, await this.shots.onFail(this.page));
+        }
+    }
+}
+exports.TableHandler = TableHandler;
+//# sourceMappingURL=AllHandlers.js.map