govuk_publishing_components 30.4.1 → 30.5.0

data/node_modules/axe-core/lib/core/utils/preload-cssom.js

@@ -1,253 +0,0 @@
-/**
- * NOTE:
- * this `eslint` rule is disabled because of calling `getStyleSheetFactory` before it is defined (further below).
- */
-/* eslint no-use-before-define: 0 */
-
-/**
- * Given a rootNode - construct CSSOM
- * -> get all source nodes (document & document fragments) within given root node
- * -> recursively call `axe.utils.parseStylesheets` to resolve styles for each node
- *
- * @method preloadCssom
- * @memberof `axe.utils`
- * @param {Object} options composite options object
- * @property {Array<String>} options.assets array of preloaded assets requested, eg: [`cssom`]
- * @property {Number} options.timeout timeout
- * @property {Object} options.treeRoot (optional) the DOM tree to be inspected
- * @returns {Promise}
- */
-axe.utils.preloadCssom = function preloadCssom({ treeRoot = axe._tree[0] }) {
-	/**
-	 * get all `document` and `documentFragment` with in given `tree`
-	 */
-	const rootNodes = getAllRootNodesInTree(treeRoot);
-
-	if (!rootNodes.length) {
-		return Promise.resolve();
-	}
-
-	const dynamicDoc = document.implementation.createHTMLDocument(
-		'Dynamic document for loading cssom'
-	);
-
-	const convertDataToStylesheet = axe.utils.getStyleSheetFactory(dynamicDoc);
-
-	return getCssomForAllRootNodes(
-		rootNodes,
-		convertDataToStylesheet
-	).then(assets => flattenAssets(assets));
-};
-
-/**
- * Returns am array of source nodes containing `document` and `documentFragment` in a given `tree`.
- *
- * @param {Object} treeRoot tree
- * @returns {Array<Object>} array of objects, which each object containing a root and an optional `shadowId`
- */
-function getAllRootNodesInTree(tree) {
-	let ids = [];
-
-	const rootNodes = axe.utils
-		.querySelectorAllFilter(tree, '*', node => {
-			if (ids.includes(node.shadowId)) {
-				return false;
-			}
-			ids.push(node.shadowId);
-			return true;
-		})
-		.map(node => {
-			return {
-				shadowId: node.shadowId,
-				rootNode: axe.utils.getRootNode(node.actualNode)
-			};
-		});
-
-	return axe.utils.uniqueArray(rootNodes, []);
-}
-
-/**
- * Process CSSOM on all root nodes
- *
- * @param {Array<Object>} rootNodes array of root nodes, where node  is an enhanced `document` or `documentFragment` object returned from `getAllRootNodesInTree`
- * @param {Function} convertDataToStylesheet fn to convert given data to Stylesheet object
- * @returns {Promise}
- */
-function getCssomForAllRootNodes(rootNodes, convertDataToStylesheet) {
-	const promises = [];
-
-	rootNodes.forEach(({ rootNode, shadowId }, index) => {
-		const sheets = getStylesheetsOfRootNode(
-			rootNode,
-			shadowId,
-			convertDataToStylesheet
-		);
-		if (!sheets) {
-			return Promise.all(promises);
-		}
-
-		const rootIndex = index + 1;
-		const parseOptions = {
-			rootNode,
-			shadowId,
-			convertDataToStylesheet,
-			rootIndex
-		};
-		/**
-		 * Note:
-		 * `importedUrls` - keeps urls of already imported stylesheets, to prevent re-fetching
-		 * eg: nested, cyclic or cross referenced `@import` urls
-		 */
-		const importedUrls = [];
-
-		const p = Promise.all(
-			sheets.map((sheet, sheetIndex) => {
-				const priority = [rootIndex, sheetIndex];
-
-				return axe.utils.parseStylesheet(
-					sheet,
-					parseOptions,
-					priority,
-					importedUrls
-				);
-			})
-		);
-
-		promises.push(p);
-	});
-
-	return Promise.all(promises);
-}
-
-/**
- * Flatten CSSOM assets
- *
- * @param {Array.<Object[]>} assets nested assets (varying depth)
- * @returns {Array<Object>} Array of CSSOM object
- */
-function flattenAssets(assets) {
-	return assets.reduce(
-		(acc, val) =>
-			Array.isArray(val) ? acc.concat(flattenAssets(val)) : acc.concat(val),
-		[]
-	);
-}
-
-/**
- * Get stylesheet(s) for root
- *
- * @param {Object} options.rootNode `document` or `documentFragment`
- * @param {String} options.shadowId an id if undefined denotes that given root is a document fragment/ shadowDOM
- * @param {Function} options.convertDataToStylesheet a utility function to generate a style sheet from given data (text)
- * @returns {Array<Object>} an array of stylesheets
- */
-function getStylesheetsOfRootNode(rootNode, shadowId, convertDataToStylesheet) {
-	let sheets;
-
-	// nodeType === 11  -> DOCUMENT_FRAGMENT
-	if (rootNode.nodeType === 11 && shadowId) {
-		sheets = getStylesheetsFromDocumentFragment(
-			rootNode,
-			convertDataToStylesheet
-		);
-	} else {
-		sheets = getStylesheetsFromDocument(rootNode);
-	}
-
-	return filterStylesheetsWithSameHref(sheets);
-}
-
-/**
- * Get stylesheets from `documentFragment`
- *
- * @property {Object} options.rootNode `documentFragment`
- * @property {Function} options.convertDataToStylesheet a utility function to generate a stylesheet from given data
- * @returns {Array<Object>}
- */
-function getStylesheetsFromDocumentFragment(rootNode, convertDataToStylesheet) {
-	return (
-		Array.from(rootNode.children)
-			.filter(filerStyleAndLinkAttributesInDocumentFragment)
-			// Reducer to convert `<style></style>` and `<link>` references to `CSSStyleSheet` object
-			.reduce((out, node) => {
-				const nodeName = node.nodeName.toUpperCase();
-				const data = nodeName === 'STYLE' ? node.textContent : node;
-				const isLink = nodeName === 'LINK';
-				const stylesheet = convertDataToStylesheet({
-					data,
-					isLink,
-					root: rootNode
-				});
-				out.push(stylesheet.sheet);
-				return out;
-			}, [])
-	);
-}
-
-/**
- * Get stylesheets from `document`
- * -> filter out stylesheet that are `media=print`
- *
- * @param {Object} rootNode `document`
- * @returns {Array<Object>}
- */
-function getStylesheetsFromDocument(rootNode) {
-	return Array.from(rootNode.styleSheets).filter(sheet =>
-		filterMediaIsPrint(sheet.media.mediaText)
-	);
-}
-
-/**
- * Get all `<style></style>` and `<link>` attributes
- * -> limit to only `style` or `link` attributes with `rel=stylesheet` and `media != print`
- *
- * @param {Object} node HTMLElement
- * @returns {Boolean}
- */
-function filerStyleAndLinkAttributesInDocumentFragment(node) {
-	const nodeName = node.nodeName.toUpperCase();
-	const linkHref = node.getAttribute('href');
-	const linkRel = node.getAttribute('rel');
-	const isLink =
-		nodeName === 'LINK' &&
-		linkHref &&
-		linkRel &&
-		node.rel.toUpperCase().includes('STYLESHEET');
-	const isStyle = nodeName === 'STYLE';
-	return isStyle || (isLink && filterMediaIsPrint(node.media));
-}
-
-/**
- * Exclude `link[rel='stylesheet]` attributes where `media=print`
- *
- * @param {String} media media value eg: 'print'
- * @returns {Boolean}
- */
-function filterMediaIsPrint(media) {
-	if (!media) {
-		return true;
-	}
-	return !media.toUpperCase().includes('PRINT');
-}
-
-/**
- * Exclude any duplicate `stylesheets`, that share the same `href`
- *
- * @param {Array<Object>} sheets stylesheets
- * @returns {Array<Object>}
- */
-function filterStylesheetsWithSameHref(sheets) {
-	let hrefs = [];
-	return sheets.filter(sheet => {
-		if (!sheet.href) {
-			// include sheets without `href`
-			return true;
-		}
-		// if `href` is present, ensure they are not duplicates
-		if (hrefs.includes(sheet.href)) {
-			return false;
-		}
-		hrefs.push(sheet.href);
-		return true;
-	});
-}

data/node_modules/axe-core/lib/core/utils/preload-media.js

@@ -1,65 +0,0 @@
-/**
- * Given a rootNode
- * -> get all HTMLMediaElement's and ensure their metadata is loaded
- *
- * @method preloadMedia
- * @memberof axe.utils
- * @property {Object} options.treeRoot (optional) the DOM tree to be inspected
- */
-axe.utils.preloadMedia = function preloadMedia({ treeRoot = axe._tree[0] }) {
-	const mediaVirtualNodes = axe.utils.querySelectorAllFilter(
-		treeRoot,
-		'video, audio',
-		({ actualNode }) => {
-			/**
-			 * this is to safe-gaurd against empty `src` values which can get resolved `window.location`, thus never preloading as the URL is not a media asset
-			 */
-			if (actualNode.hasAttribute('src')) {
-				return !!actualNode.getAttribute('src');
-			}
-
-			/**
-			 * The `src` on <source> element is essential for `audio` and `video` elements
-			 */
-			const sourceWithSrc = Array.from(
-				actualNode.getElementsByTagName('source')
-			).filter(source => !!source.getAttribute('src'));
-			if (sourceWithSrc.length <= 0) {
-				return false;
-			}
-
-			return true;
-		}
-	);
-
-	return Promise.all(
-		mediaVirtualNodes.map(({ actualNode }) => isMediaElementReady(actualNode))
-	);
-};
-
-/**
- * Ensures a media element's metadata is loaded
- * @param {HTMLMediaElement} elm elm
- * @returns {Promise}
- */
-function isMediaElementReady(elm) {
-	return new Promise(resolve => {
-		/**
-		 * See - https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/readyState
-		 */
-		if (elm.readyState > 0) {
-			resolve(elm);
-		}
-
-		function onMediaReady() {
-			elm.removeEventListener('loadedmetadata', onMediaReady);
-			resolve(elm);
-		}
-
-		/**
-		 * Given media is not ready, wire up listener for `loadedmetadata`
-		 * See - https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/loadedmetadata_event
-		 */
-		elm.addEventListener('loadedmetadata', onMediaReady);
-	});
-}

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

@@ -1,144 +0,0 @@
-/**
- * Validated the preload object
- * @param {Object | boolean} preload configuration object or boolean passed via the options parameter to axe.run
- * @return {boolean}
- * @private
- */
-function isValidPreloadObject(preload) {
-	return typeof preload === 'object' && Array.isArray(preload.assets);
-}
-
-/**
- * Returns a boolean which decides if preload is configured
- * @param {Object} options run configuration options (or defaults) passed via axe.run
- * @return {boolean} defaults to true
- */
-axe.utils.shouldPreload = function shouldPreload(options) {
-	if (!options || options.preload === undefined || options.preload === null) {
-		return true; // by default `preload` requested assets eg: ['cssom']
-	}
-	if (typeof options.preload === 'boolean') {
-		return options.preload;
-	}
-	return isValidPreloadObject(options.preload);
-};
-
-/**
- * Constructs a configuration object representing the preload requested assets & timeout
- * @param {Object} options run configuration options (or defaults) passed via axe.run
- * @return {Object} configuration
- */
-axe.utils.getPreloadConfig = function getPreloadConfig(options) {
-	const { assets, timeout } = axe.constants.preload;
-	const config = {
-		assets,
-		timeout
-	};
-
-	// if no `preload` is configured via `options` - return default config
-	if (!options.preload) {
-		return config;
-	}
-
-	// if type is boolean
-	if (typeof options.preload === 'boolean') {
-		return config;
-	}
-
-	// check if requested assets to preload are valid items
-	const areRequestedAssetsValid = options.preload.assets.every(a =>
-		assets.includes(a.toLowerCase())
-	);
-
-	if (!areRequestedAssetsValid) {
-		throw new Error(
-			`Requested assets, not supported. ` +
-				`Supported assets are: ${assets.join(', ')}.`
-		);
-	}
-
-	// unique assets to load, in case user had requested same asset type many times.
-	config.assets = axe.utils.uniqueArray(
-		options.preload.assets.map(a => a.toLowerCase()),
-		[]
-	);
-
-	if (
-		options.preload.timeout &&
-		typeof options.preload.timeout === 'number' &&
-		!isNaN(options.preload.timeout)
-	) {
-		config.timeout = options.preload.timeout;
-	}
-	return config;
-};
-
-/**
- * Returns a Promise with results of all requested preload(able) assets. eg: ['cssom'].
- *
- * @param {Object} options run configuration options (or defaults) passed via axe.run
- * @return {Object} Promise
- */
-axe.utils.preload = function preload(options) {
-	const preloadFunctionsMap = {
-		cssom: axe.utils.preloadCssom,
-		media: axe.utils.preloadMedia
-	};
-
-	const shouldPreload = axe.utils.shouldPreload(options);
-	if (!shouldPreload) {
-		return Promise.resolve();
-	}
-
-	return new Promise((resolve, reject) => {
-		const { assets, timeout } = axe.utils.getPreloadConfig(options);
-
-		/**
-		 * Start `timeout` timer for preloading assets
-		 * -> reject if allowed time expires.
-		 */
-		const preloadTimeout = setTimeout(
-			() => reject(new Error(`Preload assets timed out.`)),
-			timeout
-		);
-
-		/**
-		 * Fetch requested `assets`
-		 */
-		Promise.all(
-			assets.map(asset =>
-				preloadFunctionsMap[asset](options).then(results => {
-					return {
-						[asset]: results
-					};
-				})
-			)
-		)
-			.then(results => {
-				/**
-				 * Combine array of results into an object map
-				 *
-				 * From ->
-				 * 	[{cssom: [...], aom: [...]}]
-				 * To ->
-				 * 	{
-				 * 		cssom: [...]
-				 * 	 	aom: [...]
-				 * 	}
-				 */
-				const preloadAssets = results.reduce((out, result) => {
-					return {
-						...out,
-						...result
-					};
-				}, {});
-
-				clearTimeout(preloadTimeout);
-				resolve(preloadAssets);
-			})
-			.catch(err => {
-				clearTimeout(preloadTimeout);
-				reject(err);
-			});
-	});
-};

data/node_modules/axe-core/lib/core/utils/process-message.js

@@ -1,72 +0,0 @@
-/* global helpers */
-const dataRegex = /\$\{\s?data\s?\}/g;
-
-/**
- * Replace a placeholder with the value of a data string or object
- * @param {String} str
- * @param {String|Object} data
- */
-function substitute(str, data) {
-	// replace all instances of ${ data } with the value of the string
-	if (typeof data === 'string') {
-		return str.replace(dataRegex, data);
-	}
-
-	// replace all instances of ${ data[prop] } with the value of the property
-	for (const prop in data) {
-		if (data.hasOwnProperty(prop)) {
-			const regex = new RegExp('\\${\\s?data\\.' + prop + '\\s?}', 'g');
-			str = str.replace(regex, data[prop]);
-		}
-	}
-
-	return str;
-}
-
-/**
- * Process a metadata message.
- * @param {String|Object} message
- * @param {Object} data
- * @return {String}
- */
-axe.utils.processMessage = function processMessage(message, data) {
-	if (!message) {
-		return;
-	}
-
-	// data as array
-	if (Array.isArray(data)) {
-		data.values = data.join(', ');
-
-		if (
-			typeof message.singular === 'string' &&
-			typeof message.plural === 'string'
-		) {
-			const str = data.length === 1 ? message.singular : message.plural;
-			return substitute(str, data);
-		}
-
-		// no singular/plural message so just pass data
-		return substitute(message, data);
-	}
-
-	// message is a string that uses data as a string or object properties
-	if (typeof message === 'string') {
-		return substitute(message, data);
-	}
-
-	// message is an object that uses value of data to determine message
-	if (typeof data === 'string') {
-		const str = message[data];
-		return substitute(str, data);
-	}
-
-	// message uses value of data property to determine message
-	let str = message.default || helpers.incompleteFallbackMessage();
-
-	if (data && data.messageKey && message[data.messageKey]) {
-		str = message[data.messageKey];
-	}
-
-	return processMessage(str, data);
-};

data/node_modules/axe-core/lib/core/utils/publish-metadata.js

@@ -1,106 +0,0 @@
-/* global helpers */
-/**
- * Construct incomplete message from check.data
- * @param  {Object} checkData Check result with reason specified
- * @param  {Object} messages Source data object with message options
- * @return  {String}
- * @private
- */
-function getIncompleteReason(checkData, messages) {
-	function getDefaultMsg(messages) {
-		if (messages.incomplete && messages.incomplete.default) {
-			// fall back to the default message if no reason specified
-			return messages.incomplete.default;
-		} else {
-			return helpers.incompleteFallbackMessage();
-		}
-	}
-	if (checkData && checkData.missingData) {
-		try {
-			var msg = messages.incomplete[checkData.missingData[0].reason];
-			if (!msg) {
-				throw new Error();
-			}
-			return msg;
-		} catch (e) {
-			if (typeof checkData.missingData === 'string') {
-				// return a string with the appropriate reason
-				return messages.incomplete[checkData.missingData];
-			} else {
-				return getDefaultMsg(messages);
-			}
-		}
-	} else if (checkData && checkData.messageKey) {
-		return messages.incomplete[checkData.messageKey];
-	} else {
-		return getDefaultMsg(messages);
-	}
-}
-
-/**
- * Extend checksData with the correct result message
- * @param  {Object} checksData The check result data
- * @param  {Boolean} shouldBeTrue Result of pass/fail check run
- * @return {Function}
- * @private
- */
-function extender(checksData, shouldBeTrue) {
-	'use strict';
-	return function(check) {
-		var sourceData = checksData[check.id] || {};
-		var messages = sourceData.messages || {};
-		var data = Object.assign({}, sourceData);
-		delete data.messages;
-		if (check.result === undefined) {
-			// handle old doT template
-			if (
-				typeof messages.incomplete === 'object' &&
-				!Array.isArray(check.data)
-			) {
-				data.message = getIncompleteReason(check.data, messages);
-			}
-
-			// fallback to new process message style
-			if (!data.message) {
-				data.message = messages.incomplete;
-			}
-		} else {
-			data.message =
-				check.result === shouldBeTrue ? messages.pass : messages.fail;
-		}
-
-		// don't process doT template functions
-		if (typeof data.message !== 'function') {
-			data.message = axe.utils.processMessage(data.message, check.data);
-		}
-
-		axe.utils.extendMetaData(check, data);
-	};
-}
-
-/**
- * Publish metadata from axe._audit.data
- * @param  {RuleResult} result Result to publish to
- * @private
- */
-axe.utils.publishMetaData = function(ruleResult) {
-	'use strict';
-
-	var checksData = axe._audit.data.checks || {};
-	var rulesData = axe._audit.data.rules || {};
-	var rule = axe.utils.findBy(axe._audit.rules, 'id', ruleResult.id) || {};
-
-	ruleResult.tags = axe.utils.clone(rule.tags || []);
-
-	var shouldBeTrue = extender(checksData, true);
-	var shouldBeFalse = extender(checksData, false);
-	ruleResult.nodes.forEach(function(detail) {
-		detail.any.forEach(shouldBeTrue);
-		detail.all.forEach(shouldBeTrue);
-		detail.none.forEach(shouldBeFalse);
-	});
-	axe.utils.extendMetaData(
-		ruleResult,
-		axe.utils.clone(rulesData[ruleResult.id] || {})
-	);
-};