govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/checks/mobile/css-orientation-lock.json

@@ -0,0 +1,12 @@
+{
+	"id": "css-orientation-lock",
+	"evaluate": "css-orientation-lock.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Display is operable, and orientation lock does not exist",
+			"fail": "CSS Orientation lock is applied, and makes display inoperable",
+			"incomplete": "CSS Orientation lock cannot be determined"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/mobile/meta-viewport-large.json

@@ -0,0 +1,15 @@
+{
+	"id": "meta-viewport-large",
+	"evaluate": "meta-viewport-scale.js",
+	"options": {
+		"scaleMinimum": 5,
+		"lowerBound": 2
+	},
+	"metadata": {
+		"impact": "minor",
+		"messages": {
+			"pass": "<meta> tag does not prevent significant zooming on mobile devices",
+			"fail": "<meta> tag limits zooming on mobile devices"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/mobile/meta-viewport-scale.js

@@ -0,0 +1,38 @@
+options = options || {};
+var params,
+	content = node.getAttribute('content') || '',
+	parsedParams = content.split(/[;,]/),
+	result = {},
+	minimum = options.scaleMinimum || 2,
+	lowerBound = options.lowerBound || false;
+
+for (var i = 0, l = parsedParams.length; i < l; i++) {
+	params = parsedParams[i].split('=');
+	var key = params.shift().toLowerCase();
+	if (key && params.length) {
+		result[key.trim()] = params
+			.shift()
+			.trim()
+			.toLowerCase();
+	}
+}
+
+if (
+	lowerBound &&
+	result['maximum-scale'] &&
+	parseFloat(result['maximum-scale']) < lowerBound
+) {
+	return true;
+}
+
+if (!lowerBound && result['user-scalable'] === 'no') {
+	this.data('user-scalable=no');
+	return false;
+}
+
+if (result['maximum-scale'] && parseFloat(result['maximum-scale']) < minimum) {
+	this.data('maximum-scale');
+	return false;
+}
+
+return true;

data/node_modules/axe-core/lib/checks/mobile/meta-viewport.json

@@ -0,0 +1,14 @@
+{
+	"id": "meta-viewport",
+	"evaluate": "meta-viewport-scale.js",
+	"options": {
+		"scaleMinimum": 2
+	},
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "<meta> tag does not disable zooming on mobile devices",
+			"fail": "{{=it.data}} on <meta> tag disables zooming on mobile devices"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/header-present.js

@@ -0,0 +1,4 @@
+return !!axe.utils.querySelectorAll(
+	virtualNode,
+	'h1, h2, h3, h4, h5, h6, [role="heading"]'
+)[0];

data/node_modules/axe-core/lib/checks/navigation/header-present.json

@@ -0,0 +1,11 @@
+{
+	"id": "header-present",
+	"evaluate": "header-present.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Page has a header",
+			"fail": "Page does not have a header"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/heading-order-after.js

@@ -0,0 +1,14 @@
+if (results.length < 2) {
+	return results;
+}
+
+var prevLevel = results[0].data;
+
+for (var i = 1; i < results.length; i++) {
+	if (results[i].result && results[i].data > prevLevel + 1) {
+		results[i].result = false;
+	}
+	prevLevel = results[i].data;
+}
+
+return results;

data/node_modules/axe-core/lib/checks/navigation/heading-order.js

@@ -0,0 +1,15 @@
+var ariaHeadingLevel = node.getAttribute('aria-level');
+
+if (ariaHeadingLevel !== null) {
+	this.data(parseInt(ariaHeadingLevel, 10));
+	return true;
+}
+
+var headingLevel = node.nodeName.toUpperCase().match(/H(\d)/);
+
+if (headingLevel) {
+	this.data(parseInt(headingLevel[1], 10));
+	return true;
+}
+
+return true;

data/node_modules/axe-core/lib/checks/navigation/heading-order.json

@@ -0,0 +1,12 @@
+{
+	"id": "heading-order",
+	"evaluate": "heading-order.js",
+	"after": "heading-order-after.js",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "Heading order valid",
+			"fail": "Heading order invalid"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/internal-link-present.js

@@ -0,0 +1,4 @@
+const links = axe.utils.querySelectorAll(virtualNode, 'a[href]');
+return links.some(vLink => {
+	return /^#[^/!]/.test(vLink.actualNode.getAttribute('href'));
+});

data/node_modules/axe-core/lib/checks/navigation/internal-link-present.json

@@ -0,0 +1,11 @@
+{
+	"id": "internal-link-present",
+	"evaluate": "internal-link-present.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Valid skip link found",
+			"fail": "No valid skip link found"
+		}
+	}
+}

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

@@ -0,0 +1,3 @@
+return (
+	axe.utils.querySelectorAll(virtualNode, 'main, [role="main"]').length > 0
+);

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

@@ -0,0 +1,11 @@
+{
+	"id": "landmark",
+	"evaluate": "landmark.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Page has a landmark region",
+			"fail": "Page does not have a landmark region"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/meta-refresh.js

@@ -0,0 +1,4 @@
+var content = node.getAttribute('content') || '',
+	parsedParams = content.split(/[;,]/);
+
+return content === '' || parsedParams[0] === '0';

data/node_modules/axe-core/lib/checks/navigation/meta-refresh.json

@@ -0,0 +1,11 @@
+{
+	"id": "meta-refresh",
+	"evaluate": "meta-refresh.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "<meta> tag does not immediately refresh the page",
+			"fail": "<meta> tag forces timed refresh of page"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/p-as-heading.js

@@ -0,0 +1,93 @@
+let siblings = Array.from(node.parentNode.children);
+let currentIndex = siblings.indexOf(node);
+
+options = options || {};
+let margins = options.margins || [];
+
+let nextSibling = siblings
+	.slice(currentIndex + 1)
+	.find(elm => elm.nodeName.toUpperCase() === 'P');
+
+let prevSibling = siblings
+	.slice(0, currentIndex)
+	.reverse()
+	.find(elm => elm.nodeName.toUpperCase() === 'P');
+
+function getTextContainer(elm) {
+	let nextNode = elm;
+	let outerText = elm.textContent.trim();
+	let innerText = outerText;
+
+	while (innerText === outerText && nextNode !== undefined) {
+		let i = -1;
+		elm = nextNode;
+		if (elm.children.length === 0) {
+			return elm;
+		}
+
+		do {
+			// find the first non-empty child
+			i++;
+			innerText = elm.children[i].textContent.trim();
+		} while (innerText === '' && i + 1 < elm.children.length);
+		nextNode = elm.children[i];
+	}
+
+	return elm;
+}
+
+function normalizeFontWeight(weight) {
+	/* eslint indent: 0*/
+	switch (weight) {
+		case 'lighter':
+			return 100;
+		case 'normal':
+			return 400;
+		case 'bold':
+			return 700;
+		case 'bolder':
+			return 900;
+	}
+	weight = parseInt(weight);
+	return !isNaN(weight) ? weight : 400;
+}
+
+function getStyleValues(node) {
+	let style = window.getComputedStyle(getTextContainer(node));
+	return {
+		fontWeight: normalizeFontWeight(style.getPropertyValue('font-weight')),
+		fontSize: parseInt(style.getPropertyValue('font-size')),
+		isItalic: style.getPropertyValue('font-style') === 'italic'
+	};
+}
+
+function isHeaderStyle(styleA, styleB, margins) {
+	return margins.reduce((out, margin) => {
+		return (
+			out ||
+			((!margin.size || styleA.fontSize / margin.size > styleB.fontSize) &&
+				(!margin.weight ||
+					styleA.fontWeight - margin.weight > styleB.fontWeight) &&
+				(!margin.italic || (styleA.isItalic && !styleB.isItalic)))
+		);
+	}, false);
+}
+
+const currStyle = getStyleValues(node);
+const nextStyle = nextSibling ? getStyleValues(nextSibling) : null;
+const prevStyle = prevSibling ? getStyleValues(prevSibling) : null;
+
+if (!nextStyle || !isHeaderStyle(currStyle, nextStyle, margins)) {
+	return true;
+}
+
+let blockquote = axe.commons.dom.findUpVirtual(virtualNode, 'blockquote');
+if (blockquote && blockquote.nodeName.toUpperCase() === 'BLOCKQUOTE') {
+	return undefined;
+}
+
+if (prevStyle && !isHeaderStyle(currStyle, prevStyle, margins)) {
+	return undefined;
+}
+
+return false;

data/node_modules/axe-core/lib/checks/navigation/p-as-heading.json

@@ -0,0 +1,30 @@
+{
+	"id": "p-as-heading",
+	"evaluate": "p-as-heading.js",
+	"options": {
+		"margins": [
+			{
+				"weight": 150,
+				"italic": true
+			},
+			{
+				"weight": 150,
+				"size": 1.15
+			},
+			{
+				"italic": true,
+				"size": 1.15
+			},
+			{
+				"size": 1.4
+			}
+		]
+	},
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "<p> elements are not styled as headings",
+			"fail": "Heading elements should be used instead of styled p elements"
+		}
+	}
+}

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

@@ -0,0 +1 @@
+return [results[0]];

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

@@ -0,0 +1,85 @@
+const { dom, aria } = axe.commons;
+
+// Return the skplink, if any
+function getSkiplink(virtualNode) {
+	const firstLink = axe.utils.querySelectorAll(virtualNode, 'a[href]')[0];
+	if (
+		firstLink &&
+		axe.commons.dom.getElementByReference(firstLink.actualNode, 'href')
+	) {
+		return firstLink.actualNode;
+	}
+}
+
+const skipLink = getSkiplink(virtualNode);
+const landmarkRoles = aria.getRolesByType('landmark');
+
+// Create a list of nodeNames that have a landmark as an implicit role
+const implicitLandmarks = landmarkRoles
+	.reduce((arr, role) => arr.concat(aria.implicitNodes(role)), [])
+	.filter(r => r !== null);
+
+// Check if the current element is the skiplink
+function isSkipLink(vNode) {
+	return skipLink && skipLink === vNode.actualNode;
+}
+
+// Check if the current element is a landmark
+function isRegion(virtualNode) {
+	const node = virtualNode.actualNode;
+	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)) {
+		return true;
+	}
+
+	// Check if the node matches any of the CSS selectors of implicit landmarks
+	return implicitLandmarks.some(implicitSelector => {
+		let matches = axe.utils.matchesSelector(node, implicitSelector);
+		if (node.nodeName.toUpperCase() === 'FORM') {
+			let titleAttr = node.getAttribute('title');
+			let title =
+				titleAttr && titleAttr.trim() !== ''
+					? axe.commons.text.sanitize(titleAttr)
+					: null;
+			return matches && (!!aria.labelVirtual(virtualNode) || !!title);
+		}
+		return matches;
+	});
+}
+
+/**
+ * Find all visible elements not wrapped inside a landmark or skiplink
+ */
+function findRegionlessElms(virtualNode) {
+	const node = virtualNode.actualNode;
+	// End recursion if the element is a landmark, skiplink, or hidden content
+	if (
+		isRegion(virtualNode) ||
+		isSkipLink(virtualNode) ||
+		!dom.isVisible(node, true)
+	) {
+		return [];
+
+		// Return the node is a content element
+	} else if (dom.hasContent(node, /* noRecursion: */ true)) {
+		return [node];
+
+		// Recursively look at all child elements
+	} else {
+		return virtualNode.children
+			.filter(({ actualNode }) => actualNode.nodeType === 1)
+			.map(findRegionlessElms)
+			.reduce((a, b) => a.concat(b), []); // flatten the results
+	}
+}
+
+var regionlessNodes = findRegionlessElms(virtualNode);
+this.relatedNodes(regionlessNodes);
+
+return regionlessNodes.length === 0;

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

@@ -0,0 +1,12 @@
+{
+	"id": "region",
+	"evaluate": "region.js",
+	"after": "region-after.js",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "All page content is contained by landmarks",
+			"fail": "Some page content is not contained by landmarks"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/navigation/skip-link.js

@@ -0,0 +1,5 @@
+const target = axe.commons.dom.getElementByReference(node, 'href');
+if (target) {
+	return axe.commons.dom.isVisible(target, true) || undefined;
+}
+return false;

data/node_modules/axe-core/lib/checks/navigation/skip-link.json

@@ -0,0 +1,12 @@
+{
+	"id": "skip-link",
+	"evaluate": "skip-link.js",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "Skip link target exists",
+			"incomplete": "Skip link target should become visible on activation",
+			"fail": "No skip link target"
+		}
+	}
+}