govuk_publishing_components 30.3.0 → 30.5.0

data/node_modules/axe-core/lib/core/base/audit.js

@@ -1,781 +0,0 @@
-/*global Rule, Check, RuleResult, commons: true */
-const dotRegex = /\{\{.+?\}\}/g;
-
-/*eslint no-unused-vars: 0*/
-function getDefaultConfiguration(audit) {
-	'use strict';
-	var config;
-	if (audit) {
-		config = axe.utils.clone(audit);
-		// Commons are configured into axe like everything else,
-		// however because things go funky if we have multiple commons objects
-		// we're not using the copy of that.
-		config.commons = audit.commons;
-	} else {
-		config = {};
-	}
-
-	config.reporter = config.reporter || null;
-	config.rules = config.rules || [];
-	config.checks = config.checks || [];
-	config.data = { checks: {}, rules: {}, ...config.data };
-	return config;
-}
-
-function unpackToObject(collection, audit, method) {
-	'use strict';
-
-	var i, l;
-	for (i = 0, l = collection.length; i < l; i++) {
-		audit[method](collection[i]);
-	}
-}
-
-/**
- * Constructor which holds configured rules and information about the document under test
- */
-function Audit(audit) {
-	// defaults
-	this.brand = 'axe';
-	this.application = 'axeAPI';
-	this.tagExclude = ['experimental'];
-	this.lang = 'en';
-
-	this.defaultConfig = audit;
-	this._init();
-
-	// A copy of the "default" locale. This will be set if the user
-	// provides a new locale to `axe.configure()` and used to undo
-	// changes in `axe.reset()`.
-	this._defaultLocale = null;
-}
-
-/**
- * Build and set the previous locale. Will noop if a previous
- * locale was already set, as we want the ability to "reset"
- * to the default ("first") configuration.
- */
-
-Audit.prototype._setDefaultLocale = function() {
-	if (this._defaultLocale) {
-		return;
-	}
-
-	const locale = {
-		checks: {},
-		rules: {},
-		failureSummaries: {},
-		incompleteFallbackMessage: '',
-		lang: this.lang
-	};
-
-	// XXX: unable to use `for-of` here, as doing so would
-	// require us to polyfill `Symbol`.
-	const checkIDs = Object.keys(this.data.checks);
-	for (let i = 0; i < checkIDs.length; i++) {
-		const id = checkIDs[i];
-		const check = this.data.checks[id];
-		const { pass, fail, incomplete } = check.messages;
-		locale.checks[id] = {
-			pass,
-			fail,
-			incomplete
-		};
-	}
-
-	const ruleIDs = Object.keys(this.data.rules);
-	for (let i = 0; i < ruleIDs.length; i++) {
-		const id = ruleIDs[i];
-		const rule = this.data.rules[id];
-		const { description, help } = rule;
-		locale.rules[id] = { description, help };
-	}
-
-	const failureSummaries = Object.keys(this.data.failureSummaries);
-	for (let i = 0; i < failureSummaries.length; i++) {
-		const type = failureSummaries[i];
-		const failureSummary = this.data.failureSummaries[type];
-		const { failureMessage } = failureSummary;
-		locale.failureSummaries[type] = { failureMessage };
-	}
-
-	locale.incompleteFallbackMessage = this.data.incompleteFallbackMessage;
-
-	this._defaultLocale = locale;
-};
-
-/**
- * Reset the locale to the "default".
- */
-
-Audit.prototype._resetLocale = function() {
-	// If the default locale has not already been set, we can exit early.
-	const defaultLocale = this._defaultLocale;
-	if (!defaultLocale) {
-		return;
-	}
-
-	// Apply the default locale
-	this.applyLocale(defaultLocale);
-};
-
-/**
- * Merge two check locales (a, b), favoring `b`.
- *
- * Both locale `a` and the returned shape resemble:
- *
- *    {
- *      impact: string,
- *      messages: {
- *        pass: string | function,
- *        fail: string | function,
- *        incomplete: string | {
- *          [key: string]: string | function
- *        }
- *      }
- *    }
- *
- * Locale `b` follows the `axe.CheckLocale` shape and resembles:
- *
- *    {
- *      pass: string,
- *      fail: string,
- *      incomplete: string | { [key: string]: string }
- *    }
- */
-
-const mergeCheckLocale = (a, b) => {
-	let { pass, fail } = b;
-	// If the message(s) are Strings, they have not yet been run
-	// thru doT (which will return a Function).
-	if (typeof pass === 'string' && dotRegex.test(pass)) {
-		pass = axe.imports.doT.compile(pass);
-	}
-	if (typeof fail === 'string' && dotRegex.test(fail)) {
-		fail = axe.imports.doT.compile(fail);
-	}
-	return {
-		...a,
-		messages: {
-			pass: pass || a.messages.pass,
-			fail: fail || a.messages.fail,
-			incomplete:
-				typeof a.messages.incomplete === 'object'
-					? // TODO: for compleness-sake, we should be running
-					  // incomplete messages thru doT as well. This was
-					  // out-of-scope for runtime localization, but should
-					  // eventually be addressed.
-					  { ...a.messages.incomplete, ...b.incomplete }
-					: b.incomplete
-		}
-	};
-};
-
-/**
- * Merge two rule locales (a, b), favoring `b`.
- */
-
-const mergeRuleLocale = (a, b) => {
-	let { help, description } = b;
-	// If the message(s) are Strings, they have not yet been run
-	// thru doT (which will return a Function).
-	if (typeof help === 'string' && dotRegex.test(help)) {
-		help = axe.imports.doT.compile(help);
-	}
-	if (typeof description === 'string' && dotRegex.test(description)) {
-		description = axe.imports.doT.compile(description);
-	}
-	return {
-		...a,
-		help: help || a.help,
-		description: description || a.description
-	};
-};
-
-/**
- * Merge two failure messages (a, b), favoring `b`.
- */
-
-const mergeFailureMessage = (a, b) => {
-	let { failureMessage } = b;
-	// If the message(s) are Strings, they have not yet been run
-	// thru doT (which will return a Function).
-	if (typeof failureMessage === 'string' && dotRegex.test(failureMessage)) {
-		failureMessage = axe.imports.doT.compile(failureMessage);
-	}
-	return {
-		...a,
-		failureMessage: failureMessage || a.failureMessage
-	};
-};
-
-/**
- * Merge two incomplete fallback messages (a, b), favoring `b`.
- */
-
-const mergeFallbackMessage = (a, b) => {
-	if (typeof b === 'string' && dotRegex.test(b)) {
-		b = axe.imports.doT.compile(b);
-	}
-	return b || a;
-};
-
-/**
- * Apply locale for the given `checks`.
- */
-
-Audit.prototype._applyCheckLocale = function(checks) {
-	const keys = Object.keys(checks);
-	for (let i = 0; i < keys.length; i++) {
-		const id = keys[i];
-		if (!this.data.checks[id]) {
-			throw new Error(`Locale provided for unknown check: "${id}"`);
-		}
-
-		this.data.checks[id] = mergeCheckLocale(this.data.checks[id], checks[id]);
-	}
-};
-
-/**
- * Apply locale for the given `rules`.
- */
-
-Audit.prototype._applyRuleLocale = function(rules) {
-	const keys = Object.keys(rules);
-	for (let i = 0; i < keys.length; i++) {
-		const id = keys[i];
-		if (!this.data.rules[id]) {
-			throw new Error(`Locale provided for unknown rule: "${id}"`);
-		}
-		this.data.rules[id] = mergeRuleLocale(this.data.rules[id], rules[id]);
-	}
-};
-
-/**
- * Apply locale for the given failureMessage
- */
-
-Audit.prototype._applyFailureSummaries = function(messages) {
-	const keys = Object.keys(messages);
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		if (!this.data.failureSummaries[key]) {
-			throw new Error(`Locale provided for unknown failureMessage: "${key}"`);
-		}
-		this.data.failureSummaries[key] = mergeFailureMessage(
-			this.data.failureSummaries[key],
-			messages[key]
-		);
-	}
-};
-
-/**
- * Apply the given `locale`.
- *
- * @param {axe.Locale}
- */
-
-Audit.prototype.applyLocale = function(locale) {
-	this._setDefaultLocale();
-
-	if (locale.checks) {
-		this._applyCheckLocale(locale.checks);
-	}
-
-	if (locale.rules) {
-		this._applyRuleLocale(locale.rules);
-	}
-
-	if (locale.failureSummaries) {
-		this._applyFailureSummaries(locale.failureSummaries, 'failureSummaries');
-	}
-
-	if (locale.incompleteFallbackMessage) {
-		this.data.incompleteFallbackMessage = mergeFallbackMessage(
-			this.data.incompleteFallbackMessage,
-			locale.incompleteFallbackMessage
-		);
-	}
-
-	if (locale.lang) {
-		this.lang = locale.lang;
-	}
-};
-
-/**
- * Initializes the rules and checks
- */
-Audit.prototype._init = function() {
-	var audit = getDefaultConfiguration(this.defaultConfig);
-
-	axe.commons = commons = audit.commons;
-
-	this.lang = audit.lang || 'en';
-	this.reporter = audit.reporter;
-	this.commands = {};
-	this.rules = [];
-	this.checks = {};
-
-	unpackToObject(audit.rules, this, 'addRule');
-	unpackToObject(audit.checks, this, 'addCheck');
-
-	this.data = {};
-	this.data.checks = (audit.data && audit.data.checks) || {};
-	this.data.rules = (audit.data && audit.data.rules) || {};
-	this.data.failureSummaries =
-		(audit.data && audit.data.failureSummaries) || {};
-	this.data.incompleteFallbackMessage =
-		(audit.data && audit.data.incompleteFallbackMessage) || '';
-
-	this._constructHelpUrls(); // create default helpUrls
-};
-
-/**
- * Adds a new command to the audit
- */
-
-Audit.prototype.registerCommand = function(command) {
-	'use strict';
-	this.commands[command.id] = command.callback;
-};
-
-/**
- * Adds a new rule to the Audit.  If a rule with specified ID already exists, it will be overridden
- * @param {Object} spec Rule specification object
- */
-Audit.prototype.addRule = function(spec) {
-	'use strict';
-
-	if (spec.metadata) {
-		this.data.rules[spec.id] = spec.metadata;
-	}
-
-	let rule = this.getRule(spec.id);
-	if (rule) {
-		rule.configure(spec);
-	} else {
-		this.rules.push(new Rule(spec, this));
-	}
-};
-
-/**
- * Adds a new check to the Audit.  If a Check with specified ID already exists, it will be
- * reconfigured
- *
- * @param {Object} spec Check specification object
- */
-Audit.prototype.addCheck = function(spec) {
-	/*eslint no-eval: 0 */
-	'use strict';
-	let metadata = spec.metadata;
-
-	if (typeof metadata === 'object') {
-		this.data.checks[spec.id] = metadata;
-		// Transform messages into functions:
-		if (typeof metadata.messages === 'object') {
-			Object.keys(metadata.messages)
-				.filter(
-					prop =>
-						metadata.messages.hasOwnProperty(prop) &&
-						typeof metadata.messages[prop] === 'string'
-				)
-				.forEach(prop => {
-					if (metadata.messages[prop].indexOf('function') === 0) {
-						metadata.messages[prop] = new Function(
-							'return ' + metadata.messages[prop] + ';'
-						)();
-					}
-				});
-		}
-	}
-
-	if (this.checks[spec.id]) {
-		this.checks[spec.id].configure(spec);
-	} else {
-		this.checks[spec.id] = new Check(spec);
-	}
-};
-
-/**
- * Splits a given array of rules to two, with rules that can be run immediately and one's that are dependent on preloadedAssets
- * @method getRulesToRun
- * @param {Array<Object>} rules complete list of rules
- * @param {Object} context
- * @param {Object} options
- * @return {Object} out, an object containing two arrays, one being list of rules to run now and list of rules to run later
- * @private
- */
-function getRulesToRun(rules, context, options) {
-	// entry object for reduce function below
-	const base = {
-		now: [],
-		later: []
-	};
-
-	// iterate through rules and separate out rules that need to be run now vs later
-	const splitRules = rules.reduce((out, rule) => {
-		// ensure rule can run
-		if (!axe.utils.ruleShouldRun(rule, context, options)) {
-			return out;
-		}
-
-		// does rule require preload assets - push to later array
-		if (rule.preload) {
-			out.later.push(rule);
-			return out;
-		}
-
-		// default to now array
-		out.now.push(rule);
-
-		// return
-		return out;
-	}, base);
-
-	// return
-	return splitRules;
-}
-
-/**
- * Convenience method, that consturcts a rule `run` function that can be deferred
- * @param {Object} rule rule to be deferred
- * @param {Object} context context object essential to be passed into rule `run`
- * @param {Object} options normalised options to be passed into rule `run`
- * @param {Object} assets (optional) preloaded assets to be passed into rule and checks (if the rule is preload dependent)
- * @return {Function} a deferrable function for rule
- */
-function getDefferedRule(rule, context, options) {
-	// init performance timer of requested via options
-	if (options.performanceTimer) {
-		axe.utils.performanceTimer.mark('mark_rule_start_' + rule.id);
-	}
-
-	return (resolve, reject) => {
-		// invoke `rule.run`
-		rule.run(
-			context,
-			options,
-			// resolve callback for rule `run`
-			ruleResult => {
-				// resolve
-				resolve(ruleResult);
-			},
-			// reject callback for rule `run`
-			err => {
-				// if debug - construct error details
-				if (!options.debug) {
-					const errResult = Object.assign(new RuleResult(rule), {
-						result: axe.constants.CANTTELL,
-						description: 'An error occured while running this rule',
-						message: err.message,
-						stack: err.stack,
-						error: err,
-						// Add a serialized reference to the node the rule failed on for easier debugging.
-						// See https://github.com/dequelabs/axe-core/issues/1317.
-						errorNode: err.errorNode
-					});
-					// resolve
-					resolve(errResult);
-				} else {
-					// reject
-					reject(err);
-				}
-			}
-		);
-	};
-}
-
-/**
- * Runs the Audit; which in turn should call `run` on each rule.
- * @async
- * @param  {Context}   context The scope definition/context for analysis (include/exclude)
- * @param  {Object}    options Options object to pass into rules and/or disable rules or checks
- * @param  {Function} fn       Callback function to fire when audit is complete
- */
-Audit.prototype.run = function(context, options, resolve, reject) {
-	'use strict';
-
-	this.normalizeOptions(options);
-	axe._selectCache = [];
-
-	// get a list of rules to run NOW vs. LATER (later are preload assets dependent rules)
-	const allRulesToRun = getRulesToRun(this.rules, context, options);
-	const runNowRules = allRulesToRun.now;
-	const runLaterRules = allRulesToRun.later;
-
-	// init a NOW queue for rules to run immediately
-	const nowRulesQueue = axe.utils.queue();
-	// construct can run NOW rules into NOW queue
-	runNowRules.forEach(rule => {
-		nowRulesQueue.defer(getDefferedRule(rule, context, options));
-	});
-
-	// init a PRELOADER queue to start preloading assets
-	const preloaderQueue = axe.utils.queue();
-	// defer preload if preload dependent rules exist
-	if (runLaterRules.length) {
-		preloaderQueue.defer(resolve => {
-			// handle both success and fail of preload
-			// and resolve, to allow to run all checks
-			axe.utils
-				.preload(options)
-				.then(assets => resolve(assets))
-				.catch(err => {
-					/**
-					 * Note:
-					 * we do not reject, to allow other (non-preload) rules to `run`
-					 * -> instead we resolve as `undefined`
-					 */
-					console.warn(`Couldn't load preload assets: `, err);
-					resolve(undefined);
-				});
-		});
-	}
-
-	// defer now and preload queue to run immediately
-	const queueForNowRulesAndPreloader = axe.utils.queue();
-	queueForNowRulesAndPreloader.defer(nowRulesQueue);
-	queueForNowRulesAndPreloader.defer(preloaderQueue);
-
-	// invoke the now queue
-	queueForNowRulesAndPreloader
-		.then(nowRulesAndPreloaderResults => {
-			// interpolate results into separate variables
-			const assetsFromQueue = nowRulesAndPreloaderResults.pop();
-			if (assetsFromQueue && assetsFromQueue.length) {
-				// result is a queue (again), hence the index resolution
-				// assets is either an object of key value pairs of asset type and values
-				// eg: cssom: [stylesheets]
-				// or undefined if preload failed
-				const assets = assetsFromQueue[0];
-				// extend context with preloaded assets
-				if (assets) {
-					context = {
-						...context,
-						...assets
-					};
-				}
-			}
-
-			// the reminder of the results are RuleResults
-			const nowRulesResults = nowRulesAndPreloaderResults[0];
-
-			// if there are no rules to run LATER - resolve with rule results
-			if (!runLaterRules.length) {
-				// remove the cache
-				axe._selectCache = undefined;
-				// resolve
-				resolve(nowRulesResults.filter(result => !!result));
-				return;
-			}
-
-			// init a LATER queue for rules that are dependant on preloaded assets
-			const laterRulesQueue = axe.utils.queue();
-			runLaterRules.forEach(rule => {
-				const deferredRule = getDefferedRule(rule, context, options);
-				laterRulesQueue.defer(deferredRule);
-			});
-			// invoke the later queue
-			laterRulesQueue
-				.then(laterRuleResults => {
-					// remove the cache
-					axe._selectCache = undefined;
-					// resolve
-					resolve(
-						nowRulesResults.concat(laterRuleResults).filter(result => !!result)
-					);
-				})
-				.catch(reject);
-		})
-		.catch(reject);
-};
-
-/**
- * Runs Rule `after` post processing functions
- * @param  {Array} results  Array of RuleResults to postprocess
- * @param  {Mixed} options  Options object to pass into rules and/or disable rules or checks
- */
-Audit.prototype.after = function(results, options) {
-	'use strict';
-
-	var rules = this.rules;
-
-	return results.map(function(ruleResult) {
-		var rule = axe.utils.findBy(rules, 'id', ruleResult.id);
-		if (!rule) {
-			// If you see this, you're probably running the Mocha tests with the axe extension installed
-			throw new Error(
-				'Result for unknown rule. You may be running mismatch axe-core versions'
-			);
-		}
-
-		return rule.after(ruleResult, options);
-	});
-};
-
-/**
- * Get the rule with a given ID
- * @param  {string}
- * @return {Rule}
- */
-Audit.prototype.getRule = function(ruleId) {
-	return this.rules.find(rule => rule.id === ruleId);
-};
-
-/**
- * Ensure all rules that are expected to run exist
- * @throws {Error} If any tag or rule specified in options is unknown
- * @param  {Object} options  Options object
- * @return {Object}          Validated options object
- */
-Audit.prototype.normalizeOptions = function(options) {
-	'use strict';
-	var audit = this;
-
-	const tags = [];
-	const ruleIds = [];
-	audit.rules.forEach(rule => {
-		ruleIds.push(rule.id);
-		rule.tags.forEach(tag => {
-			if (!tags.includes(tag)) {
-				tags.push(tag);
-			}
-		});
-	});
-
-	// Validate runOnly
-	if (typeof options.runOnly === 'object') {
-		if (Array.isArray(options.runOnly)) {
-			const hasTag = options.runOnly.find(value => tags.includes(value));
-			const hasRule = options.runOnly.find(value => ruleIds.includes(value));
-
-			if (hasTag && hasRule) {
-				throw new Error('runOnly cannot be both rules and tags');
-			}
-			if (hasRule) {
-				options.runOnly = {
-					type: 'rule',
-					values: options.runOnly
-				};
-			} else {
-				options.runOnly = {
-					type: 'tag',
-					values: options.runOnly
-				};
-			}
-		}
-		const only = options.runOnly;
-		if (only.value && !only.values) {
-			only.values = only.value;
-			delete only.value;
-		}
-
-		if (!Array.isArray(only.values) || only.values.length === 0) {
-			throw new Error('runOnly.values must be a non-empty array');
-		}
-
-		// Check if every value in options.runOnly is a known rule ID
-		if (['rule', 'rules'].includes(only.type)) {
-			only.type = 'rule';
-			only.values.forEach(function(ruleId) {
-				if (!ruleIds.includes(ruleId)) {
-					throw new Error('unknown rule `' + ruleId + '` in options.runOnly');
-				}
-			});
-
-			// Validate 'tags' (e.g. anything not 'rule')
-		} else if (['tag', 'tags', undefined].includes(only.type)) {
-			only.type = 'tag';
-			const unmatchedTags = only.values.filter(tag => !tags.includes(tag));
-
-			if (unmatchedTags.length !== 0) {
-				axe.log('Could not find tags `' + unmatchedTags.join('`, `') + '`');
-			}
-		} else {
-			throw new Error(`Unknown runOnly type '${only.type}'`);
-		}
-	}
-
-	if (typeof options.rules === 'object') {
-		Object.keys(options.rules).forEach(function(ruleId) {
-			if (!ruleIds.includes(ruleId)) {
-				throw new Error('unknown rule `' + ruleId + '` in options.rules');
-			}
-		});
-	}
-
-	return options;
-};
-
-/*
- * Updates the default options and then applies them
- * @param  {Mixed} options  Options object
- */
-
-Audit.prototype.setBranding = function(branding) {
-	'use strict';
-	let previous = {
-		brand: this.brand,
-		application: this.application
-	};
-	if (
-		branding &&
-		branding.hasOwnProperty('brand') &&
-		branding.brand &&
-		typeof branding.brand === 'string'
-	) {
-		this.brand = branding.brand;
-	}
-	if (
-		branding &&
-		branding.hasOwnProperty('application') &&
-		branding.application &&
-		typeof branding.application === 'string'
-	) {
-		this.application = branding.application;
-	}
-	this._constructHelpUrls(previous);
-};
-
-/**
- * For all the rules, create the helpUrl and add it to the data for that rule
- */
-function getHelpUrl({ brand, application, lang }, ruleId, version) {
-	return (
-		axe.constants.helpUrlBase +
-		brand +
-		'/' +
-		(version || axe.version.substring(0, axe.version.lastIndexOf('.'))) +
-		'/' +
-		ruleId +
-		'?application=' +
-		encodeURIComponent(application) +
-		(lang && lang !== 'en' ? '&lang=' + encodeURIComponent(lang) : '')
-	);
-}
-
-Audit.prototype._constructHelpUrls = function(previous = null) {
-	var version = (axe.version.match(/^[1-9][0-9]*\.[0-9]+/) || ['x.y'])[0];
-	this.rules.forEach(rule => {
-		if (!this.data.rules[rule.id]) {
-			this.data.rules[rule.id] = {};
-		}
-		let metaData = this.data.rules[rule.id];
-		if (
-			typeof metaData.helpUrl !== 'string' ||
-			(previous && metaData.helpUrl === getHelpUrl(previous, rule.id, version))
-		) {
-			metaData.helpUrl = getHelpUrl(this, rule.id, version);
-		}
-	});
-};
-
-/**
- * Reset the default rules, checks and meta data
- */
-
-Audit.prototype.resetRulesAndChecks = function() {
-	'use strict';
-	this._init();
-	this._resetLocale();
-};