snap-ally 0.0.1

package/dist/A11yReportAssets.js

@@ -0,0 +1,180 @@
+"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.A11yReportAssets = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Utilities for managing and copying report assets like videos and screenshots.
+ */
+class A11yReportAssets {
+    /**
+     * Copies a file from source to a destination folder.
+     */
+    copyToFolder(destFolder, srcPath, fileName) {
+        if (!srcPath || !fs.existsSync(srcPath)) {
+            return '';
+        }
+        const name = fileName || path.basename(srcPath);
+        const destFile = path.join(destFolder, name);
+        if (!fs.existsSync(destFolder)) {
+            fs.mkdirSync(destFolder, { recursive: true });
+        }
+        fs.copyFileSync(srcPath, destFile);
+        return name;
+    }
+    /**
+     * Copies the test video if available.
+     * Includes a small retry to ensure Playwright has finished flushing the file.
+     */
+    async copyTestVideo(result, destFolder) {
+        const videoAttachments = result.attachments.filter(a => a.name === 'video');
+        let bestVideo = null;
+        let maxSize = -1;
+        for (const attachment of videoAttachments) {
+            if (!attachment.path)
+                continue;
+            // Retry logic: Wait for file to exist and have non-zero size (up to 2 seconds)
+            let attempts = 0;
+            let isReady = false;
+            while (attempts < 10) {
+                if (fs.existsSync(attachment.path)) {
+                    try {
+                        if (fs.statSync(attachment.path).size > 0) {
+                            isReady = true;
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        // statSync might fail if file is temporarily locked
+                    }
+                }
+                await new Promise(r => setTimeout(r, 200));
+                attempts++;
+            }
+            if (isReady) {
+                try {
+                    const size = fs.statSync(attachment.path).size;
+                    if (size > maxSize) {
+                        maxSize = size;
+                        bestVideo = attachment.path;
+                    }
+                }
+                catch (err) {
+                    console.error(`[SnapAlly] Error checking video stats: ${err}`);
+                }
+            }
+            else {
+                console.warn(`[SnapAlly] Video attachment found but file is missing or empty: ${attachment.path}`);
+            }
+        }
+        if (bestVideo) {
+            try {
+                return this.copyToFolder(destFolder, bestVideo);
+            }
+            catch (e) {
+                console.error(`[SnapAlly] Failed to copy video: ${e}`);
+                return path.basename(bestVideo);
+            }
+        }
+        return '';
+    }
+    /**
+     * Copies all screenshots found in the test attachments.
+     */
+    copyScreenshots(result, destFolder) {
+        return result.attachments
+            .filter(a => a.name === 'screenshot')
+            .map(a => {
+            if (a.path) {
+                return this.copyToFolder(destFolder, a.path);
+            }
+            else if (a.body) {
+                return this.writeBuffer(destFolder, `screenshot-${Date.now()}.png`, a.body);
+            }
+            return '';
+        })
+            .filter(path => path !== '');
+    }
+    /**
+     * Copies all PNG attachments to the report folder and returns their new names.
+     */
+    copyPngAttachments(result, destFolder) {
+        return result.attachments
+            .filter(a => a.name.endsWith('.png') && a.name !== 'screenshot')
+            .map(a => {
+            let name = '';
+            if (a.path) {
+                name = this.copyToFolder(destFolder, a.path, a.name);
+            }
+            else if (a.body) {
+                name = this.writeBuffer(destFolder, a.name, a.body);
+            }
+            return name ? { path: name, name: a.name } : null;
+        })
+            .filter((item) => item !== null);
+    }
+    /**
+     * Copies all other attachments (traces, logs, etc.) to the report folder.
+     */
+    copyAllOtherAttachments(result, destFolder) {
+        const excludedNames = ['screenshot', 'video', 'A11y'];
+        return result.attachments
+            .filter(a => !excludedNames.includes(a.name) && !a.name.endsWith('.png'))
+            .map(a => {
+            let name = '';
+            if (a.path) {
+                name = this.copyToFolder(destFolder, a.path, a.name);
+            }
+            else if (a.body) {
+                name = this.writeBuffer(destFolder, a.name, a.body);
+            }
+            return name ? { path: name, name: a.name } : null;
+        })
+            .filter((item) => item !== null);
+    }
+    /**
+     * Writes a buffer to a file in the destination folder.
+     */
+    writeBuffer(destFolder, fileName, buffer) {
+        if (!fs.existsSync(destFolder)) {
+            fs.mkdirSync(destFolder, { recursive: true });
+        }
+        const destFile = path.join(destFolder, fileName);
+        fs.writeFileSync(destFile, buffer);
+        return fileName;
+    }
+}
+exports.A11yReportAssets = A11yReportAssets;

package/dist/A11yScanner.d.ts

@@ -0,0 +1,25 @@
+import { Page, Locator, TestInfo } from '@playwright/test';
+export interface A11yScannerOptions {
+    /** Specific selector or locator to include in the scan. */
+    include?: string | Locator;
+    /** Alias for include. */
+    box?: string | Locator;
+    /** Whether to log violations to the console. @default true */
+    verbose?: boolean;
+    /** Alias for verbose. */
+    consoleLog?: boolean;
+    /** Specific Axe rules to enable or disable. */
+    rules?: Record<string, {
+        enabled: boolean;
+    }>;
+    /** Specific WCAG tags to check (e.g., ['wcag2a', 'wcag2aa']). */
+    tags?: string[];
+    /** Any other Axe-core options to pass to the builder. */
+    axeOptions?: Record<string, unknown>;
+}
+/**
+ * Performs an accessibility audit using Axe and Lighthouse.
+ */
+export declare function scanA11y(page: Page, testInfo: TestInfo, options?: A11yScannerOptions): Promise<void>;
+/** Alias for backward compatibility */
+export declare const checkAccessibility: typeof scanA11y;

package/dist/A11yScanner.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAccessibility = void 0;
+exports.scanA11y = scanA11y;
+const playwright_1 = __importDefault(require("@axe-core/playwright"));
+const test_1 = require("@playwright/test");
+const A11yAuditOverlay_1 = require("./A11yAuditOverlay");
+const models_1 = require("./models");
+/**
+ * Performs an accessibility audit using Axe and Lighthouse.
+ */
+async function scanA11y(page, testInfo, options = {}) {
+    var _a;
+    const verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : true;
+    const overlay = new A11yAuditOverlay_1.A11yAuditOverlay(page, page.url());
+    // Configure Axe
+    let axeBuilder = new playwright_1.default({ page });
+    const target = options.include || options.box;
+    if (target) {
+        if (typeof target === 'string') {
+            axeBuilder = axeBuilder.include(target);
+        }
+        else {
+            // AxeBuilder for playwright also supports locators/elements in include
+            axeBuilder = axeBuilder.include(target);
+        }
+    }
+    if (options.rules) {
+        axeBuilder = axeBuilder.options({ rules: options.rules });
+    }
+    if (options.tags) {
+        axeBuilder = axeBuilder.withTags(options.tags);
+    }
+    if (options.axeOptions) {
+        axeBuilder = axeBuilder.options(options.axeOptions);
+    }
+    const axeResults = await axeBuilder.analyze();
+    const violationCount = axeResults.violations.length;
+    if (verbose && violationCount > 0) {
+        console.log(`\n[A11yScanner] Violations found: ${violationCount}`);
+        axeResults.violations.forEach((v, i) => {
+            console.log(`  ${i + 1}. ${v.id} [${v.impact}] - ${v.help}`);
+        });
+    }
+    // Fail the test if violations found (softly)
+    test_1.expect.soft(violationCount, `Accessibility audit failed with ${violationCount} violations.`).toBe(0);
+    // Run Axe Audit
+    const errors = [];
+    const colorMap = {
+        minor: '#0ea5e9', // Ocean Blue
+        moderate: '#f59e0b', // Amber/Honey
+        serious: '#ea580c', // Deep Orange
+        critical: '#dc2626' // Power Red
+    };
+    // Process violations for the report
+    for (const violation of axeResults.violations) {
+        let errorIdx = 0;
+        const targets = [];
+        const severityColor = colorMap[violation.impact || ''] || '#757575';
+        for (const node of violation.nodes) {
+            for (const selector of node.target) {
+                const elementSelector = selector.toString();
+                const locator = page.locator(elementSelector);
+                await overlay.showViolationOverlay({ id: violation.id, help: violation.help }, severityColor);
+                if (await locator.isVisible()) {
+                    await overlay.highlightElement(elementSelector, severityColor);
+                    // Allow time for video capture or manual inspection during debug
+                    // eslint-disable-next-line playwright/no-wait-for-timeout
+                    await page.waitForTimeout(2000);
+                    const screenshotName = `a11y-${violation.id}-${errorIdx++}.png`;
+                    const buffer = await overlay.captureAndAttachScreenshot(screenshotName, testInfo);
+                    // Capture execution steps for context
+                    const excluded = new Set(['Pre Condition', 'Post Condition', 'Description', 'A11y']);
+                    const contextSteps = (testInfo.annotations || [])
+                        .filter(a => !excluded.has(a.type))
+                        .map(a => a.description || '');
+                    const nodeHtml = node.html || '';
+                    const friendlySnippet = elementSelector; // Use full CSS selector path from Axe core
+                    targets.push({
+                        element: elementSelector,
+                        snippet: friendlySnippet,
+                        html: nodeHtml,
+                        screenshot: screenshotName,
+                        steps: contextSteps,
+                        stepsJson: JSON.stringify(contextSteps),
+                        screenshotBase64: buffer.toString('base64')
+                    });
+                    await overlay.unhighlightElement();
+                }
+            }
+        }
+        errors.push({
+            id: violation.id,
+            description: violation.description,
+            severity: violation.impact || 'unknown',
+            helpUrl: violation.helpUrl,
+            help: violation.help,
+            guideline: violation.tags[1] || 'N/A',
+            wcagRule: violation.tags.find(t => t.startsWith('wcag')) || violation.tags[1] || 'N/A',
+            total: targets.length || violation.nodes.length, // Fallback to node count if no screenshots
+            target: targets
+        });
+    }
+    // Prepare data for the reporter
+    const reportData = {
+        pageKey: page.url(),
+        accessibilityScore: 0, // No longer used, derivation from Lighthouse removed
+        errors,
+        video: 'a11y-scan-video.webm', // Reference name for reporter
+        criticalColor: models_1.Severity.critical,
+        seriousColor: models_1.Severity.serious,
+        moderateColor: models_1.Severity.moderate,
+        minorColor: models_1.Severity.minor,
+        adoOrganization: process.env.ADO_ORGANIZATION || '',
+        adoProject: process.env.ADO_PROJECT || ''
+    };
+    await overlay.addTestAttachment(testInfo, 'A11y', JSON.stringify(reportData));
+    await overlay.hideViolationOverlay();
+}
+/** Alias for backward compatibility */
+exports.checkAccessibility = scanA11y;

package/dist/A11yTimeUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Time utility functions for formatting test durations.
+ */
+export declare class A11yTimeUtils {
+    /**
+     * Formats milliseconds into a human-readable duration string.
+     */
+    static formatDuration(ms: number): string;
+}

package/dist/A11yTimeUtils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A11yTimeUtils = void 0;
+/**
+ * Time utility functions for formatting test durations.
+ */
+class A11yTimeUtils {
+    /**
+     * Formats milliseconds into a human-readable duration string.
+     */
+    static formatDuration(ms) {
+        if (ms < 1000) {
+            return `${ms.toFixed(0)}ms`;
+        }
+        const seconds = ms / 1000;
+        if (seconds < 60) {
+            return `${seconds.toFixed(1)}s`;
+        }
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}m ${remainingSeconds.toFixed(0)}s`;
+    }
+}
+exports.A11yTimeUtils = A11yTimeUtils;

package/dist/SnapAllyLegacyReporter.d.ts

@@ -0,0 +1,30 @@
+import { Reporter, TestCase, TestResult, FullResult, FullConfig } from '@playwright/test/reporter';
+import { TestSummary } from './models';
+export interface AccessibilityReporterOptions {
+    outputFolder?: string;
+    colors?: {
+        critical?: string;
+        serious?: string;
+        moderate?: string;
+        minor?: string;
+    };
+    ado?: {
+        organization?: string;
+        project?: string;
+    };
+}
+declare class SnapAllyLegacyReporter implements Reporter {
+    private testNo;
+    private folderResults;
+    private fileHelper;
+    private htmlHelper;
+    private options;
+    private testDir;
+    summary: TestSummary;
+    constructor(options?: AccessibilityReporterOptions);
+    onBegin(config: FullConfig): void;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+    onEnd(result: FullResult): Promise<void>;
+    private getTestSteps;
+}
+export default SnapAllyLegacyReporter;

package/dist/SnapAllyLegacyReporter.js

@@ -0,0 +1,235 @@
+"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 models_1 = require("./models");
+const A11yReportAssets_1 = require("./A11yReportAssets");
+const A11yHtmlRenderer_1 = require("./A11yHtmlRenderer");
+const A11yTimeUtils_1 = require("./A11yTimeUtils");
+const path = __importStar(require("path"));
+class SnapAllyLegacyReporter {
+    constructor(options = {}) {
+        this.testNo = 0;
+        this.fileHelper = new A11yReportAssets_1.A11yReportAssets();
+        this.htmlHelper = new A11yHtmlRenderer_1.A11yHtmlRenderer();
+        this.testDir = 'tests';
+        // Summary state
+        this.summary = {
+            duration: '',
+            status: '',
+            statusIcon: '',
+            total: 0,
+            totalFailed: 0,
+            totalFlaky: 0,
+            totalPassed: 0,
+            totalSkipped: 0,
+            groupedResults: {},
+            wcagErrors: {},
+            totalA11yErrorCount: 0
+        };
+        this.options = options;
+        this.folderResults = options.outputFolder || 'steps-report';
+    }
+    onBegin(config) {
+        this.testDir = config.rootDir || 'tests';
+    }
+    async onTestEnd(test, result) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        this.testNo++;
+        const folderTest = path.join(this.folderResults, this.testNo.toString());
+        // --- Step Reporting Logic ---
+        const groupKey = path.relative(this.testDir, test.location.file);
+        if (!this.summary.groupedResults[groupKey]) {
+            this.summary.groupedResults[groupKey] = [];
+        }
+        const tags = (_a = test.tags.map(tag => tag.replace('@', ''))) !== null && _a !== void 0 ? _a : [];
+        const statusIcon = models_1.TestStatusIcon[result.status];
+        // Parse annotations for status report
+        const descriptionAnnotation = test.annotations.find(annotation => annotation.type == 'Description');
+        const description = (_b = descriptionAnnotation === null || descriptionAnnotation === void 0 ? void 0 : descriptionAnnotation.description) !== null && _b !== void 0 ? _b : 'No Description';
+        const browser = (_d = (_c = test.parent.project()) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : 'No browser';
+        // Steps filtering (exclude internal ones)
+        const excludedSteps = new Set(['Pre Condition', 'Post Condition', 'Description', 'A11y']);
+        const steps = test.annotations
+            .filter(annotation => !excludedSteps.has(annotation.type))
+            .map(annotation => { var _a; return (_a = annotation.description) !== null && _a !== void 0 ? _a : 'No steps'; });
+        const preConditions = test.annotations.filter(annotation => annotation.type == 'Pre Condition')
+            .map(annotation => { var _a; return (_a = annotation.description) !== null && _a !== void 0 ? _a : 'No pre conditions'; });
+        const postConditions = test.annotations.filter(annotation => annotation.type == 'Post Condition')
+            .map(annotation => { var _a; return (_a = annotation.description) !== null && _a !== void 0 ? _a : 'No post conditions'; });
+        const attachments = (_e = result.attachments
+            .filter(attachment => attachment.name !== 'screenshot' && attachment.name !== 'video' && !attachment.name.toLowerCase().includes('allure'))
+            .map(attachment => { var _a, _b; return ({ path: (_a = attachment.path) !== null && _a !== void 0 ? _a : '', name: (_b = attachment.name) !== null && _b !== void 0 ? _b : '' }); })) !== null && _e !== void 0 ? _e : [];
+        const reportAttachments = attachments.map(attachment => ({
+            path: this.fileHelper.copyToFolder(folderTest, attachment.path),
+            name: attachment.name
+        }));
+        const videoPath = await this.fileHelper.copyTestVideo(result, folderTest);
+        const screenshotPaths = this.fileHelper.copyScreenshots(result, folderTest);
+        const errors = (_f = result.errors.map(error => { var _a; return this.htmlHelper.ansiToHtml((_a = error.message) !== null && _a !== void 0 ? _a : 'No errors'); })) !== null && _f !== void 0 ? _f : [];
+        const resultItem = {
+            num: this.testNo,
+            folderName: this.testNo.toString(),
+            title: test.title,
+            fileName: groupKey,
+            timeDuration: result.duration,
+            duration: A11yTimeUtils_1.A11yTimeUtils.formatDuration(result.duration),
+            description: description,
+            status: result.status,
+            browser: browser,
+            tags: tags,
+            preConditions: preConditions,
+            steps: steps,
+            postConditions: postConditions,
+            statusIcon: statusIcon,
+            videoPath: videoPath,
+            screenshotPaths: screenshotPaths,
+            attachments: reportAttachments,
+            errors: errors
+        };
+        this.summary.groupedResults[groupKey].push(resultItem);
+        const wasRetried = test.results && test.results.length > 1;
+        const isFlaky = wasRetried && result.status === 'passed';
+        if (isFlaky)
+            this.summary.totalFlaky++;
+        switch (result.status) {
+            case 'passed':
+                this.summary.totalPassed++;
+                break;
+            case 'failed':
+                this.summary.totalFailed++;
+                break;
+            case 'skipped':
+                this.summary.totalSkipped++;
+                break;
+        }
+        this.summary.total++;
+        // Generate Step Report (index.html)
+        const indexFilePath = path.join(folderTest, 'index.html');
+        await this.htmlHelper.render('stepReporter.html', { result: resultItem }, folderTest, indexFilePath);
+        // --- Accessibility Reporting Logic ---
+        // Only process if there is A11y annotation
+        const reportDataAnnotation = test.annotations.find(annotation => annotation.type === 'A11y');
+        if (reportDataAnnotation) {
+            let fileName = `a11y${this.testNo}.html`;
+            let reportData = JSON.parse((_g = reportDataAnnotation.description) !== null && _g !== void 0 ? _g : '{}');
+            // Sanitize pageKey for filename
+            if (reportData.pageKey) {
+                const sanitizedKey = reportData.pageKey
+                    .replace(/https?:\/\//, '')
+                    .replace(/[^a-z0-9]+/gi, '-')
+                    .replace(/^-+|-+$/g, '')
+                    .toLowerCase();
+                fileName = sanitizedKey ? `${sanitizedKey}.html` : fileName;
+            }
+            const filePath = path.join(folderTest, fileName);
+            // Override configs with options or defaults
+            reportData.criticalColor = ((_h = this.options.colors) === null || _h === void 0 ? void 0 : _h.critical) || '#bd1f35';
+            reportData.seriousColor = ((_j = this.options.colors) === null || _j === void 0 ? void 0 : _j.serious) || '#d67f05';
+            reportData.moderateColor = ((_k = this.options.colors) === null || _k === void 0 ? void 0 : _k.moderate) || '#f0c000';
+            reportData.minorColor = ((_l = this.options.colors) === null || _l === void 0 ? void 0 : _l.minor) || '#2da4cf';
+            if (this.options.ado) {
+                if (this.options.ado.organization)
+                    reportData.adoOrganization = this.options.ado.organization;
+                if (this.options.ado.project)
+                    reportData.adoProject = this.options.ado.project;
+            }
+            // Enrich with Playwright steps if available
+            const playwrightSteps = this.getTestSteps(result);
+            if (playwrightSteps.length > 0 && reportData.errors) {
+                reportData.errors.forEach(error => {
+                    if (error.target) {
+                        error.target.forEach(target => {
+                            // Merge annotation steps with Playwright steps
+                            const existingSteps = new Set(target.steps || []);
+                            playwrightSteps.forEach(step => {
+                                if (!existingSteps.has(step)) {
+                                    if (!target.steps)
+                                        target.steps = [];
+                                    target.steps.push(step);
+                                }
+                            });
+                            // Update JSON for bug creation
+                            target.stepsJson = JSON.stringify(target.steps);
+                        });
+                    }
+                    // Aggregate WCAG errors for summary chart
+                    const ruleId = error.id;
+                    const totalViolations = error.total || 0;
+                    if (!this.summary.wcagErrors[ruleId]) {
+                        this.summary.wcagErrors[ruleId] = { count: 0, severity: error.severity, helpUrl: error.helpUrl };
+                    }
+                    this.summary.wcagErrors[ruleId].count += totalViolations;
+                });
+            }
+            this.fileHelper.copyPngAttachments(result, folderTest);
+            await this.htmlHelper.render('page-report.html', { data: reportData, folderTest }, folderTest, filePath);
+        }
+    }
+    async onEnd(result) {
+        var _a, _b, _c, _d;
+        const folderTest = this.folderResults;
+        const summaryName = 'index.html';
+        const summaryPath = path.join(folderTest, summaryName);
+        this.summary.duration = A11yTimeUtils_1.A11yTimeUtils.formatDuration(result.duration);
+        this.summary.status = result.status;
+        const statusIcon = models_1.TestStatusIcon[result.status];
+        this.summary.statusIcon = statusIcon;
+        const colors = {
+            critical: ((_a = this.options.colors) === null || _a === void 0 ? void 0 : _a.critical) || '#bd1f35',
+            serious: ((_b = this.options.colors) === null || _b === void 0 ? void 0 : _b.serious) || '#d67f05',
+            moderate: ((_c = this.options.colors) === null || _c === void 0 ? void 0 : _c.moderate) || '#f0c000',
+            minor: ((_d = this.options.colors) === null || _d === void 0 ? void 0 : _d.minor) || '#2da4cf'
+        };
+        await this.htmlHelper.render('global-summary.html', { results: this.summary, colors }, folderTest, summaryPath);
+    }
+    getTestSteps(result) {
+        const steps = [];
+        const processSteps = (testSteps) => {
+            for (const step of testSteps) {
+                if (step.category === 'test.step') {
+                    steps.push(step.title);
+                }
+                if (step.steps) {
+                    processSteps(step.steps);
+                }
+            }
+        };
+        if (result.steps) {
+            processSteps(result.steps);
+        }
+        return steps;
+    }
+}
+exports.default = SnapAllyLegacyReporter;

package/dist/SnapAllyReporter.d.ts

@@ -0,0 +1,44 @@
+import { Reporter, TestCase, TestResult, FullResult, FullConfig } from '@playwright/test/reporter';
+export interface AccessibilityReporterOptions {
+    /**
+     * Folder where the reports will be generated.
+     * @default "steps-report"
+     */
+    outputFolder?: string;
+    /**
+     * Custom colors for violation severities in the report.
+     */
+    colors?: {
+        critical?: string;
+        serious?: string;
+        moderate?: string;
+        minor?: string;
+    };
+    /**
+     * Azure DevOps integration options.
+     */
+    ado?: {
+        organization?: string;
+        project?: string;
+    };
+}
+/**
+ * Playwright reporter for accessibility audits and test steps.
+ * Generates an execution summary and detailed reports per test.
+ */
+declare class SnapAllyReporter implements Reporter {
+    private testIndex;
+    private outputFolder;
+    private assetsManager;
+    private renderer;
+    private options;
+    private projectRoot;
+    private executionSummary;
+    private tasks;
+    constructor(options?: AccessibilityReporterOptions);
+    onBegin(config: FullConfig): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    private processTestResult;
+    onEnd(result: FullResult): Promise<void>;
+}
+export default SnapAllyReporter;