govuk_publishing_components 21.16.3 → 21.17.0

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

@@ -1,7 +1,6 @@
 /*global RuleResult, createExecutionContext, SupportError */
 
 function Rule(spec, parentAudit) {
-	/*eslint complexity: ["error", 11] */
 	'use strict';
 
 	this._audit = parentAudit;
@@ -90,16 +89,48 @@ Rule.prototype.matches = function() {
 /**
  * Selects `HTMLElement`s based on configured selector
  * @param  {Context} context The resolved Context object
+ * @param  {Mixed}   options Options specific to this rule
  * @return {Array}           All matching `HTMLElement`s
  */
-Rule.prototype.gather = function(context) {
-	'use strict';
+Rule.prototype.gather = function(context, options = {}) {
+	const markStart = 'mark_gather_start_' + this.id;
+	const markEnd = 'mark_gather_end_' + this.id;
+	const markHiddenStart = 'mark_isHidden_start_' + this.id;
+	const markHiddenEnd = 'mark_isHidden_end_' + this.id;
+
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.mark(markStart);
+	}
+
 	var elements = axe.utils.select(this.selector, context);
 	if (this.excludeHidden) {
-		return elements.filter(function(element) {
+		if (options.performanceTimer) {
+			axe.utils.performanceTimer.mark(markHiddenStart);
+		}
+
+		elements = elements.filter(function(element) {
 			return !axe.utils.isHidden(element.actualNode);
 		});
+
+		if (options.performanceTimer) {
+			axe.utils.performanceTimer.mark(markHiddenEnd);
+			axe.utils.performanceTimer.measure(
+				'rule_' + this.id + '#gather_axe.utils.isHidden',
+				markHiddenStart,
+				markHiddenEnd
+			);
+		}
+	}
+
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.mark(markEnd);
+		axe.utils.performanceTimer.measure(
+			'rule_' + this.id + '#gather',
+			markStart,
+			markEnd
+		);
 	}
+
 	return elements;
 };
 
@@ -135,29 +166,46 @@ Rule.prototype.runChecks = function(
 		.catch(reject);
 };
 
+/**
+ * Run a check for a rule synchronously.
+ */
+Rule.prototype.runChecksSync = function(type, node, options, context) {
+	'use strict';
+
+	const self = this;
+	let results = [];
+
+	this[type].forEach(function(c) {
+		const check = self._audit.checks[c.id || c];
+		const option = axe.utils.getCheckOption(check, self.id, options);
+		results.push(check.runSync(node, option, context));
+	});
+
+	results = results.filter(function(check) {
+		return check;
+	});
+
+	return { type: type, results: results };
+};
+
 /**
  * Runs the Rule's `evaluate` function
  * @param  {Context}   context  The resolved Context object
  * @param  {Mixed}   options  Options specific to this rule
  * @param  {Function} callback Function to call when evaluate is complete; receives a RuleResult instance
  */
-Rule.prototype.run = function(context, options, resolve, reject) {
-	/*eslint max-statements: ["error",17] */
+Rule.prototype.run = function(context, options = {}, resolve, reject) {
+	if (options.performanceTimer) {
+		this._trackPerformance();
+	}
 
 	const q = axe.utils.queue();
 	const ruleResult = new RuleResult(this);
-	const markStart = 'mark_rule_start_' + this.id;
-	const markEnd = 'mark_rule_end_' + this.id;
-	const markChecksStart = 'mark_runchecks_start_' + this.id;
-	const markChecksEnd = 'mark_runchecks_end_' + this.id;
-
 	let nodes;
 
 	try {
 		// Matches throws an error when it lacks support for document methods
-		nodes = this.gather(context).filter(node =>
-			this.matches(node.actualNode, node, context)
-		);
+		nodes = this.gatherAndMatchNodes(context, options);
 	} catch (error) {
 		// Exit the rule execution if matches fails
 		reject(new SupportError({ cause: error, ruleId: this.id }));
@@ -165,13 +213,7 @@ Rule.prototype.run = function(context, options, resolve, reject) {
 	}
 
 	if (options.performanceTimer) {
-		axe.log(
-			'gather (',
-			nodes.length,
-			'):',
-			axe.utils.performanceTimer.timeElapsed() + 'ms'
-		);
-		axe.utils.performanceTimer.mark(markChecksStart);
+		this._logGatherPerformance(nodes);
 	}
 
 	nodes.forEach(node => {
@@ -186,22 +228,10 @@ Rule.prototype.run = function(context, options, resolve, reject) {
 
 			checkQueue
 				.then(function(results) {
-					if (results.length) {
-						var hasResults = false,
-							result = {};
-						results.forEach(function(r) {
-							var res = r.results.filter(function(result) {
-								return result;
-							});
-							result[r.type] = res;
-							if (res.length) {
-								hasResults = true;
-							}
-						});
-						if (hasResults) {
-							result.node = new axe.utils.DqElement(node.actualNode, options);
-							ruleResult.nodes.push(result);
-						}
+					const result = getResult(results);
+					if (result) {
+						result.node = new axe.utils.DqElement(node.actualNode, options);
+						ruleResult.nodes.push(result);
 					}
 					resolveNode();
 				})
@@ -214,18 +244,165 @@ Rule.prototype.run = function(context, options, resolve, reject) {
 	q.defer(resolve => setTimeout(resolve, 0));
 
 	if (options.performanceTimer) {
-		axe.utils.performanceTimer.mark(markChecksEnd);
-		axe.utils.performanceTimer.mark(markEnd);
+		this._logRulePerformance();
+	}
+
+	q.then(() => resolve(ruleResult)).catch(error => reject(error));
+};
+
+/**
+ * Runs the Rule's `evaluate` function synchronously
+ * @param  {Context}   context  The resolved Context object
+ * @param  {Mixed}   options  Options specific to this rule
+ */
+Rule.prototype.runSync = function(context, options = {}) {
+	if (options.performanceTimer) {
+		this._trackPerformance();
+	}
+
+	const ruleResult = new RuleResult(this);
+	let nodes;
+
+	try {
+		nodes = this.gatherAndMatchNodes(context, options);
+	} catch (error) {
+		// Exit the rule execution if matches fails
+		throw new SupportError({ cause: error, ruleId: this.id });
+	}
+
+	if (options.performanceTimer) {
+		this._logGatherPerformance(nodes);
+	}
+
+	nodes.forEach(node => {
+		let results = [];
+		['any', 'all', 'none'].forEach(type => {
+			results.push(this.runChecksSync(type, node, options, context));
+		});
+
+		const result = getResult(results);
+		if (result) {
+			result.node = node.actualNode
+				? new axe.utils.DqElement(node.actualNode, options)
+				: null;
+			ruleResult.nodes.push(result);
+		}
+	});
+
+	if (options.performanceTimer) {
+		this._logRulePerformance();
+	}
+
+	return ruleResult;
+};
+
+/**
+ * Add performance tracking properties to the rule
+ * @private
+ */
+Rule.prototype._trackPerformance = function() {
+	this._markStart = 'mark_rule_start_' + this.id;
+	this._markEnd = 'mark_rule_end_' + this.id;
+	this._markChecksStart = 'mark_runchecks_start_' + this.id;
+	this._markChecksEnd = 'mark_runchecks_end_' + this.id;
+};
+
+/**
+ * Log performance of rule.gather
+ * @private
+ * @param {Rule} rule The rule to log
+ * @param {Array} nodes Result of rule.gather
+ */
+Rule.prototype._logGatherPerformance = function(nodes) {
+	axe.log(
+		'gather (',
+		nodes.length,
+		'):',
+		axe.utils.performanceTimer.timeElapsed() + 'ms'
+	);
+	axe.utils.performanceTimer.mark(this._markChecksStart);
+};
+
+/**
+ * Log performance of the rule
+ * @private
+ * @param {Rule} rule The rule to log
+ */
+Rule.prototype._logRulePerformance = function() {
+	axe.utils.performanceTimer.mark(this._markChecksEnd);
+	axe.utils.performanceTimer.mark(this._markEnd);
+	axe.utils.performanceTimer.measure(
+		'runchecks_' + this.id,
+		this._markChecksStart,
+		this._markChecksEnd
+	);
+
+	axe.utils.performanceTimer.measure(
+		'rule_' + this.id,
+		this._markStart,
+		this._markEnd
+	);
+};
+
+/**
+ * Process the results of each check and return the result if a check
+ * has a result
+ * @private
+ * @param {Array} results  Array of each check result
+ * @returns {Object|null}
+ */
+function getResult(results) {
+	if (results.length) {
+		let hasResults = false,
+			result = {};
+		results.forEach(function(r) {
+			const res = r.results.filter(function(result) {
+				return result;
+			});
+			result[r.type] = res;
+			if (res.length) {
+				hasResults = true;
+			}
+		});
+
+		if (hasResults) {
+			return result;
+		}
+
+		return null;
+	}
+}
+
+/**
+ * Selects `HTMLElement`s based on configured selector and filters them based on
+ * the rules matches function
+ * @param  {Rule} rule The rule to check for after checks
+ * @param  {Context} context The resolved Context object
+ * @param  {Mixed}   options Options specific to this rule
+ * @return {Array}           All matching `HTMLElement`s
+ */
+Rule.prototype.gatherAndMatchNodes = function(context, options) {
+	const markMatchesStart = 'mark_matches_start_' + this.id;
+	const markMatchesEnd = 'mark_matches_end_' + this.id;
+
+	let nodes = this.gather(context, options);
+
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.mark(markMatchesStart);
+	}
+
+	nodes = nodes.filter(node => this.matches(node.actualNode, node, context));
+
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.mark(markMatchesEnd);
 		axe.utils.performanceTimer.measure(
-			'runchecks_' + this.id,
-			markChecksStart,
-			markChecksEnd
+			'rule_' + this.id + '#matches',
+			markMatchesStart,
+			markMatchesEnd
 		);
-
-		axe.utils.performanceTimer.measure('rule_' + this.id, markStart, markEnd);
 	}
 
-	q.then(() => resolve(ruleResult)).catch(error => reject(error));
+	return nodes;
 };
 
 /**
@@ -336,7 +513,7 @@ Rule.prototype.after = function(result, options) {
  * @param {Object} spec - the attributes to be reconfigured
  */
 Rule.prototype.configure = function(spec) {
-	/*eslint complexity:["error",14], max-statements:["error",22], no-eval:0 */
+	/*eslint no-eval:0 */
 	'use strict';
 
 	if (spec.hasOwnProperty('selector')) {

data/node_modules/axe-core/lib/core/base/virtual-node/abstract-virtual-node.js

@@ -0,0 +1,40 @@
+const whitespaceRegex = /[\t\r\n\f]/g;
+
+class AbstractVirtualNode {
+	constructor() {
+		this.children = [];
+		this.parent = null;
+	}
+
+	get props() {
+		throw new Error(
+			'VirtualNode class must have a "props" object consisting ' +
+				'of "nodeType" and "nodeName" properties'
+		);
+	}
+
+	attr() {
+		throw new Error('VirtualNode class must have a "attr" function');
+	}
+
+	hasAttr() {
+		throw new Error('VirtualNode class must have a "hasAttr" function');
+	}
+
+	hasClass(className) {
+		// get the value of the class attribute as svgs return a SVGAnimatedString
+		// if you access the className property
+		let classAttr = this.attr('class');
+		if (!classAttr) {
+			return false;
+		}
+
+		let selector = ' ' + className + ' ';
+		return (
+			(' ' + classAttr + ' ').replace(whitespaceRegex, ' ').indexOf(selector) >=
+			0
+		);
+	}
+}
+
+axe.AbstractVirtualNode = AbstractVirtualNode;

data/node_modules/axe-core/lib/core/base/virtual-node/serial-virtual-node.js

@@ -0,0 +1,86 @@
+// eslint-disable-next-line no-unused-vars
+class SerialVirtualNode extends axe.AbstractVirtualNode {
+	/**
+	 * Convert a serialised node into a VirtualNode object
+	 * @param {Object} node Serialised node
+	 */
+	constructor(serialNode) {
+		super();
+		this._props = normaliseProps(serialNode);
+		this._attrs = normaliseAttrs(serialNode);
+	}
+
+	// Accessof for DOM node properties
+	get props() {
+		return this._props;
+	}
+
+	/**
+	 * Get the value of the given attribute name.
+	 * @param {String} attrName The name of the attribute.
+	 * @return {String|null} The value of the attribute or null if the attribute does not exist
+	 */
+	attr(attrName) {
+		return this._attrs[attrName] || null;
+	}
+
+	/**
+	 * Determine if the element has the given attribute.
+	 * @param {String} attrName The name of the attribute
+	 * @return {Boolean} True if the element has the attribute, false otherwise.
+	 */
+	hasAttr(attrName) {
+		return this._attrs[attrName] !== undefined;
+	}
+}
+
+/**
+ * Convert between serialised props and DOM-like properties
+ * @param {Object} serialNode
+ * @return {Object} normalProperties
+ */
+function normaliseProps(serialNode) {
+	let { nodeName, nodeType = 1 } = serialNode;
+	axe.utils.assert(
+		nodeType === 1,
+		`nodeType has to be undefined or 1, got '${nodeType}'`
+	);
+	axe.utils.assert(
+		typeof nodeName === 'string',
+		`nodeName has to be a string, got '${nodeName}'`
+	);
+
+	const props = {
+		...serialNode,
+		nodeType,
+		nodeName: nodeName.toLowerCase()
+	};
+	delete props.attributes;
+	return Object.freeze(props);
+}
+
+/**
+ * Convert between serialised attributes and DOM-like attributes
+ * @param {Object} serialNode
+ * @return {Object} normalAttributes
+ */
+function normaliseAttrs({ attributes = {} }) {
+	const attrMap = {
+		htmlFor: 'for',
+		className: 'class'
+	};
+
+	return Object.keys(attributes).reduce((attrs, attrName) => {
+		const value = attributes[attrName];
+		axe.utils.assert(
+			typeof value !== 'object' || value === null,
+			`expects attributes not to be an object, '${attrName}' was`
+		);
+
+		if (value !== undefined) {
+			const mappedName = attrMap[attrName] || attrName;
+			attrs[mappedName] = value !== null ? String(value) : null;
+		}
+		return attrs;
+	}, {});
+}