@govtechsg/oobee 0.10.83 → 0.10.84

package/dist/mergeAxeResults/itemReferences.js

@@ -0,0 +1,55 @@
+/**
+ * Builds pre-computed HTML groups to optimize Group by HTML Element functionality.
+ * Keys are composite "html\x00xpath" strings to ensure unique matching per element instance.
+ */
+export const buildHtmlGroups = (rule, items, pageUrl) => {
+    if (!rule.htmlGroups) {
+        rule.htmlGroups = {};
+    }
+    items.forEach(item => {
+        // Use composite key of html + xpath for precise matching
+        const htmlKey = `${item.html || 'No HTML element'}\x00${item.xpath || ''}`;
+        if (!rule.htmlGroups[htmlKey]) {
+            // Create new group with the first occurrence
+            rule.htmlGroups[htmlKey] = {
+                html: item.html || '',
+                xpath: item.xpath || '',
+                message: item.message || '',
+                screenshotPath: item.screenshotPath || '',
+                displayNeedsReview: item.displayNeedsReview,
+                pageUrls: [],
+            };
+        }
+        if (!rule.htmlGroups[htmlKey].pageUrls.includes(pageUrl)) {
+            rule.htmlGroups[htmlKey].pageUrls.push(pageUrl);
+        }
+    });
+};
+/**
+ * Converts items in pagesAffected to references (html\x00xpath composite keys) for embedding in HTML report.
+ * Additionally, it deep-clones allIssues, replaces page.items objects with composite reference keys.
+ * Those refs are specifically for htmlGroups lookup (html + xpath).
+ */
+export const convertItemsToReferences = (allIssues) => {
+    const cloned = JSON.parse(JSON.stringify(allIssues));
+    ['mustFix', 'goodToFix', 'needsReview', 'passed'].forEach(category => {
+        if (!cloned.items[category]?.rules)
+            return;
+        cloned.items[category].rules.forEach((rule) => {
+            if (!rule.pagesAffected || !rule.htmlGroups)
+                return;
+            rule.pagesAffected.forEach((page) => {
+                if (!page.items)
+                    return;
+                page.items = page.items.map((item) => {
+                    if (typeof item === 'string')
+                        return item; // Already a reference
+                    // Use composite key matching buildHtmlGroups
+                    const htmlKey = `${item.html || 'No HTML element'}\x00${item.xpath || ''}`;
+                    return htmlKey;
+                });
+            });
+        });
+    });
+    return cloned;
+};

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,
+    };
+}