govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/commons/table/is-header.js

@@ -0,0 +1,22 @@
+/* global table, axe */
+
+/**
+ * Determine if a `HTMLTableCellElement` is a header
+ * @method isHeader
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableCellElement} cell The table cell to test
+ * @return {Boolean}
+ */
+table.isHeader = function(cell) {
+	if (table.isColumnHeader(cell) || table.isRowHeader(cell)) {
+		return true;
+	}
+
+	if (cell.getAttribute('id')) {
+		const id = axe.utils.escapeSelector(cell.getAttribute('id'));
+		return !!document.querySelector(`[headers~="${id}"]`);
+	}
+
+	return false;
+};

data/node_modules/axe-core/lib/commons/table/is-row-header.js

@@ -0,0 +1,13 @@
+/* global table */
+
+/**
+ * Determine if a `HTMLTableCellElement` is a row header
+ * @method isRowHeader
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableCellElement} cell The table cell to test
+ * @return {Boolean}
+ */
+table.isRowHeader = function(cell) {
+	return ['row', 'auto'].includes(table.getScope(cell));
+};

data/node_modules/axe-core/lib/commons/table/to-grid.js

@@ -0,0 +1,38 @@
+/*global table */
+
+/**
+ * Converts a table to an Array of arrays, normalized for row and column spans
+ * @method toGrid
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableElement} node The table to convert
+ * @return {Array<HTMLTableCellElement>} Array of HTMLTableCellElements
+ */
+table.toGrid = function(node) {
+	var table = [];
+	var rows = node.rows;
+	for (var i = 0, rowLength = rows.length; i < rowLength; i++) {
+		var cells = rows[i].cells;
+		table[i] = table[i] || [];
+
+		var columnIndex = 0;
+
+		for (var j = 0, cellLength = cells.length; j < cellLength; j++) {
+			for (var colSpan = 0; colSpan < cells[j].colSpan; colSpan++) {
+				for (var rowSpan = 0; rowSpan < cells[j].rowSpan; rowSpan++) {
+					table[i + rowSpan] = table[i + rowSpan] || [];
+					while (table[i + rowSpan][columnIndex]) {
+						columnIndex++;
+					}
+					table[i + rowSpan][columnIndex] = cells[j];
+				}
+				columnIndex++;
+			}
+		}
+	}
+
+	return table;
+};
+
+// This was the old name
+table.toArray = table.toGrid;

data/node_modules/axe-core/lib/commons/table/traverse.js

@@ -0,0 +1,78 @@
+/* global table */
+(function(table) {
+	var traverseTable = function(dir, position, tableGrid, callback) {
+		var result;
+		var cell = tableGrid[position.y]
+			? tableGrid[position.y][position.x]
+			: undefined;
+		if (!cell) {
+			return [];
+		}
+		if (typeof callback === 'function') {
+			result = callback(cell, position, tableGrid);
+			if (result === true) {
+				// abort
+				return [cell];
+			}
+		}
+
+		result = traverseTable(
+			dir,
+			{
+				x: position.x + dir.x,
+				y: position.y + dir.y
+			},
+			tableGrid,
+			callback
+		);
+		result.unshift(cell);
+		return result;
+	};
+
+	/**
+	 * Traverses a table in a given direction, passing the cell to the callback
+	 * @method traverse
+	 * @memberof axe.commons.table
+	 * @instance
+	 * @param  {Object|String} dir Direction that will be added recursively {x: 1, y: 0}, 'left';
+	 * @param  {Object}   startPos    x/y coordinate: {x: 0, y: 0};
+	 * @param  {Array}    [tablegrid]  A matrix of the table obtained using axe.commons.table.toArray (OPTIONAL)
+	 * @param  {Function} callback Function to which each cell will be passed
+	 * @return {NodeElement}       If the callback returns true, the traversal will end and the cell will be returned
+	 */
+	table.traverse = function(dir, startPos, tableGrid, callback) {
+		/* eslint indent: 0 */
+		if (Array.isArray(startPos)) {
+			callback = tableGrid;
+			tableGrid = startPos;
+			startPos = { x: 0, y: 0 };
+		}
+
+		if (typeof dir === 'string') {
+			switch (dir) {
+				case 'left':
+					dir = { x: -1, y: 0 };
+					break;
+				case 'up':
+					dir = { x: 0, y: -1 };
+					break;
+				case 'right':
+					dir = { x: 1, y: 0 };
+					break;
+				case 'down':
+					dir = { x: 0, y: 1 };
+					break;
+			}
+		}
+
+		return traverseTable(
+			dir,
+			{
+				x: startPos.x + dir.x,
+				y: startPos.y + dir.y
+			},
+			tableGrid,
+			callback
+		);
+	};
+})(table);

data/node_modules/axe-core/lib/commons/text/accessible-text-virtual.js

@@ -0,0 +1,152 @@
+/* global text, dom, aria, axe */
+
+/**
+ * Finds virtual node and calls accessibleTextVirtual()
+ * IMPORTANT: This method requires the composed tree at axe._tree
+ *
+ * @param {HTMLElement} element The HTMLElement
+ * @param {Object} context
+ * @property {Bool} inControlContext
+ * @property {Bool} inLabelledByContext
+ * @return {string}
+ */
+text.accessibleText = function accessibleText(element, context) {
+	let virtualNode = axe.utils.getNodeFromTree(axe._tree[0], element); // throws an exception on purpose if axe._tree not correct
+	return text.accessibleTextVirtual(virtualNode, context);
+};
+
+/**
+ * Finds virtual node and calls accessibleTextVirtual()
+ * IMPORTANT: This method requires the composed tree at axe._tree
+ *
+ * @param {HTMLElement} element The HTMLElement
+ * @param {Object} context
+ * @property {Bool} inControlContext
+ * @property {Bool} inLabelledByContext
+ * @return {string}
+ */
+text.accessibleTextVirtual = function accessibleTextVirtual(
+	virtualNode,
+	context = {}
+) {
+	const { actualNode } = virtualNode;
+	context = prepareContext(virtualNode, context);
+
+	// Step 2A, check visibility
+	if (shouldIgnoreHidden(virtualNode, context)) {
+		return '';
+	}
+
+	const computationSteps = [
+		aria.arialabelledbyText, // Step 2B.1
+		aria.arialabelText, // Step 2C
+		text.nativeTextAlternative, // Step 2D
+		text.formControlValue, // Step 2E
+		text.subtreeText, // Step 2F + Step 2H
+		textNodeContent, // Step 2G (order with 2H does not matter)
+		text.titleText // Step 2I
+	];
+
+	// Find the first step that returns a non-empty string
+	let accName = computationSteps.reduce((accName, step) => {
+		if (accName !== '') {
+			// yes, whitespace only a11y names halt the algorithm
+			return accName;
+		}
+		return step(virtualNode, context);
+	}, '');
+
+	if (context.startNode === virtualNode) {
+		accName = text.sanitize(accName);
+	}
+
+	if (context.debug) {
+		axe.log(accName || '{empty-value}', actualNode, context);
+	}
+	return accName;
+};
+
+/**
+ * Return the textContent of a node
+ * @param {VirtualNode} element
+ * @return {String} textContent value
+ */
+function textNodeContent({ actualNode }) {
+	if (actualNode.nodeType !== 3) {
+		return '';
+	}
+	return actualNode.textContent;
+}
+
+/**
+ * Check if the
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {VirtualNode[]} processed
+ * @return {Boolean}
+ */
+function shouldIgnoreHidden({ actualNode }, context) {
+	if (
+		// If the parent isn't ignored, the text node should not be either
+		actualNode.nodeType !== 1 ||
+		// If the target of aria-labelledby is hidden, ignore all descendents
+		context.includeHidden
+	) {
+		return false;
+	}
+
+	return !dom.isVisible(actualNode, true);
+}
+
+/**
+ * Apply defaults to the context
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @return {Object} context object with defaults applied
+ */
+function prepareContext(virtualNode, context) {
+	const { actualNode } = virtualNode;
+	if (!context.startNode) {
+		context = { startNode: virtualNode, ...context };
+	}
+	/**
+	 * When `aria-labelledby` directly references a `hidden` element
+	 * the element needs to be included in the accessible name.
+	 *
+	 * When a descendent of the `aria-labelledby` reference is `hidden`
+	 * the element should not be included in the accessible name.
+	 *
+	 * This is done by setting `includeHidden` for the `aria-labelledby` reference.
+	 */
+	if (
+		actualNode.nodeType === 1 &&
+		context.inLabelledByContext &&
+		context.includeHidden === undefined
+	) {
+		context = {
+			includeHidden: !dom.isVisible(actualNode, true),
+			...context
+		};
+	}
+	return context;
+}
+
+/**
+ * Check if the node is processed with this context before
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {VirtualNode[]} processed
+ * @return {Boolean}
+ */
+text.accessibleTextVirtual.alreadyProcessed = function alreadyProcessed(
+	virtualnode,
+	context
+) {
+	context.processed = context.processed || [];
+	if (context.processed.includes(virtualnode)) {
+		return true;
+	}
+
+	context.processed.push(virtualnode);
+	return false;
+};

data/node_modules/axe-core/lib/commons/text/form-control-value.js

@@ -0,0 +1,204 @@
+/* global text, aria, dom */
+const selectRoles = ['combobox', 'listbox'];
+const rangeRoles = ['progressbar', 'scrollbar', 'slider', 'spinbutton'];
+const controlValueRoles = ['textbox', ...selectRoles, ...rangeRoles];
+
+text.formControlValueMethods = {
+	nativeTextboxValue,
+	nativeSelectValue,
+	ariaTextboxValue,
+	ariaListboxValue,
+	ariaComboboxValue,
+	ariaRangeValue
+};
+
+/**
+ * Calculate value of a form control
+ *
+ * @param {VirtualNode} element The VirtualNode instance whose value we want
+ * @param {Object} context
+ * @property {Element} startNode First node in accessible name computation
+ * @property {String[]} unsupported List of roles where value computation is unsupported
+ * @property {Bool} debug Enable logging for formControlValue
+ * @return {string} The calculated value
+ */
+text.formControlValue = function formControlValue(virtualNode, context = {}) {
+	const { actualNode } = virtualNode;
+	const unsupported = text.unsupported.accessibleNameFromFieldValue || [];
+	const role = aria.getRole(actualNode);
+
+	if (
+		// For the targeted node, the accessible name is never the value:
+		context.startNode === virtualNode ||
+		// Only elements with a certain role can return their value
+		!controlValueRoles.includes(role) ||
+		// Skip unsupported roles
+		unsupported.includes(role)
+	) {
+		return '';
+	}
+
+	// Object.values:
+	const valueMethods = Object.keys(text.formControlValueMethods).map(
+		name => text.formControlValueMethods[name]
+	);
+
+	// Return the value of the first step that returns with text
+	let valueString = valueMethods.reduce((accName, step) => {
+		return accName || step(virtualNode, context);
+	}, '');
+
+	if (context.debug) {
+		axe.log(valueString || '{empty-value}', actualNode, context);
+	}
+	return valueString;
+};
+
+/**
+ * Calculate value of a native textbox element (input and textarea)
+ *
+ * @param {VirtualNode|Element} element The element whose value we want
+ * @return {string} The calculated value
+ */
+function nativeTextboxValue(node) {
+	node = node.actualNode || node;
+	const nonTextInputTypes = [
+		'button',
+		'checkbox',
+		'file',
+		'hidden',
+		'image',
+		'password',
+		'radio',
+		'reset',
+		'submit',
+		'color'
+	];
+	const nodeName = node.nodeName.toUpperCase();
+
+	if (
+		nodeName === 'TEXTAREA' ||
+		(nodeName === 'INPUT' && !nonTextInputTypes.includes(node.type))
+	) {
+		return node.value || '';
+	}
+	return '';
+}
+
+/**
+ * Calculate value of a select element
+ *
+ * @param {VirtualNode} element The VirtualNode instance whose value we want
+ * @return {string} The calculated value
+ */
+function nativeSelectValue(node) {
+	node = node.actualNode || node;
+	if (node.nodeName.toUpperCase() !== 'SELECT') {
+		return '';
+	}
+	return (
+		Array.from(node.options)
+			.filter(option => option.selected)
+			.map(option => option.text)
+			.join(' ') || ''
+	);
+}
+
+/**
+ * Calculate value of a an element with role=textbox
+ *
+ * @param {VirtualNode} element The VirtualNode instance whose value we want
+ * @return {string} The calculated value
+ */
+function ariaTextboxValue(virtualNode) {
+	const { actualNode } = virtualNode;
+	const role = aria.getRole(actualNode);
+	if (role !== 'textbox') {
+		return '';
+	}
+	if (!dom.isHiddenWithCSS(actualNode)) {
+		return text.visibleVirtual(virtualNode, true);
+	} else {
+		return actualNode.textContent;
+	}
+}
+
+/**
+ * Calculate value of an element with role=combobox or role=listbox
+ *
+ * @param {VirtualNode} element The VirtualNode instance whose value we want
+ * @param {Object} context The VirtualNode instance whose value we want
+ * @property {Element} startNode First node in accessible name computation
+ * @property {String[]} unsupported List of roles where value computation is unsupported
+ * @property {Bool} debug Enable logging for formControlValue
+ * @return {string} The calculated value
+ */
+function ariaListboxValue(virtualNode, context) {
+	const { actualNode } = virtualNode;
+	const role = aria.getRole(actualNode);
+	if (role !== 'listbox') {
+		return '';
+	}
+
+	const selected = aria
+		.getOwnedVirtual(virtualNode)
+		.filter(
+			owned =>
+				aria.getRole(owned) === 'option' &&
+				owned.actualNode.getAttribute('aria-selected') === 'true'
+		);
+
+	if (selected.length === 0) {
+		return '';
+	}
+	// Note: Even with aria-multiselectable, only the first value will be used
+	// in the accessible name. This isn't spec'ed out, but seems to be how all
+	// browser behave.
+	return axe.commons.text.accessibleTextVirtual(selected[0], context);
+}
+
+/**
+ * Calculate value of an element with role=combobox or role=listbox
+ *
+ * @param {VirtualNode} element The VirtualNode instance whose value we want
+ * @param {Object} context The VirtualNode instance whose value we want
+ * @property {Element} startNode First node in accessible name computation
+ * @property {String[]} unsupported List of roles where value computation is unsupported
+ * @property {Bool} debug Enable logging for formControlValue
+ * @return {string} The calculated value
+ */
+function ariaComboboxValue(virtualNode, context) {
+	const { actualNode } = virtualNode;
+	const role = aria.getRole(actualNode, { noImplicit: true });
+	let listbox;
+
+	// For combobox, find the first owned listbox:
+	if (!role === 'combobox') {
+		return '';
+	}
+	listbox = aria
+		.getOwnedVirtual(virtualNode)
+		.filter(elm => aria.getRole(elm) === 'listbox')[0];
+
+	return listbox
+		? text.formControlValueMethods.ariaListboxValue(listbox, context)
+		: '';
+}
+
+/**
+ * Calculate value of an element with range-type role
+ *
+ * @param {VirtualNode|Node} element The VirtualNode instance whose value we want
+ * @return {string} The calculated value
+ */
+function ariaRangeValue(node) {
+	node = node.actualNode || node;
+	const role = aria.getRole(node);
+	if (!rangeRoles.includes(role) || !node.hasAttribute('aria-valuenow')) {
+		return '';
+	}
+	// Validate the number, if not, return 0.
+	// Chrome 70 typecasts this, Firefox 62 does not
+	const valueNow = +node.getAttribute('aria-valuenow');
+	return !isNaN(valueNow) ? String(valueNow) : '0';
+}