govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/core/utils/aggregate.js

@@ -0,0 +1,19 @@
+/**
+ * From a list of values, find the one with the greatest weight according to
+ * the supplied map
+ * @param  {object} params Contains 3 properties:
+ * - map: a map indicating the order of values to run in
+ *        example: ['small', 'medium', 'large']
+ * - values: Array of values to take the highest from
+ * - initial: optional starting value
+ */
+axe.utils.aggregate = function(map, values, initial) {
+	values = values.slice();
+	if (initial) {
+		values.push(initial);
+	}
+
+	var sorting = values.map(val => map.indexOf(val)).sort(); // Stupid NodeJS array.sort functor doesn't work!!
+
+	return map[sorting.pop()];
+};

data/node_modules/axe-core/lib/core/utils/aggregateChecks.js

@@ -0,0 +1,85 @@
+const { CANTTELL_PRIO, FAIL_PRIO } = axe.constants;
+let checkMap = [];
+checkMap[axe.constants.PASS_PRIO] = true;
+checkMap[axe.constants.CANTTELL_PRIO] = null;
+checkMap[axe.constants.FAIL_PRIO] = false;
+
+/**
+ * Map over the any / all / none properties
+ */
+let checkTypes = ['any', 'all', 'none'];
+function anyAllNone(obj, functor) {
+	return checkTypes.reduce(function(out, type) {
+		out[type] = (obj[type] || []).map(val => functor(val, type));
+		return out;
+	}, {});
+}
+
+axe.utils.aggregateChecks = function(nodeResOriginal) {
+	// Create a copy
+	let nodeResult = Object.assign({}, nodeResOriginal);
+
+	// map each result value to a priority
+	anyAllNone(nodeResult, function(check, type) {
+		let i =
+			typeof check.result === 'undefined' ? -1 : checkMap.indexOf(check.result);
+		// default to cantTell
+		check.priority = i !== -1 ? i : axe.constants.CANTTELL_PRIO;
+
+		if (type === 'none') {
+			// For none, swap pass and fail outcomes.
+			// none-type checks should pass when result is false rather than true.
+			if (check.priority === axe.constants.PASS_PRIO) {
+				check.priority = axe.constants.FAIL_PRIO;
+			} else if (check.priority === axe.constants.FAIL_PRIO) {
+				check.priority = axe.constants.PASS_PRIO;
+			}
+		}
+	});
+
+	// Find the result with the highest priority
+	const priorities = {
+		all: nodeResult.all.reduce((a, b) => Math.max(a, b.priority), 0),
+		none: nodeResult.none.reduce((a, b) => Math.max(a, b.priority), 0),
+		// get the lowest passing of 'any' defaulting
+		// to 0 by wrapping around 4 to 0 (inapplicable)
+		any: nodeResult.any.reduce((a, b) => Math.min(a, b.priority), 4) % 4
+	};
+
+	nodeResult.priority = Math.max(
+		priorities.all,
+		priorities.none,
+		priorities.any
+	);
+
+	// Of each type, filter out all results not matching the final priority
+	let impacts = [];
+	checkTypes.forEach(type => {
+		nodeResult[type] = nodeResult[type].filter(check => {
+			return (
+				check.priority === nodeResult.priority &&
+				check.priority === priorities[type]
+			);
+		});
+		nodeResult[type].forEach(check => impacts.push(check.impact));
+	});
+
+	// for failed nodes, define the impact
+	if ([CANTTELL_PRIO, FAIL_PRIO].includes(nodeResult.priority)) {
+		nodeResult.impact = axe.utils.aggregate(axe.constants.impact, impacts);
+	} else {
+		nodeResult.impact = null;
+	}
+
+	// Delete the old result and priority properties
+	anyAllNone(nodeResult, c => {
+		delete c.result;
+		delete c.priority;
+	});
+
+	// Convert the index to a result string value
+	nodeResult.result = axe.constants.results[nodeResult.priority];
+	delete nodeResult.priority;
+
+	return nodeResult;
+};

data/node_modules/axe-core/lib/core/utils/aggregateNodeResults.js

@@ -0,0 +1,61 @@
+(function() {
+	/**
+	 * Calculates the result of a Rule based on its types and the result of its child Checks
+	 * @param	{Array} nodeResults The array of nodes tested by the Rule
+	 */
+	axe.utils.aggregateNodeResults = function(nodeResults) {
+		let ruleResult = {};
+
+		// For each node, retrieve the result and impact
+		nodeResults = nodeResults.map(function(nodeResult) {
+			// Known result
+			if (nodeResult.any && nodeResult.all && nodeResult.none) {
+				return axe.utils.aggregateChecks(nodeResult);
+			} else if (Array.isArray(nodeResult.node)) {
+				return axe.utils.finalizeRuleResult(nodeResult);
+			} else {
+				throw new TypeError('Invalid Result type');
+			}
+		});
+
+		// Aggregate the result
+		// If there were no nodes passed in, mark the test as inapplicable
+		if (nodeResults && nodeResults.length) {
+			let resultList = nodeResults.map(node => node.result);
+			ruleResult.result = axe.utils.aggregate(
+				axe.constants.results,
+				resultList,
+				ruleResult.result
+			);
+		} else {
+			ruleResult.result = 'inapplicable';
+		}
+
+		// Create an array for each type
+		axe.constants.resultGroups.forEach(group => (ruleResult[group] = []));
+
+		// Fill the array with nodes
+		nodeResults.forEach(function(nodeResult) {
+			var groupName = axe.constants.resultGroupMap[nodeResult.result];
+			ruleResult[groupName].push(nodeResult);
+		});
+
+		// Take the highest impact of failed or canttell rules
+		var impactGroup = axe.constants.FAIL_GROUP;
+		if (ruleResult[impactGroup].length === 0) {
+			impactGroup = axe.constants.CANTTELL_GROUP;
+		}
+
+		if (ruleResult[impactGroup].length > 0) {
+			// Get the impact of all issues
+			let impactList = ruleResult[impactGroup].map(failure => failure.impact);
+
+			ruleResult.impact =
+				axe.utils.aggregate(axe.constants.impact, impactList) || null;
+		} else {
+			ruleResult.impact = null;
+		}
+
+		return ruleResult;
+	};
+})();

data/node_modules/axe-core/lib/core/utils/aggregateResult.js

@@ -0,0 +1,37 @@
+function copyToGroup(resultObject, subResult, group) {
+	var resultCopy = Object.assign({}, subResult);
+	resultCopy.nodes = (resultCopy[group] || []).concat();
+	axe.constants.resultGroups.forEach(group => {
+		delete resultCopy[group];
+	});
+	resultObject[group].push(resultCopy);
+}
+
+/**
+ * Calculates the result of a Rule based on its types and the result of its child Checks
+ * @param  {RuleResult} ruleResult The RuleResult to calculate the result of
+ */
+axe.utils.aggregateResult = function(results) {
+	let resultObject = {};
+
+	// Create an array for each type
+	axe.constants.resultGroups.forEach(
+		groupName => (resultObject[groupName] = [])
+	);
+
+	// Fill the array with nodes
+	results.forEach(function(subResult) {
+		if (subResult.error) {
+			copyToGroup(resultObject, subResult, axe.constants.CANTTELL_GROUP);
+		} else if (subResult.result === axe.constants.NA) {
+			copyToGroup(resultObject, subResult, axe.constants.NA_GROUP);
+		} else {
+			axe.constants.resultGroups.forEach(function(group) {
+				if (Array.isArray(subResult[group]) && subResult[group].length > 0) {
+					copyToGroup(resultObject, subResult, group);
+				}
+			});
+		}
+	});
+	return resultObject;
+};

data/node_modules/axe-core/lib/core/utils/are-styles-set.js

@@ -0,0 +1,24 @@
+/* global axe*/
+
+function areStylesSet(el, styles, stopAt) {
+	'use strict';
+	var styl = window.getComputedStyle(el, null);
+	var set = false;
+	if (!styl) {
+		return false;
+	}
+	styles.forEach(function(att) {
+		if (styl.getPropertyValue(att.property) === att.value) {
+			set = true;
+		}
+	});
+	if (set) {
+		return true;
+	}
+	if (el.nodeName.toUpperCase() === stopAt.toUpperCase() || !el.parentNode) {
+		return false;
+	}
+	return areStylesSet(el.parentNode, styles, stopAt);
+}
+
+axe.utils.areStylesSet = areStylesSet;

data/node_modules/axe-core/lib/core/utils/check-helper.js

@@ -0,0 +1,38 @@
+/**
+ * Helper to denote which checks are asyncronous and provide callbacks and pass data back to the CheckResult
+ * @param  {CheckResult}   checkResult The target object
+ * @param  {Function} callback    The callback to expose when `this.async()` is called
+ * @return {Object}               Bound to `this` for a check's fn
+ */
+axe.utils.checkHelper = function checkHelper(
+	checkResult,
+	options,
+	resolve,
+	reject
+) {
+	'use strict';
+
+	return {
+		isAsync: false,
+		async: function() {
+			this.isAsync = true;
+			return function(result) {
+				if (result instanceof Error === false) {
+					checkResult.result = result;
+					resolve(checkResult);
+				} else {
+					reject(result);
+				}
+			};
+		},
+		data: function(data) {
+			checkResult.data = data;
+		},
+		relatedNodes: function(nodes) {
+			nodes = nodes instanceof Node ? [nodes] : axe.utils.toArray(nodes);
+			checkResult.relatedNodes = nodes.map(function(element) {
+				return new axe.utils.DqElement(element, options);
+			});
+		}
+	};
+};

data/node_modules/axe-core/lib/core/utils/clone.js

@@ -0,0 +1,27 @@
+/**
+ * Deeply clones an object or array
+ * @param  {Mixed} obj The object/array to clone
+ * @return {Mixed}     A clone of the initial object or array
+ */
+axe.utils.clone = function(obj) {
+	/* eslint guard-for-in: 0*/
+	'use strict';
+	var index,
+		length,
+		out = obj;
+
+	if (obj !== null && typeof obj === 'object') {
+		if (Array.isArray(obj)) {
+			out = [];
+			for (index = 0, length = obj.length; index < length; index++) {
+				out[index] = axe.utils.clone(obj[index]);
+			}
+		} else {
+			out = {};
+			for (index in obj) {
+				out[index] = axe.utils.clone(obj[index]);
+			}
+		}
+	}
+	return out;
+};

data/node_modules/axe-core/lib/core/utils/collect-results-from-frames.js

@@ -0,0 +1,127 @@
+function err(message, node) {
+	'use strict';
+	var selector;
+	if (axe._tree) {
+		selector = axe.utils.getSelector(node);
+	}
+	return new Error(message + ': ' + (selector || node));
+}
+
+/**
+ * Sends a command to an instance of axe in the specified frame
+ * @param  {Element}  node       The frame element to send the message to
+ * @param  {Object}   parameters Parameters to pass to the frame
+ * @param  {Function} callback   Function to call when results from the frame has returned
+ */
+axe.utils.sendCommandToFrame = function(node, parameters, resolve, reject) {
+	'use strict';
+
+	var win = node.contentWindow;
+	if (!win) {
+		axe.log('Frame does not have a content window', node);
+		resolve(null);
+		return;
+	}
+
+	// give the frame .5s to respond to 'axe.ping', else log failed response
+	var timeout = setTimeout(function() {
+		// This double timeout is important for allowing iframes to respond
+		// DO NOT REMOVE
+		timeout = setTimeout(function() {
+			if (!parameters.debug) {
+				resolve(null);
+			} else {
+				reject(err('No response from frame', node));
+			}
+		}, 0);
+	}, 500);
+
+	// send 'axe.ping' to the frame
+	axe.utils.respondable(win, 'axe.ping', null, undefined, function() {
+		clearTimeout(timeout);
+
+		// Give aXe 60s (or user-supplied value) to respond to 'axe.start'
+		var frameWaitTime =
+			(parameters.options && parameters.options.frameWaitTime) || 60000;
+
+		timeout = setTimeout(function() {
+			reject(err('Axe in frame timed out', node));
+		}, frameWaitTime);
+
+		// send 'axe.start' and send the callback if it responded
+		axe.utils.respondable(win, 'axe.start', parameters, undefined, function(
+			data
+		) {
+			clearTimeout(timeout);
+			if (data instanceof Error === false) {
+				resolve(data);
+			} else {
+				reject(data);
+			}
+		});
+	});
+};
+
+/**
+ * Sends a message to axe running in frames to start analysis and collate results (via `mergeResults`)
+ * @private
+ * @param  {Context}  context   The resolved Context object
+ * @param  {Object}   options   Options object (as passed to `runRules`)
+ * @param  {string}   command   Command sent to all frames
+ * @param  {Array}    parameter Array of values to be passed along side the command
+ * @param  {Function} callback  Function to call when results from all frames have returned
+ */
+function collectResultsFromFrames(
+	context,
+	options,
+	command,
+	parameter,
+	resolve,
+	reject
+) {
+	'use strict';
+
+	var q = axe.utils.queue();
+	var frames = context.frames;
+
+	// Tell each axe running in each frame to collect results
+	frames.forEach(function(frame) {
+		var params = {
+			options: options,
+			command: command,
+			parameter: parameter,
+			context: {
+				initiator: false,
+				page: context.page,
+				include: frame.include || [],
+				exclude: frame.exclude || []
+			}
+		};
+
+		q.defer(function(res, rej) {
+			var node = frame.node;
+			axe.utils.sendCommandToFrame(
+				node,
+				params,
+				function(data) {
+					if (data) {
+						return res({
+							results: data,
+							frameElement: node,
+							frame: axe.utils.getSelector(node)
+						});
+					}
+					res(null);
+				},
+				rej
+			);
+		});
+	});
+
+	// Combine results from all frames and give it back
+	q.then(function(data) {
+		resolve(axe.utils.mergeResults(data, options));
+	}).catch(reject);
+}
+
+axe.utils.collectResultsFromFrames = collectResultsFromFrames;

data/node_modules/axe-core/lib/core/utils/contains.js

@@ -0,0 +1,30 @@
+/**
+ * Wrapper for Node#contains; PhantomJS does not support Node#contains and erroneously reports that it does
+ * @method contains
+ * @memberof axe.utils
+ * @param  {HTMLElement} node      The candidate container node
+ * @param  {HTMLElement} otherNode The node to test is contained by `node`
+ * @return {Boolean}           Whether `node` contains `otherNode`
+ */
+axe.utils.contains = function(node, otherNode) {
+	/*eslint no-bitwise: 0*/
+	'use strict';
+	function containsShadowChild(node, otherNode) {
+		if (node.shadowId === otherNode.shadowId) {
+			return true;
+		}
+		return !!node.children.find(child => {
+			return containsShadowChild(child, otherNode);
+		});
+	}
+
+	if (node.shadowId || otherNode.shadowId) {
+		return containsShadowChild(node, otherNode);
+	}
+
+	if (typeof node.actualNode.contains === 'function') {
+		return node.actualNode.contains(otherNode.actualNode);
+	}
+
+	return !!(node.actualNode.compareDocumentPosition(otherNode.actualNode) & 16);
+};