govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/checks/language/xml-lang-mismatch.json

@@ -0,0 +1,11 @@
+{
+	"id": "xml-lang-mismatch",
+	"evaluate": "xml-lang-mismatch.js",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "Lang and xml:lang attributes have the same base language",
+			"fail": "Lang and xml:lang attributes do not have the same base language"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/lists/dlitem.js

@@ -0,0 +1,23 @@
+let parent = axe.commons.dom.getComposedParent(node);
+let parentTagName = parent.nodeName.toUpperCase();
+let parentRole = axe.commons.aria.getRole(parent, { noImplicit: true });
+
+if (
+	parentTagName === 'DIV' &&
+	['presentation', 'none', null].includes(parentRole)
+) {
+	parent = axe.commons.dom.getComposedParent(parent);
+	parentTagName = parent.nodeName.toUpperCase();
+	parentRole = axe.commons.aria.getRole(parent, { noImplicit: true });
+}
+
+// Unlike with UL|OL+LI, DT|DD must be in a DL
+if (parentTagName !== 'DL') {
+	return false;
+}
+
+if (!parentRole || parentRole === 'list') {
+	return true;
+}
+
+return false;

data/node_modules/axe-core/lib/checks/lists/dlitem.json

@@ -0,0 +1,11 @@
+{
+	"id": "dlitem",
+	"evaluate": "dlitem.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Description list item has a <dl> parent element",
+			"fail": "Description list item does not have a <dl> parent element"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/lists/listitem.js

@@ -0,0 +1,18 @@
+const parent = axe.commons.dom.getComposedParent(node);
+if (!parent) {
+	// Can only happen with detached DOM nodes and roots:
+	return undefined;
+}
+
+const parentTagName = parent.nodeName.toUpperCase();
+const parentRole = (parent.getAttribute('role') || '').toLowerCase();
+
+if (parentRole === 'list') {
+	return true;
+}
+
+if (parentRole && axe.commons.aria.isValidRole(parentRole)) {
+	return false;
+}
+
+return ['UL', 'OL'].includes(parentTagName);

data/node_modules/axe-core/lib/checks/lists/listitem.json

@@ -0,0 +1,11 @@
+{
+	"id": "listitem",
+	"evaluate": "listitem.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "List item has a <ul>, <ol> or role=\"list\" parent element",
+			"fail": "List item does not have a <ul>, <ol> or role=\"list\" parent element"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/lists/only-dlitems.js

@@ -0,0 +1,42 @@
+const { dom, aria } = axe.commons;
+const ALLOWED_ROLES = ['definition', 'term', 'list'];
+let base = {
+	badNodes: [],
+	hasNonEmptyTextNode: false
+};
+
+const content = virtualNode.children.reduce((content, child) => {
+	const { actualNode } = child;
+	if (
+		actualNode.nodeName.toUpperCase() === 'DIV' &&
+		aria.getRole(actualNode) === null
+	) {
+		return content.concat(child.children);
+	}
+	return content.concat(child);
+}, []);
+
+const result = content.reduce((out, childNode) => {
+	const { actualNode } = childNode;
+	const tagName = actualNode.nodeName.toUpperCase();
+
+	if (actualNode.nodeType === 1 && dom.isVisible(actualNode, true, false)) {
+		const explicitRole = aria.getRole(actualNode, { noImplicit: true });
+
+		if ((tagName !== 'DT' && tagName !== 'DD') || explicitRole) {
+			if (!ALLOWED_ROLES.includes(explicitRole)) {
+				// handle comment - https://github.com/dequelabs/axe-core/pull/518/files#r139284668
+				out.badNodes.push(actualNode);
+			}
+		}
+	} else if (actualNode.nodeType === 3 && actualNode.nodeValue.trim() !== '') {
+		out.hasNonEmptyTextNode = true;
+	}
+	return out;
+}, base);
+
+if (result.badNodes.length) {
+	this.relatedNodes(result.badNodes);
+}
+
+return !!result.badNodes.length || result.hasNonEmptyTextNode;

data/node_modules/axe-core/lib/checks/lists/only-dlitems.json

@@ -0,0 +1,11 @@
+{
+	"id": "only-dlitems",
+	"evaluate": "only-dlitems.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "List element only has direct children that are allowed inside <dt> or <dd> elements",
+			"fail": "List element has direct children that are not allowed inside <dt> or <dd> elements"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/lists/only-listitems.js

@@ -0,0 +1,68 @@
+const { dom } = axe.commons;
+const getIsListItemRole = (role, tagName) => {
+	return role === 'listitem' || (tagName === 'LI' && !role);
+};
+
+const getHasListItem = (hasListItem, tagName, isListItemRole) => {
+	return hasListItem || (tagName === 'LI' && isListItemRole) || isListItemRole;
+};
+
+let base = {
+	badNodes: [],
+	isEmpty: true,
+	hasNonEmptyTextNode: false,
+	hasListItem: false,
+	liItemsWithRole: 0
+};
+
+let out = virtualNode.children.reduce((out, { actualNode }) => {
+	/*eslint 
+		max-statements: ["error", 20]
+		complexity: ["error", 12]
+		*/
+	const tagName = actualNode.nodeName.toUpperCase();
+
+	if (actualNode.nodeType === 1 && dom.isVisible(actualNode, true, false)) {
+		const role = (actualNode.getAttribute('role') || '').toLowerCase();
+		const isListItemRole = getIsListItemRole(role, tagName);
+
+		out.hasListItem = getHasListItem(out.hasListItem, tagName, isListItemRole);
+
+		if (isListItemRole) {
+			out.isEmpty = false;
+		}
+		if (tagName === 'LI' && !isListItemRole) {
+			out.liItemsWithRole++;
+		}
+		if (tagName !== 'LI' && !isListItemRole) {
+			out.badNodes.push(actualNode);
+		}
+	}
+	if (actualNode.nodeType === 3) {
+		if (actualNode.nodeValue.trim() !== '') {
+			out.hasNonEmptyTextNode = true;
+		}
+	}
+
+	return out;
+}, base);
+
+const virtualNodeChildrenOfTypeLi = virtualNode.children.filter(
+	({ actualNode }) => {
+		return actualNode.nodeName.toUpperCase() === 'LI';
+	}
+);
+
+const allLiItemsHaveRole =
+	out.liItemsWithRole > 0 &&
+	virtualNodeChildrenOfTypeLi.length === out.liItemsWithRole;
+
+if (out.badNodes.length) {
+	this.relatedNodes(out.badNodes);
+}
+
+const isInvalidListItem = !(
+	out.hasListItem ||
+	(out.isEmpty && !allLiItemsHaveRole)
+);
+return isInvalidListItem || !!out.badNodes.length || out.hasNonEmptyTextNode;

data/node_modules/axe-core/lib/checks/lists/only-listitems.json

@@ -0,0 +1,11 @@
+{
+	"id": "only-listitems",
+	"evaluate": "only-listitems.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "List element only has direct children that are allowed inside <li> elements",
+			"fail": "List element has direct children that are not allowed inside <li> elements"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/lists/structured-dlitems.js

@@ -0,0 +1,22 @@
+var children = virtualNode.children;
+if (!children || !children.length) {
+	return false;
+}
+
+var hasDt = false,
+	hasDd = false,
+	nodeName;
+for (var i = 0; i < children.length; i++) {
+	nodeName = children[i].actualNode.nodeName.toUpperCase();
+	if (nodeName === 'DT') {
+		hasDt = true;
+	}
+	if (hasDt && nodeName === 'DD') {
+		return false;
+	}
+	if (nodeName === 'DD') {
+		hasDd = true;
+	}
+}
+
+return hasDt || hasDd;

data/node_modules/axe-core/lib/checks/lists/structured-dlitems.json

@@ -0,0 +1,11 @@
+{
+	"id": "structured-dlitems",
+	"evaluate": "structured-dlitems.js",
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "When not empty, element has both <dt> and <dd> elements",
+			"fail": "When not empty, element does not have at least one <dt> element followed by at least one <dd> element"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/media/caption.js

@@ -0,0 +1,8 @@
+const tracks = axe.utils.querySelectorAll(virtualNode, 'track');
+const hasCaptions = tracks.some(
+	({ actualNode }) =>
+		(actualNode.getAttribute('kind') || '').toLowerCase() === 'captions'
+);
+
+// Undefined if there are no tracks - media may use another caption method
+return hasCaptions ? false : undefined;

data/node_modules/axe-core/lib/checks/media/caption.json

@@ -0,0 +1,11 @@
+{
+	"id": "caption",
+	"evaluate": "caption.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "The multimedia element has a captions track",
+			"incomplete": "Check that captions is available for the element"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/media/description.js

@@ -0,0 +1,8 @@
+const tracks = axe.utils.querySelectorAll(virtualNode, 'track');
+const hasDescriptions = tracks.some(
+	({ actualNode }) =>
+		(actualNode.getAttribute('kind') || '').toLowerCase() === 'descriptions'
+);
+
+// Undefined if there are no tracks - media may have another description method
+return hasDescriptions ? false : undefined;

data/node_modules/axe-core/lib/checks/media/description.json

@@ -0,0 +1,11 @@
+{
+	"id": "description",
+	"evaluate": "description.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "The multimedia element has an audio description track",
+			"incomplete": "Check that audio description is available for the element"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/media/frame-tested.js

@@ -0,0 +1,28 @@
+const resolve = this.async();
+const { isViolation, timeout } = Object.assign(
+	{ isViolation: false, timeout: 500 },
+	options
+);
+
+// give the frame .5s to respond to 'axe.ping', else log failed response
+let timer = setTimeout(function() {
+	// This double timeout is important for allowing iframes to respond
+	// DO NOT REMOVE
+	timer = setTimeout(function() {
+		timer = null;
+		resolve(isViolation ? false : undefined);
+	}, 0);
+}, timeout);
+
+axe.utils.respondable(
+	node.contentWindow,
+	'axe.ping',
+	null,
+	undefined,
+	function() {
+		if (timer !== null) {
+			clearTimeout(timer);
+			resolve(true);
+		}
+	}
+);

data/node_modules/axe-core/lib/checks/media/frame-tested.json

@@ -0,0 +1,15 @@
+{
+	"id": "frame-tested",
+	"evaluate": "frame-tested.js",
+	"options": {
+		"isViolation": false
+	},
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "The iframe was tested with axe-core",
+			"fail": "The iframe could not be tested with axe-core",
+			"incomplete": "The iframe still has to be tested with axe-core"
+		}
+	}
+}

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

@@ -0,0 +1,132 @@
+/* global context */
+
+// extract asset of type `cssom` from context
+const { cssom = undefined } = context || {};
+
+// if there is no cssom <- return incomplete
+if (!cssom || !cssom.length) {
+	return undefined;
+}
+
+// combine all rules from each sheet into one array
+const rulesGroupByDocumentFragment = cssom.reduce(
+	(out, { sheet, root, shadowId }) => {
+		// construct key based on shadowId or top level document
+		const key = shadowId ? shadowId : 'topDocument';
+		// init property if does not exist
+		if (!out[key]) {
+			out[key] = {
+				root,
+				rules: []
+			};
+		}
+		// check if sheet and rules exist
+		if (!sheet || !sheet.cssRules) {
+			//return
+			return out;
+		}
+		const rules = Array.from(sheet.cssRules);
+		// add rules into same document fragment
+		out[key].rules = out[key].rules.concat(rules);
+
+		//return
+		return out;
+	},
+	{}
+);
+
+// Note:
+// Some of these functions can be extracted to utils, but best to do it when other cssom rules are authored.
+
+// extract styles for each orientation rule to verify transform is applied
+let isLocked = false;
+let relatedElements = [];
+
+Object.keys(rulesGroupByDocumentFragment).forEach(key => {
+	const { root, rules } = rulesGroupByDocumentFragment[key];
+
+	// filter media rules from all rules
+	const mediaRules = rules.filter(r => {
+		// doc: https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule
+		// type value of 4 (CSSRule.MEDIA_RULE) pertains to media rules
+		return r.type === 4;
+	});
+	if (!mediaRules || !mediaRules.length) {
+		return;
+	}
+
+	// narrow down to media rules with `orientation` as a keyword
+	const orientationRules = mediaRules.filter(r => {
+		// conditionText exists on media rules, which contains only the @media condition
+		// eg: screen and (max-width: 767px) and (min-width: 320px) and (orientation: landscape)
+		const cssText = r.cssText;
+		return (
+			/orientation:\s+landscape/i.test(cssText) ||
+			/orientation:\s+portrait/i.test(cssText)
+		);
+	});
+	if (!orientationRules || !orientationRules.length) {
+		return;
+	}
+
+	orientationRules.forEach(r => {
+		// r.cssRules is a RULEList and not an array
+		if (!r.cssRules.length) {
+			return;
+		}
+		// cssRules ia a list of rules
+		// a media query has framents of css styles applied to various selectors
+		// iteration through cssRules and see if orientation lock has been applied
+		Array.from(r.cssRules).forEach(cssRule => {
+			/* eslint max-statements: ["error", 20], complexity: ["error", 15] */
+
+			// ensure selectorText exists
+			if (!cssRule.selectorText) {
+				return;
+			}
+			// ensure the given selector has styles declared (non empty selector)
+			if (cssRule.style.length <= 0) {
+				return;
+			}
+
+			// check if transform style exists
+			const transformStyleValue = cssRule.style.transform || false;
+			// transformStyleValue -> is the value applied to property
+			// eg: "rotate(-90deg)"
+			if (!transformStyleValue) {
+				return;
+			}
+
+			const rotate = transformStyleValue.match(/rotate\(([^)]+)deg\)/);
+			const deg = parseInt((rotate && rotate[1]) || 0);
+			const locked = deg % 90 === 0 && deg % 180 !== 0;
+
+			// if locked
+			// and not root HTML
+			// preserve as relatedNodes
+			if (locked && cssRule.selectorText.toUpperCase() !== 'HTML') {
+				const selector = cssRule.selectorText;
+				const elms = Array.from(root.querySelectorAll(selector));
+				if (elms && elms.length) {
+					relatedElements = relatedElements.concat(elms);
+				}
+			}
+
+			// set locked boolean
+			isLocked = locked;
+		});
+	});
+});
+
+if (!isLocked) {
+	// return
+	return true;
+}
+
+// set relatedNodes
+if (relatedElements.length) {
+	this.relatedNodes(relatedElements);
+}
+
+// return fail
+return false;