govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/commons/matches/index.js

@@ -0,0 +1,37 @@
+/* exported matches */
+
+/**
+ * Check if a DOM element matches a definition
+ *
+ * Example:
+ * ```js
+ * // Match a single nodeName:
+ * axe.commons.matches(elm, 'div')
+ *
+ * // Match one of multiple nodeNames:
+ * axe.commons.matches(elm, ['ul', 'ol'])
+ *
+ * // Match a node with nodeName 'button' and with aria-hidden: true:
+ * axe.commons.matches(elm, {
+ * 	 nodeName: 'button',
+ * 	 attributes: { 'aria-hidden': 'true' }
+ * })
+ *
+ * // Mixed input. Match button nodeName, input[type=button] and input[type=reset]
+ * axe.commons.matches(elm, ['button', {
+ * 	nodeName: 'input', // nodeName match isn't case sensitive
+ * 	properties: { type: ['button', 'reset'] }
+ * }])
+ * ```
+ *
+ * @namespace matches
+ * @memberof axe.commons
+ * @param {HTMLElement|VirtualNode} node node to verify attributes against constraints
+ * @param {Array<ElementDefinition>|String|Object|Function|Regex} definition
+ * @return {Boolean} true/ false based on if node passes the constraints expected
+ */
+function matches(node, definition) {
+	return matches.fromDefinition(node, definition);
+}
+
+commons.matches = matches;

data/node_modules/axe-core/lib/commons/matches/node-name.js

@@ -0,0 +1,34 @@
+/* global matches */
+let isXHTMLGlobal;
+/**
+ * Check if the nodeName of a node matches some value
+ *
+ * Note: matches.nodeName(node, matcher) can be indirectly used through
+ * matches(node, { nodeName: matcher })
+ *
+ * Example:
+ * ```js
+ * matches.nodeName(node, ['div', 'span'])
+ * ```
+ *
+ * @param {HTMLElement|VirtualNode} node
+ * @param {Object} Attribute matcher
+ * @returns {Boolean}
+ */
+matches.nodeName = function matchNodeName(node, matcher, { isXHTML } = {}) {
+	node = node.actualNode || node;
+	if (typeof isXHTML === 'undefined') {
+		// When the matcher is a string, use native .matches() function:
+		if (typeof matcher === 'string') {
+			return axe.utils.matchesSelector(node, matcher);
+		}
+
+		if (typeof isXHTMLGlobal === 'undefined') {
+			isXHTMLGlobal = axe.utils.isXHTML(node.ownerDocument);
+		}
+		isXHTML = isXHTMLGlobal;
+	}
+
+	const nodeName = isXHTML ? node.nodeName : node.nodeName.toLowerCase();
+	return matches.fromPrimative(nodeName, matcher);
+};

data/node_modules/axe-core/lib/commons/matches/properties.js

@@ -0,0 +1,25 @@
+/* global matches */
+
+/**
+ * Check if a node matches some attribute(s)
+ *
+ * Note: matches.properties(node, matcher) can be indirectly used through
+ * matches(node, { properties: matcher })
+ *
+ * Example:
+ * ```js
+ * matches.properties(node, {
+ *   type: 'text', // Simple string match
+ *   value: value => value.trim() !== '', // None-empty value, using a function matcher
+ * })
+ * ```
+ *
+ * @param {HTMLElement|VirtualNode} node
+ * @param {Object} matcher
+ * @returns {Boolean}
+ */
+matches.properties = function matchesProperties(node, matcher) {
+	node = node.actualNode || node;
+	const out = matches.fromFunction(propName => node[propName], matcher);
+	return out;
+};

data/node_modules/axe-core/lib/commons/outro.stub

@@ -0,0 +1,2 @@
+	return commons;
+}())

data/node_modules/axe-core/lib/commons/table/get-all-cells.js

@@ -0,0 +1,28 @@
+/* global table */
+
+/**
+ * Returns all cells contained in given HTMLTableElement
+ * @method getAllCells
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableElement} tableElm Table Element to get cells from
+ * @return {Array<HTMLTableCellElement>}
+ */
+table.getAllCells = function(tableElm) {
+	var rowIndex, cellIndex, rowLength, cellLength;
+	var cells = [];
+	for (
+		rowIndex = 0, rowLength = tableElm.rows.length;
+		rowIndex < rowLength;
+		rowIndex++
+	) {
+		for (
+			cellIndex = 0, cellLength = tableElm.rows[rowIndex].cells.length;
+			cellIndex < cellLength;
+			cellIndex++
+		) {
+			cells.push(tableElm.rows[rowIndex].cells[cellIndex]);
+		}
+	}
+	return cells;
+};

data/node_modules/axe-core/lib/commons/table/get-cell-position.js

@@ -0,0 +1,28 @@
+/* global table, dom */
+
+/**
+ * Get the x, y coordinates of a table cell; normalized for rowspan and colspan
+ * @method getCellPosition
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableCellElement} cell The table cell of which to get the position
+ * @return {Object} Object with `x` and `y` properties of the coordinates
+ */
+table.getCellPosition = function(cell, tableGrid) {
+	var rowIndex, index;
+	if (!tableGrid) {
+		tableGrid = table.toGrid(dom.findUp(cell, 'table'));
+	}
+
+	for (rowIndex = 0; rowIndex < tableGrid.length; rowIndex++) {
+		if (tableGrid[rowIndex]) {
+			index = tableGrid[rowIndex].indexOf(cell);
+			if (index !== -1) {
+				return {
+					x: index,
+					y: rowIndex
+				};
+			}
+		}
+	}
+};

data/node_modules/axe-core/lib/commons/table/get-headers.js

@@ -0,0 +1,29 @@
+/* global table */
+
+/**
+ * Get any associated table headers for a `HTMLTableCellElement`
+ * @method getHeaders
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableCellElement} cell The cell of which to get headers
+ * @return {Array<HTMLTableCellElement>} Array of headers associated to the table cell
+ */
+table.getHeaders = function(cell) {
+	if (cell.hasAttribute('headers')) {
+		return commons.dom.idrefs(cell, 'headers');
+	}
+
+	var tableGrid = commons.table.toGrid(commons.dom.findUp(cell, 'table'));
+	var position = commons.table.getCellPosition(cell, tableGrid);
+
+	// TODO: RTL text
+	var rowHeaders = table
+		.traverse('left', position, tableGrid)
+		.filter(cell => table.isRowHeader(cell));
+
+	var colHeaders = table
+		.traverse('up', position, tableGrid)
+		.filter(cell => table.isColumnHeader(cell));
+
+	return [].concat(rowHeaders, colHeaders).reverse();
+};

data/node_modules/axe-core/lib/commons/table/get-scope.js

@@ -0,0 +1,54 @@
+/* global table, dom */
+
+/**
+ * Determine if a `HTMLTableCellElement` is a column header, if so get the scope of the header
+ * @method getScope
+ * @memberof axe.commons.table
+ * @instance
+ * @param {HTMLTableCellElement} cell The table cell to test
+ * @return {Boolean|String} Returns `false` if not a column header, or the scope of the column header element
+ */
+table.getScope = function(cell) {
+	var scope = cell.getAttribute('scope');
+	var role = cell.getAttribute('role');
+
+	if (
+		cell instanceof Element === false ||
+		['TD', 'TH'].indexOf(cell.nodeName.toUpperCase()) === -1
+	) {
+		throw new TypeError('Expected TD or TH element');
+	}
+
+	if (role === 'columnheader') {
+		return 'col';
+	} else if (role === 'rowheader') {
+		return 'row';
+	} else if (scope === 'col' || scope === 'row') {
+		return scope;
+	} else if (cell.nodeName.toUpperCase() !== 'TH') {
+		return false;
+	}
+	var tableGrid = table.toGrid(dom.findUp(cell, 'table'));
+	var pos = table.getCellPosition(cell);
+
+	// The element is in a row with all th elements, that makes it a column header
+	var headerRow = tableGrid[pos.y].reduce((headerRow, cell) => {
+		return headerRow && cell.nodeName.toUpperCase() === 'TH';
+	}, true);
+
+	if (headerRow) {
+		return 'col';
+	}
+
+	// The element is in a column with all th elements, that makes it a row header
+	var headerCol = tableGrid
+		.map(col => col[pos.x])
+		.reduce((headerCol, cell) => {
+			return headerCol && cell && cell.nodeName.toUpperCase() === 'TH';
+		}, true);
+
+	if (headerCol) {
+		return 'row';
+	}
+	return 'auto';
+};

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

@@ -0,0 +1,9 @@
+/* exported table */
+/*eslint no-unused-vars: 0*/
+/**
+ * Namespace for table-related utilities.
+ * @namespace table
+ * @memberof axe.commons
+ */
+
+var table = (commons.table = {});

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

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

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

@@ -0,0 +1,22 @@
+/* global table */
+
+/**
+ * Determine if a `HTMLTableCellElement` is a data cell
+ * @method isDataCell
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableCellElement} node The table cell to test
+ * @return {Boolean}
+ */
+table.isDataCell = function(cell) {
+	// @see http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#empty-cell
+	if (!cell.children.length && !cell.textContent.trim()) {
+		return false;
+	}
+	const role = cell.getAttribute('role');
+	if (axe.commons.aria.isValidRole(role)) {
+		return ['cell', 'gridcell'].includes(role);
+	} else {
+		return cell.nodeName.toUpperCase() === 'TD';
+	}
+};

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

@@ -0,0 +1,190 @@
+/* global table, dom */
+/* eslint max-statements: ["error",70], complexity: ["error",47] */
+
+/**
+ * Determines whether a table is a data table
+ * @method isDataTable
+ * @memberof axe.commons.table
+ * @instance
+ * @param  {HTMLTableElement} node The table to test
+ * @return {Boolean}
+ * @see http://asurkov.blogspot.co.uk/2011/10/data-vs-layout-table.html
+ */
+table.isDataTable = function(node) {
+	var role = (node.getAttribute('role') || '').toLowerCase();
+
+	// The element is not focusable and has role=presentation
+	if ((role === 'presentation' || role === 'none') && !dom.isFocusable(node)) {
+		return false;
+	}
+
+	// Table inside editable area is data table always since the table structure is crucial for table editing
+	if (
+		node.getAttribute('contenteditable') === 'true' ||
+		dom.findUp(node, '[contenteditable="true"]')
+	) {
+		return true;
+	}
+
+	// Table having ARIA table related role is data table
+	if (role === 'grid' || role === 'treegrid' || role === 'table') {
+		return true;
+	}
+
+	// Table having ARIA landmark role is data table
+	if (commons.aria.getRoleType(role) === 'landmark') {
+		return true;
+	}
+
+	// Table having datatable="0" attribute is layout table
+	if (node.getAttribute('datatable') === '0') {
+		return false;
+	}
+
+	// Table having summary attribute is data table
+	if (node.getAttribute('summary')) {
+		return true;
+	}
+
+	// Table having legitimate data table structures is data table
+	if (node.tHead || node.tFoot || node.caption) {
+		return true;
+	}
+	// colgroup / col - colgroup is magically generated
+	for (
+		var childIndex = 0, childLength = node.children.length;
+		childIndex < childLength;
+		childIndex++
+	) {
+		if (node.children[childIndex].nodeName.toUpperCase() === 'COLGROUP') {
+			return true;
+		}
+	}
+
+	var cells = 0;
+	var rowLength = node.rows.length;
+	var row, cell;
+	var hasBorder = false;
+	for (var rowIndex = 0; rowIndex < rowLength; rowIndex++) {
+		row = node.rows[rowIndex];
+		for (
+			var cellIndex = 0, cellLength = row.cells.length;
+			cellIndex < cellLength;
+			cellIndex++
+		) {
+			cell = row.cells[cellIndex];
+			if (cell.nodeName.toUpperCase() === 'TH') {
+				return true;
+			}
+			if (
+				!hasBorder &&
+				(cell.offsetWidth !== cell.clientWidth ||
+					cell.offsetHeight !== cell.clientHeight)
+			) {
+				hasBorder = true;
+			}
+			if (
+				cell.getAttribute('scope') ||
+				cell.getAttribute('headers') ||
+				cell.getAttribute('abbr')
+			) {
+				return true;
+			}
+			if (
+				['columnheader', 'rowheader'].includes(
+					(cell.getAttribute('role') || '').toLowerCase()
+				)
+			) {
+				return true;
+			}
+			// abbr element as a single child element of table cell
+			if (
+				cell.children.length === 1 &&
+				cell.children[0].nodeName.toUpperCase() === 'ABBR'
+			) {
+				return true;
+			}
+			cells++;
+		}
+	}
+
+	// Table having nested table is layout table
+	if (node.getElementsByTagName('table').length) {
+		return false;
+	}
+
+	// Table having only one row or column is layout table (row)
+	if (rowLength < 2) {
+		return false;
+	}
+
+	// Table having only one row or column is layout table (column)
+	var sampleRow = node.rows[Math.ceil(rowLength / 2)];
+	if (sampleRow.cells.length === 1 && sampleRow.cells[0].colSpan === 1) {
+		return false;
+	}
+
+	// Table having many columns (>= 5) is data table
+	if (sampleRow.cells.length >= 5) {
+		return true;
+	}
+
+	// Table having borders around cells is data table
+	if (hasBorder) {
+		return true;
+	}
+
+	// Table having differently colored rows is data table
+	var bgColor, bgImage;
+	for (rowIndex = 0; rowIndex < rowLength; rowIndex++) {
+		row = node.rows[rowIndex];
+		if (
+			bgColor &&
+			bgColor !==
+				window.getComputedStyle(row).getPropertyValue('background-color')
+		) {
+			return true;
+		} else {
+			bgColor = window
+				.getComputedStyle(row)
+				.getPropertyValue('background-color');
+		}
+		if (
+			bgImage &&
+			bgImage !==
+				window.getComputedStyle(row).getPropertyValue('background-image')
+		) {
+			return true;
+		} else {
+			bgImage = window
+				.getComputedStyle(row)
+				.getPropertyValue('background-image');
+		}
+	}
+
+	// Table having many rows (>= 20) is data table
+	if (rowLength >= 20) {
+		return true;
+	}
+
+	// Wide table (more than 95% of the document width) is layout table
+	if (
+		dom.getElementCoordinates(node).width >
+		dom.getViewportSize(window).width * 0.95
+	) {
+		return false;
+	}
+
+	// Table having small amount of cells (<= 10) is layout table
+	if (cells < 10) {
+		return false;
+	}
+
+	// Table containing embed, object, applet of iframe elements (typical advertisements elements) is layout table
+	if (node.querySelector('object, embed, iframe, applet')) {
+		return false;
+	}
+
+	// Otherwise it's data table
+	return true;
+};