govuk_publishing_components 18.1.0 → 18.1.1

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

@@ -0,0 +1,33 @@
+/*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

@@ -0,0 +1,123 @@
+/*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) {
+	/* eslint max-statements: ["error", 17] */
+	'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);
+	}
+};
+
+/**
+ * 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

@@ -0,0 +1,273 @@
+/*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) {
+	/*eslint complexity: ["error", 13] */
+	'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(context.flatTree[0], 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(context.flatTree[0], node);
+					})
+				);
+			}
+		} else if (item instanceof Node) {
+			if (item.documentElement instanceof Node) {
+				result.push(context.flatTree[0]);
+			} else {
+				result.push(axe.utils.getNodeFromTree(context.flatTree[0], 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
+	const localDocument = selectors.reduce((result, item) => {
+		if (result) {
+			return result;
+		} else if (item instanceof Element) {
+			return item.ownerDocument;
+		} else if (item instanceof Document) {
+			return item;
+		}
+	}, null);
+
+	return (localDocument || 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 max-statements:["error",22], 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

@@ -0,0 +1,39 @@
+/*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 = [];
+}