@govtechsg/oobee 0.10.83 → 0.10.85

package/dist/mergeAxeResults/jsonArtifacts.js

@@ -0,0 +1,335 @@
+import fs from 'fs-extra';
+import path from 'path';
+import zlib from 'zlib';
+import { Base64Encode } from 'base64-stream';
+import { pipeline } from 'stream/promises';
+import { a11yRuleShortDescriptionMap } from '../constants/constants.js';
+import { consoleLogger } from '../logs.js';
+function* serializeObject(obj, depth = 0, indent = '  ') {
+    const currentIndent = indent.repeat(depth);
+    const nextIndent = indent.repeat(depth + 1);
+    if (obj instanceof Date) {
+        yield JSON.stringify(obj.toISOString());
+        return;
+    }
+    if (Array.isArray(obj)) {
+        yield '[\n';
+        for (let i = 0; i < obj.length; i++) {
+            if (i > 0)
+                yield ',\n';
+            yield nextIndent;
+            yield* serializeObject(obj[i], depth + 1, indent);
+        }
+        yield `\n${currentIndent}]`;
+        return;
+    }
+    if (obj !== null && typeof obj === 'object') {
+        yield '{\n';
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (i > 0)
+                yield ',\n';
+            yield `${nextIndent}${JSON.stringify(key)}: `;
+            yield* serializeObject(obj[key], depth + 1, indent);
+        }
+        yield `\n${currentIndent}}`;
+        return;
+    }
+    if (obj === null || typeof obj === 'function' || typeof obj === 'undefined') {
+        yield 'null';
+        return;
+    }
+    yield JSON.stringify(obj);
+}
+function writeLargeJsonToFile(obj, filePath) {
+    return new Promise((resolve, reject) => {
+        const writeStream = fs.createWriteStream(filePath, { encoding: 'utf8' });
+        writeStream.on('error', error => {
+            consoleLogger.error('Stream error:', error);
+            reject(error);
+        });
+        writeStream.on('finish', () => {
+            consoleLogger.info(`JSON file written successfully: ${filePath}`);
+            resolve(true);
+        });
+        const generator = serializeObject(obj);
+        function write() {
+            let next;
+            while (!(next = generator.next()).done) {
+                if (!writeStream.write(next.value)) {
+                    writeStream.once('drain', write);
+                    return;
+                }
+            }
+            writeStream.end();
+        }
+        write();
+    });
+}
+const writeLargeScanItemsJsonToFile = async (obj, filePath) => {
+    return new Promise((resolve, reject) => {
+        const writeStream = fs.createWriteStream(filePath, { flags: 'a', encoding: 'utf8' });
+        const writeQueue = [];
+        let isWriting = false;
+        const processNextWrite = async () => {
+            if (isWriting || writeQueue.length === 0)
+                return;
+            isWriting = true;
+            const data = writeQueue.shift();
+            try {
+                if (!writeStream.write(data)) {
+                    await new Promise(resolve => {
+                        writeStream.once('drain', () => {
+                            resolve();
+                        });
+                    });
+                }
+            }
+            catch (error) {
+                writeStream.destroy(error);
+                return;
+            }
+            isWriting = false;
+            processNextWrite();
+        };
+        const queueWrite = (data) => {
+            writeQueue.push(data);
+            processNextWrite();
+        };
+        writeStream.on('error', error => {
+            consoleLogger.error(`Error writing object to JSON file: ${error}`);
+            reject(error);
+        });
+        writeStream.on('finish', () => {
+            consoleLogger.info(`JSON file written successfully: ${filePath}`);
+            resolve(true);
+        });
+        try {
+            queueWrite('{\n');
+            const keys = Object.keys(obj);
+            keys.forEach((key, i) => {
+                const value = obj[key];
+                if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                    queueWrite(`  "${key}": ${JSON.stringify(value)}`);
+                }
+                else {
+                    queueWrite(`  "${key}": {\n`);
+                    const { rules, ...otherProperties } = value;
+                    Object.entries(otherProperties).forEach(([propKey, propValue], j) => {
+                        const propValueString = propValue === null ||
+                            typeof propValue === 'function' ||
+                            typeof propValue === 'undefined'
+                            ? 'null'
+                            : JSON.stringify(propValue);
+                        queueWrite(`    "${propKey}": ${propValueString}`);
+                        if (j < Object.keys(otherProperties).length - 1 || (rules && rules.length >= 0)) {
+                            queueWrite(',\n');
+                        }
+                        else {
+                            queueWrite('\n');
+                        }
+                    });
+                    if (rules && Array.isArray(rules)) {
+                        queueWrite('    "rules": [\n');
+                        rules.forEach((rule, j) => {
+                            queueWrite('      {\n');
+                            const { pagesAffected, ...otherRuleProperties } = rule;
+                            Object.entries(otherRuleProperties).forEach(([ruleKey, ruleValue], k) => {
+                                const ruleValueString = ruleValue === null ||
+                                    typeof ruleValue === 'function' ||
+                                    typeof ruleValue === 'undefined'
+                                    ? 'null'
+                                    : JSON.stringify(ruleValue);
+                                queueWrite(`        "${ruleKey}": ${ruleValueString}`);
+                                if (k < Object.keys(otherRuleProperties).length - 1 || pagesAffected) {
+                                    queueWrite(',\n');
+                                }
+                                else {
+                                    queueWrite('\n');
+                                }
+                            });
+                            if (pagesAffected && Array.isArray(pagesAffected)) {
+                                queueWrite('        "pagesAffected": [\n');
+                                pagesAffected.forEach((page, p) => {
+                                    const pageJson = JSON.stringify(page, null, 2)
+                                        .split('\n')
+                                        .map(line => `          ${line}`)
+                                        .join('\n');
+                                    queueWrite(pageJson);
+                                    if (p < pagesAffected.length - 1) {
+                                        queueWrite(',\n');
+                                    }
+                                    else {
+                                        queueWrite('\n');
+                                    }
+                                });
+                                queueWrite('        ]');
+                            }
+                            queueWrite('\n      }');
+                            if (j < rules.length - 1) {
+                                queueWrite(',\n');
+                            }
+                            else {
+                                queueWrite('\n');
+                            }
+                        });
+                        queueWrite('    ]');
+                    }
+                    queueWrite('\n  }');
+                }
+                if (i < keys.length - 1) {
+                    queueWrite(',\n');
+                }
+                else {
+                    queueWrite('\n');
+                }
+            });
+            queueWrite('}\n');
+            const checkQueueAndEnd = () => {
+                if (writeQueue.length === 0 && !isWriting) {
+                    writeStream.end();
+                }
+                else {
+                    setTimeout(checkQueueAndEnd, 100);
+                }
+            };
+            checkQueueAndEnd();
+        }
+        catch (err) {
+            writeStream.destroy(err);
+            reject(err);
+        }
+    });
+};
+async function compressJsonFileStreaming(inputPath, outputPath) {
+    const readStream = fs.createReadStream(inputPath);
+    const writeStream = fs.createWriteStream(outputPath);
+    const gzip = zlib.createGzip();
+    const base64Encode = new Base64Encode();
+    await pipeline(readStream, gzip, base64Encode, writeStream);
+    consoleLogger.info(`File successfully compressed and saved to ${outputPath}`);
+}
+const writeJsonFileAndCompressedJsonFile = async (data, storagePath, filename) => {
+    try {
+        consoleLogger.info(`Writing JSON to ${filename}.json`);
+        const jsonFilePath = path.join(storagePath, `${filename}.json`);
+        if (filename === 'scanItems') {
+            await writeLargeScanItemsJsonToFile(data, jsonFilePath);
+        }
+        else {
+            await writeLargeJsonToFile(data, jsonFilePath);
+        }
+        consoleLogger.info(`Reading ${filename}.json, gzipping and base64 encoding it into ${filename}.json.gz.b64`);
+        const base64FilePath = path.join(storagePath, `${filename}.json.gz.b64`);
+        await compressJsonFileStreaming(jsonFilePath, base64FilePath);
+        consoleLogger.info(`Finished compression and base64 encoding for ${filename}`);
+        return {
+            jsonFilePath,
+            base64FilePath,
+        };
+    }
+    catch (error) {
+        consoleLogger.error(`Error compressing and encoding ${filename}`);
+        throw error;
+    }
+};
+const writeJsonAndBase64Files = async (allIssues, storagePath) => {
+    const { items, ...rest } = allIssues;
+    const { jsonFilePath: scanDataJsonFilePath, base64FilePath: scanDataBase64FilePath } = await writeJsonFileAndCompressedJsonFile(rest, storagePath, 'scanData');
+    const { jsonFilePath: scanItemsJsonFilePath, base64FilePath: scanItemsBase64FilePath } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...items }, storagePath, 'scanItems');
+    ['mustFix', 'goodToFix', 'needsReview', 'passed'].forEach(category => {
+        if (items[category].rules && Array.isArray(items[category].rules)) {
+            items[category].rules.forEach(rule => {
+                rule.pagesAffectedCount = Array.isArray(rule.pagesAffected) ? rule.pagesAffected.length : 0;
+            });
+            items[category].rules.sort((a, b) => (b.pagesAffectedCount || 0) - (a.pagesAffectedCount || 0));
+        }
+    });
+    const scanIssuesSummary = {
+        mustFix: items.mustFix.rules.map(({ pagesAffected, ...ruleInfo }) => ({
+            ...ruleInfo,
+            description: a11yRuleShortDescriptionMap[ruleInfo.rule] || ruleInfo.description,
+        })),
+        goodToFix: items.goodToFix.rules.map(({ pagesAffected, ...ruleInfo }) => ({
+            ...ruleInfo,
+            description: a11yRuleShortDescriptionMap[ruleInfo.rule] || ruleInfo.description,
+        })),
+        needsReview: items.needsReview.rules.map(({ pagesAffected, ...ruleInfo }) => ({
+            ...ruleInfo,
+            description: a11yRuleShortDescriptionMap[ruleInfo.rule] || ruleInfo.description,
+        })),
+        passed: items.passed.rules.map(({ pagesAffected, ...ruleInfo }) => ({
+            ...ruleInfo,
+            description: a11yRuleShortDescriptionMap[ruleInfo.rule] || ruleInfo.description,
+        })),
+    };
+    const { jsonFilePath: scanIssuesSummaryJsonFilePath, base64FilePath: scanIssuesSummaryBase64FilePath, } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...scanIssuesSummary }, storagePath, 'scanIssuesSummary');
+    items.mustFix.rules.forEach(rule => {
+        rule.pagesAffected.forEach(page => {
+            page.itemsCount = page.items.length;
+        });
+    });
+    items.goodToFix.rules.forEach(rule => {
+        rule.pagesAffected.forEach(page => {
+            page.itemsCount = page.items.length;
+        });
+    });
+    items.needsReview.rules.forEach(rule => {
+        rule.pagesAffected.forEach(page => {
+            page.itemsCount = page.items.length;
+        });
+    });
+    items.passed.rules.forEach(rule => {
+        rule.pagesAffected.forEach(page => {
+            page.itemsCount = page.items.length;
+        });
+    });
+    items.mustFix.totalRuleIssues = items.mustFix.rules.length;
+    items.goodToFix.totalRuleIssues = items.goodToFix.rules.length;
+    items.needsReview.totalRuleIssues = items.needsReview.rules.length;
+    items.passed.totalRuleIssues = items.passed.rules.length;
+    const { topTenPagesWithMostIssues, wcagLinks, wcagPassPercentage, progressPercentage, issuesPercentage, totalPagesScanned, totalPagesNotScanned, topTenIssues, } = rest;
+    const summaryItems = {
+        mustFix: {
+            totalItems: items.mustFix?.totalItems || 0,
+            totalRuleIssues: items.mustFix?.totalRuleIssues || 0,
+        },
+        goodToFix: {
+            totalItems: items.goodToFix?.totalItems || 0,
+            totalRuleIssues: items.goodToFix?.totalRuleIssues || 0,
+        },
+        needsReview: {
+            totalItems: items.needsReview?.totalItems || 0,
+            totalRuleIssues: items.needsReview?.totalRuleIssues || 0,
+        },
+        topTenPagesWithMostIssues,
+        wcagLinks,
+        wcagPassPercentage,
+        progressPercentage,
+        issuesPercentage,
+        totalPagesScanned,
+        totalPagesNotScanned,
+        topTenIssues,
+    };
+    const { jsonFilePath: scanItemsSummaryJsonFilePath, base64FilePath: scanItemsSummaryBase64FilePath, } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...summaryItems }, storagePath, 'scanItemsSummary');
+    const { jsonFilePath: scanPagesDetailJsonFilePath, base64FilePath: scanPagesDetailBase64FilePath, } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...allIssues.scanPagesDetail }, storagePath, 'scanPagesDetail');
+    const { jsonFilePath: scanPagesSummaryJsonFilePath, base64FilePath: scanPagesSummaryBase64FilePath, } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...allIssues.scanPagesSummary }, storagePath, 'scanPagesSummary');
+    return {
+        scanDataJsonFilePath,
+        scanDataBase64FilePath,
+        scanItemsJsonFilePath,
+        scanItemsBase64FilePath,
+        scanItemsSummaryJsonFilePath,
+        scanItemsSummaryBase64FilePath,
+        scanIssuesSummaryJsonFilePath,
+        scanIssuesSummaryBase64FilePath,
+        scanPagesDetailJsonFilePath,
+        scanPagesDetailBase64FilePath,
+        scanPagesSummaryJsonFilePath,
+        scanPagesSummaryBase64FilePath,
+        scanDataJsonFileSize: fs.statSync(scanDataJsonFilePath).size,
+        scanItemsJsonFileSize: fs.statSync(scanItemsJsonFilePath).size,
+    };
+};
+export { compressJsonFileStreaming, writeJsonAndBase64Files, writeJsonFileAndCompressedJsonFile };

package/dist/mergeAxeResults/scanPages.js

@@ -0,0 +1,159 @@
+/**
+ * Build allIssues.scanPagesDetail and allIssues.scanPagesSummary
+ * by analyzing pagesScanned (including mustFix/goodToFix/etc.).
+ */
+export default function populateScanPagesDetail(allIssues) {
+    const allScannedPages = Array.isArray(allIssues.pagesScanned) ? allIssues.pagesScanned : [];
+    const mustFixCategory = 'mustFix';
+    const goodToFixCategory = 'goodToFix';
+    const needsReviewCategory = 'needsReview';
+    const passedCategory = 'passed';
+    const pagesMap = {};
+    Object.entries(allIssues.items).forEach(([categoryName, categoryData]) => {
+        if (!categoryData?.rules)
+            return;
+        categoryData.rules.forEach(rule => {
+            const { rule: ruleId, conformance = [] } = rule;
+            rule.pagesAffected.forEach(p => {
+                const { url, pageTitle, items = [] } = p;
+                const itemsCount = items.length;
+                if (!pagesMap[url]) {
+                    pagesMap[url] = {
+                        pageTitle,
+                        url,
+                        totalOccurrencesFailedIncludingNeedsReview: 0,
+                        totalOccurrencesFailedExcludingNeedsReview: 0,
+                        totalOccurrencesNeedsReview: 0,
+                        totalOccurrencesPassed: 0,
+                        typesOfIssues: {},
+                    };
+                }
+                if (!pagesMap[url].typesOfIssues[ruleId]) {
+                    pagesMap[url].typesOfIssues[ruleId] = {
+                        ruleId,
+                        wcagConformance: conformance,
+                        occurrencesMustFix: 0,
+                        occurrencesGoodToFix: 0,
+                        occurrencesNeedsReview: 0,
+                        occurrencesPassed: 0,
+                    };
+                }
+                if (categoryName === mustFixCategory) {
+                    pagesMap[url].typesOfIssues[ruleId].occurrencesMustFix += itemsCount;
+                    pagesMap[url].totalOccurrencesFailedIncludingNeedsReview += itemsCount;
+                    pagesMap[url].totalOccurrencesFailedExcludingNeedsReview += itemsCount;
+                }
+                else if (categoryName === goodToFixCategory) {
+                    pagesMap[url].typesOfIssues[ruleId].occurrencesGoodToFix += itemsCount;
+                    pagesMap[url].totalOccurrencesFailedIncludingNeedsReview += itemsCount;
+                    pagesMap[url].totalOccurrencesFailedExcludingNeedsReview += itemsCount;
+                }
+                else if (categoryName === needsReviewCategory) {
+                    pagesMap[url].typesOfIssues[ruleId].occurrencesNeedsReview += itemsCount;
+                    pagesMap[url].totalOccurrencesFailedIncludingNeedsReview += itemsCount;
+                    pagesMap[url].totalOccurrencesNeedsReview += itemsCount;
+                }
+                else if (categoryName === passedCategory) {
+                    pagesMap[url].typesOfIssues[ruleId].occurrencesPassed += itemsCount;
+                    pagesMap[url].totalOccurrencesPassed += itemsCount;
+                }
+            });
+        });
+    });
+    const pagesInMap = Object.values(pagesMap);
+    const pagesInMapUrls = new Set(Object.keys(pagesMap));
+    const pagesAllPassed = pagesInMap.filter(p => p.totalOccurrencesFailedIncludingNeedsReview === 0);
+    const pagesNoEntries = allScannedPages
+        .filter(sp => !pagesInMapUrls.has(sp.url))
+        .map(sp => ({
+        pageTitle: sp.pageTitle,
+        url: sp.url,
+        totalOccurrencesFailedIncludingNeedsReview: 0,
+        totalOccurrencesFailedExcludingNeedsReview: 0,
+        totalOccurrencesNeedsReview: 0,
+        totalOccurrencesPassed: 0,
+        typesOfIssues: {},
+    }));
+    const pagesNotAffectedRaw = [...pagesAllPassed, ...pagesNoEntries];
+    const pagesAffectedRaw = pagesInMap.filter(p => p.totalOccurrencesFailedIncludingNeedsReview > 0);
+    function transformPageData(page) {
+        const typesOfIssuesArray = Object.values(page.typesOfIssues);
+        const mustFixSum = typesOfIssuesArray.reduce((acc, r) => acc + r.occurrencesMustFix, 0);
+        const goodToFixSum = typesOfIssuesArray.reduce((acc, r) => acc + r.occurrencesGoodToFix, 0);
+        const needsReviewSum = typesOfIssuesArray.reduce((acc, r) => acc + r.occurrencesNeedsReview, 0);
+        const categoriesPresent = [];
+        if (mustFixSum > 0)
+            categoriesPresent.push('mustFix');
+        if (goodToFixSum > 0)
+            categoriesPresent.push('goodToFix');
+        if (needsReviewSum > 0)
+            categoriesPresent.push('needsReview');
+        const failedRuleIds = new Set();
+        typesOfIssuesArray.forEach(r => {
+            if ((r.occurrencesMustFix || 0) > 0 ||
+                (r.occurrencesGoodToFix || 0) > 0 ||
+                (r.occurrencesNeedsReview || 0) > 0) {
+                failedRuleIds.add(r.ruleId);
+            }
+        });
+        const failedRuleCount = failedRuleIds.size;
+        const typesOfIssuesExcludingNeedsReviewCount = typesOfIssuesArray.filter(r => (r.occurrencesMustFix || 0) + (r.occurrencesGoodToFix || 0) > 0).length;
+        const typesOfIssuesExclusiveToNeedsReviewCount = typesOfIssuesArray.filter(r => (r.occurrencesNeedsReview || 0) > 0 &&
+            (r.occurrencesMustFix || 0) === 0 &&
+            (r.occurrencesGoodToFix || 0) === 0).length;
+        const allConformance = typesOfIssuesArray.reduce((acc, curr) => {
+            const nonPassedCount = (curr.occurrencesMustFix || 0) +
+                (curr.occurrencesGoodToFix || 0) +
+                (curr.occurrencesNeedsReview || 0);
+            if (nonPassedCount > 0) {
+                return acc.concat(curr.wcagConformance || []);
+            }
+            return acc;
+        }, []);
+        const conformance = Array.from(new Set(allConformance));
+        return {
+            pageTitle: page.pageTitle,
+            url: page.url,
+            totalOccurrencesFailedIncludingNeedsReview: page.totalOccurrencesFailedIncludingNeedsReview,
+            totalOccurrencesFailedExcludingNeedsReview: page.totalOccurrencesFailedExcludingNeedsReview,
+            totalOccurrencesMustFix: mustFixSum,
+            totalOccurrencesGoodToFix: goodToFixSum,
+            totalOccurrencesNeedsReview: needsReviewSum,
+            totalOccurrencesPassed: page.totalOccurrencesPassed,
+            typesOfIssuesExclusiveToNeedsReviewCount,
+            typesOfIssuesCount: failedRuleCount,
+            typesOfIssuesExcludingNeedsReviewCount,
+            categoriesPresent,
+            conformance,
+            typesOfIssues: typesOfIssuesArray,
+        };
+    }
+    const pagesAffected = pagesAffectedRaw.map(transformPageData);
+    const pagesNotAffected = pagesNotAffectedRaw.map(transformPageData);
+    pagesAffected.sort((a, b) => b.typesOfIssuesCount - a.typesOfIssuesCount);
+    pagesNotAffected.sort((a, b) => b.typesOfIssuesCount - a.typesOfIssuesCount);
+    const scannedPagesCount = pagesAffected.length + pagesNotAffected.length;
+    const pagesNotScannedCount = Array.isArray(allIssues.pagesNotScanned)
+        ? allIssues.pagesNotScanned.length
+        : 0;
+    allIssues.scanPagesDetail = {
+        pagesAffected,
+        pagesNotAffected,
+        scannedPagesCount,
+        pagesNotScanned: Array.isArray(allIssues.pagesNotScanned) ? allIssues.pagesNotScanned : [],
+        pagesNotScannedCount,
+    };
+    function stripTypesOfIssues(page) {
+        const { typesOfIssues, ...rest } = page;
+        return rest;
+    }
+    const summaryPagesAffected = pagesAffected.map(stripTypesOfIssues);
+    const summaryPagesNotAffected = pagesNotAffected.map(stripTypesOfIssues);
+    allIssues.scanPagesSummary = {
+        pagesAffected: summaryPagesAffected,
+        pagesNotAffected: summaryPagesNotAffected,
+        scannedPagesCount,
+        pagesNotScanned: Array.isArray(allIssues.pagesNotScanned) ? allIssues.pagesNotScanned : [],
+        pagesNotScannedCount,
+    };
+}

package/dist/mergeAxeResults/sentryTelemetry.js

@@ -0,0 +1,152 @@
+import * as Sentry from '@sentry/node';
+import { sentryConfig, setSentryUser } from '../constants/constants.js';
+import { categorizeWcagCriteria, getUserDataTxt, getWcagCriteriaMap } from '../utils.js';
+// Format WCAG tag in requested format: wcag111a_Occurrences
+const formatWcagTag = async (wcagId) => {
+    // Get dynamic WCAG criteria map
+    const wcagCriteriaMap = await getWcagCriteriaMap();
+    if (wcagCriteriaMap[wcagId]) {
+        const { level } = wcagCriteriaMap[wcagId];
+        return `${wcagId}${level}_Occurrences`;
+    }
+    return null;
+};
+// Send WCAG criteria breakdown to Sentry
+const sendWcagBreakdownToSentry = async (appVersion, wcagBreakdown, ruleIdJson, scanInfo, allIssues, pagesScannedCount = 0) => {
+    try {
+        // Initialize Sentry
+        Sentry.init(sentryConfig);
+        // Set user ID for Sentry tracking
+        const userData = getUserDataTxt();
+        if (userData && userData.userId) {
+            setSentryUser(userData.userId);
+        }
+        // Prepare tags for the event
+        const tags = {};
+        const wcagCriteriaBreakdown = {};
+        // Tag app version
+        tags.version = appVersion;
+        // Get dynamic WCAG criteria map once
+        const wcagCriteriaMap = await getWcagCriteriaMap();
+        // Categorize all WCAG criteria for reporting
+        const wcagIds = Array.from(new Set([...Object.keys(wcagCriteriaMap), ...Array.from(wcagBreakdown.keys())]));
+        const categorizedWcag = await categorizeWcagCriteria(wcagIds);
+        // First ensure all WCAG criteria are included in the tags with a value of 0
+        // This ensures criteria with no violations are still reported
+        for (const [wcagId, info] of Object.entries(wcagCriteriaMap)) {
+            const formattedTag = await formatWcagTag(wcagId);
+            if (formattedTag) {
+                // Initialize with zero
+                tags[formattedTag] = '0';
+                // Store in breakdown object with category information
+                wcagCriteriaBreakdown[formattedTag] = {
+                    count: 0,
+                    category: categorizedWcag[wcagId] || 'mustFix', // Default to mustFix if not found
+                };
+            }
+        }
+        // Now override with actual counts from the scan
+        for (const [wcagId, count] of wcagBreakdown.entries()) {
+            const formattedTag = await formatWcagTag(wcagId);
+            if (formattedTag) {
+                // Add as a tag with the count as value
+                tags[formattedTag] = String(count);
+                // Update count in breakdown object
+                if (wcagCriteriaBreakdown[formattedTag]) {
+                    wcagCriteriaBreakdown[formattedTag].count = count;
+                }
+                else {
+                    // If somehow this wasn't in our initial map
+                    wcagCriteriaBreakdown[formattedTag] = {
+                        count,
+                        category: categorizedWcag[wcagId] || 'mustFix',
+                    };
+                }
+            }
+        }
+        // Calculate category counts based on actual issue counts from the report
+        // rather than occurrence counts from wcagBreakdown
+        const categoryCounts = {
+            mustFix: 0,
+            goodToFix: 0,
+            needsReview: 0,
+        };
+        if (allIssues) {
+            // Use the actual report data for the counts
+            categoryCounts.mustFix = allIssues.items.mustFix.rules.length;
+            categoryCounts.goodToFix = allIssues.items.goodToFix.rules.length;
+            categoryCounts.needsReview = allIssues.items.needsReview.rules.length;
+        }
+        else {
+            // Fallback to the old way if allIssues not provided
+            Object.values(wcagCriteriaBreakdown).forEach(item => {
+                if (item.count > 0 && categoryCounts[item.category] !== undefined) {
+                    categoryCounts[item.category] += 1; // Count rules, not occurrences
+                }
+            });
+        }
+        // Add category counts as tags
+        tags['WCAG-MustFix-Count'] = String(categoryCounts.mustFix);
+        tags['WCAG-GoodToFix-Count'] = String(categoryCounts.goodToFix);
+        tags['WCAG-NeedsReview-Count'] = String(categoryCounts.needsReview);
+        // Also add occurrence counts for reference
+        if (allIssues) {
+            tags['WCAG-MustFix-Occurrences'] = String(allIssues.items.mustFix.totalItems);
+            tags['WCAG-GoodToFix-Occurrences'] = String(allIssues.items.goodToFix.totalItems);
+            tags['WCAG-NeedsReview-Occurrences'] = String(allIssues.items.needsReview.totalItems);
+            // Add number of pages scanned tag
+            tags['Pages-Scanned-Count'] = String(allIssues.totalPagesScanned);
+        }
+        else if (pagesScannedCount > 0) {
+            // Still add the pages scanned count even if we don't have allIssues
+            tags['Pages-Scanned-Count'] = String(pagesScannedCount);
+        }
+        // Send the event to Sentry
+        await Sentry.captureEvent({
+            message: 'Accessibility Scan Completed',
+            level: 'info',
+            tags: {
+                ...tags,
+                event_type: 'accessibility_scan',
+                scanType: scanInfo.scanType,
+                browser: scanInfo.browser,
+                entryUrl: scanInfo.entryUrl,
+            },
+            user: {
+                ...(scanInfo.email && scanInfo.name
+                    ? {
+                        email: scanInfo.email,
+                        username: scanInfo.name,
+                    }
+                    : {}),
+                ...(userData && userData.userId ? { id: userData.userId } : {}),
+            },
+            extra: {
+                additionalScanMetadata: ruleIdJson != null ? JSON.stringify(ruleIdJson) : '{}',
+                wcagBreakdown: wcagCriteriaBreakdown,
+                reportCounts: allIssues
+                    ? {
+                        mustFix: {
+                            issues: allIssues.items.mustFix.rules?.length ?? 0,
+                            occurrences: allIssues.items.mustFix.totalItems ?? 0,
+                        },
+                        goodToFix: {
+                            issues: allIssues.items.goodToFix.rules?.length ?? 0,
+                            occurrences: allIssues.items.goodToFix.totalItems ?? 0,
+                        },
+                        needsReview: {
+                            issues: allIssues.items.needsReview.rules?.length ?? 0,
+                            occurrences: allIssues.items.needsReview.totalItems ?? 0,
+                        },
+                    }
+                    : undefined,
+            },
+        });
+        // Wait for events to be sent
+        await Sentry.flush(2000);
+    }
+    catch (error) {
+        console.error('Error sending WCAG breakdown to Sentry:', error);
+    }
+};
+export default sendWcagBreakdownToSentry;

package/dist/mergeAxeResults/types.js

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