govuk_publishing_components 21.16.3 → 21.17.0

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

@@ -0,0 +1,85 @@
+// class is unused in the file...
+// eslint-disable-next-line no-unused-vars
+class VirtualNode extends axe.AbstractVirtualNode {
+	/**
+	 * Wrap the real node and provide list of the flattened children
+	 * @param {Node} node the node in question
+	 * @param {VirtualNode} parent The parent VirtualNode
+	 * @param {String} shadowId the ID of the shadow DOM to which this node belongs
+	 */
+	constructor(node, parent, shadowId) {
+		super();
+		this.shadowId = shadowId;
+		this.children = [];
+		this.actualNode = node;
+		this.parent = parent;
+
+		this._isHidden = null; // will be populated by axe.utils.isHidden
+		this._cache = {};
+
+		if (axe._cache.get('nodeMap')) {
+			axe._cache.get('nodeMap').set(node, this);
+		}
+	}
+
+	// abstract Node properties so we can run axe in DOM-less environments.
+	// add to the prototype so memory is shared across all virtual nodes
+	get props() {
+		const { nodeType, nodeName, id, type } = this.actualNode;
+
+		return {
+			nodeType,
+			nodeName: nodeName.toLowerCase(),
+			id,
+			type
+		};
+	}
+
+	/**
+	 * 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) {
+		if (typeof this.actualNode.getAttribute !== 'function') {
+			return null;
+		}
+
+		return this.actualNode.getAttribute(attrName);
+	}
+
+	/**
+	 * 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) {
+		if (typeof this.actualNode.hasAttribute !== 'function') {
+			return false;
+		}
+
+		return this.actualNode.hasAttribute(attrName);
+	}
+
+	/**
+	 * Determine if the element is focusable and cache the result.
+	 * @return {Boolean} True if the element is focusable, false otherwise.
+	 */
+	get isFocusable() {
+		if (!this._cache.hasOwnProperty('isFocusable')) {
+			this._cache.isFocusable = axe.commons.dom.isFocusable(this.actualNode);
+		}
+		return this._cache.isFocusable;
+	}
+
+	/**
+	 * Return the list of tabbable elements for this element and cache the result.
+	 * @return {VirtualNode[]}
+	 */
+	get tabbableElements() {
+		if (!this._cache.hasOwnProperty('tabbableElements')) {
+			this._cache.tabbableElements = axe.commons.dom.getTabbableElements(this);
+		}
+		return this._cache.tabbableElements;
+	}
+}

data/node_modules/axe-core/lib/core/constants.js

@@ -32,8 +32,16 @@
 		resultGroups: [],
 		resultGroupMap: {},
 		impact: Object.freeze(['minor', 'moderate', 'serious', 'critical']),
-		preloadAssets: Object.freeze(['cssom']), // overtime this array will grow with other preload asset types, this constant is to verify if a requested preload type by the user via the configuration is supported by axe.
-		preloadAssetsTimeout: 10000
+		preload: Object.freeze({
+			/**
+			 * array of supported & preload(able) asset types.
+			 */
+			assets: ['cssom'],
+			/**
+			 * timeout value when resolving preload(able) assets
+			 */
+			timeout: 10000
+		})
 	};
 
 	definitions.forEach(function(definition) {

data/node_modules/axe-core/lib/core/imports/index.js

@@ -10,7 +10,31 @@
  * Polyfill `Promise`
  * Reference: https://www.npmjs.com/package/es6-promise
  */
-require('es6-promise').polyfill();
+if (!('Promise' in window)) {
+	require('es6-promise').polyfill();
+}
+
+/**
+ * Polyfill required TypedArray and functions
+ * Reference https://github.com/zloirock/core-js/
+ */
+if (!('Uint32Array' in window)) {
+	require('core-js/features/typed-array/uint32-array');
+}
+if (window.Uint32Array) {
+	if (!('some' in window.Uint32Array.prototype)) {
+		require('core-js/features/typed-array/some');
+	}
+	if (!('reduce' in window.Uint32Array.prototype)) {
+		require('core-js/features/typed-array/reduce');
+	}
+}
+
+/**
+ * Polyfill `WeakMap`
+ * Reference: https://github.com/polygonplanet/weakmap-polyfill
+ */
+require('weakmap-polyfill');
 
 /**
  * Namespace `axe.imports` which holds required external dependencies
@@ -21,6 +45,7 @@ require('es6-promise').polyfill();
 axe.imports = {
 	axios: require('axios'),
 	CssSelectorParser: require('css-selector-parser').CssSelectorParser,
-	doT: require('dot'),
-	emojiRegexText: require('emoji-regex')
+	doT: require('@deque/dot'),
+	emojiRegexText: require('emoji-regex'),
+	memoize: require('memoizee')
 };

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

@@ -1,6 +1,6 @@
 /*exported axe, commons */
 /*global axeFunction, module, define */
-// exported namespace for aXe
+// exported namespace for axe
 /*eslint no-use-before-define: 0, no-unused-vars: 0*/
 var axe = axe || {};
 axe.version = '<%= pkg.version %>';
@@ -32,9 +32,7 @@ var commons;
 function SupportError(error) {
 	this.name = 'SupportError';
 	this.cause = error.cause;
-	this.message = `\`${
-		error.cause
-	}\` - feature unsupported in your environment.`;
+	this.message = `\`${error.cause}\` - feature unsupported in your environment.`;
 	if (error.ruleId) {
 		this.ruleId = error.ruleId;
 		this.message += ` Skipping ${this.ruleId} rule.`;

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

@@ -1,6 +1,5 @@
 /* global reporters */
 function configureChecksRulesAndBranding(spec) {
-	/*eslint max-statements: ["error",21]*/
 	'use strict';
 	var audit;
 
@@ -9,6 +8,34 @@ function configureChecksRulesAndBranding(spec) {
 		throw new Error('No audit configured');
 	}
 
+	if (spec.axeVersion || spec.ver) {
+		let specVersion = spec.axeVersion || spec.ver;
+		if (!/^\d+\.\d+\.\d+(-canary)?/.test(specVersion)) {
+			throw new Error(`Invalid configured version ${specVersion}`);
+		}
+
+		let [version, canary] = specVersion.split('-');
+		let [major, minor, patch] = version.split('.').map(Number);
+
+		let [axeVersion, axeCanary] = axe.version.split('-');
+		let [axeMajor, axeMinor, axePatch] = axeVersion.split('.').map(Number);
+
+		if (
+			major !== axeMajor ||
+			axeMinor < minor ||
+			(axeMinor === minor && axePatch < patch) ||
+			(major === axeMajor &&
+				minor === axeMinor &&
+				patch === axePatch &&
+				canary &&
+				canary !== axeCanary)
+		) {
+			throw new Error(
+				`Configured version ${specVersion} is not compatible with current axe version ${axe.version}`
+			);
+		}
+	}
+
 	if (
 		spec.reporter &&
 		(typeof spec.reporter === 'function' || reporters[spec.reporter])

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

@@ -3,6 +3,8 @@
 
 // Clean up after resolve / reject
 function cleanup() {
+	axe._memoizedFns.forEach(fn => fn.clear());
+	axe._cache.clear();
 	axe._tree = undefined;
 	axe._selectorData = undefined;
 }

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

@@ -0,0 +1,50 @@
+/* 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,4 +1,3 @@
-/*eslint indent: 0, complexity:["error", 12]*/
 function isContext(potential) {
 	'use strict';
 	switch (true) {
@@ -81,7 +80,6 @@ function normalizeRunParams(context, options, callback) {
  * @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');
@@ -109,11 +107,22 @@ axe.run = function(context, options, callback) {
 		});
 	}
 
+	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);
@@ -133,12 +142,14 @@ axe.run = function(context, options, callback) {
 					respond(results);
 				}
 			} catch (err) {
+				axe._running = false;
 				cleanup();
 				callback(err);
 				reject(err);
 			}
 		},
 		function(err) {
+			axe._running = false;
 			callback(err);
 			reject(err);
 		}

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

@@ -40,7 +40,7 @@ var resultKeys = axe.constants.resultGroups;
  */
 
 /**
- * Aggregrate and process the aXe results,
+ * Aggregrate and process the axe results,
  * adding desired data to nodes and relatedNodes in each rule result.
  *
  * Prepares result data for reporters.

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

@@ -3,6 +3,10 @@
 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 = {};

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

@@ -0,0 +1,12 @@
+/*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,8 +1,32 @@
 axe.addReporter('raw', function(results, options, callback) {
 	'use strict';
+
 	if (typeof options === 'function') {
 		callback = options;
 		options = {};
 	}
-	callback(results);
+
+	// 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/utils/are-styles-set.js

@@ -3,19 +3,16 @@
 function areStylesSet(el, styles, stopAt) {
 	'use strict';
 	var styl = window.getComputedStyle(el, null);
-	var set = false;
 	if (!styl) {
 		return false;
 	}
-	styles.forEach(function(att) {
+	for (var i = 0; i < styles.length; ++i) {
+		var att = styles[i];
 		if (styl.getPropertyValue(att.property) === att.value) {
-			set = true;
+			return true;
 		}
-	});
-	if (set) {
-		return true;
 	}
-	if (el.nodeName.toUpperCase() === stopAt.toUpperCase() || !el.parentNode) {
+	if (!el.parentNode || el.nodeName.toUpperCase() === stopAt.toUpperCase()) {
 		return false;
 	}
 	return areStylesSet(el.parentNode, styles, stopAt);

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

@@ -0,0 +1,12 @@
+/* global axe*/
+
+/**
+ * If the first argument is falsey, throw an error using the second argument as a message.
+ * @param {boolean} bool
+ * @param {string} message
+ */
+axe.utils.assert = function assert(bool, message) {
+	if (!bool) {
+		throw new Error(message);
+	}
+};

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

@@ -40,11 +40,11 @@ axe.utils.sendCommandToFrame = function(node, parameters, resolve, reject) {
 	axe.utils.respondable(win, 'axe.ping', null, undefined, function() {
 		clearTimeout(timeout);
 
-		// Give aXe 60s (or user-supplied value) to respond to 'axe.start'
+		// Give axe 60s (or user-supplied value) to respond to 'axe.start'
 		var frameWaitTime =
 			(parameters.options && parameters.options.frameWaitTime) || 60000;
 
-		timeout = setTimeout(function() {
+		timeout = setTimeout(function collectResultFramesTimeout() {
 			reject(err('Axe in frame timed out', node));
 		}, frameWaitTime);
 

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

@@ -2,29 +2,43 @@
  * 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`
+ * @param  {VirtualNode} vNode     The candidate container VirtualNode
+ * @param  {VirtualNode} otherVNode The vNode to test is contained by `vNode`
+ * @return {Boolean}           Whether `vNode` contains `otherVNode`
  */
-axe.utils.contains = function(node, otherNode) {
+axe.utils.contains = function(vNode, otherVNode) {
 	/*eslint no-bitwise: 0*/
 	'use strict';
-	function containsShadowChild(node, otherNode) {
-		if (node.shadowId === otherNode.shadowId) {
+	function containsShadowChild(vNode, otherVNode) {
+		if (vNode.shadowId === otherVNode.shadowId) {
 			return true;
 		}
-		return !!node.children.find(child => {
-			return containsShadowChild(child, otherNode);
+		return !!vNode.children.find(child => {
+			return containsShadowChild(child, otherVNode);
 		});
 	}
 
-	if (node.shadowId || otherNode.shadowId) {
-		return containsShadowChild(node, otherNode);
+	if (vNode.shadowId || otherVNode.shadowId) {
+		return containsShadowChild(vNode, otherVNode);
 	}
 
-	if (typeof node.actualNode.contains === 'function') {
-		return node.actualNode.contains(otherNode.actualNode);
+	if (vNode.actualNode) {
+		if (typeof vNode.actualNode.contains === 'function') {
+			return vNode.actualNode.contains(otherVNode.actualNode);
+		}
+
+		return !!(
+			vNode.actualNode.compareDocumentPosition(otherVNode.actualNode) & 16
+		);
+	} else {
+		// fallback for virtualNode only contexts (e.g. linting)
+		// @see https://github.com/Financial-Times/polyfill-service/pull/183/files
+		do {
+			if (otherVNode === vNode) {
+				return true;
+			}
+		} while ((otherVNode = otherVNode && otherVNode.parent));
 	}
 
-	return !!(node.actualNode.compareDocumentPosition(otherNode.actualNode) & 16);
+	return false;
 };