govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/checks/tables/has-th.json

@@ -0,0 +1,11 @@
+{
+	"id": "has-th",
+	"evaluate": "has-th.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Layout table does not use <th> elements",
+			"fail": "Layout table uses <th> elements"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/headers-visible-text.js

@@ -0,0 +1,30 @@
+var row,
+	cell,
+	badHeaders = [];
+for (
+	var rowIndex = 0, rowLength = node.rows.length;
+	rowIndex < rowLength;
+	rowIndex++
+) {
+	row = node.rows[rowIndex];
+	for (
+		var cellIndex = 0, cellLength = row.cells.length;
+		cellIndex < cellLength;
+		cellIndex++
+	) {
+		cell = row.cells[cellIndex];
+		if (
+			axe.commons.table.isHeader(cell) &&
+			!axe.commons.text.accessibleText(cell)
+		) {
+			badHeaders.push(cell);
+		}
+	}
+}
+
+if (badHeaders.length) {
+	this.relatedNodes(badHeaders);
+	return true;
+}
+
+return false;

data/node_modules/axe-core/lib/checks/tables/html5-scope.js

@@ -0,0 +1,5 @@
+if (!axe.commons.dom.isHTML5(document)) {
+	return true;
+}
+
+return node.nodeName.toUpperCase() === 'TH';

data/node_modules/axe-core/lib/checks/tables/html5-scope.json

@@ -0,0 +1,11 @@
+{
+	"id": "html5-scope",
+	"evaluate": "html5-scope.js",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "Scope attribute is only used on table header elements (<th>)",
+			"fail": "In HTML 5, scope attributes may only be used on table header elements (<th>)"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/same-caption-summary.js

@@ -0,0 +1,7 @@
+// passing node.caption to accessibleText instead of using
+// the logic in accessibleTextVirtual on virtualNode
+return (
+	!!(node.summary && node.caption) &&
+	node.summary.toLowerCase() ===
+		axe.commons.text.accessibleText(node.caption).toLowerCase()
+);

data/node_modules/axe-core/lib/checks/tables/same-caption-summary.json

@@ -0,0 +1,11 @@
+{
+	"id": "same-caption-summary",
+	"evaluate": "same-caption-summary.js",
+	"metadata": {
+		"impact": "minor",
+		"messages": {
+			"pass": "Content of summary attribute and <caption> are not duplicated",
+			"fail": "Content of summary attribute and <caption> element are identical"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/scope-value.js

@@ -0,0 +1,5 @@
+options = options || {};
+var value = node.getAttribute('scope').toLowerCase();
+var validVals = ['row', 'col', 'rowgroup', 'colgroup'] || options.values;
+
+return validVals.indexOf(value) !== -1;

data/node_modules/axe-core/lib/checks/tables/scope-value.json

@@ -0,0 +1,11 @@
+{
+	"id": "scope-value",
+	"evaluate": "scope-value.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "Scope attribute is used correctly",
+			"fail": "The value of the scope attribute may only be 'row' or 'col'"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/td-has-header.js

@@ -0,0 +1,29 @@
+var tableUtils = axe.commons.table;
+var badCells = [];
+var cells = tableUtils.getAllCells(node);
+
+cells.forEach(cell => {
+	// For each non-empty data cell that doesn't have an aria label
+	if (
+		axe.commons.dom.hasContent(cell) &&
+		tableUtils.isDataCell(cell) &&
+		!axe.commons.aria.label(cell)
+	) {
+		// Check if it has any headers
+		const hasHeaders = tableUtils.getHeaders(cell).some(header => {
+			return header !== null && !!axe.commons.dom.hasContent(header);
+		});
+
+		// If no headers, put it on the naughty list
+		if (!hasHeaders) {
+			badCells.push(cell);
+		}
+	}
+});
+
+if (badCells.length) {
+	this.relatedNodes(badCells);
+	return false;
+}
+
+return true;

data/node_modules/axe-core/lib/checks/tables/td-has-header.json

@@ -0,0 +1,11 @@
+{
+	"id": "td-has-header",
+	"evaluate": "td-has-header.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "All non-empty data cells have table headers",
+			"fail": "Some non-empty data cells do not have table headers"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/td-headers-attr.js

@@ -0,0 +1,62 @@
+var cells = [];
+
+for (
+	var rowIndex = 0, rowLength = node.rows.length;
+	rowIndex < rowLength;
+	rowIndex++
+) {
+	var row = node.rows[rowIndex];
+	for (
+		var cellIndex = 0, cellLength = row.cells.length;
+		cellIndex < cellLength;
+		cellIndex++
+	) {
+		cells.push(row.cells[cellIndex]);
+	}
+}
+
+var ids = cells.reduce(function(ids, cell) {
+	if (cell.getAttribute('id')) {
+		ids.push(cell.getAttribute('id'));
+	}
+	return ids;
+}, []);
+
+var badCells = cells.reduce(function(badCells, cell) {
+	var isSelf, notOfTable;
+
+	// Get a list all the values of the headers attribute
+	var headers = (cell.getAttribute('headers') || '')
+		.split(/\s/)
+		.reduce(function(headers, header) {
+			header = header.trim();
+			if (header) {
+				headers.push(header);
+			}
+			return headers;
+		}, []);
+
+	if (headers.length !== 0) {
+		// Check if the cell's id is in this list
+		if (cell.getAttribute('id')) {
+			isSelf = headers.indexOf(cell.getAttribute('id').trim()) !== -1;
+		}
+
+		// Check if the headers are of cells inside the table
+		notOfTable = headers.reduce(function(fail, header) {
+			return fail || ids.indexOf(header) === -1;
+		}, false);
+
+		if (isSelf || notOfTable) {
+			badCells.push(cell);
+		}
+	}
+	return badCells;
+}, []);
+
+if (badCells.length > 0) {
+	this.relatedNodes(badCells);
+	return false;
+} else {
+	return true;
+}

data/node_modules/axe-core/lib/checks/tables/td-headers-attr.json

@@ -0,0 +1,11 @@
+{
+	"id": "td-headers-attr",
+	"evaluate": "td-headers-attr.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "The headers attribute is exclusively used to refer to other cells in the table",
+			"fail": "The headers attribute is not exclusively used to refer to other cells in the table"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/th-has-data-cells.js

@@ -0,0 +1,76 @@
+var tableUtils = axe.commons.table;
+var cells = tableUtils.getAllCells(node);
+var checkResult = this;
+
+// Get a list of all headers reffed to in this rule
+var reffedHeaders = [];
+cells.forEach(function(cell) {
+	var headers = cell.getAttribute('headers');
+	if (headers) {
+		reffedHeaders = reffedHeaders.concat(headers.split(/\s+/));
+	}
+
+	var ariaLabel = cell.getAttribute('aria-labelledby');
+	if (ariaLabel) {
+		reffedHeaders = reffedHeaders.concat(ariaLabel.split(/\s+/));
+	}
+});
+
+// Get all the headers
+var headers = cells.filter(function(cell) {
+	if (axe.commons.text.sanitize(cell.textContent) === '') {
+		return false;
+	}
+	return (
+		cell.nodeName.toUpperCase() === 'TH' ||
+		['rowheader', 'columnheader'].indexOf(cell.getAttribute('role')) !== -1
+	);
+});
+
+var tableGrid = tableUtils.toGrid(node);
+
+// Look for all the bad headers
+var out = headers.reduce(function(res, header) {
+	if (
+		header.getAttribute('id') &&
+		reffedHeaders.includes(header.getAttribute('id'))
+	) {
+		return !res ? res : true;
+	}
+
+	var hasCell = false;
+	var pos = tableUtils.getCellPosition(header, tableGrid);
+
+	// Look for any data cells or row headers that this might refer to
+	if (tableUtils.isColumnHeader(header)) {
+		hasCell = tableUtils
+			.traverse('down', pos, tableGrid)
+			.reduce((out, cell) => {
+				return (
+					out ||
+					(axe.commons.dom.hasContent(cell) && !tableUtils.isColumnHeader(cell))
+				);
+			}, false);
+	}
+
+	// Look for any data cells or column headers that this might refer to
+	if (!hasCell && tableUtils.isRowHeader(header)) {
+		hasCell = tableUtils
+			.traverse('right', pos, tableGrid)
+			.reduce((out, cell) => {
+				return (
+					out ||
+					(axe.commons.dom.hasContent(cell) && !tableUtils.isRowHeader(cell))
+				);
+			}, false);
+	}
+
+	// report the node as having failed
+	if (!hasCell) {
+		checkResult.relatedNodes(header);
+	}
+
+	return res && hasCell;
+}, true);
+
+return out ? true : undefined;

data/node_modules/axe-core/lib/checks/tables/th-has-data-cells.json

@@ -0,0 +1,12 @@
+{
+	"id": "th-has-data-cells",
+	"evaluate": "th-has-data-cells.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "All table header cells refer to data cells",
+			"fail": "Not all table header cells refer to data cells",
+			"incomplete": "Table data cells are missing or empty"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/tables/th-single-row-column.js

@@ -0,0 +1,39 @@
+var row,
+	cell,
+	position,
+	rowHeaders = [],
+	columnHeaders = [];
+
+for (
+	var rowIndex = 0, rowLength = node.rows.length;
+	rowIndex < rowLength;
+	rowIndex++
+) {
+	row = node.rows[rowIndex];
+	for (
+		var cellIndex = 0, cellLength = row.cells.length;
+		cellIndex < cellLength;
+		cellIndex++
+	) {
+		cell = row.cells[cellIndex];
+		if (cell.nodeType === 1) {
+			if (
+				axe.commons.table.isColumnHeader(cell) &&
+				columnHeaders.indexOf(rowIndex) === -1
+			) {
+				columnHeaders.push(rowIndex);
+			} else if (axe.commons.table.isRowHeader(cell)) {
+				position = axe.commons.table.getCellPosition(cell);
+				if (rowHeaders.indexOf(position.x) === -1) {
+					rowHeaders.push(position.x);
+				}
+			}
+		}
+	}
+}
+
+if (columnHeaders.length > 1 || rowHeaders.length > 1) {
+	return true;
+}
+
+return false;

data/node_modules/axe-core/lib/checks/visibility/hidden-content.js

@@ -0,0 +1,21 @@
+const whitelist = ['SCRIPT', 'HEAD', 'TITLE', 'NOSCRIPT', 'STYLE', 'TEMPLATE'];
+if (
+	!whitelist.includes(node.nodeName.toUpperCase()) &&
+	axe.commons.dom.hasContentVirtual(virtualNode)
+) {
+	const styles = window.getComputedStyle(node);
+	if (styles.getPropertyValue('display') === 'none') {
+		return undefined;
+	} else if (styles.getPropertyValue('visibility') === 'hidden') {
+		// Check if visibility isn't inherited
+		const parent = axe.commons.dom.getComposedParent(node);
+		const parentStyle = parent && window.getComputedStyle(parent);
+		if (
+			!parentStyle ||
+			parentStyle.getPropertyValue('visibility') !== 'hidden'
+		) {
+			return undefined;
+		}
+	}
+}
+return true;

data/node_modules/axe-core/lib/checks/visibility/hidden-content.json

@@ -0,0 +1,12 @@
+{
+	"id": "hidden-content",
+	"evaluate": "hidden-content.js",
+	"metadata": {
+		"impact": "minor",
+		"messages": {
+			"pass": "All content on the page has been analyzed.",
+			"fail": "There were problems analyzing the content on this page.",
+			"incomplete": "There is hidden content on the page that was not analyzed. You will need to trigger the display of this content in order to analyze it."
+		}
+	}
+}

data/node_modules/axe-core/lib/commons/aria/arialabel-text.js

@@ -0,0 +1,15 @@
+/* global aria */
+
+/**
+ * Get the text value of aria-label, if any
+ *
+ * @param {VirtualNode|Element} element
+ * @return {string} ARIA label
+ */
+aria.arialabelText = function arialabelText(node) {
+	node = node.actualNode || node;
+	if (node.nodeType !== 1) {
+		return '';
+	}
+	return node.getAttribute('aria-label') || '';
+};

data/node_modules/axe-core/lib/commons/aria/arialabelledby-text.js

@@ -0,0 +1,52 @@
+/* global aria, dom, text */
+
+/**
+ * Get the accessible name based on aria-labelledby
+ *
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {Bool} inLabelledByContext Whether or not the lookup is part of aria-labelledby reference
+ * @property {Bool} inControlContext Whether or not the lookup is part of a native label reference
+ * @property {Element} startNode First node in accessible name computation
+ * @property {Bool} debug Enable logging for formControlValue
+ * @return {string} Cancatinated text value for referenced elements
+ */
+aria.arialabelledbyText = function arialabelledbyText(node, context = {}) {
+	node = node.actualNode || node;
+	/**
+	 * Note: The there are significant difference in how many "leads" browsers follow.
+	 * - Firefox stops after the first IDREF, so it
+	 * 		doesn't follow aria-labelledby after a for:>ID ref.
+	 * - Chrome seems to just keep iterating no matter how many levels deep.
+	 * - AccName-AAM 1.1 suggests going one level deep, but to treat
+	 * 		each ref type separately.
+	 *
+	 * Axe-core's implementation behaves most closely like Firefox as it seems
+	 *  to be the common denominator. Main difference is that Firefox
+	 *  includes the value of form controls in addition to aria-label(s),
+	 *  something no other browser seems to do. Axe doesn't do that.
+	 */
+	if (
+		node.nodeType !== 1 ||
+		context.inLabelledByContext ||
+		context.inControlContext
+	) {
+		return '';
+	}
+
+	const refs = dom.idrefs(node, 'aria-labelledby').filter(elm => elm);
+	return refs.reduce((accessibleName, elm) => {
+		const accessibleNameAdd = text.accessibleText(elm, {
+			// Prevent the infinite reference loop:
+			inLabelledByContext: true,
+			startNode: context.startNode || node,
+			...context
+		});
+
+		if (!accessibleName) {
+			return accessibleNameAdd;
+		} else {
+			return `${accessibleName} ${accessibleNameAdd}`;
+		}
+	}, '');
+};