govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/core/public/run.js

@@ -0,0 +1,148 @@
+/*eslint indent: 0, complexity:["error", 12]*/
+function isContext(potential) {
+	'use strict';
+	switch (true) {
+		case typeof potential === 'string':
+		case Array.isArray(potential):
+		case Node && potential instanceof Node:
+		case NodeList && potential instanceof NodeList:
+			return true;
+
+		case typeof potential !== 'object':
+			return false;
+
+		case potential.include !== undefined:
+		case potential.exclude !== undefined:
+		case typeof potential.length === 'number':
+			return true;
+
+		default:
+			return false;
+	}
+}
+
+var noop = function() {};
+
+/**
+ * Normalize the optional params of axe.run()
+ * @param  {object}   context
+ * @param  {object}   options
+ * @param  {Function} callback
+ * @return {object}            With 3 keys: context, options, callback
+ */
+function normalizeRunParams(context, options, callback) {
+	'use strict';
+	let typeErr = new TypeError('axe.run arguments are invalid');
+
+	// Determine the context
+	if (!isContext(context)) {
+		if (callback !== undefined) {
+			// Either context is invalid or there are too many params
+			throw typeErr;
+		}
+		// Set default and shift one over
+		callback = options;
+		options = context;
+		context = document;
+	}
+
+	// Determine the options
+	if (typeof options !== 'object') {
+		if (callback !== undefined) {
+			// Either options is invalid or there are too many params
+			throw typeErr;
+		}
+		// Set default and shift one over
+		callback = options;
+		options = {};
+	}
+
+	// Set the callback or noop;
+	if (typeof callback !== 'function' && callback !== undefined) {
+		throw typeErr;
+	}
+
+	return {
+		context: context,
+		options: options,
+		callback: callback || noop
+	};
+}
+
+/**
+ * Runs a number of rules against the provided HTML page and returns the
+ * resulting issue list
+ *
+ * @param  {Object}   context  (optional) Defines the scope of the analysis
+ * @param  {Object}   options  (optional) Set of options passed into rules or checks
+ * @param  {Function} callback (optional) The callback when axe is done, given 2 params:
+ *                             - Error    If any errors occured, otherwise null
+ *                             - Results  The results object / array, or undefined on error
+ * @return {Promise}           Resolves with the axe results. Only available when natively supported
+ */
+axe.run = function(context, options, callback) {
+	/*eslint max-statements:["error",18] */
+	'use strict';
+	if (!axe._audit) {
+		throw new Error('No audit configured');
+	}
+
+	let args = normalizeRunParams(context, options, callback);
+	context = args.context;
+	options = args.options;
+	callback = args.callback;
+
+	// set defaults:
+	options.reporter = options.reporter || axe._audit.reporter || 'v1';
+
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.start();
+	}
+	let p;
+	let reject = noop;
+	let resolve = noop;
+
+	if (typeof Promise === 'function' && callback === noop) {
+		p = new Promise(function(_resolve, _reject) {
+			reject = _reject;
+			resolve = _resolve;
+		});
+	}
+
+	axe._runRules(
+		context,
+		options,
+		function(rawResults, cleanup) {
+			let respond = function(results) {
+				cleanup();
+				try {
+					callback(null, results);
+				} catch (e) {
+					axe.log(e);
+				}
+				resolve(results);
+			};
+			if (options.performanceTimer) {
+				axe.utils.performanceTimer.end();
+			}
+
+			try {
+				let reporter = axe.getReporter(options.reporter);
+				let results = reporter(rawResults, options, respond);
+				if (results !== undefined) {
+					respond(results);
+				}
+			} catch (err) {
+				cleanup();
+				callback(err);
+				reject(err);
+			}
+		},
+		function(err) {
+			callback(err);
+			reject(err);
+		}
+	);
+
+	return p;
+};

data/node_modules/axe-core/lib/core/reporters/helpers/failure-summary.js

@@ -0,0 +1,35 @@
+/*global helpers */
+
+/**
+ * Finds failing Checks and combines each help message into an array
+ * @param  {Object} nodeData Individual "detail" object to generate help messages for
+ * @return {String}          failure messages
+ */
+helpers.failureSummary = function failureSummary(nodeData) {
+	'use strict';
+
+	var failingChecks = {};
+	// combine "all" and "none" as messaging is the same
+	failingChecks.none = nodeData.none.concat(nodeData.all);
+	failingChecks.any = nodeData.any;
+
+	return Object.keys(failingChecks)
+		.map(function(key) {
+			if (!failingChecks[key].length) {
+				return;
+			}
+
+			var sum = axe._audit.data.failureSummaries[key];
+			if (sum && typeof sum.failureMessage === 'function') {
+				return sum.failureMessage(
+					failingChecks[key].map(function(check) {
+						return check.message || '';
+					})
+				);
+			}
+		})
+		.filter(function(i) {
+			return i !== undefined;
+		})
+		.join('\n\n');
+};

data/node_modules/axe-core/lib/core/reporters/helpers/get-environment-data.js

@@ -0,0 +1,39 @@
+/*global helpers */
+
+/**
+ * Add information about the environment axe was run in.
+ * @return {Object}
+ */
+helpers.getEnvironmentData = function getEnvironmentData(win = window) {
+	// TODO: remove parameter once we are testing axe-core in jsdom and other
+	// supported environments
+	const {
+		screen = {},
+		navigator = {},
+		location = {},
+		innerHeight,
+		innerWidth
+	} = win;
+
+	const orientation =
+		screen.msOrientation || screen.orientation || screen.mozOrientation || {};
+
+	return {
+		testEngine: {
+			name: 'axe-core',
+			version: axe.version
+		},
+		testRunner: {
+			name: axe._audit.brand
+		},
+		testEnvironment: {
+			userAgent: navigator.userAgent,
+			windowWidth: innerWidth,
+			windowHeight: innerHeight,
+			orientationAngle: orientation.angle,
+			orientationType: orientation.type
+		},
+		timestamp: new Date().toISOString(),
+		url: location.href
+	};
+};

data/node_modules/axe-core/lib/core/reporters/helpers/incomplete-fallback-msg.js

@@ -0,0 +1,11 @@
+/*global helpers */
+
+/**
+ * Provides a fallback message in case incomplete checks don't provide one
+ * This mechanism allows the string to be localized.
+ * @return {String}
+ */
+helpers.incompleteFallbackMessage = function incompleteFallbackMessage() {
+	'use strict';
+	return axe._audit.data.incompleteFallbackMessage();
+};

data/node_modules/axe-core/lib/core/reporters/helpers/index.js

@@ -0,0 +1,3 @@
+/*eslint no-unused-vars: 0*/
+/*exported helpers */
+var helpers = {};

data/node_modules/axe-core/lib/core/reporters/helpers/process-aggregate.js

@@ -0,0 +1,102 @@
+/*global helpers */
+function normalizeRelatedNodes(node, options) {
+	'use strict';
+	['any', 'all', 'none'].forEach(type => {
+		if (!Array.isArray(node[type])) {
+			return;
+		}
+		node[type]
+			.filter(checkRes => Array.isArray(checkRes.relatedNodes))
+			.forEach(checkRes => {
+				checkRes.relatedNodes = checkRes.relatedNodes.map(relatedNode => {
+					var res = {
+						html: relatedNode.source
+					};
+					if (options.elementRef && !relatedNode.fromFrame) {
+						res.element = relatedNode.element;
+					}
+					if (options.selectors !== false || relatedNode.fromFrame) {
+						res.target = relatedNode.selector;
+					}
+					if (options.xpath) {
+						res.xpath = relatedNode.xpath;
+					}
+					return res;
+				});
+			});
+	});
+}
+
+var resultKeys = axe.constants.resultGroups;
+
+/**
+ * Configures the processing of axe results.
+ *
+ * @typedef ProcessOptions
+ * @property {Array} resultsTypes limit the types of results to process ('passes', 'violations', etc.)
+ * @property {Boolean} elementRef display node's element references
+ * @property {Boolean} selectors display node's selectors
+ * @property {Boolean} xpath display node's xpaths
+ */
+
+/**
+ * Aggregrate and process the aXe results,
+ * adding desired data to nodes and relatedNodes in each rule result.
+ *
+ * Prepares result data for reporters.
+ *
+ * @method processAggregate
+ * @memberof helpers
+ * @param	{Array} results
+ * @param	{ProcessOptions} options
+ * @return {Object}
+ *
+ */
+helpers.processAggregate = function(results, options) {
+	var resultObject = axe.utils.aggregateResult(results);
+
+	resultKeys.forEach(function(key) {
+		if (options.resultTypes && !options.resultTypes.includes(key)) {
+			// If the user asks us to, truncate certain finding types to maximum one finding
+			(resultObject[key] || []).forEach(function(ruleResult) {
+				if (Array.isArray(ruleResult.nodes) && ruleResult.nodes.length > 0) {
+					ruleResult.nodes = [ruleResult.nodes[0]];
+				}
+			});
+		}
+		resultObject[key] = (resultObject[key] || []).map(function(ruleResult) {
+			ruleResult = Object.assign({}, ruleResult);
+
+			if (Array.isArray(ruleResult.nodes) && ruleResult.nodes.length > 0) {
+				ruleResult.nodes = ruleResult.nodes.map(function(subResult) {
+					if (typeof subResult.node === 'object') {
+						subResult.html = subResult.node.source;
+						if (options.elementRef && !subResult.node.fromFrame) {
+							subResult.element = subResult.node.element;
+						}
+						if (options.selectors !== false || subResult.node.fromFrame) {
+							subResult.target = subResult.node.selector;
+						}
+						if (options.xpath) {
+							subResult.xpath = subResult.node.xpath;
+						}
+					}
+					delete subResult.result;
+					delete subResult.node;
+
+					normalizeRelatedNodes(subResult, options);
+
+					return subResult;
+				});
+			}
+
+			resultKeys.forEach(key => delete ruleResult[key]);
+			delete ruleResult.pageLevel;
+			delete ruleResult.result;
+
+			return ruleResult;
+		});
+	});
+
+	return resultObject;
+};

data/node_modules/axe-core/lib/core/reporters/na.js

@@ -0,0 +1,20 @@
+/*global helpers */
+
+axe.addReporter('na', function(results, options, callback) {
+	'use strict';
+
+	if (typeof options === 'function') {
+		callback = options;
+		options = {};
+	}
+
+	var out = helpers.processAggregate(results, options);
+	callback({
+		...helpers.getEnvironmentData(),
+		toolOptions: options,
+		violations: out.violations,
+		passes: out.passes,
+		incomplete: out.incomplete,
+		inapplicable: out.inapplicable
+	});
+});

data/node_modules/axe-core/lib/core/reporters/no-passes.js

@@ -0,0 +1,18 @@
+/*global helpers */
+axe.addReporter('no-passes', function(results, options, callback) {
+	'use strict';
+	if (typeof options === 'function') {
+		callback = options;
+		options = {};
+	}
+	// limit result processing to types we want to include in the output
+	options.resultTypes = ['violations'];
+
+	var out = helpers.processAggregate(results, options);
+
+	callback({
+		...helpers.getEnvironmentData(),
+		toolOptions: options,
+		violations: out.violations
+	});
+});

data/node_modules/axe-core/lib/core/reporters/raw.js

@@ -0,0 +1,8 @@
+axe.addReporter('raw', function(results, options, callback) {
+	'use strict';
+	if (typeof options === 'function') {
+		callback = options;
+		options = {};
+	}
+	callback(results);
+});

data/node_modules/axe-core/lib/core/reporters/v1.js

@@ -0,0 +1,26 @@
+/*global helpers */
+
+axe.addReporter('v1', function(results, options, callback) {
+	'use strict';
+
+	if (typeof options === 'function') {
+		callback = options;
+		options = {};
+	}
+	var out = helpers.processAggregate(results, options);
+
+	out.violations.forEach(result =>
+		result.nodes.forEach(nodeResult => {
+			nodeResult.failureSummary = helpers.failureSummary(nodeResult);
+		})
+	);
+
+	callback({
+		...helpers.getEnvironmentData(),
+		toolOptions: options,
+		violations: out.violations,
+		passes: out.passes,
+		incomplete: out.incomplete,
+		inapplicable: out.inapplicable
+	});
+});

data/node_modules/axe-core/lib/core/reporters/v2.js

@@ -0,0 +1,22 @@
+/*global helpers */
+
+axe.addReporter(
+	'v2',
+	function(results, options, callback) {
+		'use strict';
+		if (typeof options === 'function') {
+			callback = options;
+			options = {};
+		}
+		var out = helpers.processAggregate(results, options);
+		callback({
+			...helpers.getEnvironmentData(),
+			toolOptions: options,
+			violations: out.violations,
+			passes: out.passes,
+			incomplete: out.incomplete,
+			inapplicable: out.inapplicable
+		});
+	},
+	true
+);