govuk_publishing_components 21.22.1 → 21.22.2

data/node_modules/axe-core/lib/checks/navigation/identical-links-same-purpose-after.js

@@ -0,0 +1,100 @@
+/**
+ * Skip, as no results to curate
+ */
+if (results.length < 2) {
+	return results;
+}
+
+/**
+ * Filter results for which `result` is undefined & thus `data`, `relatedNodes` are undefined
+ */
+const incompleteResults = results.filter(({ result }) => result !== undefined);
+
+/**
+ * for each result
+ * - get other results with matching accessible name
+ * - check if same purpose is served
+ * - if not change `result` to `undefined`
+ * - construct a list of unique results with relatedNodes to return
+ */
+const uniqueResults = [];
+const nameMap = {};
+
+for (let index = 0; index < incompleteResults.length; index++) {
+	const currentResult = incompleteResults[index];
+
+	const { name, urlProps } = currentResult.data;
+	/**
+	 * This is to avoid duplications in the `nodeMap`
+	 */
+	if (nameMap[name]) {
+		continue;
+	}
+
+	const sameNameResults = incompleteResults.filter(
+		({ data }, resultNum) => data.name === name && resultNum !== index
+	);
+	const isSameUrl = sameNameResults.every(({ data }) =>
+		isIdenticalObject(data.urlProps, urlProps)
+	);
+
+	/**
+	 * when identical nodes exists but do not resolve to same url, flag result as `incomplete`
+	 */
+	if (sameNameResults.length && !isSameUrl) {
+		currentResult.result = undefined;
+	}
+
+	/**
+	 *  -> deduplicate results (for both `pass` or `incomplete`) and add `relatedNodes` if any
+	 */
+	currentResult.relatedNodes = [];
+	currentResult.relatedNodes.push(
+		...sameNameResults.map(node => node.relatedNodes[0])
+	);
+
+	/**
+	 * Update `nodeMap` with `sameNameResults`
+	 */
+	nameMap[name] = sameNameResults;
+
+	uniqueResults.push(currentResult);
+}
+
+return uniqueResults;
+
+/**
+ * Check if two given objects are the same (Note: this fn is not extensive in terms of depth equality)
+ * @param {Object} a object a, to compare
+ * @param {*} b object b, to compare
+ * @returns {Boolean}
+ */
+function isIdenticalObject(a, b) {
+	if (!a || !b) {
+		return false;
+	}
+
+	const aProps = Object.getOwnPropertyNames(a);
+	const bProps = Object.getOwnPropertyNames(b);
+
+	if (aProps.length !== bProps.length) {
+		return false;
+	}
+
+	const result = aProps.every(propName => {
+		const aValue = a[propName];
+		const bValue = b[propName];
+
+		if (typeof aValue !== typeof bValue) {
+			return false;
+		}
+
+		if (typeof aValue === `object` || typeof bValue === `object`) {
+			return isIdenticalObject(aValue, bValue);
+		}
+
+		return aValue === bValue;
+	});
+
+	return result;
+}

data/node_modules/axe-core/lib/checks/navigation/identical-links-same-purpose.js

@@ -0,0 +1,31 @@
+/**
+ * Note: `identical-links-same-purpose-after` fn, helps reconcile the results
+ */
+const { dom, text } = axe.commons;
+
+const accText = text.accessibleTextVirtual(virtualNode);
+const name = text
+	.sanitize(
+		text.removeUnicode(accText, {
+			emoji: true,
+			nonBmp: true,
+			punctuations: true
+		})
+	)
+	.toLowerCase();
+
+if (!name) {
+	return undefined;
+}
+
+/**
+ * Set `data` and `relatedNodes` for use in `after` fn
+ */
+const afterData = {
+	name,
+	urlProps: dom.urlPropsFromAttribute(node, 'href')
+};
+this.data(afterData);
+this.relatedNodes([node]);
+
+return true;

data/node_modules/axe-core/lib/checks/navigation/identical-links-same-purpose.json

@@ -0,0 +1,12 @@
+{
+	"id": "identical-links-same-purpose",
+	"evaluate": "identical-links-same-purpose.js",
+	"after": "identical-links-same-purpose-after.js",
+	"metadata": {
+		"impact": "minor",
+		"messages": {
+			"pass": "There are no other links with the same name, that go to a different URL",
+			"incomplete": "Check that links have the same purpose, or are intentionally ambiguous."
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/region.js

@@ -1,5 +1,11 @@
 const { dom, aria } = axe.commons;
 const landmarkRoles = aria.getRolesByType('landmark');
+const implicitAriaLiveRoles = ['alert', 'log', 'status'];
+
+let regionlessNodes = axe._cache.get('regionlessNodes');
+if (regionlessNodes) {
+	return !regionlessNodes.includes(virtualNode);
+}
 
 // Create a list of nodeNames that have a landmark as an implicit role
 const implicitLandmarks = landmarkRoles
@@ -12,14 +18,18 @@ function isRegion(virtualNode) {
 	const explicitRole = axe.commons.aria.getRole(node, { noImplicit: true });
 	const ariaLive = (node.getAttribute('aria-live') || '').toLowerCase().trim();
 
-	if (explicitRole) {
-		return explicitRole === 'dialog' || landmarkRoles.includes(explicitRole);
-	}
 	// Ignore content inside of aria-live
-	if (['assertive', 'polite'].includes(ariaLive)) {
+	if (
+		['assertive', 'polite'].includes(ariaLive) ||
+		implicitAriaLiveRoles.includes(explicitRole)
+	) {
 		return true;
 	}
 
+	if (explicitRole) {
+		return explicitRole === 'dialog' || landmarkRoles.includes(explicitRole);
+	}
+
 	// Check if the node matches any of the CSS selectors of implicit landmarks
 	return implicitLandmarks.some(implicitSelector => {
 		let matches = axe.utils.matchesSelector(node, implicitSelector);
@@ -47,11 +57,18 @@ function findRegionlessElms(virtualNode) {
 			dom.getElementByReference(virtualNode.actualNode, 'href')) ||
 		!dom.isVisible(node, true)
 	) {
+		// Mark each parent node as having region descendant
+		let vNode = virtualNode;
+		while (vNode) {
+			vNode._hasRegionDescendant = true;
+			vNode = vNode.parent;
+		}
+
 		return [];
 
 		// Return the node is a content element
 	} else if (dom.hasContent(node, /* noRecursion: */ true)) {
-		return [node];
+		return [virtualNode];
 
 		// Recursively look at all child elements
 	} else {
@@ -62,7 +79,24 @@ function findRegionlessElms(virtualNode) {
 	}
 }
 
-var regionlessNodes = findRegionlessElms(virtualNode);
-this.relatedNodes(regionlessNodes);
+regionlessNodes = findRegionlessElms(axe._tree[0])
+	// Find first parent marked as having region descendant (or body) and
+	// return the node right before it as the "outer" element
+	.map(vNode => {
+		while (
+			vNode.parent &&
+			!vNode.parent._hasRegionDescendant &&
+			vNode.parent.actualNode !== document.body
+		) {
+			vNode = vNode.parent;
+		}
+
+		return vNode;
+	})
+	// Remove duplicate containers
+	.filter((vNode, index, array) => {
+		return array.indexOf(vNode) === index;
+	});
+axe._cache.set('regionlessNodes', regionlessNodes);
 
-return regionlessNodes.length === 0;
+return !regionlessNodes.includes(virtualNode);

data/node_modules/axe-core/lib/checks/navigation/region.json

@@ -1,7 +1,6 @@
 {
 	"id": "region",
 	"evaluate": "region.js",
-	"after": "region-after.js",
 	"metadata": {
 		"impact": "moderate",
 		"messages": {

data/node_modules/axe-core/lib/checks/shared/svg-non-empty-title.js

@@ -0,0 +1,4 @@
+const titleNode = virtualNode.children.find(({ props }) => {
+	return props.nodeName === 'title';
+});
+return !!titleNode && titleNode.actualNode.textContent.trim() !== '';

data/node_modules/axe-core/lib/checks/shared/svg-non-empty-title.json

@@ -0,0 +1,11 @@
+{
+	"id": "svg-non-empty-title",
+	"evaluate": "svg-non-empty-title.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "element has a child that is a title",
+			"fail": "element has no child that is a title"
+		}
+	}
+}

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

@@ -68,7 +68,9 @@ lookupTable.attributes = {
 		unstandardized: true
 	},
 	'aria-details': {
-		unsupported: true
+		type: 'idref',
+		allowEmpty: true,
+		unsupported: false
 	},
 	'aria-disabled': {
 		type: 'boolean',
@@ -250,6 +252,7 @@ lookupTable.globalAttributes = [
 	'aria-controls',
 	'aria-current',
 	'aria-describedby',
+	'aria-details',
 	'aria-disabled',
 	'aria-dropeffect',
 	'aria-flowto',
@@ -433,7 +436,7 @@ lookupTable.role = {
 			required: ['aria-expanded']
 		},
 		owned: {
-			all: ['listbox', 'textbox']
+			all: ['listbox', 'tree', 'grid', 'dialog', 'textbox']
 		},
 		nameFrom: ['author'],
 		context: null,
@@ -2166,8 +2169,12 @@ lookupTable.elementsAllowedNoRole = [
 	},
 	{
 		nodeName: 'select',
-		condition: node => {
-			return Number(node.getAttribute('size')) > 1;
+		condition: vNode => {
+			if (!(vNode instanceof axe.AbstractVirtualNode)) {
+				vNode = axe.utils.getNodeFromTree(vNode);
+			}
+
+			return Number(vNode.attr('size')) > 1;
 		},
 		properties: {
 			multiple: true
@@ -2406,6 +2413,7 @@ lookupTable.rolesOfType = {
 		'progressbar',
 		'radio',
 		'scrollbar',
+		'searchbox',
 		'slider',
 		'spinbutton',
 		'status',

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

@@ -9,39 +9,9 @@
  * @memberof axe.commons.color
  * @param	{Element} elm Element to determine background color
  * @param	{Array}	 [bgElms=[]] elements to inspect
- * @param	{Boolean} [noScroll=false] should scroll
  * @returns {Color}
  */
-color.getBackgroundColor = function getBackgroundColor(
-	elm,
-	bgElms = [],
-	noScroll = false
-) {
-	if (noScroll !== true) {
-		/**
-		 * Avoid scrolling overflow:hidden containers, by only aligning to top,
-		 * when not doing so would move the center point above the viewport top.
-		 */
-		const clientHeight = elm.getBoundingClientRect().height;
-		const alignToTop = clientHeight - 2 >= window.innerHeight * 2;
-		elm.scrollIntoView(alignToTop);
-
-		// ensure element is scrolled into view horizontally
-		let center, scrollParent;
-		do {
-			const rect = elm.getBoundingClientRect();
-
-			// 'x' does not exist in IE11
-			const x = 'x' in rect ? rect.x : rect.left;
-			center = x + rect.width / 2;
-
-			if (center < 0) {
-				scrollParent = getScrollParent(elm);
-				scrollParent.scrollLeft = 0;
-			}
-		} while (center < 0 && scrollParent !== document.documentElement);
-	}
-
+color.getBackgroundColor = function getBackgroundColor(elm, bgElms = []) {
 	let bgColors = [];
 	let elmStack = color.getBackgroundStack(elm);
 
@@ -101,7 +71,6 @@ color.getBackgroundStack = function getBackgroundStack(elm) {
 	if (elmStack === null) {
 		return null;
 	}
-	elmStack = includeMissingElements(elmStack, elm);
 	elmStack = dom.reduceToElementsBelowFloating(elmStack, elm);
 	elmStack = sortPageBackground(elmStack);
 
@@ -133,15 +102,6 @@ color.filteredRectStack = function filteredRectStack(elm) {
 		const boundingStack = rectStack.shift();
 		let isSame;
 
-		// Safari v12.1 does not include labels as part of elementsFromPoint()
-		// if they wrap an input element (UNLESS the label has a background
-		// color). this results in two different rectStacks (since
-		// elm.getClientRects() returns two rects for the element) which
-		// returns null as isSame is false. we can fix this by adding in the
-		// missing label to the boundingStack before checking for isSame
-		// @see https://bugs.webkit.org/show_bug.cgi?id=197743
-		includeMissingElements(boundingStack, elm);
-
 		// iterating over arrays of DOMRects
 		rectStack.forEach((rectList, index) => {
 			if (index === 0) {
@@ -179,38 +139,16 @@ color.filteredRectStack = function filteredRectStack(elm) {
  * @return {Array}
  */
 color.getRectStack = function(elm) {
-	const boundingCoords = axe.commons.color.centerPointOfRect(
-		elm.getBoundingClientRect()
-	);
+	const boundingStack = axe.commons.dom.getElementStack(elm);
 
-	if (!boundingCoords) {
-		return null;
-	}
-
-	let boundingStack = dom.shadowElementsFromPoint(
-		boundingCoords.x,
-		boundingCoords.y
-	);
+	// Handle inline elements spanning multiple lines to be evaluated
+	const filteredArr = axe.commons.dom.getTextElementStack(elm);
 
-	let rects = Array.from(elm.getClientRects());
 	// If the element does not have multiple rects, like for display:block, return a single stack
-	if (!rects || rects.length <= 1) {
+	if (!filteredArr || filteredArr.length <= 1) {
 		return [boundingStack];
 	}
 
-	// Handle inline elements spanning multiple lines to be evaluated
-	let filteredArr = rects
-		.filter(rect => {
-			// exclude manual line breaks in Chrome/Safari
-			return rect.width && rect.width > 0;
-		})
-		.map(rect => {
-			const coords = axe.commons.color.centerPointOfRect(rect);
-			if (coords) {
-				return dom.shadowElementsFromPoint(coords.x, coords.y);
-			}
-		});
-
 	if (filteredArr.some(stack => stack === undefined)) {
 		// Can be happen when one or more of the rects sits outside the viewport
 		return null;
@@ -263,66 +201,6 @@ function sortPageBackground(elmStack) {
 	return bgNodes;
 }
 
-/**
- * Include nodes missing from initial gathering because
- * document.elementsFromPoint misses some elements we need
- * i.e. TR is missing from table elementStack and leaves out bgColor
- * https://github.com/dequelabs/axe-core/issues/273
- * @private
- * @param {Array} elmStack
- * @param {Element} elm
- * @returns {Array}
- */
-function includeMissingElements(elmStack, elm) {
-	/*eslint max-depth:["error",7]*/
-	const nodeName = elm.nodeName.toUpperCase();
-	const elementMap = {
-		TD: ['TR', 'THEAD', 'TBODY', 'TFOOT'],
-		TH: ['TR', 'THEAD', 'TBODY', 'TFOOT'],
-		INPUT: ['LABEL']
-	};
-	const tagArray = elmStack.map(elm => {
-		return elm.nodeName.toUpperCase();
-	});
-	let bgNodes = elmStack;
-	for (let candidate in elementMap) {
-		// check that TR or LABEL has paired nodeName from elementMap, but don't expect elm to be that candidate
-		if (tagArray.includes(candidate)) {
-			for (
-				let candidateIndex = 0;
-				candidateIndex < elementMap[candidate].length;
-				candidateIndex++
-			) {
-				// look up the tree for a matching candidate
-				let ancestorMatch = axe.commons.dom.findUp(
-					elm,
-					elementMap[candidate][candidateIndex]
-				);
-				if (ancestorMatch && elmStack.indexOf(ancestorMatch) === -1) {
-					// found an ancestor not in elmStack, and it overlaps
-					let overlaps = axe.commons.dom.visuallyOverlaps(
-						elm.getBoundingClientRect(),
-						ancestorMatch
-					);
-					if (overlaps) {
-						// if target is in the elementMap, use its position.
-						bgNodes.splice(tagArray.indexOf(candidate) + 1, 0, ancestorMatch);
-					}
-				}
-				// nodeName matches value
-				// (such as LABEL, when matching itself. It should be in the list, but Phantom skips it)
-				if (
-					nodeName === elementMap[candidate][candidateIndex] &&
-					tagArray.indexOf(nodeName) === -1
-				) {
-					bgNodes.splice(tagArray.indexOf(candidate) + 1, 0, elm);
-				}
-			}
-		}
-	}
-	return bgNodes;
-}
-
 /**
  * Determine if element is partially overlapped, triggering a Can't Tell result
  * @private
@@ -393,36 +271,6 @@ function contentOverlapping(targetElement, bgNode) {
 	return false;
 }
 
-/**
- * Return the scrolling parent element
- * @see https://stackoverflow.com/questions/35939886/find-first-scrollable-parent#42543908
- * @param {Element} element
- * @param {Boolean} includeHidden
- * @return {Element}
- */
-function getScrollParent(element, includeHidden) {
-	var style = getComputedStyle(element);
-	var excludeStaticParent = style.position === 'absolute';
-	var overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/;
-
-	if (style.position === 'fixed') {
-		return document.documentElement;
-	}
-	for (var parent = element; (parent = parent.parentElement); ) {
-		style = getComputedStyle(parent);
-		if (excludeStaticParent && style.position === 'static') {
-			continue;
-		}
-		if (
-			overflowRegex.test(style.overflow + style.overflowY + style.overflowX)
-		) {
-			return parent;
-		}
-	}
-
-	return document.documentElement;
-}
-
 /**
  * Determines whether an element has a fully opaque background, whether solid color or an image
  * @param {Element} node