govuk_publishing_components 18.1.0 → 18.1.1

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

@@ -0,0 +1,138 @@
+(function() {
+	'use strict';
+	function noop() {}
+	function funcGuard(f) {
+		if (typeof f !== 'function') {
+			throw new TypeError('Queue methods require functions as arguments');
+		}
+	}
+
+	/**
+	 * Create an asynchronous "queue", list of functions to be invoked in parallel, but not necessarily returned in order
+	 * @return {Queue} The newly generated "queue"
+	 */
+	function queue() {
+		var tasks = [];
+		var started = 0;
+		var remaining = 0; // number of tasks not yet finished
+		var completeQueue = noop;
+		var complete = false;
+		var err;
+
+		// By default, wait until the next tick,
+		// if no catch was set, throw to console.
+		var defaultFail = function(e) {
+			err = e;
+			setTimeout(function() {
+				if (err !== undefined && err !== null) {
+					axe.log('Uncaught error (of queue)', err);
+				}
+			}, 1);
+		};
+		var failed = defaultFail;
+
+		function createResolve(i) {
+			return function(r) {
+				tasks[i] = r;
+				remaining -= 1;
+				if (!remaining && completeQueue !== noop) {
+					complete = true;
+					completeQueue(tasks);
+				}
+			};
+		}
+
+		function abort(msg) {
+			// reset tasks
+			completeQueue = noop;
+
+			// notify catch
+			failed(msg);
+			// return unfinished work
+			return tasks;
+		}
+
+		function pop() {
+			var length = tasks.length;
+			for (; started < length; started++) {
+				var task = tasks[started];
+
+				try {
+					task.call(null, createResolve(started), abort);
+				} catch (e) {
+					abort(e);
+				}
+			}
+		}
+
+		var q = {
+			/**
+			 * Defer a function that may or may not run asynchronously.
+			 *
+			 * First parameter should be the function to execute with subsequent
+			 * parameters being passed as arguments to that function
+			 */
+			defer: function(fn) {
+				if (typeof fn === 'object' && fn.then && fn.catch) {
+					var defer = fn;
+					fn = function(resolve, reject) {
+						defer.then(resolve).catch(reject);
+					};
+				}
+				funcGuard(fn);
+				if (err !== undefined) {
+					return;
+				} else if (complete) {
+					throw new Error('Queue already completed');
+				}
+
+				tasks.push(fn);
+				++remaining;
+				pop();
+				return q;
+			},
+
+			/**
+			 * The callback to execute once all "deferred" functions have completed.  Will only be invoked once.
+			 * @param  {Function} f The callback, receives an array of the return/callbacked
+			 * values of each of the "deferred" functions
+			 */
+			then: function(fn) {
+				funcGuard(fn);
+				if (completeQueue !== noop) {
+					throw new Error('queue `then` already set');
+				}
+				if (!err) {
+					completeQueue = fn;
+					if (!remaining) {
+						complete = true;
+						completeQueue(tasks);
+					}
+				}
+				return q;
+			},
+
+			catch: function(fn) {
+				funcGuard(fn);
+				if (failed !== defaultFail) {
+					throw new Error('queue `catch` already set');
+				}
+				if (!err) {
+					failed = fn;
+				} else {
+					fn(err);
+					err = null;
+				}
+				return q;
+			},
+			/**
+			 * Abort the "queue" and prevent `then` function from firing
+			 * @param  {Function} fn The callback to execute; receives an array of the results which have completed
+			 */
+			abort: abort
+		};
+		return q;
+	}
+
+	axe.utils.queue = queue;
+})();

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

@@ -0,0 +1,243 @@
+/*global uuid, utils, axe */
+(function(exports) {
+	'use strict';
+	var messages = {},
+		subscribers = {},
+		errorTypes = Object.freeze([
+			'EvalError',
+			'RangeError',
+			'ReferenceError',
+			'SyntaxError',
+			'TypeError',
+			'URIError'
+		]);
+
+	/**
+	 * get the unique string to be used to identify our instance of aXe
+	 * @private
+	 */
+	function _getSource() {
+		var application = 'axeAPI',
+			version = '',
+			src;
+		if (typeof axe !== 'undefined' && axe._audit && axe._audit.application) {
+			application = axe._audit.application;
+		}
+		if (typeof axe !== 'undefined') {
+			version = axe.version;
+		}
+		src = application + '.' + version;
+		return src;
+	}
+	/**
+	 * Verify the received message is from the "respondable" module
+	 * @private
+	 * @param  {Object} postedMessage The message received via postMessage
+	 * @return {Boolean}              `true` if the message is verified from respondable
+	 */
+	function verify(postedMessage) {
+		if (
+			// Check incoming message is valid
+			typeof postedMessage === 'object' &&
+			typeof postedMessage.uuid === 'string' &&
+			postedMessage._respondable === true
+		) {
+			var messageSource = _getSource();
+			return (
+				// Check the version matches
+				postedMessage._source === messageSource ||
+				// Allow free communication with axe test
+				postedMessage._source === 'axeAPI.x.y.z' ||
+				messageSource === 'axeAPI.x.y.z'
+			);
+		}
+		return false;
+	}
+
+	/**
+	 * Posts the message to correct frame.
+	 * This abstraction necessary because IE9 & 10 do not support posting Objects; only strings
+	 * @private
+	 * @param  {Window}   win      The `window` to post the message to
+	 * @param  {String}   topic    The topic of the message
+	 * @param  {Object}   message  The message content
+	 * @param  {String}   uuid     The UUID, or pseudo-unique ID of the message
+	 * @param  {Boolean}  keepalive Whether to allow multiple responses - default is false
+	 * @param  {Function} callback The function to invoke when/if the message is responded to
+	 */
+	function post(win, topic, message, uuid, keepalive, callback) {
+		var error;
+		if (message instanceof Error) {
+			error = {
+				name: message.name,
+				message: message.message,
+				stack: message.stack
+			};
+			message = undefined;
+		}
+
+		var data = {
+			uuid: uuid,
+			topic: topic,
+			message: message,
+			error: error,
+			_respondable: true,
+			_source: _getSource(),
+			_keepalive: keepalive
+		};
+
+		if (typeof callback === 'function') {
+			messages[uuid] = callback;
+		}
+
+		win.postMessage(JSON.stringify(data), '*');
+	}
+
+	/**
+	 * Post a message to a window who may or may not respond to it.
+	 * @param  {Window}   win      The window to post the message to
+	 * @param  {String}   topic    The topic of the message
+	 * @param  {Object}   message  The message content
+	 * @param  {Boolean}  keepalive Whether to allow multiple responses - default is false
+	 * @param  {Function} callback The function to invoke when/if the message is responded to
+	 */
+	function respondable(win, topic, message, keepalive, callback) {
+		var id = uuid.v1();
+		post(win, topic, message, id, keepalive, callback);
+	}
+
+	/**
+	 * Subscribe to messages sent via the `respondable` module.
+	 *
+	 * Axe._load uses this to listen for messages from other frames
+	 *
+	 * @param  {String}   topic    The topic to listen to
+	 * @param  {Function} callback The function to invoke when a message is received
+	 */
+	respondable.subscribe = function(topic, callback) {
+		subscribers[topic] = callback;
+	};
+
+	/**
+	 * checks if the current context is inside a frame
+	 * @return {Boolean}
+	 */
+	respondable.isInFrame = function(win) {
+		win = win || window;
+		return !!win.frameElement;
+	};
+
+	/**
+	 * Helper closure to create a function that may be used to respond to a message
+	 * @private
+	 * @param  {Window} source The window from which the message originated
+	 * @param  {String} topic  The topic of the message
+	 * @param  {String} uuid   The "unique" ID of the original message
+	 * @return {Function}      A function that may be invoked to respond to the message
+	 */
+	function createResponder(source, topic, uuid) {
+		return function(message, keepalive, callback) {
+			post(source, topic, message, uuid, keepalive, callback);
+		};
+	}
+
+	/**
+	 * Publishes the "respondable" message to the appropriate subscriber
+	 * @private
+	 * @param  {Window}  source    The window from which the message originated
+	 * @param  {Object}  data      The data sent with the message
+	 * @param  {Boolean} keepalive Whether to allow multiple responses - default is false
+	 */
+	function publish(source, data, keepalive) {
+		var topic = data.topic;
+		var subscriber = subscribers[topic];
+
+		if (subscriber) {
+			var responder = createResponder(source, null, data.uuid);
+			subscriber(data.message, keepalive, responder);
+		}
+	}
+
+	/**
+	 * Convert a javascript Error into something that can be stringified
+	 * @param  {Error} error  Any type of error
+	 * @return {Object}       Processable object
+	 */
+	function buildErrorObject(error) {
+		var msg = error.message || 'Unknown error occurred';
+		var errorName = errorTypes.includes(error.name) ? error.name : 'Error';
+		var ErrConstructor = window[errorName] || Error;
+
+		if (error.stack) {
+			msg += '\n' + error.stack.replace(error.message, '');
+		}
+		return new ErrConstructor(msg);
+	}
+
+	/**
+	 * Parse the received message for processing
+	 * @param  {string} dataString Message received
+	 * @return {object}            Object to be used for pub/sub
+	 */
+	function parseMessage(dataString) {
+		/*eslint no-empty: 0*/
+		var data;
+		if (typeof dataString !== 'string') {
+			return;
+		}
+
+		try {
+			data = JSON.parse(dataString);
+		} catch (ex) {}
+
+		if (!verify(data)) {
+			return;
+		}
+
+		if (typeof data.error === 'object') {
+			data.error = buildErrorObject(data.error);
+		} else {
+			data.error = undefined;
+		}
+		return data;
+	}
+
+	if (typeof window.addEventListener === 'function') {
+		window.addEventListener(
+			'message',
+			function(e) {
+				/* eslint max-statements: ["error", 20]*/
+				var data = parseMessage(e.data);
+				if (!data) {
+					return;
+				}
+
+				var uuid = data.uuid;
+
+				var keepalive = data._keepalive;
+				var callback = messages[uuid];
+
+				if (callback) {
+					var result = data.error || data.message;
+					var responder = createResponder(e.source, data.topic, uuid);
+					callback(result, keepalive, responder);
+
+					if (!keepalive) {
+						delete messages[uuid];
+					}
+				}
+
+				if (!data.error) {
+					try {
+						publish(e.source, data, keepalive);
+					} catch (err) {
+						post(e.source, data.topic, err, uuid, false);
+					}
+				}
+			},
+			false
+		);
+	}
+
+	exports.respondable = respondable;
+})(utils);

data/node_modules/axe-core/lib/core/utils/rule-should-run.js

@@ -0,0 +1,83 @@
+/**
+ * Check if a rule matches the value of runOnly type=tag
+ * @private
+ * @param  {object} rule
+ * @param  {object}	runOnly Value of runOnly with type=tags
+ * @return {bool}
+ */
+/* eslint complexity: ["error", 14]*/
+function matchTags(rule, runOnly) {
+	'use strict';
+	var include, exclude, matching;
+	var defaultExclude =
+		axe._audit && axe._audit.tagExclude ? axe._audit.tagExclude : [];
+
+	// normalize include/exclude
+	if (runOnly.hasOwnProperty('include') || runOnly.hasOwnProperty('exclude')) {
+		// Wrap include and exclude if it's not already an array
+		include = runOnly.include || [];
+		include = Array.isArray(include) ? include : [include];
+
+		exclude = runOnly.exclude || [];
+		exclude = Array.isArray(exclude) ? exclude : [exclude];
+		// add defaults, unless mentioned in include
+		exclude = exclude.concat(
+			defaultExclude.filter(function(tag) {
+				return include.indexOf(tag) === -1;
+			})
+		);
+
+		// Otherwise, only use the include value, ignore exclude
+	} else {
+		include = Array.isArray(runOnly) ? runOnly : [runOnly];
+		// exclude the defaults not included
+		exclude = defaultExclude.filter(function(tag) {
+			return include.indexOf(tag) === -1;
+		});
+	}
+
+	matching = include.some(function(tag) {
+		return rule.tags.indexOf(tag) !== -1;
+	});
+	if (matching || (include.length === 0 && rule.enabled !== false)) {
+		return exclude.every(function(tag) {
+			return rule.tags.indexOf(tag) === -1;
+		});
+	} else {
+		return false;
+	}
+}
+
+/**
+ * Determines whether a rule should run
+ * @param  {Rule}    rule     The rule to test
+ * @param  {Context} context  The context of the Audit
+ * @param  {Object}  options  Options object
+ * @return {Boolean}
+ */
+axe.utils.ruleShouldRun = function(rule, context, options) {
+	'use strict';
+	var runOnly = options.runOnly || {};
+	var ruleOptions = (options.rules || {})[rule.id];
+
+	// Never run page level rules if the context is not on the page
+	if (rule.pageLevel && !context.page) {
+		return false;
+
+		// First, runOnly type rule overrides anything else
+	} else if (runOnly.type === 'rule') {
+		return runOnly.values.indexOf(rule.id) !== -1;
+
+		// Second, if options.rules[rule].enabled is set, it overrides all
+	} else if (ruleOptions && typeof ruleOptions.enabled === 'boolean') {
+		return ruleOptions.enabled;
+
+		// Third, if tags are set, look at those
+	} else if (runOnly.type === 'tag' && runOnly.values) {
+		return matchTags(rule, runOnly.values);
+
+		// If nothing is set, only check for default excludes
+	} else {
+		return matchTags(rule, []);
+	}
+};