@flash-ai-team/flash-test-framework 0.0.1

package/dist/keywords/WebUI.js

@@ -0,0 +1,502 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Web = void 0;
+const test_1 = require("@playwright/test");
+const Keyword_1 = require("../core/Keyword");
+const ObjectRepository_1 = require("../core/ObjectRepository");
+const fs_1 = __importDefault(require("fs"));
+class Web {
+    static get page() {
+        return Keyword_1.KeywordContext.page;
+    }
+    static getLocator(to) {
+        return this.page.locator(to.selector);
+    }
+    /**
+     * Navigates to the specified URL.
+     * @param url - The URL to navigate to.
+     */
+    static async navigateToUrl(url) {
+        await this.page.goto(url);
+    }
+    /**
+     * Clicks on the specified element.
+     * @param to - The TestObject representing the element.
+     */
+    static async click(to) {
+        await this.getLocator(to).click();
+    }
+    /**
+     * Sets the text of an input element.
+     * @param to - The TestObject representing the input element.
+     * @param text - The text to set.
+     */
+    static async setText(to, text) {
+        await this.getLocator(to).fill(text);
+    }
+    /**
+     * Searches for the specified text using heuristic selectors.
+     * @param text - The text to search for.
+     */
+    static async search(text) {
+        // Common search input selectors
+        const selectors = [
+            'input[name="q"]',
+            'textarea[name="q"]',
+            'input[type="search"]',
+            'input[aria-label*="Search" i]',
+            'input[placeholder*="Search" i]',
+            'button[aria-label*="Search" i]' // sometimes search is a button that expands? No, sticking to inputs for now.
+        ];
+        // Combine into a single OR selector
+        const combinedSelector = selectors.join(', ');
+        const locator = this.page.locator(combinedSelector).first();
+        await locator.fill(text);
+    }
+    /**
+     * Verifies that the specified element is present (visible) on the page.
+     * @param to - The TestObject representing the element.
+     * @param timeout - The maximum time to wait in milliseconds (default: 5000).
+     */
+    static async verifyElementPresent(to, timeout = 5000) {
+        await (0, test_1.expect)(this.getLocator(to)).toBeVisible({ timeout });
+    }
+    /**
+     * Gets the visible text of the specified element.
+     * @param to - The TestObject representing the element.
+     * @returns The text content of the element.
+     */
+    static async getText(to) {
+        return await this.getLocator(to).innerText();
+    }
+    /**
+     * Closes the current browser context/page.
+     */
+    static async closeBrowser() {
+        await this.page.close();
+    }
+    // --- Interaction Keywords ---
+    /**
+     * Double clicks on the specified element.
+     * @param to - The TestObject representing the element.
+     */
+    static async doubleClick(to) {
+        await this.getLocator(to).dblclick();
+    }
+    /**
+     * Right clicks (context click) on the specified element.
+     * @param to - The TestObject representing the element.
+     */
+    static async rightClick(to) {
+        await this.getLocator(to).click({ button: 'right' });
+    }
+    /**
+     * Hovers over the specified element.
+     * @param to - The TestObject representing the element.
+     */
+    static async mouseOver(to) {
+        await this.getLocator(to).hover();
+    }
+    /**
+     * Drags the source element and drops it onto the target element.
+     * @param source - The TestObject representing the source element.
+     * @param target - The TestObject representing the target element.
+     */
+    static async dragAndDrop(source, target) {
+        await this.getLocator(source).dragTo(this.getLocator(target));
+    }
+    /**
+     * Checks (selects) the specified checkbox or radio button.
+     * @param to - The TestObject representing the element.
+     */
+    static async check(to) {
+        await this.getLocator(to).check();
+    }
+    /**
+     * Unchecks (deselects) the specified checkbox.
+     * @param to - The TestObject representing the element.
+     */
+    static async uncheck(to) {
+        await this.getLocator(to).uncheck();
+    }
+    /**
+     * Selects an option by its value.
+     * @param to - The TestObject representing the dropdown.
+     * @param value - The value of the option to select.
+     */
+    static async selectOptionByValue(to, value) {
+        await this.getLocator(to).selectOption({ value: value });
+    }
+    /**
+     * Selects an option by its label (visible text).
+     * @param to - The TestObject representing the dropdown.
+     * @param label - The label of the option to select.
+     */
+    static async selectOptionByLabel(to, label) {
+        await this.getLocator(to).selectOption({ label: label });
+    }
+    /**
+     * Sends keys to the specified element (sequentially).
+     * @param to - The TestObject representing the element.
+     * @param key - The key(s) to send.
+     */
+    static async sendKeys(to, key) {
+        await this.getLocator(to).pressSequentially(key);
+    }
+    /**
+     * Presses a specific key on the keyboard.
+     * @param key - The name of the key to press (e.g., "Enter", "Tab", "ArrowDown").
+     */
+    static async pressKey(key) {
+        await this.page.keyboard.press(key);
+    }
+    /**
+     * Uploads a file to the specified file input element.
+     * @param to - The TestObject representing the file input.
+     * @param absolutePath - The absolute path to the file.
+     */
+    static async uploadFile(to, absolutePath) {
+        await this.getLocator(to).setInputFiles(absolutePath);
+    }
+    /**
+     * Clicks on an image template found on the screen.
+     * @param imagePath - The absolute path to the template image.
+     */
+    static async clickImage(imagePath) {
+        if (!fs_1.default.existsSync(imagePath)) {
+            throw new Error(`Image not found at: ${imagePath}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { Jimp, intToRGBA } = require('jimp');
+        const screenshotBuffer = await this.page.screenshot();
+        const screenshot = await Jimp.read(screenshotBuffer);
+        const template = await Jimp.read(imagePath);
+        const sWidth = screenshot.bitmap.width;
+        const sHeight = screenshot.bitmap.height;
+        const tWidth = template.bitmap.width;
+        const tHeight = template.bitmap.height;
+        let bestMatch = { x: -1, y: -1, score: 1.0 }; // Lower score is better (0 is perfect)
+        // Simple scan (optimization: step 5 pixels? or partial check?)
+        // For robustness, full scan or slightly optimized.
+        // Let's do a naive scan but check center pixel of template first?
+        // Or just straightforward pixel check.
+        // Optimization: Checking every pixel is slow.
+        // Let's assume exact match for now. Jimp diff?
+        // Manual sliding window with threshold
+        const threshold = 0.1; // 10% tolerance per pixel
+        for (let x = 0; x <= sWidth - tWidth; x++) {
+            for (let y = 0; y <= sHeight - tHeight; y++) {
+                // Quick check: Top-left corner
+                const sColor = intToRGBA(screenshot.getPixelColor(x, y));
+                const tColor = intToRGBA(template.getPixelColor(0, 0));
+                if (Math.abs(sColor.r - tColor.r) > 255 * threshold ||
+                    Math.abs(sColor.g - tColor.g) > 255 * threshold ||
+                    Math.abs(sColor.b - tColor.b) > 255 * threshold) {
+                    continue;
+                }
+                // Full check
+                let diff = 0;
+                let match = true;
+                for (let tx = 0; tx < tWidth; tx += 5) { // Skip pixels for speed
+                    for (let ty = 0; ty < tHeight; ty += 5) {
+                        const sc = intToRGBA(screenshot.getPixelColor(x + tx, y + ty));
+                        const tc = intToRGBA(template.getPixelColor(tx, ty));
+                        const localDiff = (Math.abs(sc.r - tc.r) + Math.abs(sc.g - tc.g) + Math.abs(sc.b - tc.b)) / (255 * 3);
+                        if (localDiff > threshold) {
+                            match = false;
+                            break;
+                        }
+                        diff += localDiff;
+                    }
+                    if (!match)
+                        break;
+                }
+                if (match) {
+                    // Found!
+                    bestMatch = { x, y, score: diff };
+                    // Click center
+                    console.log(`Image match found at (${x}, ${y})`);
+                    await this.page.mouse.click(x + tWidth / 2, y + tHeight / 2);
+                    return;
+                }
+            }
+        }
+        throw new Error(`Image template not found on screen: ${imagePath}`);
+    }
+    // --- Verification Keywords ---
+    /**
+     * Verifies that the specified element is NOT present (hidden) on the page.
+     * @param to - The TestObject representing the element.
+     * @param timeout - The maximum time to wait in milliseconds (default: 5000).
+     */
+    static async verifyElementNotPresent(to, timeout = 5000) {
+        await (0, test_1.expect)(this.getLocator(to)).toBeHidden({ timeout });
+    }
+    /**
+     * Verifies that the element's text matches the expected text.
+     * @param to - The TestObject representing the element.
+     * @param expectedText - The expected text.
+     */
+    static async verifyElementText(to, expectedText) {
+        await (0, test_1.expect)(this.getLocator(to)).toHaveText(expectedText);
+    }
+    /**
+     * Verifies that the element's attribute matches the expected value.
+     * @param to - The TestObject representing the element.
+     * @param attribute - The attribute name.
+     * @param expectedValue - The expected attribute value.
+     */
+    static async verifyElementAttributeValue(to, attribute, expectedValue) {
+        await (0, test_1.expect)(this.getLocator(to)).toHaveAttribute(attribute, expectedValue);
+    }
+    // --- Wait Keywords ---
+    /**
+     * Waits for the specified element to be visible.
+     * @param to - The TestObject representing the element.
+     * @param timeout - The maximum time to wait in milliseconds (default: 5000).
+     */
+    static async waitForElementVisible(to, timeout = 5000) {
+        await this.getLocator(to).waitFor({ state: 'visible', timeout });
+    }
+    /**
+     * Waits for the specified element to be clickable.
+     * @param to - The TestObject representing the element.
+     * @param timeout - The maximum time to wait in milliseconds (default: 5000).
+     */
+    static async waitForElementClickable(to, timeout = 5000) {
+        // Playwright auto-waits for clickability on action, but we can explicit wait just for state if needed.
+        // There isn't a direct 'clickable' state in waitFor, typically we wait for visible + enabled.
+        const locator = this.getLocator(to);
+        await locator.waitFor({ state: 'visible', timeout });
+        await (0, test_1.expect)(locator).toBeEnabled({ timeout });
+    }
+    /**
+     * Waits for the specified element to be not visible (hidden).
+     * @param to - The TestObject representing the element.
+     * @param timeout - The maximum time to wait in milliseconds (default: 5000).
+     */
+    static async waitForElementNotVisible(to, timeout = 5000) {
+        await this.getLocator(to).waitFor({ state: 'hidden', timeout });
+    }
+    /**
+     * Delays execution for a specified number of seconds.
+     * @param seconds - The number of seconds to wait.
+     */
+    static async delay(seconds) {
+        //need a simple delay
+        await new Promise(r => setTimeout(r, seconds * 1000));
+    }
+    // --- Utility Keywords ---
+    /**
+     * Takes a screenshot and saves it to the reports folder.
+     * @param filename - The name of the screenshot file (optional).
+     */
+    static async takeScreenshot(filename) {
+        const path = filename ? `reports/screenshots/${filename}.png` : undefined;
+        await this.page.screenshot({ path, fullPage: true });
+    }
+    /**
+     * Gets the value of the specified attribute.
+     * @param to - The TestObject representing the element.
+     * @param attribute - The name of the attribute.
+     * @returns The attribute value or null.
+     */
+    static async getAttribute(to, attribute) {
+        return await this.getLocator(to).getAttribute(attribute);
+    }
+    /**
+     * Scrolls the element into view.
+     * @param to - The TestObject representing the element.
+     */
+    static async scrollToElement(to) {
+        await this.getLocator(to).scrollIntoViewIfNeeded();
+    }
+}
+exports.Web = Web;
+__decorate([
+    (0, Keyword_1.Keyword)("Navigate To Url"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], Web, "navigateToUrl", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Click"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "click", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Set Text"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "setText", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Search"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], Web, "search", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Verify Element Present"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, Number]),
+    __metadata("design:returntype", Promise)
+], Web, "verifyElementPresent", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Get Text"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "getText", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Close Browser"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], Web, "closeBrowser", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Double Click"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "doubleClick", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Right Click"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "rightClick", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Mouse Over"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "mouseOver", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Drag And Drop"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "dragAndDrop", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Check"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "check", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Uncheck"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "uncheck", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Select Option By Value"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "selectOptionByValue", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Select Option By Label"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "selectOptionByLabel", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Send Keys"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "sendKeys", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Press Key"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], Web, "pressKey", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Upload File"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "uploadFile", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Click Image"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], Web, "clickImage", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Verify Element Not Present"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, Number]),
+    __metadata("design:returntype", Promise)
+], Web, "verifyElementNotPresent", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Verify Element Text"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "verifyElementText", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Verify Element Attribute Value"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String, String]),
+    __metadata("design:returntype", Promise)
+], Web, "verifyElementAttributeValue", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Wait For Element Visible"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, Number]),
+    __metadata("design:returntype", Promise)
+], Web, "waitForElementVisible", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Wait For Element Clickable"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, Number]),
+    __metadata("design:returntype", Promise)
+], Web, "waitForElementClickable", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Wait For Element Not Visible"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, Number]),
+    __metadata("design:returntype", Promise)
+], Web, "waitForElementNotVisible", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Delay"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], Web, "delay", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Take Screenshot"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], Web, "takeScreenshot", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Get Attribute"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject, String]),
+    __metadata("design:returntype", Promise)
+], Web, "getAttribute", null);
+__decorate([
+    (0, Keyword_1.Keyword)("Scroll To Element"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectRepository_1.TestObject]),
+    __metadata("design:returntype", Promise)
+], Web, "scrollToElement", null);

package/dist/objects/LoginPage.d.ts

@@ -0,0 +1,6 @@
+export declare class LoginPage {
+    static readonly username: import("../core/ObjectRepository").TestObject;
+    static readonly password: import("../core/ObjectRepository").TestObject;
+    static readonly loginBtn: import("../core/ObjectRepository").TestObject;
+    static readonly successMessage: import("../core/ObjectRepository").TestObject;
+}

package/dist/objects/LoginPage.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginPage = void 0;
+const ObjectRepository_1 = require("../core/ObjectRepository");
+class LoginPage {
+}
+exports.LoginPage = LoginPage;
+LoginPage.username = (0, ObjectRepository_1.el)("#username", "Username input field");
+LoginPage.password = (0, ObjectRepository_1.el)("#password", "Password input field");
+LoginPage.loginBtn = (0, ObjectRepository_1.el)("button[type='submit']", "Login button");
+LoginPage.successMessage = (0, ObjectRepository_1.el)(".flash.success", "Success message");

package/dist/reporting/CustomReporter.d.ts

@@ -0,0 +1,11 @@
+import { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+declare class CustomReporter implements Reporter {
+    private results;
+    private logBuffer;
+    private reportFolder;
+    private log;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): void;
+}
+export default CustomReporter;

package/dist/reporting/CustomReporter.js

@@ -0,0 +1,129 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ReporterUtils_1 = require("./ReporterUtils");
+class CustomReporter {
+    constructor() {
+        this.results = [];
+        this.logBuffer = [];
+        this.reportFolder = '';
+    }
+    log(message) {
+        console.log(message);
+        this.logBuffer.push(message);
+    }
+    onBegin(config, suite) {
+        this.reportFolder = (0, ReporterUtils_1.getReportFolder)(suite);
+        this.log(`\n[DEBUG] process.cwd: ${process.cwd()}`);
+        this.log(`[DEBUG] Calculated reportFolder: ${this.reportFolder}`);
+        this.log(`\nStarting test run with ${suite.allTests().length} tests...\n`);
+    }
+    onTestEnd(test, result) {
+        // Check for SourceFile annotation
+        const sourceAnnotation = test.annotations.find(a => a.type === 'SourceFile');
+        const file = sourceAnnotation ? sourceAnnotation.description : test.location.file;
+        // Check for MethodName annotation
+        const methodAnnotation = test.annotations.find(a => a.type === 'MethodName');
+        const method = methodAnnotation ? methodAnnotation.description : '';
+        // Capture step details
+        const steps = result.steps
+            .filter(step => step.category === 'test.step')
+            .map(step => ({
+            title: step.title,
+            status: step.error ? 'failed' : 'passed',
+            duration: step.duration,
+            error: step.error ? step.error.message : undefined
+        }));
+        this.results.push({
+            title: test.title,
+            file: file,
+            method: method,
+            status: result.status,
+            duration: result.duration,
+            error: result.error,
+            steps: steps
+        });
+        // Build individual test log
+        const lines = [];
+        lines.push(`Test: ${test.title} [${result.status.toUpperCase()}] (${result.duration}ms)`);
+        for (const step of result.steps) {
+            if (step.category === 'test.step') {
+                lines.push(`  -> ${step.title} (${step.duration}ms)`);
+                if (step.error) {
+                    lines.push(`     Error: ${step.error.message}`);
+                }
+            }
+        }
+        lines.push(''); // Empty line
+        // Log to valid console/main buffer
+        lines.forEach(line => this.log(line));
+        // Write to individual file
+        if (this.reportFolder) {
+            // Ensure folder exists (it normally should be created in onEnd, but we are in onTestEnd now. 
+            // We might need to create it here if it doesn't exist yet, or wait?
+            // Safest is to ensure it exists.
+            if (!fs.existsSync(this.reportFolder)) {
+                try {
+                    fs.mkdirSync(this.reportFolder, { recursive: true });
+                }
+                catch (e) { /* ignore race */ }
+            }
+            const sanitizedTitle = test.title.replace(/[^a-z0-9]/gi, '_');
+            const individualLogPath = path.join(this.reportFolder, `execution_${sanitizedTitle}.log`);
+            try {
+                fs.writeFileSync(individualLogPath, lines.join('\n'));
+            }
+            catch (e) {
+                console.error(`Failed to write log for ${test.title}`, e);
+            }
+        }
+    }
+    onEnd(result) {
+        if (!this.reportFolder)
+            return;
+        const reportPath = path.join(this.reportFolder, 'custom-report.json');
+        const logPath = path.join(this.reportFolder, 'execution.log');
+        if (!fs.existsSync(this.reportFolder)) {
+            fs.mkdirSync(this.reportFolder, { recursive: true });
+        }
+        fs.writeFileSync(reportPath, JSON.stringify(this.results, null, 2));
+        this.log(`Custom JSON Report generated at: ${reportPath}`);
+        fs.writeFileSync(logPath, this.logBuffer.join('\n'));
+        console.log(`Execution Log generated at: ${logPath}`);
+    }
+}
+exports.default = CustomReporter;

package/dist/reporting/EmailReporter.d.ts

@@ -0,0 +1,8 @@
+import { Reporter, FullResult, FullConfig, Suite } from '@playwright/test/reporter';
+export default class EmailReporter implements Reporter {
+    private suiteStartTime;
+    private rootSuite;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onEnd(result: FullResult): Promise<void>;
+    private zipDirectory;
+}