govuk_publishing_components 16.6.0 → 16.7.0

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

@@ -0,0 +1,8 @@
+/* exported text */
+/*eslint no-unused-vars: 0*/
+/**
+ * Namespace for text-related utilities.
+ * @namespace text
+ * @memberof axe.commons
+ */
+var text = (commons.text = { EdgeFormDefaults: {} });

data/node_modules/axe-core/lib/commons/text/is-human-interpretable.js

@@ -0,0 +1,51 @@
+/* global text */
+
+/**
+ * Determines if a given text is human friendly and interpretable
+ *
+ * @method isHumanInterpretable
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {String} str text to be validated
+ * @returns {Number} Between 0 and 1, (0 -> not interpretable, 1 -> interpretable)
+ */
+text.isHumanInterpretable = function(str) {
+	/**
+	 * Steps:
+	 * 1) Check for single character edge cases
+	 * 		a) handle if character is alphanumeric & within the given icon mapping
+	 * 					eg: x (close), i (info)
+	 *
+	 * 3) handle unicode from astral  (non bilingual multi plane) unicode, emoji & punctuations
+	 * 					eg: Windings font
+	 * 					eg: '💪'
+	 * 					eg: I saw a shooting 💫
+	 * 					eg: ? (help), > (next arrow), < (back arrow), need help ?
+	 */
+
+	if (!str.length) {
+		return 0;
+	}
+
+	// Step 1
+	const alphaNumericIconMap = [
+		'x', // close
+		'i' // info
+	];
+	// Step 1a
+	if (alphaNumericIconMap.includes(str)) {
+		return 0;
+	}
+
+	// Step 2
+	const noUnicodeStr = text.removeUnicode(str, {
+		emoji: true,
+		nonBmp: true,
+		punctuations: true
+	});
+	if (!text.sanitize(noUnicodeStr)) {
+		return 0;
+	}
+
+	return 1;
+};

data/node_modules/axe-core/lib/commons/text/is-valid-autocomplete.js

@@ -0,0 +1,118 @@
+/* global text */
+const autocomplete = {
+	stateTerms: ['on', 'off'],
+	standaloneTerms: [
+		'name',
+		'honorific-prefix',
+		'given-name',
+		'additional-name',
+		'family-name',
+		'honorific-suffix',
+		'nickname',
+		'username',
+		'new-password',
+		'current-password',
+		'organization-title',
+		'organization',
+		'street-address',
+		'address-line1',
+		'address-line2',
+		'address-line3',
+		'address-level4',
+		'address-level3',
+		'address-level2',
+		'address-level1',
+		'country',
+		'country-name',
+		'postal-code',
+		'cc-name',
+		'cc-given-name',
+		'cc-additional-name',
+		'cc-family-name',
+		'cc-number',
+		'cc-exp',
+		'cc-exp-month',
+		'cc-exp-year',
+		'cc-csc',
+		'cc-type',
+		'transaction-currency',
+		'transaction-amount',
+		'language',
+		'bday',
+		'bday-day',
+		'bday-month',
+		'bday-year',
+		'sex',
+		'url',
+		'photo'
+	],
+	qualifiers: ['home', 'work', 'mobile', 'fax', 'pager'],
+	qualifiedTerms: [
+		'tel',
+		'tel-country-code',
+		'tel-national',
+		'tel-area-code',
+		'tel-local',
+		'tel-local-prefix',
+		'tel-local-suffix',
+		'tel-extension',
+		'email',
+		'impp'
+	],
+	locations: ['billing', 'shipping']
+};
+text.autocomplete = autocomplete;
+
+text.isValidAutocomplete = function isValidAutocomplete(
+	autocomplete,
+	{
+		looseTyped = false,
+		stateTerms = [],
+		locations = [],
+		qualifiers = [],
+		standaloneTerms = [],
+		qualifiedTerms = []
+	} = {}
+) {
+	/*eslint max-statements: ["error", 23] */
+	autocomplete = autocomplete.toLowerCase().trim();
+	stateTerms = stateTerms.concat(text.autocomplete.stateTerms);
+	if (stateTerms.includes(autocomplete) || autocomplete === '') {
+		return true;
+	}
+
+	qualifiers = qualifiers.concat(text.autocomplete.qualifiers);
+	locations = locations.concat(text.autocomplete.locations);
+	standaloneTerms = standaloneTerms.concat(text.autocomplete.standaloneTerms);
+	qualifiedTerms = qualifiedTerms.concat(text.autocomplete.qualifiedTerms);
+
+	const autocompleteTerms = autocomplete.split(/\s+/g);
+	if (!looseTyped) {
+		if (
+			autocompleteTerms[0].length > 8 &&
+			autocompleteTerms[0].substr(0, 8) === 'section-'
+		) {
+			autocompleteTerms.shift();
+		}
+
+		if (locations.includes(autocompleteTerms[0])) {
+			autocompleteTerms.shift();
+		}
+
+		if (qualifiers.includes(autocompleteTerms[0])) {
+			autocompleteTerms.shift();
+			// only quantifiers allowed at this point
+			standaloneTerms = [];
+		}
+
+		if (autocompleteTerms.length !== 1) {
+			return false;
+		}
+	}
+
+	const purposeTerm = autocompleteTerms[autocompleteTerms.length - 1];
+	return (
+		standaloneTerms.includes(purposeTerm) ||
+		qualifiedTerms.includes(purposeTerm)
+	);
+};

data/node_modules/axe-core/lib/commons/text/label-text.js

@@ -0,0 +1,58 @@
+/* global dom, text */
+
+/**
+ * Return accessible text for an implicit and/or explicit HTML label element
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {Bool} inControlContext
+ * @property {Bool} inLabelledByContext
+ * @return {String} Label text
+ */
+text.labelText = function labelText(virtualNode, context = {}) {
+	const { alreadyProcessed } = text.accessibleTextVirtual
+	if (
+		context.inControlContext ||
+		context.inLabelledByContext ||
+		alreadyProcessed(virtualNode, context)
+	) {
+		return '';
+	}
+	if (!context.startNode) {
+		context.startNode = virtualNode;
+	}
+
+	const labelContext = { inControlContext: true, ...context };
+	const explicitLabels = getExplicitLabels(virtualNode);
+	const implicitLabel = dom.findUpVirtual(virtualNode, 'label');
+
+	let labels;
+	if (implicitLabel) {
+		labels = [...explicitLabels, implicitLabel];
+		labels.sort(axe.utils.nodeSorter);
+	} else {
+		labels = explicitLabels;
+	}
+
+	return labels
+		.map(label => text.accessibleText(label, labelContext))
+		.filter(text => text !== '')
+		.join(' ');
+};
+
+/**
+ * Find a non-ARIA label for an element
+ * @private
+ * @param {VirtualNode} element The VirtualNode instance whose label we are seeking
+ * @return {HTMLElement} The label element, or null if none is found
+ */
+function getExplicitLabels({ actualNode }) {
+	if (!actualNode.id) {
+		return [];
+	}
+	return dom.findElmsInContext({
+		elm: 'label',
+		attr: 'for',
+		value: actualNode.id,
+		context: actualNode
+	});
+}

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

@@ -0,0 +1,53 @@
+/* global text, dom, axe, aria */
+
+/**
+ * Gets the visible text of a label for a given input
+ * @see http://www.w3.org/WAI/PF/aria/roles#namecalculation
+ * @method labelVirtual
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {VirtualNode} node The virtual node mapping to the input to test
+ * @return {Mixed} String of visible text, or `null` if no label is found
+ */
+text.labelVirtual = function(node) {
+	var ref, candidate, doc;
+
+	candidate = aria.labelVirtual(node);
+	if (candidate) {
+		return candidate;
+	}
+
+	// explicit label
+	if (node.actualNode.id) {
+		const id = axe.utils.escapeSelector(node.actualNode.getAttribute('id'));
+		doc = axe.commons.dom.getRootNode(node.actualNode);
+		ref = doc.querySelector('label[for="' + id + '"]');
+		candidate = ref && text.visible(ref, true);
+		if (candidate) {
+			return candidate;
+		}
+	}
+
+	ref = dom.findUpVirtual(node, 'label');
+	candidate = ref && text.visible(ref, true);
+	if (candidate) {
+		return candidate;
+	}
+
+	return null;
+};
+
+/**
+ * Finds virtual node and calls labelVirtual()
+ * IMPORTANT: This method requires the composed tree at axe._tree
+ * @see axe.commons.text.virtualLabel
+ * @method label
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {Element} node The virtual node mapping to the input to test
+ * @return {Mixed} String of visible text, or `null` if no label is found
+ */
+text.label = function(node) {
+	node = axe.utils.getNodeFromTree(axe._tree[0], node);
+	return text.labelVirtual(node);
+};

data/node_modules/axe-core/lib/commons/text/native-element-types.js

@@ -0,0 +1,100 @@
+/* global text */
+text.nativeElementType = [
+	{
+		// 5.1 input type="text", input type="password", input type="search", input type="tel", input type="url" and textarea Element
+		matches: [
+			{
+				nodeName: 'textarea'
+			},
+			{
+				nodeName: 'input',
+				properties: {
+					type: ['text', 'password', 'search', 'tel', 'email', 'url']
+				}
+			}
+		],
+		namingMethods: 'labelText'
+	},
+	{
+		// 5.2 input type="button", input type="submit" and input type="reset"
+		matches: {
+			nodeName: 'input',
+			properties: {
+				type: ['button', 'submit', 'reset']
+			}
+		},
+		namingMethods: ['valueText', 'titleText', 'buttonDefaultText']
+	},
+	{
+		// 5.3 input type="image"
+		matches: {
+			nodeName: 'input',
+			properties: {
+				type: 'image'
+			}
+		},
+		namingMethods: [
+			'altText',
+			'valueText',
+			'labelText',
+			'titleText',
+			'buttonDefaultText'
+		]
+	},
+	{
+		// 5.4 button Element
+		matches: 'button',
+		namingMethods: 'subtreeText'
+	},
+	{
+		// 5.5 fieldset and legend Elements
+		matches: 'fieldset',
+		namingMethods: 'fieldsetLegendText'
+	},
+	{
+		// 5.6 output Element
+		matches: 'OUTPUT',
+		namingMethods: 'subtreeText'
+	},
+	{
+		// 5.7 Other Form Elements
+		matches: [
+			{
+				nodeName: 'select'
+			},
+			{
+				nodeName: 'input',
+				properties: {
+					// Regex: Everything other than these
+					type: /^(?!text|password|search|tel|email|url|button|submit|reset)/
+				}
+			}
+		],
+		namingMethods: 'labelText'
+	},
+	{
+		// 5.8 summary Element
+		matches: 'summary',
+		namingMethods: 'subtreeText'
+	},
+	{
+		// 5.9 figure and figcaption Elements
+		matches: 'figure',
+		namingMethods: ['figureText', 'titleText']
+	},
+	{
+		// 5.10 img Element
+		matches: 'img',
+		namingMethods: 'altText'
+	},
+	{
+		// 5.11 table Element
+		matches: 'table',
+		namingMethods: ['tableCaptionText', 'tableSummaryText']
+	},
+	{
+		matches: ['hr', 'br'],
+		namingMethods: ['titleText', 'singleSpace']
+	}
+	// All else defaults to just title
+];

data/node_modules/axe-core/lib/commons/text/native-text-alternative.js

@@ -0,0 +1,50 @@
+/* global text, aria */
+
+/**
+ * Get the accessible text using native HTML methods only
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {Bool} debug Enable logging for formControlValue
+ * @return {String} Accessible text
+ */
+text.nativeTextAlternative = function nativeTextAlternative(
+	virtualNode,
+	context = {}
+) {
+	const { actualNode } = virtualNode;
+	if (
+		actualNode.nodeType !== 1 ||
+		['presentation', 'none'].includes(aria.getRole(actualNode))
+	) {
+		return '';
+	}
+
+	const textMethods = findTextMethods(virtualNode);
+	// Find the first step that returns a non-empty string
+	let accName = textMethods.reduce((accName, step) => {
+		return accName || step(virtualNode, context);
+	}, '');
+
+	if (context.debug) {
+		axe.log(accName || '{empty-value}', actualNode, context);
+	}
+	return accName;
+};
+
+/**
+ * Get accessible text functions for a specific native HTML element
+ * @private
+ * @param {VirtualNode} element
+ * @return {Function[]} Array of native accessible name computation methods
+ */
+function findTextMethods(virtualNode) {
+	const { nativeElementType, nativeTextMethods } = text;
+	const nativeType = nativeElementType.find(({ matches }) => {
+		return axe.commons.matches(virtualNode, matches);
+	});
+
+	// Use concat because namingMethods can be a string or an array of strings
+	const methods = nativeType ? [].concat(nativeType.namingMethods) : [];
+
+	return methods.map(methodName => nativeTextMethods[methodName]);
+}

data/node_modules/axe-core/lib/commons/text/native-text-methods.js

@@ -0,0 +1,122 @@
+/* global text */
+
+const defaultButtonValues = {
+	submit: 'Submit',
+	image: 'Submit',
+	reset: 'Reset',
+	button: '' // No default for "button"
+};
+
+text.nativeTextMethods = {
+	/**
+	 * Return the value of a DOM node
+	 * @param {VirtualNode} element
+	 * @return {String} value text
+	 */
+	valueText: ({ actualNode }) => actualNode.value || '',
+
+	/**
+	 * Return default value of a button
+	 * @param {VirtualNode} element
+	 * @return {String} default button text
+	 */
+	buttonDefaultText: ({ actualNode }) =>
+		defaultButtonValues[actualNode.type] || '',
+
+	/**
+	 * Return caption text of an HTML table element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} caption text
+	 */
+	tableCaptionText: descendantText.bind(null, 'caption'),
+
+	/**
+	 * Return figcaption text of an HTML figure element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} figcaption text
+	 */
+	figureText: descendantText.bind(null, 'figcaption'),
+
+	/**
+	 * Return legend text of an HTML fieldset element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} legend text
+	 */
+	fieldsetLegendText: descendantText.bind(null, 'legend'),
+
+	/**
+	 * Return the alt text
+	 * @param {VirtualNode} element
+	 * @return {String} alt text
+	 */
+	altText: attrText.bind(null, 'alt'),
+
+	/**
+	 * Return summary text for an HTML table element
+	 * @param {VirtualNode} element
+	 * @return {String} summary text
+	 */
+	tableSummaryText: attrText.bind(null, 'summary'),
+
+	/**
+	 * Return the title text
+	 * @param {VirtualNode} element
+	 * @return {String} title text
+	 */
+	titleText: function titleText(virtualNode, context) {
+		return text.titleText(virtualNode, context);
+	},
+
+	/**
+	 * Return accessible text of the subtree
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} Subtree text
+	 */
+	subtreeText: function subtreeText(virtualNode, context) {
+		return text.subtreeText(virtualNode, context);
+	},
+
+	/**
+	 * Return accessible text for an implicit and/or explicit HTML label element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} Label text
+	 */
+	labelText: function labelText(virtualNode, context) {
+		return text.labelText(virtualNode, context);
+	},
+
+	/**
+	 * Return a single space
+	 * @return {String} Returns ` `
+	 */
+	singleSpace: function singleSpace() {
+		return ' '
+	}
+};
+
+function attrText(attr, { actualNode }) {
+	return actualNode.getAttribute(attr) || '';
+}
+
+/**
+ * Get the accessible text of first matching node
+ * IMPORTANT: This method does not look at the composed tree
+ * @private
+ */
+function descendantText(nodeName, { actualNode }, context) {
+	nodeName = nodeName.toLowerCase();
+	// Prevent accidently getting the nested element, like:
+	// fieldset > fielset > legend (1st fieldset has no legend)
+	const nodeNames = [nodeName, actualNode.nodeName.toLowerCase()].join(',');
+	const candidate = actualNode.querySelector(nodeNames);
+
+	if (!candidate || candidate.nodeName.toLowerCase() !== nodeName) {
+		return '';
+	}
+	return text.accessibleText(candidate, context);
+}