govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/commons/aria/is-accessible-ref.js

@@ -0,0 +1,55 @@
+/* global aria, axe, dom */
+function findDomNode(node, functor) {
+	if (functor(node)) {
+		return node;
+	}
+	for (let i = 0; i < node.children.length; i++) {
+		const out = findDomNode(node.children[i], functor);
+		if (out) {
+			return out;
+		}
+	}
+}
+
+/**
+ * Check that a DOM node is a reference in the accessibility tree
+ * @param {Element} node
+ * @returns {Boolean}
+ */
+aria.isAccessibleRef = function isAccessibleRef(node) {
+	node = node.actualNode || node;
+	let root = dom.getRootNode(node);
+	root = root.documentElement || root; // account for shadow roots
+	const id = node.id;
+
+	// Get all idref(s) attributes on the lookup table
+	const refAttrs = Object.keys(aria.lookupTable.attributes).filter(attr => {
+		const { type } = aria.lookupTable.attributes[attr];
+		return /^idrefs?$/.test(type);
+	});
+
+	// Find the first element that IDREF(S) the node
+	let refElm = findDomNode(root, elm => {
+		if (elm.nodeType !== 1) {
+			// Elements only
+			return;
+		}
+		if (
+			elm.nodeName.toUpperCase() === 'LABEL' &&
+			elm.getAttribute('for') === id
+		) {
+			return true;
+		}
+		// See if there are any aria attributes that reference the node
+		return refAttrs
+			.filter(attr => elm.hasAttribute(attr))
+			.some(attr => {
+				const attrValue = elm.getAttribute(attr);
+				if (aria.lookupTable.attributes[attr].type === 'idref') {
+					return attrValue === id;
+				}
+				return axe.utils.tokenList(attrValue).includes(id);
+			});
+	});
+	return typeof refElm !== 'undefined';
+};

data/node_modules/axe-core/lib/commons/aria/is-aria-role-allowed-on-element.js

@@ -0,0 +1,41 @@
+/* global aria, matches */
+/**
+ * @description validate if a given role is an allowed ARIA role for the supplied node
+ * @method isAriaRoleAllowedOnElement
+ * @param {HTMLElement} node the node to verify
+ * @param {String} role aria role to check
+ * @return {Boolean} retruns true/false
+ */
+aria.isAriaRoleAllowedOnElement = function isAriaRoleAllowedOnElement(
+	node,
+	role
+) {
+	const nodeName = node.nodeName.toUpperCase();
+	const lookupTable = axe.commons.aria.lookupTable;
+
+	// if given node can have no role - return false
+	if (matches(node, lookupTable.elementsAllowedNoRole)) {
+		return false;
+	}
+	// if given node allows any role - return true
+	if (matches(node, lookupTable.elementsAllowedAnyRole)) {
+		return true;
+	}
+
+	// get role value (if exists) from lookupTable.role
+	const roleValue = lookupTable.role[role];
+
+	// if given role does not exist in lookupTable - return false
+	if (!roleValue || !roleValue.allowedElements) {
+		return false;
+	}
+
+	// validate attributes and conditions (if any) from allowedElement to given node
+	let out = matches(node, roleValue.allowedElements);
+
+	// if given node type has complex condition to evaluate a given aria-role, execute the same
+	if (Object.keys(lookupTable.evaluateRoleForElement).includes(nodeName)) {
+		return lookupTable.evaluateRoleForElement[nodeName]({ node, role, out });
+	}
+	return out;
+};

data/node_modules/axe-core/lib/commons/aria/is-unsupported-role.js

@@ -0,0 +1,14 @@
+/* global aria */
+
+/**
+ * Check if a given role is unsupported
+ * @method isUnsupportedRole
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} role The role to check
+ * @return {Boolean}
+ */
+aria.isUnsupportedRole = function(role) {
+	const roleDefinition = aria.lookupTable.role[role];
+	return roleDefinition ? roleDefinition.unsupported : false;
+};

data/node_modules/axe-core/lib/commons/aria/label-virtual.js

@@ -0,0 +1,54 @@
+/* global axe, aria, dom, text */
+
+/**
+ * Gets the accessible ARIA label text of a given element
+ * @see http://www.w3.org/WAI/PF/aria/roles#namecalculation
+ * @method labelVirtual
+ * @memberof axe.commons.aria
+ * @instance
+ * @param  {Object} actualNode The virtualNode to test
+ * @return {Mixed}  String of visible text, or `null` if no label is found
+ */
+aria.labelVirtual = function({ actualNode }) {
+	let ref, candidate;
+
+	if (actualNode.getAttribute('aria-labelledby')) {
+		// aria-labelledby
+		ref = dom.idrefs(actualNode, 'aria-labelledby');
+		candidate = ref
+			.map(function(thing) {
+				const vNode = axe.utils.getNodeFromTree(axe._tree[0], thing);
+				return vNode ? text.visibleVirtual(vNode, true) : '';
+			})
+			.join(' ')
+			.trim();
+
+		if (candidate) {
+			return candidate;
+		}
+	}
+
+	// aria-label
+	candidate = actualNode.getAttribute('aria-label');
+	if (candidate) {
+		candidate = text.sanitize(candidate).trim();
+		if (candidate) {
+			return candidate;
+		}
+	}
+
+	return null;
+};
+
+/**
+ * Gets the aria label for a given node
+ * @method label
+ * @memberof axe.commons.aria
+ * @instance
+ * @param  {HTMLElement} node The element to check
+ * @return {Mixed} String of visible text, or `null` if no label is found
+ */
+aria.label = function(node) {
+	node = axe.utils.getNodeFromTree(axe._tree[0], node);
+	return aria.labelVirtual(node);
+};

data/node_modules/axe-core/lib/commons/aria/named-from-contents.js

@@ -0,0 +1,39 @@
+/* global aria */
+
+/**
+ * Check if an element is named from contents
+ *
+ * @param {Node|VirtualNode} element
+ * @param {Object} options
+ * @property {Bool} strict Whether or not to follow the spects strictly
+ * @return {Bool}
+ */
+aria.namedFromContents = function namedFromContents(node, { strict } = {}) {
+	node = node.actualNode || node;
+	if (node.nodeType !== 1) {
+		return false;
+	}
+
+	const role = aria.getRole(node);
+	const roleDef = aria.lookupTable.role[role];
+
+	if (
+		(roleDef && roleDef.nameFrom.includes('contents')) ||
+		// TODO: This is a workaround for axe-core's over-assertive implicitRole computation
+		// once we fix that, this extra noImplicit check can be removed.
+		node.nodeName.toUpperCase() === 'TABLE'
+	) {
+		return true;
+	}
+
+	/**
+	 * Note: Strictly speaking if the role is null, presentation, or none, the element
+	 * isn't named from contents. Axe-core often needs to know if an element
+	 * has content anyway, so we're allowing it here.
+	 * Use { strict: true } to disable this behavior.
+	 */
+	if (strict) {
+		return false;
+	}
+	return !roleDef || ['presentation', 'none'].includes(role);
+};

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

@@ -0,0 +1,208 @@
+/* global aria, axe */
+
+/**
+ * Check if a given role is valid
+ * @method isValidRole
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} role The role to check
+ * @param {Object} options Use `allowAbstract` if you want abstracts, and `flagUnsupported: true` to report unsupported roles
+ * @return {Boolean}
+ */
+aria.isValidRole = function(
+	role,
+	{ allowAbstract, flagUnsupported = false } = {}
+) {
+	const roleDefinition = aria.lookupTable.role[role];
+	const isRoleUnsupported = roleDefinition ? roleDefinition.unsupported : false;
+	if (!roleDefinition || (flagUnsupported && isRoleUnsupported)) {
+		return false;
+	}
+	return allowAbstract ? true : roleDefinition.type !== 'abstract';
+};
+
+/**
+ * Get the roles that get name from the element's contents
+ * @method getRolesWithNameFromContents
+ * @memberof axe.commons.aria
+ * @instance
+ * @return {Array} Array of roles that match the type
+ */
+aria.getRolesWithNameFromContents = function() {
+	return Object.keys(aria.lookupTable.role).filter(function(r) {
+		return (
+			aria.lookupTable.role[r].nameFrom &&
+			aria.lookupTable.role[r].nameFrom.indexOf('contents') !== -1
+		);
+	});
+};
+
+/**
+ * Get the roles that have a certain "type"
+ * @method getRolesByType
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} roleType The roletype to check
+ * @return {Array} Array of roles that match the type
+ */
+aria.getRolesByType = function(roleType) {
+	return Object.keys(aria.lookupTable.role).filter(function(r) {
+		return aria.lookupTable.role[r].type === roleType;
+	});
+};
+
+/**
+ * Get the "type" of role; either widget, composite, abstract, landmark or `null`
+ * @method getRoleType
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} role The role to check
+ * @return {Mixed} String if a matching role and its type are found, otherwise `null`
+ */
+aria.getRoleType = function(role) {
+	var r = aria.lookupTable.role[role];
+	return (r && r.type) || null;
+};
+
+/**
+ * Get the required owned (children) roles for a given role
+ * @method requiredOwned
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} role The role to check
+ * @return {Mixed} Either an Array of required owned elements or `null` if there are none
+ */
+aria.requiredOwned = function(role) {
+	'use strict';
+	var owned = null,
+		roles = aria.lookupTable.role[role];
+
+	if (roles) {
+		owned = axe.utils.clone(roles.owned);
+	}
+	return owned;
+};
+
+/**
+ * Get the required context (parent) roles for a given role
+ * @method requiredContext
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} role The role to check
+ * @return {Mixed} Either an Array of required context elements or `null` if there are none
+ */
+aria.requiredContext = function(role) {
+	'use strict';
+	var context = null,
+		roles = aria.lookupTable.role[role];
+
+	if (roles) {
+		context = axe.utils.clone(roles.context);
+	}
+	return context;
+};
+
+/**
+ * Get a list of CSS selectors of nodes that have an implicit role
+ * @method implicitNodes
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {String} role The role to check
+ * @return {Mixed} Either an Array of CSS selectors or `null` if there are none
+ */
+aria.implicitNodes = function(role) {
+	'use strict';
+
+	var implicit = null,
+		roles = aria.lookupTable.role[role];
+
+	if (roles && roles.implicit) {
+		implicit = axe.utils.clone(roles.implicit);
+	}
+	return implicit;
+};
+
+/**
+ * Get the implicit role for a given node
+ * @method implicitRole
+ * @memberof axe.commons.aria
+ * @instance
+ * @param {HTMLElement} node The node to test
+ * @return {Mixed} Either the role or `null` if there is none
+ */
+aria.implicitRole = function(node) {
+	'use strict';
+
+	/*
+	 * Filter function to reduce a list of roles to a valid list of roles for a nodetype
+	 */
+	var isValidImplicitRole = function(set, role) {
+		var validForNodeType = function(implicitNodeTypeSelector) {
+			return axe.utils.matchesSelector(node, implicitNodeTypeSelector);
+		};
+
+		if (role.implicit && role.implicit.some(validForNodeType)) {
+			set.push(role.name);
+		}
+
+		return set;
+	};
+
+	/*
+	 * Score a set of roles and aria-attributes by its optimal score
+	 * E.g. [{score: 2, name: button}, {score: 1, name: main}]
+	 */
+	var sortRolesByOptimalAriaContext = function(roles, ariaAttributes) {
+		var getScore = function(role) {
+			var allowedAriaAttributes = aria.allowedAttr(role);
+			return allowedAriaAttributes.reduce(function(score, attribute) {
+				return score + (ariaAttributes.indexOf(attribute) > -1 ? 1 : 0);
+			}, 0);
+		};
+
+		var scored = roles.map(function(role) {
+			return { score: getScore(role), name: role };
+		});
+
+		var sorted = scored.sort(function(scoredRoleA, scoredRoleB) {
+			return scoredRoleB.score - scoredRoleA.score;
+		});
+
+		return sorted.map(function(sortedRole) {
+			return sortedRole.name;
+		});
+	};
+
+	/*
+	 * Create a list of { name / implicit } role mappings to filter on
+	 */
+	var roles = Object.keys(aria.lookupTable.role).map(function(role) {
+		var lookup = aria.lookupTable.role[role];
+		return { name: role, implicit: lookup && lookup.implicit };
+	});
+
+	/* Build a list of valid implicit roles for this node */
+	var availableImplicitRoles = roles.reduce(isValidImplicitRole, []);
+
+	if (!availableImplicitRoles.length) {
+		return null;
+	}
+
+	var nodeAttributes = node.attributes;
+	var ariaAttributes = [];
+
+	/* Get all aria-attributes defined for this node */
+	/* Should be a helper function somewhere */
+	for (var i = 0, j = nodeAttributes.length; i < j; i++) {
+		var attr = nodeAttributes[i];
+		if (attr.name.match(/^aria-/)) {
+			ariaAttributes.push(attr.name);
+		}
+	}
+
+	/* Sort roles by highest score, return the first */
+	return sortRolesByOptimalAriaContext(
+		availableImplicitRoles,
+		ariaAttributes
+	).shift();
+};

data/node_modules/axe-core/lib/commons/aria/validate-attr-value.js

@@ -0,0 +1,63 @@
+/* global aria, dom */
+
+/**
+ * Validate the value of an ARIA attribute
+ * @method validateAttrValue
+ * @memberof axe.commons.aria
+ * @instance
+ * @param  {HTMLElement} node The element to check
+ * @param  {String} attr The name of the attribute
+ * @return {Boolean}
+ */
+aria.validateAttrValue = function validateAttrValue(node, attr) {
+	/*eslint complexity: ["error",17]*/
+	'use strict';
+	var matches,
+		list,
+		value = node.getAttribute(attr),
+		attrInfo = aria.lookupTable.attributes[attr];
+
+	var doc = dom.getRootNode(node);
+
+	if (!attrInfo) {
+		return true;
+	}
+	if (attrInfo.allowEmpty && (!value || value.trim() === '')) {
+		return true;
+	}
+
+	switch (attrInfo.type) {
+		case 'boolean':
+		case 'nmtoken':
+			return (
+				typeof value === 'string' &&
+				attrInfo.values.includes(value.toLowerCase())
+			);
+
+		case 'nmtokens':
+			list = axe.utils.tokenList(value);
+			// Check if any value isn't in the list of values
+			return list.reduce(function(result, token) {
+				return result && attrInfo.values.includes(token);
+				// Initial state, fail if the list is empty
+			}, list.length !== 0);
+
+		case 'idref':
+			return !!(value && doc.getElementById(value));
+
+		case 'idrefs':
+			list = axe.utils.tokenList(value);
+			return list.some(token => doc.getElementById(token));
+
+		case 'string':
+			// Not allowed empty except with allowEmpty: true
+			return value.trim() !== '';
+
+		case 'decimal':
+			matches = value.match(/^[-+]?([0-9]*)\.?([0-9]*)$/);
+			return !!(matches && (matches[1] || matches[2]));
+
+		case 'int':
+			return /^[-+]?[0-9]+$/.test(value);
+	}
+};