govuk_publishing_components 18.1.0 → 18.1.1

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.
+ */

data/node_modules/axe-core/lib/commons/dom/idrefs.js

@@ -0,0 +1,36 @@
+/*global dom, axe */
+
+/**
+ * Get elements referenced via a space-separated token attribute;
+ * it will insert `null` for any Element that is not found
+ * @method idrefs
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {HTMLElement} node
+ * @param  {String} attr The name of attribute
+ * @return {Array|null} Array of elements (or `null` if not found)
+ *
+ * NOTE: When in a shadow DOM environment: ID refs (even for slotted content)
+ * refer to the document in which the element is considered to be in the
+ * "light DOM". Therefore, we use getElementById on the root node and not QSA
+ * on the flattened tree to dereference idrefs.
+ *
+ */
+dom.idrefs = function(node, attr) {
+	'use strict';
+
+	var index,
+		length,
+		doc = dom.getRootNode(node),
+		result = [],
+		idrefs = node.getAttribute(attr);
+
+	if (idrefs) {
+		idrefs = axe.utils.tokenList(idrefs);
+		for (index = 0, length = idrefs.length; index < length; index++) {
+			result.push(doc.getElementById(idrefs[index]));
+		}
+	}
+
+	return result;
+};

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

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

data/node_modules/axe-core/lib/commons/dom/is-focusable.js

@@ -0,0 +1,90 @@
+/* global dom */
+/* eslint complexity: ["error",20] */
+
+/**
+ * Determines if focusing has been disabled on an element.
+ * @param {HTMLElement} el The HTMLElement
+ * @return {Boolean} Whether focusing has been disabled on an element.
+ */
+function focusDisabled(el) {
+	return (
+		el.disabled ||
+		(dom.isHiddenWithCSS(el) && el.nodeName.toUpperCase() !== 'AREA')
+	);
+}
+
+/**
+ * Determines if an element is focusable
+ * @method isFocusable
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} el The HTMLElement
+ * @return {Boolean} The element's focusability status
+ */
+
+dom.isFocusable = function(el) {
+	'use strict';
+	if (focusDisabled(el)) {
+		return false;
+	} else if (dom.isNativelyFocusable(el)) {
+		return true;
+	}
+	// check if the tabindex is specified and a parseable number
+	var tabindex = el.getAttribute('tabindex');
+	if (tabindex && !isNaN(parseInt(tabindex, 10))) {
+		return true;
+	}
+
+	return false;
+};
+
+/**
+ * Determines if an element is focusable without considering its tabindex
+ * @method isNativelyFocusable
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} el The HTMLElement
+ * @return {Boolean} True if the element is in the focus order but wouldn't be
+ * if its tabindex were removed. Else, false.
+ */
+dom.isNativelyFocusable = function(el) {
+	/* eslint indent: 0*/
+	'use strict';
+
+	if (!el || focusDisabled(el)) {
+		return false;
+	}
+
+	switch (el.nodeName.toUpperCase()) {
+		case 'A':
+		case 'AREA':
+			if (el.href) {
+				return true;
+			}
+			break;
+		case 'INPUT':
+			return el.type !== 'hidden';
+		case 'TEXTAREA':
+		case 'SELECT':
+		case 'DETAILS':
+		case 'BUTTON':
+			return true;
+	}
+	return false;
+};
+
+/**
+ * Determines if an element is in the focus order, but would not be if its
+ * tabindex were unspecified.
+ * @method insertedIntoFocusOrder
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} el The HTMLElement
+ * @return {Boolean} True if the element is in the focus order but wouldn't be
+ * if its tabindex were removed. Else, false.
+ */
+dom.insertedIntoFocusOrder = function(el) {
+	return (
+		el.tabIndex > -1 && dom.isFocusable(el) && !dom.isNativelyFocusable(el)
+	);
+};

data/node_modules/axe-core/lib/commons/dom/is-hidden-with-css.js

@@ -0,0 +1,60 @@
+/* eslint complexity: ["error", 13], max-statements: ["error", 25] */
+/* global dom */
+
+/**
+ * Determine whether an element is hidden based on css
+ * @method isHiddenWithCSS
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} el The HTML Element
+ * @param {Boolean} descendentVisibilityValue (Optional) immediate descendant visibility value used for recursive computation
+ * @return {Boolean} the element's hidden status
+ */
+dom.isHiddenWithCSS = function isHiddenWithCSS(el, descendentVisibilityValue) {
+	if (el.nodeType === 9) {
+		// 9 === Node.DOCUMENT
+		return false;
+	}
+
+	if (el.nodeType === 11) {
+		// 11 === Node.DOCUMENT_FRAGMENT_NODE
+		el = el.host; // swap to host node
+	}
+
+	if (['STYLE', 'SCRIPT'].includes(el.nodeName.toUpperCase())) {
+		return false;
+	}
+
+	const style = window.getComputedStyle(el, null);
+	if (!style) {
+		throw new Error('Style does not exist for the given element.');
+	}
+
+	const displayValue = style.getPropertyValue('display');
+	if (displayValue === 'none') {
+		return true;
+	}
+
+	const HIDDEN_VISIBILITY_VALUES = ['hidden', 'collapse'];
+	const visibilityValue = style.getPropertyValue('visibility');
+	if (
+		HIDDEN_VISIBILITY_VALUES.includes(visibilityValue) &&
+		!descendentVisibilityValue
+	) {
+		return true;
+	}
+
+	if (
+		HIDDEN_VISIBILITY_VALUES.includes(visibilityValue) &&
+		(descendentVisibilityValue &&
+			HIDDEN_VISIBILITY_VALUES.includes(descendentVisibilityValue))
+	) {
+		return true;
+	}
+
+	const parent = dom.getComposedParent(el);
+	if (parent && !HIDDEN_VISIBILITY_VALUES.includes(visibilityValue)) {
+		return dom.isHiddenWithCSS(parent, visibilityValue);
+	}
+	return false;
+};

data/node_modules/axe-core/lib/commons/dom/is-html5.js

@@ -0,0 +1,17 @@
+/* global dom */
+
+/**
+ * Determines if a document node is HTML 5
+ * @method isHTML5
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Node} doc
+ * @return {Boolean}
+ */
+dom.isHTML5 = function(doc) {
+	var node = doc.doctype;
+	if (node === null) {
+		return false;
+	}
+	return node.name === 'html' && !node.publicId && !node.systemId;
+};

data/node_modules/axe-core/lib/commons/dom/is-in-text-block.js

@@ -0,0 +1,95 @@
+/* global axe, dom, window */
+function walkDomNode(node, functor) {
+	if (functor(node.actualNode) !== false) {
+		node.children.forEach(child => walkDomNode(child, functor));
+	}
+}
+
+var blockLike = ['block', 'list-item', 'table', 'flex', 'grid', 'inline-block'];
+function isBlock(elm) {
+	var display = window.getComputedStyle(elm).getPropertyValue('display');
+	return blockLike.includes(display) || display.substr(0, 6) === 'table-';
+}
+
+function getBlockParent(node) {
+	// Find the closest parent
+	let parentBlock = dom.getComposedParent(node);
+	while (parentBlock && !isBlock(parentBlock)) {
+		parentBlock = dom.getComposedParent(parentBlock);
+	}
+	return axe.utils.getNodeFromTree(axe._tree[0], parentBlock);
+}
+
+/**
+ * Determines if an element is within a text block
+ * @param  {Element} node [description]
+ * @return {Boolean}      [description]
+ */
+dom.isInTextBlock = function isInTextBlock(node) {
+	/* eslint complexity: ["error",17]*/
+	if (isBlock(node)) {
+		// Ignore if the link is a block
+		return false;
+	}
+
+	// Find all the text part of the parent block not in a link, and all the text in a link
+	const virtualParent = getBlockParent(node);
+	let parentText = '';
+	let linkText = '';
+	let inBrBlock = 0;
+
+	// We want to ignore hidden text, and if br / hr is used, only use the section of the parent
+	// that has the link we're looking at
+	walkDomNode(virtualParent, function(currNode) {
+		// We're already passed it, skip everything else
+		if (inBrBlock === 2) {
+			return false;
+		}
+
+		if (currNode.nodeType === 3) {
+			// Add the text to the parent
+			parentText += currNode.nodeValue;
+		}
+		// Ignore any node that's not an element (or text as above)
+		if (currNode.nodeType !== 1) {
+			return;
+		}
+
+		var nodeName = (currNode.nodeName || '').toUpperCase();
+		// BR and HR elements break the line
+		if (['BR', 'HR'].includes(nodeName)) {
+			if (inBrBlock === 0) {
+				parentText = '';
+				linkText = '';
+			} else {
+				inBrBlock = 2;
+			}
+
+			// Don't walk nodes with content not displayed on screen.
+		} else if (
+			currNode.style.display === 'none' ||
+			currNode.style.overflow === 'hidden' ||
+			!['', null, 'none'].includes(currNode.style.float) ||
+			!['', null, 'relative'].includes(currNode.style.position)
+		) {
+			return false;
+
+			// Don't walk links, we're only interested in what's not in them.
+		} else if (
+			(nodeName === 'A' && currNode.href) ||
+			(currNode.getAttribute('role') || '').toLowerCase() === 'link'
+		) {
+			if (currNode === node) {
+				inBrBlock = 1;
+			}
+			// Grab all the text from this element, but don't walk down it's children
+			linkText += currNode.textContent;
+			return false;
+		}
+	});
+
+	parentText = axe.commons.text.sanitize(parentText);
+	linkText = axe.commons.text.sanitize(linkText);
+
+	return parentText.length > linkText.length;
+};

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

@@ -0,0 +1,13 @@
+/* global dom */
+/**
+ * Determines if element is an instance of Node
+ * @method isNode
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {Element} element
+ * @return {Boolean}
+ */
+dom.isNode = function(element) {
+	'use strict';
+	return element instanceof Node;
+};

data/node_modules/axe-core/lib/commons/dom/is-offscreen.js

@@ -0,0 +1,62 @@
+/* global dom */
+
+function noParentScrolled(element, offset) {
+	element = dom.getComposedParent(element);
+	while (element && element.nodeName.toLowerCase() !== 'html') {
+		if (element.scrollTop) {
+			offset += element.scrollTop;
+			if (offset >= 0) {
+				return false;
+			}
+		}
+		element = dom.getComposedParent(element);
+	}
+	return true;
+}
+
+/**
+ * Determines if element is off screen
+ * @method isOffscreen
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {Element} element
+ * @return {Boolean}
+ */
+dom.isOffscreen = function(element) {
+	let leftBoundary;
+	const docElement = document.documentElement;
+	const styl = window.getComputedStyle(element);
+	const dir = window
+		.getComputedStyle(document.body || docElement)
+		.getPropertyValue('direction');
+	const coords = dom.getElementCoordinates(element);
+
+	// bottom edge beyond
+	if (
+		coords.bottom < 0 &&
+		(noParentScrolled(element, coords.bottom) || styl.position === 'absolute')
+	) {
+		return true;
+	}
+
+	if (coords.left === 0 && coords.right === 0) {
+		//This is an edge case, an empty (zero-width) element that isn't positioned 'off screen'.
+		return false;
+	}
+
+	if (dir === 'ltr') {
+		if (coords.right <= 0) {
+			return true;
+		}
+	} else {
+		leftBoundary = Math.max(
+			docElement.scrollWidth,
+			dom.getViewportSize(window).width
+		);
+		if (coords.left >= leftBoundary) {
+			return true;
+		}
+	}
+
+	return false;
+};