govuk_publishing_components 30.4.1 → 30.5.0

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

@@ -1,96 +0,0 @@
-/*global Context */
-/*exported runRules */
-
-// Clean up after resolve / reject
-function cleanup() {
-	axe._memoizedFns.forEach(fn => fn.clear());
-	axe._cache.clear();
-	axe._tree = undefined;
-	axe._selectorData = undefined;
-}
-
-/**
- * Starts analysis on the current document and its subframes
- * @private
- * @param  {Object}   context  The `Context` specification object @see Context
- * @param  {Array}    options  Optional RuleOptions
- * @param  {Function} resolve  Called when done running rules, receives ([results : Object], cleanup : Function)
- * @param  {Function} reject   Called when execution failed, receives (err : Error)
- */
-function runRules(context, options, resolve, reject) {
-	'use strict';
-	try {
-		context = new Context(context);
-		axe._tree = context.flatTree;
-		axe._selectorData = axe.utils.getSelectorData(context.flatTree);
-	} catch (e) {
-		cleanup();
-		return reject(e);
-	}
-
-	var q = axe.utils.queue();
-	var audit = axe._audit;
-
-	if (options.performanceTimer) {
-		axe.utils.performanceTimer.auditStart();
-	}
-
-	if (context.frames.length && options.iframes !== false) {
-		q.defer(function(res, rej) {
-			axe.utils.collectResultsFromFrames(
-				context,
-				options,
-				'rules',
-				null,
-				res,
-				rej
-			);
-		});
-	}
-	let scrollState;
-	q.defer(function(res, rej) {
-		if (options.restoreScroll) {
-			scrollState = axe.utils.getScrollState();
-		}
-		audit.run(context, options, res, rej);
-	});
-	q.then(function(data) {
-		try {
-			if (scrollState) {
-				axe.utils.setScrollState(scrollState);
-			}
-			if (options.performanceTimer) {
-				axe.utils.performanceTimer.auditEnd();
-			}
-
-			// Add wrapper object so that we may use the same "merge" function for results from inside and outside frames
-			var results = axe.utils.mergeResults(
-				data.map(function(results) {
-					return { results };
-				})
-			);
-
-			// after should only run once, so ensure we are in the top level window
-			if (context.initiator) {
-				results = audit.after(results, options);
-
-				results.forEach(axe.utils.publishMetaData);
-				results = results.map(axe.utils.finalizeRuleResult);
-			}
-			try {
-				resolve(results, cleanup);
-			} catch (e) {
-				cleanup();
-				axe.log(e);
-			}
-		} catch (e) {
-			cleanup();
-			reject(e);
-		}
-	}).catch(e => {
-		cleanup();
-		reject(e);
-	});
-}
-
-axe._runRules = runRules;

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

@@ -1,50 +0,0 @@
-/* global helpers, SerialVirtualNode */
-
-/**
- * Run a rule in a non-browser environment
- * @param {String} ruleId  Id of the rule
- * @param {VirtualNode} vNode  The virtual node to run the rule against
- * @param {Object} options  (optional) Set of options passed into rules or checks
- * @return {Object} axe results for the rule run
- */
-axe.runVirtualRule = function(ruleId, vNode, options = {}) {
-	options.reporter = options.reporter || axe._audit.reporter || 'v1';
-	axe._selectorData = {};
-
-	if (vNode instanceof axe.AbstractVirtualNode === false) {
-		vNode = new SerialVirtualNode(vNode);
-	}
-
-	let rule = axe._audit.rules.find(rule => rule.id === ruleId);
-
-	if (!rule) {
-		throw new Error('unknown rule `' + ruleId + '`');
-	}
-
-	// rule.prototype.gather calls axe.utils.isHidden which in turn calls
-	// window.getComputedStyle if the rule excludes hidden elements. we
-	// can avoid this call by forcing the rule to not exclude hidden
-	// elements
-	rule = Object.create(rule, { excludeHidden: { value: false } });
-
-	const context = {
-		include: [vNode]
-	};
-
-	const rawResults = rule.runSync(context, options);
-	axe.utils.publishMetaData(rawResults);
-	axe.utils.finalizeRuleResult(rawResults);
-	const results = axe.utils.aggregateResult([rawResults]);
-
-	results.violations.forEach(result =>
-		result.nodes.forEach(nodeResult => {
-			nodeResult.failureSummary = helpers.failureSummary(nodeResult);
-		})
-	);
-
-	return {
-		...helpers.getEnvironmentData(),
-		...results,
-		toolOptions: options
-	};
-};

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

@@ -1,159 +0,0 @@
-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) {
-	'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;
-		});
-	}
-
-	if (axe._running) {
-		const err =
-			'Axe is already running. Use `await axe.run()` to wait ' +
-			'for the previous run to finish before starting a new run.';
-		callback(err);
-		reject(err);
-		return p;
-	}
-
-	axe._running = true;
-	axe._runRules(
-		context,
-		options,
-		function(rawResults, cleanup) {
-			let respond = function(results) {
-				axe._running = false;
-				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) {
-				axe._running = false;
-				cleanup();
-				callback(err);
-				reject(err);
-			}
-		},
-		function(err) {
-			axe._running = false;
-			callback(err);
-			reject(err);
-		}
-	);
-
-	return p;
-};

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

@@ -1,35 +0,0 @@
-/*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

@@ -1,39 +0,0 @@
-/*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

@@ -1,13 +0,0 @@
-/*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 typeof axe._audit.data.incompleteFallbackMessage === 'function'
-		? axe._audit.data.incompleteFallbackMessage()
-		: axe._audit.data.incompleteFallbackMessage;
-};

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

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

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

@@ -1,102 +0,0 @@
-/*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

@@ -1,24 +0,0 @@
-/*global helpers */
-
-axe.addReporter('na', function(results, options, callback) {
-	'use strict';
-
-	console.warn(
-		'"na" reporter will be deprecated in axe v4.0. Use the "v2" reporter instead.'
-	);
-
-	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

@@ -1,18 +0,0 @@
-/*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-env.js

@@ -1,12 +0,0 @@
-/*global helpers */
-axe.addReporter('rawEnv', function(results, options, callback) {
-	if (typeof options === 'function') {
-		callback = options;
-		options = {};
-	}
-	function rawCallback(raw) {
-		const env = helpers.getEnvironmentData();
-		callback({ raw, env });
-	}
-	axe.getReporter('raw')(results, options, rawCallback);
-});

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

@@ -1,32 +0,0 @@
-axe.addReporter('raw', function(results, options, callback) {
-	'use strict';
-
-	if (typeof options === 'function') {
-		callback = options;
-		options = {};
-	}
-
-	// Guard against tests which don't pass an array as the first param here.
-	if (!results || !Array.isArray(results)) {
-		return callback(results);
-	}
-
-	const transformedResults = results.map(result => {
-		const transformedResult = { ...result };
-		const types = ['passes', 'violations', 'incomplete', 'inapplicable'];
-		for (const type of types) {
-			// Some tests don't include all of the types, so we have to guard against that here.
-			// TODO: ensure tests always use "proper" results to avoid having these hacks in production code paths.
-			if (transformedResult[type] && Array.isArray(transformedResult[type])) {
-				transformedResult[type] = transformedResult[type].map(typeResult => ({
-					...typeResult,
-					node: typeResult.node.toJSON()
-				}));
-			}
-		}
-
-		return transformedResult;
-	});
-
-	callback(transformedResults);
-});

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

@@ -1,29 +0,0 @@
-/*global helpers */
-
-axe.addReporter('v1', function(results, options, callback) {
-	'use strict';
-
-	if (typeof options === 'function') {
-		callback = options;
-		options = {};
-	}
-	var out = helpers.processAggregate(results, options);
-
-	const addFailureSummaries = result => {
-		result.nodes.forEach(nodeResult => {
-			nodeResult.failureSummary = helpers.failureSummary(nodeResult);
-		});
-	};
-
-	out.incomplete.forEach(addFailureSummaries);
-	out.violations.forEach(addFailureSummaries);
-
-	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

@@ -1,22 +0,0 @@
-/*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
-);

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

@@ -1,19 +0,0 @@
-/**
- * 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()];
-};