govuk_publishing_components 21.16.3 → 21.17.0

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

@@ -0,0 +1,17 @@
+/**
+ * Memoize a function.
+ * @method memoize
+ * @memberof axe.utils
+ * @param {Function} fn Function to memoize
+ * @return {Function}
+ */
+axe._memoizedFns = [];
+axe.utils.memoize = function(fn) {
+	// keep track of each function that is memoized so it can be cleared at
+	// the end of a run. each memoized function has its own cache, so there is
+	// no method to clear all memoized caches. instead, we have to clear each
+	// individual memoized function ourselves.
+	const memoized = axe.imports.memoize(fn);
+	axe._memoizedFns.push(memoized);
+	return memoized;
+};

data/node_modules/axe-core/lib/core/utils/parse-crossorigin-stylesheet.js

@@ -0,0 +1,53 @@
+/**
+ * Parse cross-origin stylesheets
+ *
+ * @method parseCrossOriginStylesheet
+ * @memberof axe.utils
+ * @param {String} url url from which to fetch stylesheet
+ * @param {Object} options options object from `axe.utils.parseStylesheet`
+ * @param {Array<Number>} priority sheet priority
+ * @param {Array<String>} importedUrls urls of already imported stylesheets
+ * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`
+ * @returns {Promise}
+ */
+axe.utils.parseCrossOriginStylesheet = function parseCrossOriginStylesheet(
+	url,
+	options,
+	priority,
+	importedUrls,
+	isCrossOrigin
+) {
+	const axiosOptions = {
+		method: 'get',
+		url
+	};
+
+	/**
+	 * Add `url` to `importedUrls`
+	 */
+	importedUrls.push(url);
+
+	/**
+	 * Fetch `cross-origin stylesheet` via axios
+	 */
+	return axe.imports.axios(axiosOptions).then(({ data }) => {
+		const result = options.convertDataToStylesheet({
+			data,
+			isCrossOrigin,
+			priority,
+			root: options.rootNode,
+			shadowId: options.shadowId
+		});
+
+		/**
+		 * Parse resolved stylesheet further for any `@import` styles
+		 */
+		return axe.utils.parseStylesheet(
+			result.sheet,
+			options,
+			priority,
+			importedUrls,
+			result.isCrossOrigin
+		);
+	});
+};

data/node_modules/axe-core/lib/core/utils/parse-sameorigin-stylesheet.js

@@ -0,0 +1,96 @@
+/**
+ * Parse non cross-origin stylesheets
+ *
+ * @method parseSameOriginStylesheet
+ * @memberof axe.utils
+ * @param {Object} sheet CSSStylesheet object
+ * @param {Object} options options object from `axe.utils.parseStylesheet`
+ * @param {Array<Number>} priority sheet priority
+ * @param {Array<String>} importedUrls urls of already imported stylesheets
+ * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`
+ * @returns {Promise}
+ */
+axe.utils.parseSameOriginStylesheet = function parseSameOriginStylesheet(
+	sheet,
+	options,
+	priority,
+	importedUrls,
+	isCrossOrigin = false
+) {
+	const rules = Array.from(sheet.cssRules);
+
+	if (!rules) {
+		return Promise.resolve();
+	}
+
+	/**
+	 * reference -> https://developer.mozilla.org/en-US/docs/Web/API/CSSRule#Type_constants
+	 */
+	const cssImportRules = rules.filter(r => r.type === 3); // type === 3 -> CSSRule.IMPORT_RULE
+
+	/**
+	 * when no `@import` rules in given sheet -> resolve the current `sheet` & exit
+	 */
+	if (!cssImportRules.length) {
+		// exit
+		return Promise.resolve({
+			isCrossOrigin,
+			priority,
+			root: options.rootNode,
+			shadowId: options.shadowId,
+			sheet
+		});
+	}
+
+	/**
+	 * filter rules that are not already fetched
+	 */
+	const cssImportUrlsNotAlreadyImported = cssImportRules
+		// ensure rule has a href
+		.filter(rule => rule.href)
+		// extract href from object
+		.map(rule => rule.href)
+		// only href that are not already imported
+		.filter(url => !importedUrls.includes(url));
+
+	/**
+	 * iterate `@import` rules and fetch styles
+	 */
+	const promises = cssImportUrlsNotAlreadyImported.map(
+		(importUrl, cssRuleIndex) => {
+			const newPriority = [...priority, cssRuleIndex];
+			const isCrossOriginRequest = /^https?:\/\/|^\/\//i.test(importUrl);
+
+			return axe.utils.parseCrossOriginStylesheet(
+				importUrl,
+				options,
+				newPriority,
+				importedUrls,
+				isCrossOriginRequest
+			);
+		}
+	);
+
+	const nonImportCSSRules = rules.filter(r => r.type !== 3);
+
+	// no further rules to process in this sheet
+	if (!nonImportCSSRules.length) {
+		return Promise.all(promises);
+	}
+
+	// convert all `nonImportCSSRules` style rules into `text` and chain
+
+	promises.push(
+		Promise.resolve(
+			options.convertDataToStylesheet({
+				data: nonImportCSSRules.map(rule => rule.cssText).join(),
+				isCrossOrigin,
+				priority,
+				root: options.rootNode,
+				shadowId: options.shadowId
+			})
+		)
+	);
+
+	return Promise.all(promises);
+};

data/node_modules/axe-core/lib/core/utils/parse-stylesheet.js

@@ -0,0 +1,70 @@
+/**
+ * Parse a given stylesheet
+ *
+ * @method parseStylesheet
+ * @memberof axe.utils
+ * @param {Object} sheet stylesheet to parse
+ * @param {Object} options configuration options object from `axe.utils.parseStylesheets`
+ * @param {Array<Number>} priority priority of stylesheet
+ * @param {Array<String>} importedUrls list of resolved `@import` urls
+ * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`, passed for re-parsing `cross-origin` sheets
+ * @returns {Promise}
+ */
+axe.utils.parseStylesheet = function parseStylesheet(
+	sheet,
+	options,
+	priority,
+	importedUrls,
+	isCrossOrigin = false
+) {
+	const isSameOrigin = isSameOriginStylesheet(sheet);
+	if (isSameOrigin) {
+		/**
+		 * resolve `same-origin` stylesheet
+		 */
+		return axe.utils.parseSameOriginStylesheet(
+			sheet,
+			options,
+			priority,
+			importedUrls,
+			isCrossOrigin
+		);
+	}
+
+	/**
+	 * resolve `cross-origin` stylesheet
+	 */
+	return axe.utils.parseCrossOriginStylesheet(
+		sheet.href,
+		options,
+		priority,
+		importedUrls,
+		true // -> isCrossOrigin
+	);
+};
+
+/**
+ * Check if a given stylesheet is from the `same-origin`
+ * Note:
+ * `sheet.cssRules` throws an error on `cross-origin` stylesheets
+ *
+ * @param {Object} sheet CSS stylesheet
+ * @returns {Boolean}
+ */
+function isSameOriginStylesheet(sheet) {
+	try {
+		/*eslint no-unused-vars: 0*/
+		const rules = sheet.cssRules;
+
+		/**
+		 * Safari, does not throw an error when accessing cssRules property,
+		 */
+		if (!rules && sheet.href) {
+			return false;
+		}
+
+		return true;
+	} catch (e) {
+		return false;
+	}
+}

data/node_modules/axe-core/lib/core/utils/performance-timer.js

@@ -27,7 +27,7 @@ utils.performanceTimer = (function() {
 	 */
 	return {
 		/**
-		 * @member {Function} start Kicks off performance timing for overall aXe audit
+		 * @member {Function} start Kicks off performance timing for overall axe audit
 		 */
 		start: function() {
 			this.mark('mark_axe_start');
@@ -90,7 +90,12 @@ utils.performanceTimer = (function() {
 				window.performance &&
 				window.performance.getEntriesByType !== undefined
 			) {
-				var measures = window.performance.getEntriesByType('measure');
+				// only output measures that were started after axe started, otherwise
+				// we get measures made by the page before axe ran (which is confusing)
+				var axeStart = window.performance.getEntriesByName('mark_axe_start')[0];
+				var measures = window.performance
+					.getEntriesByType('measure')
+					.filter(measure => measure.startTime >= axeStart.startTime);
 				for (var i = 0; i < measures.length; ++i) {
 					var req = measures[i];
 					if (req.name === measureName) {

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

@@ -1,51 +1,41 @@
 /**
- * NOTE: 
+ * 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 `loadCssom` to resolve styles
+ * -> recursively call `axe.utils.parseStylesheets` to resolve styles for each node
  *
  * @method preloadCssom
  * @memberof `axe.utils`
- *
- * @param {Object} object argument which is a composite object, with attributes timeout, treeRoot(optional), resolve & reject
- * @property {Number} timeout timeout for any network calls made
- * @property {Object} treeRoot the DOM tree to be inspected
- * @returns {Object} `axe.utils.queue` with CSSOM assets
+ * @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({
-	timeout,
-	treeRoot = axe._tree[0]
-}) {
+axe.utils.preloadCssom = function preloadCssom({ treeRoot = axe._tree[0] }) {
 	/**
 	 * get all `document` and `documentFragment` with in given `tree`
 	 */
 	const rootNodes = getAllRootNodesInTree(treeRoot);
 
-	const q = axe.utils.queue();
-
 	if (!rootNodes.length) {
-		return q;
+		return Promise.resolve();
 	}
 
-	const dynamicDoc = document.implementation.createHTMLDocument();
-	const convertDataToStylesheet = getStyleSheetFactory(dynamicDoc);
+	const dynamicDoc = document.implementation.createHTMLDocument(
+		'Dynamic document for loading cssom'
+	);
 
-	q.defer((resolve, reject) => {
-		getCssomForAllRootNodes(rootNodes, convertDataToStylesheet, timeout)
-			.then(assets => {
-				const cssom = processCssomAssets(assets);
-				resolve(cssom);
-			})
-			.catch(reject);
-	});
+	const convertDataToStylesheet = axe.utils.getStyleSheetFactory(dynamicDoc);
 
-	return q;
+	return getCssomForAllRootNodes(rootNodes, convertDataToStylesheet).then(
+		assets => flattenAssets(assets)
+	);
 };
 
 /**
@@ -76,283 +66,89 @@ function getAllRootNodesInTree(tree) {
 }
 
 /**
- * Convert text to CSSStyleSheet
- * Is a factory (closure) function, initialized with `document.implementation.createHTMLDocument()` which surfaces DOM API for creating `style` elements.
- *
- * @param {Object} param `document.implementation.createHTMLDocument()
- * @param {Object} arg an object with properties to construct stylesheet
- * @property {String} arg.data text content of the stylesheet
- * @property {Boolean} arg.isExternal flag to notify if the resource was fetched from the network
- * @property {String} arg.shadowId (Optional) shadowId if shadowDOM
- * @property {Object} arg.root implementation document to create style elements
- * @property {String} arg.priority a number indicating the loaded priority of CSS, to denote specificity of styles contained in the sheet.
- */
-const getStyleSheetFactory = dynamicDoc => ({
-	data,
-	isExternal,
-	shadowId,
-	root,
-	priority,
-	isLink = false
-}) => {
-	const style = dynamicDoc.createElement('style');
-	if (isLink) {
-		// as creating a stylesheet as link will need to be awaited
-		// till `onload`, it is wise to convert link href to @import statement
-		const text = dynamicDoc.createTextNode(`@import "${data.href}"`);
-		style.appendChild(text);
-	} else {
-		style.appendChild(dynamicDoc.createTextNode(data));
-	}
-	dynamicDoc.head.appendChild(style);
-	return {
-		sheet: style.sheet,
-		isExternal,
-		shadowId,
-		root,
-		priority
-	};
-};
-
-/**
- * Deferred function for CSSOM queue processing on all root nodes
+ * 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 {Object} `axe.utils.queue`
+ * @returns {Promise}
  */
-function getCssomForAllRootNodes(rootNodes, convertDataToStylesheet, timeout) {
-	const q = axe.utils.queue();
-
-	rootNodes.forEach(({ rootNode, shadowId }, index) =>
-		q.defer((resolve, reject) =>
-			loadCssom({
-				rootNode,
-				shadowId,
-				timeout,
-				convertDataToStylesheet,
-				rootIndex: index + 1
-			})
-				.then(resolve)
-				.catch(reject)
-		)
-	);
-
-	return q;
-}
-
-/**
- * Process results from `loadCssom` queues of all root nodes
- * NOTE:
- * using `axe.utils.queue` from various `loadCssom` paths, returns a nested array of arrays at various depths,
- * hence the need to flatten arrays
- *
- * @param {Array<Object>} assets CSSOM assets for each root
- * @returns {Object} CSSOM object
- */
-function processCssomAssets(nestedAssets) {
-	const result = [];
-
-	nestedAssets.forEach(item => {
-		if (Array.isArray(item)) {
-			result.push(...processCssomAssets(item));
-		} else {
-			result.push(item);
-		}
-	});
-
-	return result;
-}
-
-/**
- * Returns `axe.utils.queue` of CSSStyleSheet(s) for a given root node
- *
- * @param {Object} options configuration options
- * @property {Object} options.rootNode document or document fragment
- * @property {Number} options.rootIndex a number representing the index of the document or document fragment, used for priority computation
- * @property {String} options.shadowId an id if undefined denotes that given root is a document fragment/ shadowDOM
- * @property {Number} options.timeout abort duration for network request
- * @property {Function} options.convertDataToStylesheet a utility function to generate a style sheet from given data (text)
- * @return {Object} queue
- */
-function loadCssom(options) {
-	const { rootIndex } = options;
-
-	const q = axe.utils.queue();
-
-	const sheets = getStylesheetsOfRootNode(options);
-	if (!sheets) {
-		return q;
-	}
-
-	sheets.forEach((sheet, sheetIndex) => {
-		const priority = [rootIndex, sheetIndex];
-		try {
-			const deferredQ = parseNonCrossOriginStylesheet(sheet, options, priority);
-			q.defer(deferredQ);
-		} catch (e) {
-			// cross-origin stylesheet -> make an XHR and q the response
-			const deferredQ = parseCrossOriginStylesheet(
-				sheet.href,
-				options,
-				priority
-			);
-			q.defer(deferredQ);
+function getCssomForAllRootNodes(rootNodes, convertDataToStylesheet) {
+	const promises = [];
+
+	rootNodes.forEach(({ rootNode, shadowId }, index) => {
+		const sheets = getStylesheetsOfRootNode(
+			rootNode,
+			shadowId,
+			convertDataToStylesheet
+		);
+		if (!sheets) {
+			return Promise.all(promises);
 		}
-	});
-
-	return q;
-}
-
-/**
- * Parse non cross-origin stylesheets
- *
- * @param {Object} sheet CSSStylesheet object
- * @param {Object} options `loadCssom` options
- * @param {Array<Number>} priority sheet priority
- */
-function parseNonCrossOriginStylesheet(sheet, options, priority) {
-	const q = axe.utils.queue();
-
-	/**
-	 * `sheet.cssRules` throws an error on `cross-origin` stylesheets
-	 */
-	const cssRules = sheet.cssRules;
 
-	const rules = Array.from(cssRules);
-	if (!rules) {
-		return q;
-	}
-
-	/**
-	 * reference -> https://developer.mozilla.org/en-US/docs/Web/API/CSSRule#Type_constants
-	 */
-	const cssImportRules = rules.filter(r => r.type === 3); // type === 3 -> CSSRule.IMPORT_RULE
-
-	/**
-	 * when no `@import` rules in given sheet
-	 * -> resolve the current `sheet` & exit
-	 */
-	if (!cssImportRules.length) {
-		q.defer(resolve =>
-			resolve({
-				isExternal: false,
-				priority,
-				root: options.rootNode,
-				shadowId: options.shadowId,
-				sheet
+		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
+				);
 			})
 		);
 
-		// exit
-		return q;
-	}
-
-	/**
-	 * iterate `@import` rules and fetch styles
-	 */
-	cssImportRules.forEach((importRule, cssRuleIndex) =>
-		q.defer((resolve, reject) => {
-			const importUrl = importRule.href;
-			const newPriority = [...priority, cssRuleIndex];
-			const axiosOptions = {
-				method: 'get',
-				url: importUrl,
-				timeout: options.timeout
-			};
-			axe.imports
-				.axios(axiosOptions)
-				.then(({ data }) =>
-					resolve(
-						options.convertDataToStylesheet({
-							data,
-							isExternal: true,
-							priority: newPriority,
-							root: options.rootNode,
-							shadowId: options.shadowId
-						})
-					)
-				)
-				.catch(reject);
-		})
-	);
-
-	const nonImportCSSRules = rules.filter(r => r.type !== 3);
-
-	// no further rules to process in this sheet
-	if (!nonImportCSSRules.length) {
-		return q;
-	}
-
-	// convert all `nonImportCSSRules` style rules into `text` and defer into queue
-	q.defer(resolve =>
-		resolve(
-			options.convertDataToStylesheet({
-				data: nonImportCSSRules.map(rule => rule.cssText).join(),
-				isExternal: false,
-				priority,
-				root: options.rootNode,
-				shadowId: options.shadowId
-			})
-		)
-	);
+		promises.push(p);
+	});
 
-	return q;
+	return Promise.all(promises);
 }
 
 /**
- * Parse cross-origin stylesheets
+ * Flatten CSSOM assets
  *
- * @param {String} url url from which to fetch stylesheet
- * @param {Object} options `loadCssom` options
- * @param {Array<Number>} priority sheet priority
+ * @param {Array.<Object[]>} assets nested assets (varying depth)
+ * @returns {Array<Object>} Array of CSSOM object
  */
-function parseCrossOriginStylesheet(url, options, priority) {
-	const q = axe.utils.queue();
-
-	if (!url) {
-		return q;
-	}
-
-	const axiosOptions = {
-		method: 'get',
-		url,
-		timeout: options.timeout
-	};
-
-	q.defer((resolve, reject) => {
-		axe.imports
-			.axios(axiosOptions)
-			.then(({ data }) =>
-				resolve(
-					options.convertDataToStylesheet({
-						data,
-						isExternal: true,
-						priority,
-						root: options.rootNode,
-						shadowId: options.shadowId
-					})
-				)
-			)
-			.catch(reject);
-	});
-
-	return q;
+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 configuration options of `loadCssom`
- * @returns an array of stylesheets
+ * @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(options) {
-	const { rootNode, shadowId } = options;
+function getStylesheetsOfRootNode(rootNode, shadowId, convertDataToStylesheet) {
 	let sheets;
 
 	// nodeType === 11  -> DOCUMENT_FRAGMENT
 	if (rootNode.nodeType === 11 && shadowId) {
-		sheets = getStylesheetsFromDocumentFragment(options);
+		sheets = getStylesheetsFromDocumentFragment(
+			rootNode,
+			convertDataToStylesheet
+		);
 	} else {
 		sheets = getStylesheetsFromDocument(rootNode);
 	}
@@ -363,11 +159,11 @@ function getStylesheetsOfRootNode(options) {
 /**
  * Get stylesheets from `documentFragment`
  *
- * @param {Object} options configuration options of `loadCssom`
+ * @property {Object} options.rootNode `documentFragment`
+ * @property {Function} options.convertDataToStylesheet a utility function to generate a stylesheet from given data
  * @returns {Array<Object>}
  */
-function getStylesheetsFromDocumentFragment(options) {
-	const { rootNode, convertDataToStylesheet } = options;
+function getStylesheetsFromDocumentFragment(rootNode, convertDataToStylesheet) {
 	return (
 		Array.from(rootNode.children)
 			.filter(filerStyleAndLinkAttributesInDocumentFragment)