@afixt/test-utils 1.2.0 → 1.2.2

package/src/tableUtils.js

@@ -0,0 +1,180 @@
+/**
+ * @file Table-related accessibility utilities
+ * @module tableUtils
+ */
+
+const tableUtils = {
+    /**
+     * Check if table has multiple header rows (rows containing th elements).
+     * @param {HTMLElement} table - The table element
+     * @returns {boolean} True if table has multiple header rows
+     */
+    hasMultipleHeaderRows(table) {
+        const rows = table.querySelectorAll('tr');
+        let headerRowCount = 0;
+
+        for (let i = 0; i < rows.length; i++) {
+            const thCells = rows[i].querySelectorAll('th');
+            const tdCells = rows[i].querySelectorAll('td');
+
+            if (thCells.length > 0 && thCells.length >= tdCells.length) {
+                headerRowCount++;
+            }
+        }
+
+        return headerRowCount >= 3;
+    },
+
+    /**
+     * Check if table has header cells with large colspan/rowspan values.
+     * @param {HTMLElement} table - The table element
+     * @param {number} [maxColspan=4] - Maximum acceptable colspan
+     * @param {number} [maxRowspan=3] - Maximum acceptable rowspan
+     * @returns {boolean} True if table has complex header spans
+     */
+    hasComplexHeaderSpans(table, maxColspan, maxRowspan) {
+        maxColspan = maxColspan || 4;
+        maxRowspan = maxRowspan || 3;
+
+        const headerCells = table.querySelectorAll('th[colspan], th[rowspan]');
+
+        for (let i = 0; i < headerCells.length; i++) {
+            const colspan = parseInt(headerCells[i].getAttribute('colspan'), 10) || 1;
+            const rowspan = parseInt(headerCells[i].getAttribute('rowspan'), 10) || 1;
+
+            if (colspan > maxColspan || rowspan > maxRowspan) {
+                return true;
+            }
+        }
+
+        return false;
+    },
+
+    /**
+     * Count effective columns in a table (accounting for colspan).
+     * @param {HTMLElement} table - The table element
+     * @returns {number} Maximum column count
+     */
+    getMaxColumnCount(table) {
+        const rows = table.querySelectorAll('tr');
+        let maxCols = 0;
+
+        for (let i = 0; i < rows.length; i++) {
+            let colCount = 0;
+            const cells = rows[i].querySelectorAll('td, th');
+
+            for (let j = 0; j < cells.length; j++) {
+                const colspan = parseInt(cells[j].getAttribute('colspan'), 10) || 1;
+                colCount += colspan;
+            }
+
+            if (colCount > maxCols) {
+                maxCols = colCount;
+            }
+        }
+
+        return maxCols;
+    },
+
+    /**
+     * Check if table has multiple rows with colspan/rowspan on header cells,
+     * indicating multi-level grouped headers.
+     * @param {HTMLElement} table - The table element
+     * @returns {boolean} True if table has complex header groupings
+     */
+    hasMultiLevelHeaderGroupings(table) {
+        const rows = table.querySelectorAll('tr');
+        let rowsWithHeaderSpans = 0;
+
+        for (let i = 0; i < rows.length; i++) {
+            const spannedHeaders = rows[i].querySelectorAll('th[colspan], th[rowspan]');
+            if (spannedHeaders.length > 0) {
+                rowsWithHeaderSpans++;
+            }
+        }
+
+        return rowsWithHeaderSpans >= 2;
+    },
+
+    /**
+     * Checks if an HTML table has only header cells (th) and no data cells (td).
+     * Indicates headers potentially separated from their data.
+     * @param {HTMLTableElement} table - The table element to check
+     * @returns {boolean} True if table has only headers, no data
+     */
+    isHeaderOnlyTable(table) {
+        const hasHeaders = table.querySelectorAll('th').length > 0;
+        const hasDataCells = table.querySelectorAll('td').length > 0;
+        return hasHeaders && !hasDataCells;
+    },
+
+    /**
+     * Checks if an ARIA table has only header roles and no cell roles.
+     * @param {HTMLElement} ariaTable - The element with role="table"
+     * @returns {boolean} True if ARIA table has only headers, no data cells
+     */
+    isHeaderOnlyAriaTable(ariaTable) {
+        const hasHeaders =
+            ariaTable.querySelectorAll('[role="columnheader"], [role="rowheader"]').length > 0;
+        const hasDataCells =
+            ariaTable.querySelectorAll('[role="cell"], [role="gridcell"]').length > 0;
+        return hasHeaders && !hasDataCells;
+    },
+
+    /**
+     * Checks if a string contains only punctuation characters.
+     * @param {string} str - The string to check
+     * @returns {boolean} True if the string contains only punctuation
+     */
+    isPunctuationOnly(str) {
+        return /^[\p{P}\p{S}]+$/u.test(str);
+    },
+
+    /**
+     * Checks if a summary is generic/useless.
+     * @param {string} summary - The summary text to check
+     * @param {string[]} [genericList] - Optional custom list of generic summaries
+     * @returns {boolean} True if the summary is generic
+     */
+    isGenericSummary(summary, genericList) {
+        const GENERIC_SUMMARIES = genericList || [
+            'table',
+            'data',
+            'data table',
+            'information',
+            'content',
+            'main content',
+            'layout',
+            'layout table',
+            'for layout',
+            'table for layout purposes',
+            'structural table',
+            'this table is used for page layout',
+            'header',
+            'footer',
+            'navigation',
+            'nav',
+            'body',
+            'combobox',
+            'links design table',
+            'title and navigation',
+            'main heading',
+            'spacer',
+            'spacer table',
+            'menu',
+            'n/a',
+            'na',
+            'none',
+            'null',
+            'empty',
+            'blank',
+            'undefined',
+            'table summary',
+            'summary',
+        ];
+        const normalized = summary.toLowerCase().trim();
+        return GENERIC_SUMMARIES.includes(normalized);
+    },
+};
+
+module.exports = tableUtils;

package/src/testContrast.js

@@ -25,13 +25,47 @@ function getComputedBackgroundColor(el, options) {
     if (bgImage === 'none') {
         const bgColor = styles.getPropertyValue('background-color');
 
-        if (bgColor === 'rgba(0, 0, 0, 0)') {
+        // Check for any fully transparent background (not just rgba(0,0,0,0))
+        const parsed = parseRGB(bgColor);
+        if (
+            bgColor === 'rgba(0, 0, 0, 0)' ||
+            bgColor === 'transparent' ||
+            (parsed && parsed[4] !== undefined && parseFloat(parsed[4]) === 0)
+        ) {
             if (el.parentElement) {
                 return getComputedBackgroundColor(el.parentElement, options);
             }
             return opts.fallbackColor !== undefined ? fallbackColor : false;
         }
 
+        // Handle semi-transparent backgrounds by blending with parent
+        if (parsed && parsed[4] !== undefined && parseFloat(parsed[4]) < 1) {
+            const alpha = parseFloat(parsed[4]);
+            const parentBg = el.parentElement
+                ? getComputedBackgroundColor(el.parentElement, options)
+                : fallbackColor;
+
+            if (parentBg && parentBg !== false) {
+                const parentParsed = parseRGB(parentBg);
+                if (parentParsed) {
+                    // Alpha composite: result = fg * alpha + bg * (1 - alpha)
+                    const r = Math.round(
+                        parseInt(parsed[1], 10) * alpha +
+                            parseInt(parentParsed[1], 10) * (1 - alpha)
+                    );
+                    const g = Math.round(
+                        parseInt(parsed[2], 10) * alpha +
+                            parseInt(parentParsed[2], 10) * (1 - alpha)
+                    );
+                    const b = Math.round(
+                        parseInt(parsed[3], 10) * alpha +
+                            parseInt(parentParsed[3], 10) * (1 - alpha)
+                    );
+                    return 'rgb(' + r + ', ' + g + ', ' + b + ')';
+                }
+            }
+        }
+
         return bgColor;
     } else {
         if (!skipBackgroundImages) {