govuk_publishing_components 30.4.1 → 30.5.0

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

@@ -1,33 +0,0 @@
-(function() {
-	'use strict';
-	let _cache = {};
-
-	const cache = {
-		/**
-		 * Set an item in the cache.
-		 * @param {String} key - Name of the key.
-		 * @param {*} value - Value to store.
-		 */
-		set(key, value) {
-			_cache[key] = value;
-		},
-
-		/**
-		 * Retrieve an item from the cache.
-		 * @param {String} key - Name of the key the value was stored as.
-		 * @returns {*} The item stored
-		 */
-		get(key) {
-			return _cache[key];
-		},
-
-		/**
-		 * Clear the cache.
-		 */
-		clear() {
-			_cache = {};
-		}
-	};
-
-	axe._cache = cache;
-})();

data/node_modules/axe-core/lib/core/base/check-result.js

@@ -1,33 +0,0 @@
-/*exported CheckResult */
-/*eslint no-unused-vars: 0*/
-/**
- * Constructor for the result of checks
- * @param {Check} check
- */
-function CheckResult(check) {
-	'use strict';
-
-	/**
-	 * ID of the check.  Unique in the context of a rule.
-	 * @type {String}
-	 */
-	this.id = check.id;
-
-	/**
-	 * Any data passed by Check (by calling `this.data()`)
-	 * @type {Mixed}
-	 */
-	this.data = null;
-
-	/**
-	 * Any node that is related to the Check, specified by calling `this.relatedNodes([HTMLElement...])` inside the Check
-	 * @type {Array}
-	 */
-	this.relatedNodes = [];
-
-	/**
-	 * The return value of the Check's evaluate function
-	 * @type {Mixed}
-	 */
-	this.result = null;
-}

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

@@ -1,170 +0,0 @@
-/*global CheckResult,DqElement */
-
-function createExecutionContext(spec) {
-	/*eslint no-eval:0 */
-	'use strict';
-	if (typeof spec === 'string') {
-		return new Function('return ' + spec + ';')();
-	}
-	return spec;
-}
-
-function Check(spec) {
-	if (spec) {
-		this.id = spec.id;
-		this.configure(spec);
-	}
-}
-
-/**
- * Unique ID for the check.  Checks may be re-used, so there may be additional instances of checks
- * with the same ID.
- * @type {String}
- */
-// Check.prototype.id;
-
-/**
- * Free-form options that are passed as the second parameter to the `evaluate`
- * @type {Mixed}
- */
-// Check.prototype.options;
-
-/**
- * The actual code, accepts 2 parameters: node (the node under test), options (see this.options).
- * This function is run in the context of a checkHelper, which has the following methods
- * - `async()` - if called, the check is considered to be asynchronous; returns a callback function
- * - `data()` - free-form data object, associated to the `CheckResult` which is specific to each node
- * @type {Function}
- */
-// Check.prototype.evaluate;
-
-/**
- * Optional. Filter and/or modify checks for all nodes
- * @type {Function}
- */
-// Check.prototype.after;
-
-/**
- * enabled by default, if false, this check will not be included in the rule's evaluation
- * @type {Boolean}
- */
-Check.prototype.enabled = true;
-
-/**
- * Run the check's evaluate function (call `this.evaluate(node, options)`)
- * @param  {HTMLElement} node  The node to test
- * @param  {Object} options    The options that override the defaults and provide additional
- *                             information for the check
- * @param  {Function} callback Function to fire when check is complete
- */
-Check.prototype.run = function(node, options, context, resolve, reject) {
-	'use strict';
-	options = options || {};
-	var enabled = options.hasOwnProperty('enabled')
-			? options.enabled
-			: this.enabled,
-		checkOptions = options.options || this.options;
-
-	if (enabled) {
-		var checkResult = new CheckResult(this);
-		var checkHelper = axe.utils.checkHelper(
-			checkResult,
-			options,
-			resolve,
-			reject
-		);
-		var result;
-
-		try {
-			result = this.evaluate.call(
-				checkHelper,
-				node.actualNode,
-				checkOptions,
-				node,
-				context
-			);
-		} catch (e) {
-			// In the "Audit#run: should run all the rules" test, there is no `node` here. I do
-			// not know if this is intentional or not, so to be safe, we guard against the
-			// possible reference error.
-			if (node && node.actualNode) {
-				// Save a reference to the node we errored on for futher debugging.
-				e.errorNode = new DqElement(node.actualNode).toJSON();
-			}
-			reject(e);
-			return;
-		}
-
-		if (!checkHelper.isAsync) {
-			checkResult.result = result;
-			resolve(checkResult);
-		}
-	} else {
-		resolve(null);
-	}
-};
-
-/**
- * Run the check's evaluate function (call `this.evaluate(node, options)`) synchronously
- * @param  {HTMLElement} node  The node to test
- * @param  {Object} options    The options that override the defaults and provide additional
- *                             information for the check
- */
-Check.prototype.runSync = function(node, options, context) {
-	options = options || {};
-	const { enabled = this.enabled } = options;
-
-	if (!enabled) {
-		return null;
-	}
-
-	const checkOptions = options.options || this.options;
-	const checkResult = new CheckResult(this);
-	const checkHelper = axe.utils.checkHelper(checkResult, options);
-
-	// throw error if a check is run that requires async behavior
-	checkHelper.async = function() {
-		throw new Error('Cannot run async check while in a synchronous run');
-	};
-
-	let result;
-
-	try {
-		result = this.evaluate.call(
-			checkHelper,
-			node.actualNode,
-			checkOptions,
-			node,
-			context
-		);
-	} catch (e) {
-		// In the "Audit#run: should run all the rules" test, there is no `node` here. I do
-		// not know if this is intentional or not, so to be safe, we guard against the
-		// possible reference error.
-		if (node && node.actualNode) {
-			// Save a reference to the node we errored on for futher debugging.
-			e.errorNode = new DqElement(node.actualNode).toJSON();
-		}
-		throw e;
-	}
-
-	checkResult.result = result;
-	return checkResult;
-};
-
-/**
- * Override a check's settings after construction to allow for changing options
- * without having to implement the entire check
- *
- * @param {Object} spec - the specification of the attributes to be changed
- */
-
-Check.prototype.configure = function(spec) {
-	['options', 'enabled']
-		.filter(prop => spec.hasOwnProperty(prop))
-		.forEach(prop => (this[prop] = spec[prop]));
-
-	['evaluate', 'after']
-		.filter(prop => spec.hasOwnProperty(prop))
-		.forEach(prop => (this[prop] = createExecutionContext(spec[prop])));
-};

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

@@ -1,274 +0,0 @@
-/*exported Context */
-/*global isNodeInContext */
-/**
- * Pushes a unique frame onto `frames` array, filtering any hidden iframes
- * @private
- * @param  {Array} collection The array of unique frames that is being operated on
- * @param  {HTMLElement} frame   The frame to push onto Context
- */
-function pushUniqueFrame(collection, frame) {
-	'use strict';
-	if (axe.utils.isHidden(frame)) {
-		return;
-	}
-
-	var fr = axe.utils.findBy(collection, 'node', frame);
-
-	if (!fr) {
-		collection.push({
-			node: frame,
-			include: [],
-			exclude: []
-		});
-	}
-}
-
-/**
- * Unshift selectors of matching iframes
- * @private
- * @param  {Context} context 	  The context object to operate on and assign to
- * @param  {String} type          The "type" of context, 'include' or 'exclude'
- * @param  {Array} selectorArray  Array of CSS selectors, each element represents a frame;
- * where the last element is the actual node
- */
-function pushUniqueFrameSelector(context, type, selectorArray) {
-	'use strict';
-
-	context.frames = context.frames || [];
-
-	var result, frame;
-	var frames = document.querySelectorAll(selectorArray.shift());
-
-	frameloop: for (var i = 0, l = frames.length; i < l; i++) {
-		frame = frames[i];
-		for (var j = 0, l2 = context.frames.length; j < l2; j++) {
-			if (context.frames[j].node === frame) {
-				context.frames[j][type].push(selectorArray);
-				break frameloop;
-			}
-		}
-		result = {
-			node: frame,
-			include: [],
-			exclude: []
-		};
-
-		if (selectorArray) {
-			result[type].push(selectorArray);
-		}
-
-		context.frames.push(result);
-	}
-}
-
-/**
- * Normalize the input of "context" so that many different methods of input are accepted
- * @private
- * @param  {Mixed} context  The configuration object passed to `Context`
- * @return {Object}         Normalized context spec to include both `include` and `exclude` arrays
- */
-function normalizeContext(context) {
-	'use strict';
-
-	// typeof NodeList.length in PhantomJS === function
-	if ((context && typeof context === 'object') || context instanceof NodeList) {
-		if (context instanceof Node) {
-			return {
-				include: [context],
-				exclude: []
-			};
-		}
-
-		if (
-			context.hasOwnProperty('include') ||
-			context.hasOwnProperty('exclude')
-		) {
-			return {
-				include:
-					context.include && +context.include.length
-						? context.include
-						: [document],
-				exclude: context.exclude || []
-			};
-		}
-
-		if (context.length === +context.length) {
-			return {
-				include: context,
-				exclude: []
-			};
-		}
-	}
-
-	if (typeof context === 'string') {
-		return {
-			include: [context],
-			exclude: []
-		};
-	}
-
-	return {
-		include: [document],
-		exclude: []
-	};
-}
-
-/**
- * Finds frames in context, converts selectors to Element references and pushes unique frames
- * @private
- * @param  {Context} context The instance of Context to operate on
- * @param  {String} type     The "type" of thing to parse, "include" or "exclude"
- * @return {Array}           Parsed array of matching elements
- */
-function parseSelectorArray(context, type) {
-	'use strict';
-
-	var item,
-		result = [],
-		nodeList;
-	for (var i = 0, l = context[type].length; i < l; i++) {
-		item = context[type][i];
-		// selector
-		if (typeof item === 'string') {
-			nodeList = Array.from(document.querySelectorAll(item));
-			//eslint no-loop-func:0
-			result = result.concat(
-				nodeList.map(node => {
-					return axe.utils.getNodeFromTree(node);
-				})
-			);
-			break;
-		} else if (item && item.length && !(item instanceof Node)) {
-			if (item.length > 1) {
-				pushUniqueFrameSelector(context, type, item);
-			} else {
-				nodeList = Array.from(document.querySelectorAll(item[0]));
-				//eslint no-loop-func:0
-				result = result.concat(
-					nodeList.map(node => {
-						return axe.utils.getNodeFromTree(node);
-					})
-				);
-			}
-		} else if (item instanceof Node) {
-			if (item.documentElement instanceof Node) {
-				result.push(context.flatTree[0]);
-			} else {
-				result.push(axe.utils.getNodeFromTree(item));
-			}
-		}
-	}
-
-	// filter nulls
-	return result.filter(function(r) {
-		return r;
-	});
-}
-
-/**
- * Check that the context, as well as each frame includes at least 1 element
- * @private
- * @param  {context} context
- * @return {Error}
- */
-function validateContext(context) {
-	'use strict';
-
-	if (context.include.length === 0) {
-		if (context.frames.length === 0) {
-			var env = axe.utils.respondable.isInFrame() ? 'frame' : 'page';
-			return new Error('No elements found for include in ' + env + ' Context');
-		}
-		context.frames.forEach(function(frame, i) {
-			if (frame.include.length === 0) {
-				return new Error(
-					'No elements found for include in Context of frame ' + i
-				);
-			}
-		});
-	}
-}
-
-/**
- * For a context-like object, find its shared root node
- */
-function getRootNode({ include, exclude }) {
-	const selectors = Array.from(include).concat(Array.from(exclude));
-	// Find the first Element.ownerDocument or Document
-	for (var i = 0; i < selectors.length; ++i) {
-		var item = selectors[i];
-
-		if (item instanceof Element) {
-			return item.ownerDocument.documentElement;
-		}
-
-		if (item instanceof Document) {
-			return item.documentElement;
-		}
-	}
-
-	return document.documentElement;
-}
-
-/**
- * Holds context of includes, excludes and frames for analysis.
- *
- * @todo  clarify and sync changes to design doc
- * Context : {IncludeStrings} || {
- *   // defaults to document/all
- *   include: {IncludeStrings},
- *   exclude : {ExcludeStrings}
- * }
- *
- * IncludeStrings : [{CSSSelectorArray}] || Node
- * ExcludeStrings : [{CSSSelectorArray}]
- * `CSSSelectorArray` an Array of selector strings that addresses a Node in a multi-frame document. All addresses
- * are in this form regardless of whether the document contains any frames.To evaluate the selectors to
- * find the node referenced by the array, evaluate the selectors in-order, starting in window.top. If N
- * is the length of the array, then the first N-1 selectors should result in an iframe and the last
- * selector should result in the specific node.
- *
- * @param {Object} spec Configuration or "specification" object
- */
-function Context(spec) {
-	/* eslint no-unused-vars:0 */
-	'use strict';
-
-	this.frames = [];
-	this.initiator =
-		spec && typeof spec.initiator === 'boolean' ? spec.initiator : true;
-	this.page = false;
-
-	spec = normalizeContext(spec);
-
-	//cache the flattened tree
-	this.flatTree = axe.utils.getFlattenedTree(getRootNode(spec));
-	this.exclude = spec.exclude;
-	this.include = spec.include;
-
-	this.include = parseSelectorArray(this, 'include');
-	this.exclude = parseSelectorArray(this, 'exclude');
-
-	axe.utils.select('frame, iframe', this).forEach(frame => {
-		if (isNodeInContext(frame, this)) {
-			pushUniqueFrame(this.frames, frame.actualNode);
-		}
-	});
-
-	if (
-		this.include.length === 1 &&
-		this.include[0].actualNode === document.documentElement
-	) {
-		this.page = true;
-	}
-
-	// Validate outside of a frame
-	var err = validateContext(this);
-	if (err instanceof Error) {
-		throw err;
-	}
-	if (!Array.isArray(this.include)) {
-		this.include = Array.from(this.include);
-	}
-	this.include.sort(axe.utils.nodeSorter); // ensure that the order of the include nodes is document order
-}

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

@@ -1,39 +0,0 @@
-/*exported RuleResult */
-/*eslint no-unused-vars:0*/
-/**
- * Constructor for the result of Rules
- * @param {Rule} rule
- */
-function RuleResult(rule) {
-	'use strict';
-
-	/**
-	 * The ID of the Rule whom this result belongs to
-	 * @type {String}
-	 */
-	this.id = rule.id;
-
-	/**
-	 * The calculated result of the Rule, either PASS, FAIL or NA
-	 * @type {String}
-	 */
-	this.result = axe.constants.NA;
-
-	/**
-	 * Whether the Rule is a "pageLevel" rule
-	 * @type {Boolean}
-	 */
-	this.pageLevel = rule.pageLevel;
-
-	/**
-	 * Impact of the violation
-	 * @type {String}  Plain-english impact or null if rule passes
-	 */
-	this.impact = null;
-
-	/**
-	 * Holds information regarding nodes and individual CheckResults
-	 * @type {Array}
-	 */
-	this.nodes = [];
-}