govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/checks/aria/errormessage.json

@@ -0,0 +1,11 @@
+{
+	"id": "aria-errormessage",
+	"evaluate": "errormessage.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "Uses a supported aria-errormessage technique",
+			"fail": "aria-errormessage value{{=it.data && it.data.length > 1 ? 's' : ''}} {{~it.data:value}} `{{=value}}{{~}}` must use a technique to announce the message (e.g., aria-live, aria-describedby, role=alert, etc.)"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/has-widget-role.js

@@ -0,0 +1,6 @@
+var role = node.getAttribute('role');
+if (role === null) {
+	return false;
+}
+var roleType = axe.commons.aria.getRoleType(role);
+return roleType === 'widget' || roleType === 'composite';

data/node_modules/axe-core/lib/checks/aria/has-widget-role.json

@@ -0,0 +1,12 @@
+{
+	"id": "has-widget-role",
+	"evaluate": "has-widget-role.js",
+	"options": [],
+	"metadata": {
+		"impact": "minor",
+		"messages": {
+			"pass": "Element has a widget role.",
+			"fail": "Element does not have a widget role."
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/implicit-role-fallback.js

@@ -0,0 +1,6 @@
+var role = node.getAttribute('role');
+if (role === null || !axe.commons.aria.isValidRole(role)) {
+	return true;
+}
+var roleType = axe.commons.aria.getRoleType(role);
+return axe.commons.aria.implicitRole(node) === roleType;

data/node_modules/axe-core/lib/checks/aria/implicit-role-fallback.json

@@ -0,0 +1,11 @@
+{
+	"id": "implicit-role-fallback",
+	"evaluate": "implicit-role-fallback.js",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "Element’s implicit ARIA role is an appropriate fallback",
+			"fail": "Element’s implicit ARIA role is not a good fallback for the (unsupported) role"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/invalidrole.js

@@ -0,0 +1,3 @@
+return !axe.commons.aria.isValidRole(node.getAttribute('role'), {
+	allowAbstract: true
+});

data/node_modules/axe-core/lib/checks/aria/invalidrole.json

@@ -0,0 +1,11 @@
+{
+	"id": "invalidrole",
+	"evaluate": "invalidrole.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "ARIA role is valid",
+			"fail": "Role must be one of the valid ARIA roles"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/required-attr.js

@@ -0,0 +1,28 @@
+options = options || {};
+
+var missing = [];
+
+if (node.hasAttributes()) {
+	var attr,
+		role = node.getAttribute('role'),
+		required = axe.commons.aria.requiredAttr(role);
+
+	if (Array.isArray(options[role])) {
+		required = axe.utils.uniqueArray(options[role], required);
+	}
+	if (role && required) {
+		for (var i = 0, l = required.length; i < l; i++) {
+			attr = required[i];
+			if (!node.getAttribute(attr)) {
+				missing.push(attr);
+			}
+		}
+	}
+}
+
+if (missing.length) {
+	this.data(missing);
+	return false;
+}
+
+return true;

data/node_modules/axe-core/lib/checks/aria/required-attr.json

@@ -0,0 +1,11 @@
+{
+	"id": "aria-required-attr",
+	"evaluate": "required-attr.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "All required ARIA attributes are present",
+			"fail": "Required ARIA attribute{{=it.data && it.data.length > 1 ? 's' : ''}} not present:{{~it.data:value}} {{=value}}{{~}}"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/required-children.js

@@ -0,0 +1,117 @@
+const requiredOwned = axe.commons.aria.requiredOwned;
+const implicitNodes = axe.commons.aria.implicitNodes;
+const matchesSelector = axe.utils.matchesSelector;
+const idrefs = axe.commons.dom.idrefs;
+const reviewEmpty =
+	options && Array.isArray(options.reviewEmpty) ? options.reviewEmpty : [];
+
+function owns(node, virtualTree, role, ariaOwned) {
+	if (node === null) {
+		return false;
+	}
+	var implicit = implicitNodes(role),
+		selector = ['[role="' + role + '"]'];
+
+	if (implicit) {
+		selector = selector.concat(implicit);
+	}
+
+	selector = selector.join(',');
+	return ariaOwned
+		? matchesSelector(node, selector) ||
+				!!axe.utils.querySelectorAll(virtualTree, selector)[0]
+		: !!axe.utils.querySelectorAll(virtualTree, selector)[0];
+}
+
+function ariaOwns(nodes, role) {
+	var index, length;
+
+	for (index = 0, length = nodes.length; index < length; index++) {
+		if (nodes[index] === null) {
+			continue;
+		}
+		let virtualTree = axe.utils.getNodeFromTree(axe._tree[0], nodes[index]);
+		if (owns(nodes[index], virtualTree, role, true)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function missingRequiredChildren(node, childRoles, all, role) {
+	/* eslint max-statements: ["error", 22], complexity: ["error", 17] */
+	var i,
+		l = childRoles.length,
+		missing = [],
+		ownedElements = idrefs(node, 'aria-owns');
+
+	for (i = 0; i < l; i++) {
+		var r = childRoles[i];
+		if (owns(node, virtualNode, r) || ariaOwns(ownedElements, r)) {
+			if (!all) {
+				return null;
+			}
+		} else {
+			if (all) {
+				missing.push(r);
+			}
+		}
+	}
+
+	// combobox exceptions
+	if (role === 'combobox') {
+		// remove 'textbox' from missing roles if combobox is a native text-type input
+		var textboxIndex = missing.indexOf('textbox');
+		var textTypeInputs = ['text', 'search', 'email', 'url', 'tel'];
+		if (
+			textboxIndex >= 0 &&
+			node.nodeName.toUpperCase() === 'INPUT' &&
+			textTypeInputs.includes(node.type)
+		) {
+			missing.splice(textboxIndex, 1);
+		}
+
+		// remove 'listbox' from missing roles if combobox is collapsed
+		var listboxIndex = missing.indexOf('listbox');
+		var expanded = node.getAttribute('aria-expanded');
+		if (listboxIndex >= 0 && (!expanded || expanded === 'false')) {
+			missing.splice(listboxIndex, 1);
+		}
+	}
+
+	if (missing.length) {
+		return missing;
+	}
+	if (!all && childRoles.length) {
+		return childRoles;
+	}
+	return null;
+}
+
+var role = node.getAttribute('role');
+var required = requiredOwned(role);
+
+if (!required) {
+	return true;
+}
+
+var all = false;
+var childRoles = required.one;
+if (!childRoles) {
+	var all = true;
+	childRoles = required.all;
+}
+
+var missing = missingRequiredChildren(node, childRoles, all, role);
+
+if (!missing) {
+	return true;
+}
+
+this.data(missing);
+
+if (reviewEmpty.includes(role)) {
+	return undefined;
+} else {
+	return false;
+}

data/node_modules/axe-core/lib/checks/aria/required-children.json

@@ -0,0 +1,15 @@
+{
+	"id": "aria-required-children",
+	"evaluate": "required-children.js",
+	"options": {
+		"reviewEmpty": ["listbox"]
+	},
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "Required ARIA children are present",
+			"fail": "Required ARIA {{=it.data && it.data.length > 1 ? 'children' : 'child'}} role not present:{{~it.data:value}} {{=value}}{{~}}",
+			"incomplete": "Expecting ARIA {{=it.data && it.data.length > 1 ? 'children' : 'child'}} role to be added:{{~it.data:value}} {{=value}}{{~}}"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/required-parent.js

@@ -0,0 +1,87 @@
+function getSelector(role) {
+	var impliedNative = axe.commons.aria.implicitNodes(role) || [];
+	return impliedNative.concat('[role="' + role + '"]').join(',');
+}
+
+function getMissingContext(virtualNode, requiredContext, includeElement) {
+	var index,
+		length,
+		role = virtualNode.actualNode.getAttribute('role'),
+		missing = [];
+
+	if (!requiredContext) {
+		requiredContext = axe.commons.aria.requiredContext(role);
+	}
+
+	if (!requiredContext) {
+		return null;
+	}
+
+	for (index = 0, length = requiredContext.length; index < length; index++) {
+		if (
+			includeElement &&
+			axe.utils.matchesSelector(
+				virtualNode.actualNode,
+				getSelector(requiredContext[index])
+			)
+		) {
+			return null;
+		}
+		if (
+			axe.commons.dom.findUpVirtual(
+				virtualNode,
+				getSelector(requiredContext[index])
+			)
+		) {
+			//if one matches, it passes
+			return null;
+		} else {
+			missing.push(requiredContext[index]);
+		}
+	}
+
+	return missing;
+}
+
+function getAriaOwners(element) {
+	var owners = [],
+		o = null;
+
+	while (element) {
+		if (element.getAttribute('id')) {
+			const id = axe.utils.escapeSelector(element.getAttribute('id'));
+			let doc = axe.commons.dom.getRootNode(element);
+			o = doc.querySelector(`[aria-owns~=${id}]`);
+			if (o) {
+				owners.push(o);
+			}
+		}
+		element = element.parentElement;
+	}
+
+	return owners.length ? owners : null;
+}
+
+var missingParents = getMissingContext(virtualNode);
+
+if (!missingParents) {
+	return true;
+}
+
+var owners = getAriaOwners(node);
+
+if (owners) {
+	for (var i = 0, l = owners.length; i < l; i++) {
+		missingParents = getMissingContext(
+			axe.utils.getNodeFromTree(axe._tree[0], owners[i]),
+			missingParents,
+			true
+		);
+		if (!missingParents) {
+			return true;
+		}
+	}
+}
+
+this.data(missingParents);
+return false;

data/node_modules/axe-core/lib/checks/aria/required-parent.json

@@ -0,0 +1,11 @@
+{
+	"id": "aria-required-parent",
+	"evaluate": "required-parent.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "Required ARIA parent role present",
+			"fail": "Required ARIA parent{{=it.data && it.data.length > 1 ? 's' : ''}} role not present:{{~it.data:value}} {{=value}}{{~}}"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/unsupportedattr.js

@@ -0,0 +1,39 @@
+const nodeName = node.nodeName.toUpperCase();
+const lookupTable = axe.commons.aria.lookupTable;
+const role = axe.commons.aria.getRole(node);
+
+const unsupportedAttrs = Array.from(node.attributes)
+	.filter(({ name }) => {
+		const attribute = lookupTable.attributes[name];
+
+		if (!axe.commons.aria.validateAttr(name)) {
+			return false;
+		}
+
+		const { unsupported } = attribute;
+
+		if (typeof unsupported !== 'object') {
+			return !!unsupported;
+		}
+
+		// validate attributes and conditions (if any) from allowedElement to given node
+		const isException = axe.commons.matches(node, unsupported.exceptions);
+
+		if (!Object.keys(lookupTable.evaluateRoleForElement).includes(nodeName)) {
+			return !isException;
+		}
+
+		// evaluate a given aria-role, execute the same
+		return !lookupTable.evaluateRoleForElement[nodeName]({
+			node,
+			role,
+			out: isException
+		});
+	})
+	.map(candidate => candidate.name.toString());
+
+if (unsupportedAttrs.length) {
+	this.data(unsupportedAttrs);
+	return true;
+}
+return false;

data/node_modules/axe-core/lib/checks/aria/unsupportedattr.json

@@ -0,0 +1,11 @@
+{
+	"id": "aria-unsupported-attr",
+	"evaluate": "unsupportedattr.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "ARIA attribute is supported",
+			"fail": "ARIA attribute is not widely supported in screen readers and assistive technologies: {{~it.data:value}} {{=value}}{{~}}"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/unsupportedrole.js

@@ -0,0 +1 @@
+return axe.commons.aria.isUnsupportedRole(axe.commons.aria.getRole(node));

data/node_modules/axe-core/lib/checks/aria/unsupportedrole.json

@@ -0,0 +1,11 @@
+{
+	"id": "unsupportedrole",
+	"evaluate": "unsupportedrole.js",
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "ARIA role is supported",
+			"fail": "The role used is not widely supported in screen readers and assistive technologies: {{~it.data:value}} {{=value}}{{~}}"
+		}
+	}
+}

data/node_modules/axe-core/lib/checks/aria/valid-attr-value.js

@@ -0,0 +1,32 @@
+options = Array.isArray(options) ? options : [];
+
+var invalid = [],
+	aria = /^aria-/;
+
+var attr,
+	attrName,
+	attrs = node.attributes;
+
+var skipAttrs = ['aria-errormessage'];
+
+for (var i = 0, l = attrs.length; i < l; i++) {
+	attr = attrs[i];
+	attrName = attr.name;
+	// skip any attributes handled elsewhere
+	if (!skipAttrs.includes(attrName)) {
+		if (
+			options.indexOf(attrName) === -1 &&
+			aria.test(attrName) &&
+			!axe.commons.aria.validateAttrValue(node, attrName)
+		) {
+			invalid.push(attrName + '="' + attr.nodeValue + '"');
+		}
+	}
+}
+
+if (invalid.length) {
+	this.data(invalid);
+	return false;
+}
+
+return true;