@arghajit/playwright-pulse-report 0.1.0

package/dist/reporter/attachment-utils.js

@@ -0,0 +1,192 @@
+"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 });
+exports.attachFiles = attachFiles;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs")); // Use synchronous methods for simplicity in this context
+const ATTACHMENTS_SUBDIR = "attachments"; // Consistent subdirectory name
+/**
+ * Processes attachments from a Playwright TestResult and updates the PulseTestResult.
+ * @param testId A unique identifier for the test, used for folder naming.
+ * @param pwResult The TestResult object from Playwright.
+ * @param pulseResult The internal test result structure to update.
+ * @param config The reporter configuration options.
+ */
+function attachFiles(testId, pwResult, pulseResult, config) {
+    const baseReportDir = config.outputDir || "pulse-report-output"; // Base output directory
+    // Ensure attachments are relative to the main outputDir
+    const attachmentsBaseDir = path.resolve(baseReportDir, ATTACHMENTS_SUBDIR); // Absolute path for FS operations
+    const attachmentsSubFolder = testId.replace(/[^a-zA-Z0-9_-]/g, "_"); // Sanitize testId for folder name
+    const testAttachmentsDir = path.join(attachmentsBaseDir, attachmentsSubFolder); // e.g., pulse-report-output/attachments/test_id_abc
+    try {
+        if (!fs.existsSync(testAttachmentsDir)) {
+            fs.mkdirSync(testAttachmentsDir, { recursive: true });
+        }
+    }
+    catch (error) {
+        console.error(`Pulse Reporter: Failed to create attachments directory: ${testAttachmentsDir}`, error);
+        return; // Stop processing if directory creation fails
+    }
+    if (!pwResult.attachments)
+        return;
+    const { base64Images } = config; // Get base64 embedding option
+    pulseResult.screenshots = []; // Initialize screenshots array
+    pwResult.attachments.forEach((attachment) => {
+        const { contentType, name, path: attachmentPath, body } = attachment;
+        // Skip attachments without path or body
+        if (!attachmentPath && !body) {
+            console.warn(`Pulse Reporter: Attachment "${name}" for test ${testId} has no path or body. Skipping.`);
+            return;
+        }
+        // Determine filename
+        const safeName = name.replace(/[^a-zA-Z0-9_.-]/g, "_"); // Sanitize original name
+        const extension = attachmentPath
+            ? path.extname(attachmentPath)
+            : `.${getFileExtension(contentType)}`;
+        const baseFilename = attachmentPath
+            ? path.basename(attachmentPath, extension)
+            : safeName;
+        // Ensure unique filename within the test's attachment folder
+        const fileName = `${baseFilename}_${Date.now()}${extension}`;
+        // Relative path for storing in JSON (relative to baseReportDir)
+        const relativePath = path.join(ATTACHMENTS_SUBDIR, attachmentsSubFolder, fileName);
+        // Full path for file system operations
+        const fullPath = path.join(testAttachmentsDir, fileName);
+        if (contentType === null || contentType === void 0 ? void 0 : contentType.startsWith("image/")) {
+            // Handle all image types consistently
+            handleImage(attachmentPath, body, base64Images, fullPath, relativePath, pulseResult, name);
+        }
+        else if (name === "video" || (contentType === null || contentType === void 0 ? void 0 : contentType.startsWith("video/"))) {
+            handleAttachment(attachmentPath, body, fullPath, relativePath, "videoPath", pulseResult);
+        }
+        else if (name === "trace" || contentType === "application/zip") {
+            // Trace files are zips
+            handleAttachment(attachmentPath, body, fullPath, relativePath, "tracePath", pulseResult);
+        }
+        else {
+            // Handle other generic attachments if needed (e.g., log files)
+            // console.log(`Pulse Reporter: Processing generic attachment "${name}" (Type: ${contentType}) for test ${testId}`);
+            // handleAttachment(attachmentPath, body, fullPath, relativePath, 'otherAttachments', pulseResult); // Example for storing other types
+        }
+    });
+}
+/**
+ * Handles image attachments, either embedding as base64 or copying the file.
+ */
+function handleImage(attachmentPath, body, base64Embed, fullPath, relativePath, pulseResult, attachmentName) {
+    let screenshotData = undefined;
+    if (attachmentPath) {
+        try {
+            if (base64Embed) {
+                const fileContent = fs.readFileSync(attachmentPath, "base64");
+                screenshotData = `data:image/${getFileExtension(attachmentName)};base64,${fileContent}`;
+            }
+            else {
+                fs.copyFileSync(attachmentPath, fullPath);
+                screenshotData = relativePath;
+            }
+        }
+        catch (error) {
+            console.error(`Pulse Reporter: Failed to read/copy screenshot file: ${attachmentPath}. Error: ${error.message}`);
+        }
+    }
+    else if (body) {
+        // Always embed if only body is available
+        screenshotData = `data:image/${getFileExtension(attachmentName)};base64,${body.toString("base64")}`;
+        if (!base64Embed) {
+            // Optionally save the buffer to a file even if embedding is off,
+            // but the primary representation will be base64.
+            try {
+                fs.writeFileSync(fullPath, body);
+                // console.log(`Pulse Reporter: Saved screenshot buffer to ${fullPath}`);
+            }
+            catch (error) {
+                console.error(`Pulse Reporter: Failed to save screenshot buffer: ${fullPath}. Error: ${error.message}`);
+            }
+        }
+    }
+    if (screenshotData) {
+        if (!pulseResult.screenshots) {
+            pulseResult.screenshots = [];
+        }
+        pulseResult.screenshots.push(screenshotData);
+    }
+}
+/**
+ * Handles non-image attachments by copying the file or writing the buffer.
+ */
+function handleAttachment(attachmentPath, body, fullPath, relativePath, resultKey, // Add more keys if needed
+pulseResult) {
+    try {
+        if (attachmentPath) {
+            fs.copyFileSync(attachmentPath, fullPath);
+            pulseResult[resultKey] = relativePath;
+        }
+        else if (body) {
+            fs.writeFileSync(fullPath, body);
+            pulseResult[resultKey] = relativePath; // Store relative path even if from buffer
+        }
+    }
+    catch (error) {
+        console.error(`Pulse Reporter: Failed to copy/write attachment to ${fullPath}. Error: ${error.message}`);
+        // Don't set the path in pulseResult if saving failed
+    }
+}
+/**
+ * Determines a file extension based on content type.
+ * @param contentType The MIME type string.
+ * @returns A file extension string.
+ */
+function getFileExtension(contentType) {
+    var _a;
+    if (!contentType)
+        return "bin"; // Default binary extension
+    // More robust mapping
+    const extensions = {
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/gif": "gif",
+        "image/webp": "webp",
+        "image/svg+xml": "svg",
+        "video/webm": "webm",
+        "video/mp4": "mp4",
+        "application/zip": "zip", // For traces
+        "text/plain": "txt",
+        "application/json": "json",
+    };
+    return (extensions[contentType.toLowerCase()] ||
+        ((_a = contentType.split("/")[1]) === null || _a === void 0 ? void 0 : _a.split("+")[0]) ||
+        "bin");
+}

package/dist/reporter/index.d.ts

@@ -0,0 +1,5 @@
+import { PlaywrightPulseReporter } from "./playwright-pulse-reporter";
+export default PlaywrightPulseReporter;
+export { PlaywrightPulseReporter };
+export type { PlaywrightPulseReport } from "../lib/report-types";
+export type { TestResult, TestRun, TestStep, TestStatus } from "../types";

package/dist/reporter/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightPulseReporter = void 0;
+// src/reporter/index.ts
+const playwright_pulse_reporter_1 = require("./playwright-pulse-reporter");
+Object.defineProperty(exports, "PlaywrightPulseReporter", { enumerable: true, get: function () { return playwright_pulse_reporter_1.PlaywrightPulseReporter; } });
+// Export the reporter class as the default export for CommonJS compatibility
+// and also as a named export for potential ES module consumers.
+exports.default = playwright_pulse_reporter_1.PlaywrightPulseReporter;

package/dist/reporter/lib/report-types.d.ts

@@ -0,0 +1,8 @@
+import type { TestResult, TestRun } from '@/types';
+export interface PlaywrightPulseReport {
+    run: TestRun | null;
+    results: TestResult[];
+    metadata: {
+        generatedAt: string;
+    };
+}

package/dist/reporter/lib/report-types.js

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

package/dist/reporter/playwright-pulse-reporter.d.ts

@@ -0,0 +1,27 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult as PwTestResult } from "@playwright/test/reporter";
+import type { PlaywrightPulseReporterOptions } from "../types";
+export declare class PlaywrightPulseReporter implements Reporter {
+    private config;
+    private suite;
+    private results;
+    private runStartTime;
+    private options;
+    private outputDir;
+    private attachmentsDir;
+    private baseOutputFile;
+    private isSharded;
+    private shardIndex;
+    constructor(options?: PlaywrightPulseReporterOptions);
+    printsToStdio(): boolean;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onTestBegin(test: TestCase): void;
+    private processStep;
+    onTestEnd(test: TestCase, result: PwTestResult): Promise<void>;
+    onError(error: any): void;
+    private _writeShardResults;
+    private _mergeShardResults;
+    private _cleanupTemporaryFiles;
+    private _ensureDirExists;
+    onEnd(result: FullResult): Promise<void>;
+}
+export default PlaywrightPulseReporter;

package/dist/reporter/playwright-pulse-reporter.js

@@ -0,0 +1,419 @@
+"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 });
+exports.PlaywrightPulseReporter = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const attachment_utils_1 = require("./attachment-utils"); // Use relative path
+const convertStatus = (status, testCase) => {
+    // Special case: test was expected to fail (test.fail())
+    if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "failed") {
+        return status === "failed" ? "passed" : "failed";
+    }
+    // Special case: test was expected to skip (test.skip())
+    if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "skipped") {
+        return "skipped";
+    }
+    switch (status) {
+        case "passed":
+            return "passed";
+        case "failed":
+        case "timedOut":
+        case "interrupted":
+            return "failed";
+        case "skipped":
+        default:
+            return "skipped";
+    }
+};
+const TEMP_SHARD_FILE_PREFIX = ".pulse-shard-results-";
+const ATTACHMENTS_SUBDIR = "attachments"; // Centralized definition
+class PlaywrightPulseReporter {
+    constructor(options = {}) {
+        var _a, _b;
+        this.results = [];
+        this.baseOutputFile = "playwright-pulse-report.json";
+        this.isSharded = false;
+        this.shardIndex = undefined;
+        this.options = options; // Store provided options
+        this.baseOutputFile = (_a = options.outputFile) !== null && _a !== void 0 ? _a : this.baseOutputFile;
+        // Determine outputDir relative to config file or rootDir
+        // The actual resolution happens in onBegin where config is available
+        this.outputDir = (_b = options.outputDir) !== null && _b !== void 0 ? _b : "pulse-report-output";
+        this.attachmentsDir = path.join(this.outputDir, ATTACHMENTS_SUBDIR); // Initial path, resolved fully in onBegin
+        // console.log(`Pulse Reporter Init: Configured outputDir option: ${options.outputDir}, Base file: ${this.baseOutputFile}`);
+    }
+    printsToStdio() {
+        return this.shardIndex === undefined || this.shardIndex === 0;
+    }
+    onBegin(config, suite) {
+        var _a;
+        this.config = config;
+        this.suite = suite;
+        this.runStartTime = Date.now();
+        // --- Resolve outputDir relative to config file or rootDir ---
+        const configDir = this.config.rootDir;
+        // Use config file directory if available, otherwise rootDir
+        const configFileDir = this.config.configFile
+            ? path.dirname(this.config.configFile)
+            : configDir;
+        this.outputDir = path.resolve(configFileDir, (_a = this.options.outputDir) !== null && _a !== void 0 ? _a : "pulse-report-output");
+        // Resolve attachmentsDir relative to the final outputDir
+        this.attachmentsDir = path.resolve(this.outputDir, ATTACHMENTS_SUBDIR);
+        // Update options with the resolved absolute path for internal use
+        this.options.outputDir = this.outputDir;
+        // console.log(`Pulse Reporter onBegin: Final Report Output dir resolved to ${this.outputDir}`);
+        // console.log(`Pulse Reporter onBegin: Attachments base dir resolved to ${this.attachmentsDir}`);
+        const totalShards = this.config.shard ? this.config.shard.total : 1;
+        this.isSharded = totalShards > 1;
+        this.shardIndex = this.config.shard
+            ? this.config.shard.current - 1
+            : undefined;
+        // Ensure base output directory exists (attachments handled by attachFiles util)
+        this._ensureDirExists(this.outputDir)
+            .then(() => {
+            if (this.shardIndex === undefined) {
+                console.log(`PlaywrightPulseReporter: Starting test run with ${suite.allTests().length} tests${this.isSharded ? ` across ${totalShards} shards` : ""}. Pulse outputting to ${this.outputDir}`);
+                // Clean up old shard files only in the main process
+                return this._cleanupTemporaryFiles();
+            }
+            else {
+                // console.log(`Pulse Reporter (Shard ${this.shardIndex + 1}/${totalShards}): Starting. Temp results to ${this.outputDir}`);
+                return Promise.resolve();
+            }
+        })
+            .catch((err) => console.error("Pulse Reporter: Error during initialization:", err));
+    }
+    onTestBegin(test) {
+        // Optional: Log test start if needed
+        // console.log(`Starting test: ${test.title}`);
+    }
+    async processStep(step, testId) {
+        var _a, _b, _c, _d;
+        // Determine actual step status (don't inherit from parent)
+        let stepStatus = "passed";
+        let errorMessage = ((_a = step.error) === null || _a === void 0 ? void 0 : _a.message) || undefined;
+        if ((_c = (_b = step.error) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.startsWith("Test is skipped:")) {
+            stepStatus = "skipped";
+            errorMessage = "Info: Test is skipped:";
+        }
+        else {
+            stepStatus = convertStatus(step.error ? "failed" : "passed");
+        }
+        const duration = step.duration;
+        const startTime = new Date(step.startTime);
+        const endTime = new Date(startTime.getTime() + Math.max(0, duration));
+        // Capture code location if available
+        let codeLocation = "";
+        if (step.location) {
+            codeLocation = `${path.relative(this.config.rootDir, step.location.file)}:${step.location.line}:${step.location.column}`;
+        }
+        return {
+            id: `${testId}_step_${startTime.toISOString()}-${duration}-${(0, crypto_1.randomUUID)()}`,
+            title: step.title,
+            status: stepStatus,
+            duration: duration,
+            startTime: startTime,
+            endTime: endTime,
+            errorMessage: errorMessage,
+            stackTrace: ((_d = step.error) === null || _d === void 0 ? void 0 : _d.stack) || undefined,
+            codeLocation: codeLocation || undefined,
+            isHook: step.category === "hook",
+            hookType: step.category === "hook"
+                ? step.title.toLowerCase().includes("before")
+                    ? "before"
+                    : "after"
+                : undefined,
+            steps: [], // Will be populated recursively
+        };
+    }
+    async onTestEnd(test, result) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const testStatus = convertStatus(result.status, test);
+        const startTime = new Date(result.startTime);
+        const endTime = new Date(startTime.getTime() + result.duration);
+        // Generate a slightly more robust ID for attachments, especially if test.id is missing
+        const testIdForFiles = test.id ||
+            `${test
+                .titlePath()
+                .join("_")
+                .replace(/[^a-zA-Z0-9]/g, "_")}_${startTime.getTime()}`;
+        // --- Process Steps Recursively ---
+        const processAllSteps = async (steps, parentTestStatus) => {
+            let processed = [];
+            for (const step of steps) {
+                const processedStep = await this.processStep(step, testIdForFiles);
+                processed.push(processedStep);
+                if (step.steps && step.steps.length > 0) {
+                    const nestedSteps = await processAllSteps(step.steps, processedStep.status);
+                    // Assign nested steps correctly
+                    processedStep.steps = nestedSteps;
+                }
+            }
+            return processed;
+        };
+        // --- Extract Code Snippet ---
+        let codeSnippet = undefined;
+        try {
+            if (((_a = test.location) === null || _a === void 0 ? void 0 : _a.file) && ((_b = test.location) === null || _b === void 0 ? void 0 : _b.line) && ((_c = test.location) === null || _c === void 0 ? void 0 : _c.column)) {
+                const relativePath = path.relative(this.config.rootDir, test.location.file);
+                codeSnippet = `Test defined at: ${relativePath}:${test.location.line}:${test.location.column}`;
+            }
+        }
+        catch (e) {
+            console.warn(`Pulse Reporter: Could not extract code snippet for ${test.title}`, e);
+        }
+        // --- Prepare Base TestResult ---
+        const pulseResult = {
+            id: test.id || `${test.title}-${startTime.toISOString()}-${(0, crypto_1.randomUUID)()}`, // Use the original ID logic here
+            runId: "TBD", // Will be set later
+            name: test.titlePath().join(" > "),
+            suiteName: ((_d = this.config.projects[0]) === null || _d === void 0 ? void 0 : _d.name) || "Default Suite",
+            status: testStatus,
+            duration: result.duration,
+            startTime: startTime,
+            endTime: endTime,
+            retries: result.retry,
+            steps: ((_e = result.steps) === null || _e === void 0 ? void 0 : _e.length)
+                ? await processAllSteps(result.steps, testStatus)
+                : [],
+            errorMessage: (_f = result.error) === null || _f === void 0 ? void 0 : _f.message,
+            stackTrace: (_g = result.error) === null || _g === void 0 ? void 0 : _g.stack,
+            codeSnippet: codeSnippet,
+            tags: test.tags.map((tag) => tag.startsWith("@") ? tag.substring(1) : tag),
+            screenshots: [],
+            videoPath: undefined,
+            tracePath: undefined,
+        };
+        // --- Process Attachments using the new utility ---
+        try {
+            (0, attachment_utils_1.attachFiles)(testIdForFiles, result, pulseResult, this.options);
+        }
+        catch (attachError) {
+            console.error(`Pulse Reporter: Error processing attachments for test ${pulseResult.name} (ID: ${testIdForFiles}): ${attachError.message}`);
+        }
+        this.results.push(pulseResult);
+    }
+    onError(error) {
+        var _a;
+        console.error(`PlaywrightPulseReporter: Error encountered (Shard: ${(_a = this.shardIndex) !== null && _a !== void 0 ? _a : "Main"}):`, (error === null || error === void 0 ? void 0 : error.message) || error);
+        if (error === null || error === void 0 ? void 0 : error.stack) {
+            console.error(error.stack);
+        }
+    }
+    async _writeShardResults() {
+        if (this.shardIndex === undefined) {
+            console.warn("Pulse Reporter: _writeShardResults called unexpectedly in main process. Skipping.");
+            return;
+        }
+        const tempFilePath = path.join(this.outputDir, `${TEMP_SHARD_FILE_PREFIX}${this.shardIndex}.json`);
+        try {
+            // No need to ensureDirExists here, should be done in onBegin
+            await fs.writeFile(tempFilePath, JSON.stringify(this.results, (key, value) => {
+                if (value instanceof Date) {
+                    return value.toISOString();
+                }
+                return value;
+            }, 2));
+            // console.log(`Pulse Reporter: Shard ${this.shardIndex} wrote ${this.results.length} results to ${tempFilePath}`);
+        }
+        catch (error) {
+            console.error(`Pulse Reporter: Shard ${this.shardIndex} failed to write temporary results to ${tempFilePath}`, error);
+        }
+    }
+    async _mergeShardResults(finalRunData) {
+        // console.log('Pulse Reporter: Merging results from shards...');
+        let allResults = [];
+        const totalShards = this.config.shard ? this.config.shard.total : 1;
+        for (let i = 0; i < totalShards; i++) {
+            const tempFilePath = path.join(this.outputDir, `${TEMP_SHARD_FILE_PREFIX}${i}.json`);
+            try {
+                const content = await fs.readFile(tempFilePath, "utf-8");
+                const shardResults = JSON.parse(content);
+                shardResults.forEach((r) => (r.runId = finalRunData.id));
+                allResults = allResults.concat(shardResults);
+                // console.log(`Pulse Reporter: Successfully merged ${shardResults.length} results from shard ${i}`);
+            }
+            catch (error) {
+                if ((error === null || error === void 0 ? void 0 : error.code) === "ENOENT") {
+                    console.warn(`Pulse Reporter: Shard results file not found: ${tempFilePath}. This might happen if shard ${i} had no tests or failed early.`);
+                }
+                else {
+                    console.error(`Pulse Reporter: Could not read or parse results from shard ${i} (${tempFilePath}). Error:`, error);
+                }
+            }
+        }
+        // console.log(`Pulse Reporter: Merged a total of ${allResults.length} results from ${totalShards} shards.`);
+        finalRunData.passed = allResults.filter((r) => r.status === "passed").length;
+        finalRunData.failed = allResults.filter((r) => r.status === "failed").length;
+        finalRunData.skipped = allResults.filter((r) => r.status === "skipped").length;
+        finalRunData.totalTests = allResults.length;
+        const reviveDates = (key, value) => {
+            const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+            if (typeof value === "string" && isoDateRegex.test(value)) {
+                const date = new Date(value);
+                if (!isNaN(date.getTime())) {
+                    return date;
+                }
+            }
+            return value;
+        };
+        const finalParsedResults = JSON.parse(JSON.stringify(allResults), reviveDates);
+        return {
+            run: finalRunData,
+            results: finalParsedResults,
+            metadata: { generatedAt: new Date().toISOString() },
+        };
+    }
+    async _cleanupTemporaryFiles() {
+        try {
+            // No need to ensure dir exists here if handled in onBegin
+            const files = await fs.readdir(this.outputDir);
+            const tempFiles = files.filter((f) => f.startsWith(TEMP_SHARD_FILE_PREFIX));
+            if (tempFiles.length > 0) {
+                // console.log(`Pulse Reporter: Cleaning up ${tempFiles.length} temporary shard files...`);
+                await Promise.all(tempFiles.map((f) => fs.unlink(path.join(this.outputDir, f))));
+            }
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.code) !== "ENOENT") {
+                // Ignore if the directory doesn't exist
+                console.error("Pulse Reporter: Error cleaning up temporary files:", error);
+            }
+        }
+    }
+    async _ensureDirExists(dirPath, clean = false) {
+        try {
+            if (clean) {
+                // console.log(`Pulse Reporter: Cleaning directory ${dirPath}...`);
+                await fs.rm(dirPath, { recursive: true, force: true });
+            }
+            await fs.mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            // Ignore EEXIST error if the directory already exists
+            if (error.code !== "EEXIST") {
+                console.error(`Pulse Reporter: Failed to ensure directory exists: ${dirPath}`, error);
+                throw error; // Re-throw other errors
+            }
+        }
+    }
+    async onEnd(result) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (this.shardIndex !== undefined) {
+            await this._writeShardResults();
+            // console.log(`PlaywrightPulseReporter: Shard ${this.shardIndex + 1} finished writing results.`);
+            return;
+        }
+        const runEndTime = Date.now();
+        const duration = runEndTime - this.runStartTime;
+        const runId = `run-${this.runStartTime}-${(0, crypto_1.randomUUID)()}`;
+        const runData = {
+            id: runId,
+            timestamp: new Date(this.runStartTime),
+            totalTests: 0, // Will be updated after merging/processing
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            duration,
+        };
+        let finalReport;
+        if (this.isSharded) {
+            // console.log("Pulse Reporter: Run ended, main process merging shard results...");
+            finalReport = await this._mergeShardResults(runData);
+        }
+        else {
+            // console.log("Pulse Reporter: Run ended, processing results directly (no sharding)...");
+            this.results.forEach((r) => (r.runId = runId)); // Assign runId to directly collected results
+            runData.passed = this.results.filter((r) => r.status === "passed").length;
+            runData.failed = this.results.filter((r) => r.status === "failed").length;
+            runData.skipped = this.results.filter((r) => r.status === "skipped").length;
+            runData.totalTests = this.results.length;
+            finalReport = {
+                run: runData,
+                results: this.results, // Use directly collected results
+                metadata: { generatedAt: new Date().toISOString() },
+            };
+        }
+        const finalRunStatus = ((_b = (_a = finalReport.run) === null || _a === void 0 ? void 0 : _a.failed) !== null && _b !== void 0 ? _b : 0 > 0)
+            ? "failed"
+            : ((_c = finalReport.run) === null || _c === void 0 ? void 0 : _c.totalTests) === 0
+                ? "no tests"
+                : "passed";
+        const summary = `
+PlaywrightPulseReporter: Run Finished
+-----------------------------------------
+  Overall Status: ${finalRunStatus.toUpperCase()}
+  Total Tests:    ${(_e = (_d = finalReport.run) === null || _d === void 0 ? void 0 : _d.totalTests) !== null && _e !== void 0 ? _e : "N/A"}
+  Passed:         ${(_g = (_f = finalReport.run) === null || _f === void 0 ? void 0 : _f.passed) !== null && _g !== void 0 ? _g : "N/A"}
+  Failed:         ${(_j = (_h = finalReport.run) === null || _h === void 0 ? void 0 : _h.failed) !== null && _j !== void 0 ? _j : "N/A"}
+  Skipped:        ${(_l = (_k = finalReport.run) === null || _k === void 0 ? void 0 : _k.skipped) !== null && _l !== void 0 ? _l : "N/A"}
+  Duration:       ${(duration / 1000).toFixed(2)}s
+-----------------------------------------`;
+        console.log(summary);
+        const finalOutputPath = path.join(this.outputDir, this.baseOutputFile);
+        try {
+            // Ensure directory exists before writing final report
+            await this._ensureDirExists(this.outputDir);
+            // --- Write Final JSON Report ---
+            await fs.writeFile(finalOutputPath, JSON.stringify(finalReport, (key, value) => {
+                if (value instanceof Date) {
+                    return value.toISOString(); // Ensure dates are ISO strings in JSON
+                }
+                // Handle potential BigInt if used elsewhere, though unlikely here
+                if (typeof value === "bigint") {
+                    return value.toString();
+                }
+                return value;
+            }, 2));
+            console.log(`PlaywrightPulseReporter: JSON report written to ${finalOutputPath}`);
+            // REMOVED Static HTML Generation Call
+            // The reporter's responsibility is now only to create the JSON file.
+            // The user will run `npx generate-pulse-report` separately.
+        }
+        catch (error) {
+            console.error(`Pulse Reporter: Failed to write final JSON report to ${finalOutputPath}. Error: ${error.message}`);
+        }
+        finally {
+            if (this.isSharded) {
+                // console.log("Pulse Reporter: Cleaning up temporary shard files...");
+                await this._cleanupTemporaryFiles();
+            }
+        }
+    }
+}
+exports.PlaywrightPulseReporter = PlaywrightPulseReporter;
+exports.default = PlaywrightPulseReporter;

package/dist/reporter/reporter/playwright-pulse-reporter.d.ts

@@ -0,0 +1 @@
+export {};