govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/commons/color/get-foreground-color.js

@@ -0,0 +1,32 @@
+/* global axe, color */
+
+/**
+ * Returns the flattened foreground color of an element, or null if it can't be determined because
+ * of transparency
+ * @method getForegroundColor
+ * @memberof axe.commons.color
+ * @instance
+ * @param {Element} node
+ * @param {Boolean} noScroll (default false)
+ * @return {Color|null}
+ */
+color.getForegroundColor = function(node, noScroll) {
+	var nodeStyle = window.getComputedStyle(node);
+
+	var fgColor = new color.Color();
+	fgColor.parseRgbString(nodeStyle.getPropertyValue('color'));
+	var opacity = nodeStyle.getPropertyValue('opacity');
+	fgColor.alpha = fgColor.alpha * opacity;
+	if (fgColor.alpha === 1) {
+		return fgColor;
+	}
+
+	var bgColor = color.getBackgroundColor(node, [], noScroll);
+	if (bgColor === null) {
+		var reason = axe.commons.color.incompleteData.get('bgColor');
+		axe.commons.color.incompleteData.set('fgColor', reason);
+		return null;
+	}
+
+	return color.flattenColors(fgColor, bgColor);
+};

data/node_modules/axe-core/lib/commons/color/incomplete-data.js

@@ -0,0 +1,50 @@
+/* global color */
+
+/**
+ * API for handling incomplete color data
+ * @namespace axe.commons.color.incompleteData
+ * @inner
+ */
+
+color.incompleteData = (function() {
+	var data = {};
+	return {
+		/**
+		 * Store incomplete data by key with a string value
+		 * @method set
+		 * @memberof axe.commons.color.incompleteData
+		 * @instance
+		 * @param {String} key Identifier for missing data point (fgColor, bgColor, etc.)
+		 * @param {String} reason Missing data reason to match message template
+		 */
+		set: function(key, reason) {
+			if (typeof key !== 'string') {
+				throw new Error('Incomplete data: key must be a string');
+			}
+			if (reason) {
+				data[key] = reason;
+			}
+			return data[key];
+		},
+		/**
+		 * Get incomplete data by key
+		 * @method get
+		 * @memberof axe.commons.color.incompleteData
+		 * @instance
+		 * @param {String} key 	Identifier for missing data point (fgColor, bgColor, etc.)
+		 * @return {String} String for reason we couldn't tell
+		 */
+		get: function(key) {
+			return data[key];
+		},
+		/**
+		 * Clear incomplete data on demand
+		 * @method clear
+		 * @memberof axe.commons.color.incompleteData
+		 * @instance
+		 */
+		clear: function() {
+			data = {};
+		}
+	};
+})();

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

@@ -0,0 +1,8 @@
+/**
+ * Namespace for color-related utilities.
+ * @namespace commons.color
+ * @memberof axe
+ */
+
+var color = {};
+commons.color = color;

data/node_modules/axe-core/lib/commons/dom/elements-below-floating.js

@@ -0,0 +1,39 @@
+/* global dom */
+
+/**
+ * Reduce an array of elements to only those that are below a 'floating' element.
+ * @method reduceToElementsBelowFloating
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Array} elements
+ * @param {Element} targetNode
+ * @returns {Array}
+ */
+dom.reduceToElementsBelowFloating = function(elements, targetNode) {
+	var floatingPositions = ['fixed', 'sticky'],
+		finalElements = [],
+		targetFound = false,
+		index,
+		currentNode,
+		style;
+
+	// Filter out elements that are temporarily floating above the target
+	for (index = 0; index < elements.length; ++index) {
+		currentNode = elements[index];
+		if (currentNode === targetNode) {
+			targetFound = true;
+		}
+
+		style = window.getComputedStyle(currentNode);
+
+		if (!targetFound && floatingPositions.indexOf(style.position) !== -1) {
+			//Target was not found yet, so it must be under this floating thing (and will not always be under it)
+			finalElements = [];
+			continue;
+		}
+
+		finalElements.push(currentNode);
+	}
+
+	return finalElements;
+};

data/node_modules/axe-core/lib/commons/dom/find-elms-in-context.js

@@ -0,0 +1,28 @@
+/* global axe, dom */
+
+/**
+ * Find elements referenced from a given context
+ * @method findElmsInContext
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Object} element
+ * @param {String} element.context Element in the same context
+ * @param {String} element.value Attribute value to search for
+ * @param {String} element.attr Attribute name to search for
+ * @param {String} element.elm NodeName to search for (optional)
+ * @return {Array<Node>}
+ */
+dom.findElmsInContext = function({ context, value, attr, elm = '' }) {
+	let root;
+	const escapedValue = axe.utils.escapeSelector(value);
+
+	if (context.nodeType === 9 || context.nodeType === 11) {
+		// It's already root
+		root = context;
+	} else {
+		root = dom.getRootNode(context);
+	}
+	return Array.from(
+		root.querySelectorAll(elm + '[' + attr + '=' + escapedValue + ']')
+	);
+};

data/node_modules/axe-core/lib/commons/dom/find-up.js

@@ -0,0 +1,63 @@
+/* global dom, axe */
+/**
+ * Find the virtual node and call dom.fundUpVirtual
+ *
+ * **WARNING:** this should be used sparingly, as it's not even close to being performant
+ * @method findUp
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} element The starting HTMLElement
+ * @param {String} target The selector for the HTMLElement
+ * @return {HTMLElement|null} Either the matching HTMLElement or `null` if there was no match
+ */
+dom.findUp = function(element, target) {
+	return dom.findUpVirtual(
+		axe.utils.getNodeFromTree(axe._tree[0], element),
+		target
+	);
+};
+
+/**
+ * recusively walk up the DOM, checking for a node which matches a selector
+ *
+ * **WARNING:** this should be used sparingly, as it's not even close to being performant
+ * @method findUpVirtual
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {VirtualNode} element The starting virtualNode
+ * @param {String} target The selector for the HTMLElement
+ * @return {HTMLElement|null} Either the matching HTMLElement or `null` if there was no match
+ */
+dom.findUpVirtual = function(element, target) {
+	/*eslint complexity: ["error", 12]*/
+	let parent;
+
+	parent = element.actualNode;
+	// virtualNode will have a shadowId if the element lives inside a shadow DOM or is
+	// slotted into a shadow DOM
+	if (!element.shadowId && typeof element.actualNode.closest === 'function') {
+		// non-shadow DOM elements
+		let match = element.actualNode.closest(target);
+		if (match) {
+			return match;
+		}
+		return null;
+	}
+	// handle shadow DOM elements and older browsers
+	do {
+		// recursively walk up the DOM, checking each parent node
+		parent = parent.assignedSlot ? parent.assignedSlot : parent.parentNode;
+		if (parent && parent.nodeType === 11) {
+			parent = parent.host;
+		}
+	} while (
+		parent &&
+		!axe.utils.matchesSelector(parent, target) &&
+		parent !== document.documentElement
+	);
+
+	if (!axe.utils.matchesSelector(parent, target)) {
+		return null;
+	}
+	return parent;
+};

data/node_modules/axe-core/lib/commons/dom/get-composed-parent.js

@@ -0,0 +1,25 @@
+/* global dom */
+/**
+ * Get an element's parent in the flattened tree
+ * @method getComposedParent
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Node} element
+ * @return {Node|null} Parent element or Null for root node
+ */
+dom.getComposedParent = function getComposedParent(element) {
+	if (element.assignedSlot) {
+		// NOTE: If the display of a slot element isn't 'contents',
+		// the slot shouldn't be ignored. Chrome does not support this (yet) so,
+		// we'll skip this part for now.
+		return getComposedParent(element.assignedSlot); // parent of a shadow DOM slot
+	} else if (element.parentNode) {
+		var parentNode = element.parentNode;
+		if (parentNode.nodeType === 1) {
+			return parentNode; // Regular node
+		} else if (parentNode.host) {
+			return parentNode.host; // Shadow root
+		}
+	}
+	return null; // Root node
+};

data/node_modules/axe-core/lib/commons/dom/get-element-by-reference.js

@@ -0,0 +1,34 @@
+/* global dom */
+
+/**
+ * Returns a reference to the element matching the attr URL fragment value
+ * @method getElementByReference
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Element} node
+ * @param {String} attr Attribute name (href)
+ * @return {Element}
+ */
+dom.getElementByReference = function(node, attr) {
+	let fragment = node.getAttribute(attr);
+	if (!fragment) {
+		return null;
+	}
+
+	if (fragment.charAt(0) === '#') {
+		fragment = decodeURIComponent(fragment.substring(1));
+	} else if (fragment.substr(0, 2) === '/#') {
+		fragment = decodeURIComponent(fragment.substring(2));
+	}
+
+	let candidate = document.getElementById(fragment);
+	if (candidate) {
+		return candidate;
+	}
+
+	candidate = document.getElementsByName(fragment);
+	if (candidate.length) {
+		return candidate[0];
+	}
+	return null;
+};

data/node_modules/axe-core/lib/commons/dom/get-element-coordinates.js

@@ -0,0 +1,38 @@
+/* global dom */
+
+/**
+ * Get the coordinates of the element passed into the function relative to the document
+ * @method getElementCoordinates
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} element The HTMLElement
+ * @return {elementObj} elementObj Returns a `Object` with the following properties, which
+ * each hold a value representing the pixels for each of the
+ */
+/**
+ * @typedef elementObj
+ * @type {Object}
+ * @property {Number} top The top coordinate of the element
+ * @property {Number} right The right coordinate of the element
+ * @property {Number} bottom The bottom coordinate of the element
+ * @property {Number} left The left coordinate of the element
+ * @property {Number} width The width of the element
+ * @property {Number} height The height of the element
+ */
+dom.getElementCoordinates = function(element) {
+	'use strict';
+
+	var scrollOffset = dom.getScrollOffset(document),
+		xOffset = scrollOffset.left,
+		yOffset = scrollOffset.top,
+		coords = element.getBoundingClientRect();
+
+	return {
+		top: coords.top + yOffset,
+		right: coords.right + xOffset,
+		bottom: coords.bottom + yOffset,
+		left: coords.left + xOffset,
+		width: coords.right - coords.left,
+		height: coords.bottom - coords.top
+	};
+};

data/node_modules/axe-core/lib/commons/dom/get-root-node.js

@@ -0,0 +1,12 @@
+/* global dom */
+
+/**
+ * Return the document or document fragment (shadow DOM)
+ * @method getRootNode
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Element} node
+ * @returns {DocumentFragment|Document}
+ * @deprecated use axe.utils.getRootNode
+ */
+dom.getRootNode = axe.utils.getRootNode;

data/node_modules/axe-core/lib/commons/dom/get-scroll-offset.js

@@ -0,0 +1,34 @@
+/* global dom */
+/*eslint complexity: ["error", 14]*/
+/**
+ * Get the scroll offset of the document passed in
+ * @method getScrollOffset
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Document} element The element to evaluate, defaults to document
+ * @return {Object} Contains the attributes `x` and `y` which contain the scroll offsets
+ */
+dom.getScrollOffset = function(element) {
+	'use strict';
+
+	if (!element.nodeType && element.document) {
+		element = element.document;
+	}
+
+	// 9 === Node.DOCUMENT_NODE
+	if (element.nodeType === 9) {
+		var docElement = element.documentElement,
+			body = element.body;
+
+		return {
+			left:
+				(docElement && docElement.scrollLeft) || (body && body.scrollLeft) || 0,
+			top: (docElement && docElement.scrollTop) || (body && body.scrollTop) || 0
+		};
+	}
+
+	return {
+		left: element.scrollLeft,
+		top: element.scrollTop
+	};
+};

data/node_modules/axe-core/lib/commons/dom/get-tabbable-elements.js

@@ -0,0 +1,24 @@
+/* global dom */
+
+/**
+ * Get all elements (including given node) that are part if the tab order
+ * @method getTabbableElements
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {Object} virtualNode The virtualNode to assess
+ * @return {Boolean}
+ */
+dom.getTabbableElements = function getTabbableElements(virtualNode) {
+	const nodeAndDescendents = axe.utils.querySelectorAll(virtualNode, '*');
+
+	const tabbableElements = nodeAndDescendents.filter(vNode => {
+		const isFocusable = vNode.isFocusable;
+		let tabIndex = vNode.actualNode.getAttribute('tabindex');
+		tabIndex =
+			tabIndex && !isNaN(parseInt(tabIndex, 10)) ? parseInt(tabIndex) : null;
+
+		return tabIndex ? isFocusable && tabIndex >= 0 : isFocusable;
+	});
+
+	return tabbableElements;
+};

data/node_modules/axe-core/lib/commons/dom/get-viewport-size.js

@@ -0,0 +1,37 @@
+/* global dom */
+/**
+ * Gets the width and height of the viewport; used to calculate the right and bottom boundaries of the viewable area.
+ * @method getViewportSize
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {Object}  win The `window` object that should be measured
+ * @return {Object}  Object with the `width` and `height` of the viewport
+ */
+dom.getViewportSize = function(win) {
+	'use strict';
+
+	var body,
+		doc = win.document,
+		docElement = doc.documentElement;
+
+	if (win.innerWidth) {
+		return {
+			width: win.innerWidth,
+			height: win.innerHeight
+		};
+	}
+
+	if (docElement) {
+		return {
+			width: docElement.clientWidth,
+			height: docElement.clientHeight
+		};
+	}
+
+	body = doc.body;
+
+	return {
+		width: body.clientWidth,
+		height: body.clientHeight
+	};
+};

data/node_modules/axe-core/lib/commons/dom/has-content-virtual.js

@@ -0,0 +1,73 @@
+/* global dom, aria, axe */
+const hiddenTextElms = [
+	'HEAD',
+	'TITLE',
+	'TEMPLATE',
+	'SCRIPT',
+	'STYLE',
+	'IFRAME',
+	'OBJECT',
+	'VIDEO',
+	'AUDIO',
+	'NOSCRIPT'
+];
+
+function hasChildTextNodes(elm) {
+	if (!hiddenTextElms.includes(elm.actualNode.nodeName.toUpperCase())) {
+		return elm.children.some(
+			({ actualNode }) =>
+				actualNode.nodeType === 3 && actualNode.nodeValue.trim()
+		);
+	}
+}
+
+/**
+ * Check that the element has visible content in the form of either text,
+ * an aria-label or visual content such as image
+ * @method hasContentVirtual
+ * @memberof axe.commons.dom
+ * @instance
+ * @param	{VirtualNode} elm Virtual Node to search
+ * @param	{Boolean} noRecursion If true, only the element is checked, otherwise it will search all child nodes
+ * @return {Boolean}
+ */
+dom.hasContentVirtual = function(elm, noRecursion) {
+	return (
+		// It has text
+		hasChildTextNodes(elm) ||
+		// It is a graphical element
+		dom.isVisualContent(elm.actualNode) ||
+		// It has an ARIA label
+		!!aria.labelVirtual(elm) ||
+		// or one of it's descendants does
+		(!noRecursion &&
+			elm.children.some(
+				child => child.actualNode.nodeType === 1 && dom.hasContentVirtual(child)
+			))
+	);
+};
+
+/**
+ * Find virtual node and call hasContentVirtual()
+ * IMPORTANT: This method requires the composed tree at axe._tree
+ * @see axe.commons.dom.hasContentVirtual
+ * @method hasContent
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {DOMNode} elm DOMNode element to check
+ * @param	{Boolean} noRecursion If true, only the element is checked, otherwise it will search all child nodes
+ * @return {Boolean}
+ */
+dom.hasContent = function hasContent(elm, noRecursion) {
+	elm = axe.utils.getNodeFromTree(axe._tree[0], elm);
+	return dom.hasContentVirtual(elm, noRecursion);
+};
+
+/**
+ * @typedef VirtualNode
+ * @type {Object}
+ * @property {HTMLElement} actualNode reference to actual HTML DOM element
+ * @property {Array<VirtualNode>} children array of child virtualNodes
+ * @property {String} shadowId The shadowId indicates whether the node is in a shadow root
+ * and if it is, which one it is inside the boundary.
+ */