RubyGems - govuk_publishing_components - Versions diffs - 18.1.0 → 18.1.1 - Mend

govuk_publishing_components 18.1.0 → 18.1.1

Files changed (513) hide show

data/node_modules/axe-core/doc/examples/jest_react/package.json ADDED Viewed

@@ -0,0 +1,28 @@
+{
+	"name": "axe-jest-react-example",
+	"description": "aXe Jest + React Example",
+	"version": "0.0.1",
+	"private": true,
+	"author": {
+		"name": "Wilco Fiers",
+		"organization": "Deque Systems, Inc.",
+		"url": "http://deque.com/"
+	},
+	"dependencies": {},
+	"scripts": {
+		"test": "jest"
+	},
+	"devDependencies": {
+		"axe-core": "^3.1.1",
+		"babel-jest": "^23.0.0",
+		"babel-preset-es2015": "^6.24.1",
+		"babel-preset-react": "^6.24.1",
+		"enzyme": "^3.5.0",
+		"enzyme-adapter-react-16": "^1.3.0",
+		"jest": "^22.4.0",
+		"jest-cli": "^23.0.1",
+		"react": "^16.4.0",
+		"react-dom": "^16.4.0",
+		"react-test-renderer": "^16.2.0"
+	}
+}

data/node_modules/axe-core/doc/examples/jest_react/test-helpers.js ADDED Viewed

@@ -0,0 +1,21 @@
+import { configure, mount } from 'enzyme';
+import Adapter from 'enzyme-adapter-react-16';
+configure({ adapter: new Adapter() });
+let wrapper;
+export function mountToDoc(reactElm) {
+	if (!document) {
+		// Set up a basic DOM
+		global.document = jsdom('<!doctype html><html><body></body></html>');
+	}
+	if (!wrapper) {
+		wrapper = document.createElement('main');
+		document.body.appendChild(wrapper);
+	}
+	const container = mount(reactElm);
+	wrapper.innerHTML = '';
+	wrapper.appendChild(container.getDOMNode());
+	return container;
+}

data/node_modules/axe-core/doc/examples/mocha/README.md ADDED Viewed

@@ -0,0 +1,37 @@
+# Mocha README
+This example demonstrates how to use aXe with the Mocha unit testing framework.
+The unit test is in `test/a11y.js`, and has two test cases: One that shows the
+expected results from HTML with no errors, and one that shows the expected
+result from HTML with a single error.
+## To configure the example
+- Node must be installed; please follow the directions at http://www.nodejs.org
+  to install it.
+- `npm install -g grunt-cli` to install the Grunt task runner (may need to be
+  run with `sudo` on Unix or as Administrator on Windows)
+- Move to the `doc/examples/mocha` directory
+- `npm install` to install dependencies
+## To run the example
+- Move to the `doc/examples/mocha` directory
+- `grunt mocha` to run Mocha
+You should see output indicating that the tests ran successfully, with zero
+failures.
+## To modify the example
+To run the example on your own HTML, such as widgets or controls, insert the
+HTML into the document, retrieve the root element of your widget (with e.g.,
+`document.getElementById()`), and pass that as the first argument into a call
+to `axe.run`.
+The third argument to the `axe.run` call should be the function to test
+the results. The example is simply looking at the count of violations, but much
+more detailed information is available if desired. The aXe documentation
+should be consulted for more details on customizing and
+analyzing calls to `axe.run`.

data/node_modules/axe-core/doc/examples/mocha/package.json ADDED Viewed

@@ -0,0 +1,21 @@
+{
+	"name": "axe-mocha-example",
+	"description": "aXe Mocha Example",
+	"version": "0.0.1",
+	"private": true,
+	"author": {
+		"name": "David Sturley",
+		"organization": "Deque Systems, Inc.",
+		"url": "http://deque.com/"
+	},
+	"dependencies": {},
+	"scripts": {
+		"test": "grunt mocha"
+	},
+	"devDependencies": {
+		"axe-core": "^3.1.1",
+		"chai": "~4.1.2",
+		"grunt": "~1.0.2",
+		"grunt-mocha": "1.2.0"
+	}
+}

data/node_modules/axe-core/doc/examples/phantomjs/README.md ADDED Viewed

@@ -0,0 +1,17 @@
+# PhantomJS README
+This example demonstrates how to use aXe with PhantomJS.
+## To configure the example
+- PhantomJS must be installed; please follow the directions at http://phantomjs.org/
+  to install it.
+- Run `npm install axe-core`
+## To run the example
+- Move to the `doc/examples/phantomjs` directory
+- `phantomjs axe-phantom.js http://www.deque.com` to run aXe in PhantomJS
+  against http://www.deque.com and output results to the terminal
+- `phantomjs axe-phantom.js http://www.deque.com results.json` to run aXe in PhantomJS
+  against http://www.deque.com and save results to `results.json`

data/node_modules/axe-core/doc/examples/phantomjs/axe-phantom.js ADDED Viewed

@@ -0,0 +1,51 @@
+/*global window, phantom */
+var PATH_TO_AXE = 'node_modules/axe-core/axe.min.js';
+var args = require('system').args;
+var fs = require('fs');
+var page = require('webpage').create();
+if (args.length < 2) {
+	console.log('axe-phantomjs.js accepts 1 argument, the URL to test');
+	phantom.exit(1);
+}
+console.log('Testing, please wait...');
+page.open(args[1], function(status) {
+	// Check for page load success
+	if (status !== 'success') {
+		console.log('Unable to access network');
+		return;
+	}
+	page.injectJs(PATH_TO_AXE);
+	page.framesName.forEach(function(name) {
+		page.switchToFrame(name);
+		page.injectJs(PATH_TO_AXE);
+	});
+	page.switchToMainFrame();
+	page.evaluateAsync(function() {
+		/*global axe */
+		axe.run(function(err, results) {
+			if (err) {
+				throw err;
+			}
+			window.callPhantom(results);
+		});
+	});
+	page.onCallback = function(msg) {
+		if (args[2]) {
+			fs.write(args[2], JSON.stringify(msg, null, '  '), 'w');
+		} else {
+			if (msg.violations.length) {
+				console.log(JSON.stringify(msg.violations, null, '  '));
+			} else {
+				console.log('No violations found!');
+			}
+		}
+		phantom.exit(msg.violations.length);
+	};
+});

data/node_modules/axe-core/doc/examples/phantomjs/package.json ADDED Viewed

@@ -0,0 +1,19 @@
+{
+	"name": "axe-phantomjs-example",
+	"description": "aXe Mocha Example",
+	"version": "0.0.1",
+	"private": true,
+	"author": {
+		"name": "Wlico Fiers",
+		"organization": "Deque Systems, Inc.",
+		"url": "http://deque.com/"
+	},
+	"dependencies": {},
+	"scripts": {
+		"test": "phantomjs axe-phantom.js http://www.deque.com"
+	},
+	"devDependencies": {
+		"axe-core": "^3.1.1",
+		"phantomjs": "^2.1.7"
+	}
+}

data/node_modules/axe-core/doc/examples/puppeteer/README.md ADDED Viewed

@@ -0,0 +1,12 @@
+# axe-puppeteer-example
+This (very minimal) example demonstrates how to use `axe-core` with [Puppeteer](https://github.com/GoogleChrome/puppeteer).
+The example does not have feature parity with [`axe-webdriverjs`](https://github.com/dequelabs/axe-webdriverjs), and does not run on `<iframe>`s.
+## To run the example
+- Ensure Node v8+ is installed and on `PATH`
+- Move to the `doc/examples/puppeteer` directory
+- Run `npm install`
+- Run `node axe-puppeteer.js http://www.deque.com` to run `axe-core` via Puppeteer against http://www.deque.com and output results to the terminal

data/node_modules/axe-core/doc/examples/puppeteer/axe-puppeteer.js ADDED Viewed

@@ -0,0 +1,60 @@
+const puppeteer = require('puppeteer');
+const axeCore = require('axe-core');
+const { parse: parseURL } = require('url');
+const assert = require('assert');
+// Cheap URL validation
+const isValidURL = input => {
+	const u = parseURL(input);
+	return u.protocol && u.host;
+};
+// node axe-puppeteer.js <url>
+const url = process.argv[2];
+assert(isValidURL(url), 'Invalid URL');
+const main = async url => {
+	let browser;
+	let results;
+	try {
+		// Setup Puppeteer
+		browser = await puppeteer.launch();
+		// Get new page
+		const page = await browser.newPage();
+		await page.goto(url);
+		// Inject and run axe-core
+		const handle = await page.evaluateHandle(`
+			// Inject axe source code
+			${axeCore.source}
+			// Run axe
+			axe.run()
+		`);
+		// Get the results from `axe.run()`.
+		results = await handle.jsonValue();
+		// Destroy the handle & return axe results.
+		await handle.dispose();
+	} catch (err) {
+		// Ensure we close the puppeteer connection when possible
+		if (browser) {
+			await browser.close();
+		}
+		// Re-throw
+		throw err;
+	}
+	await browser.close();
+	return results;
+};
+main(url)
+	.then(results => {
+		console.log(results);
+	})
+	.catch(err => {
+		console.error('Error running axe-core:', err.message);
+		process.exit(1);
+	});

data/node_modules/axe-core/doc/examples/puppeteer/package.json ADDED Viewed

@@ -0,0 +1,10 @@
+{
+	"name": "axe-puppeteer",
+	"version": "0.0.0",
+	"private": true,
+	"main": "axe-puppeteer.js",
+	"dependencies": {
+		"axe-core": "^3.1.1",
+		"puppeteer": "^1.6.0"
+	}
+}

data/node_modules/axe-core/doc/examples/qunit/README.md ADDED Viewed

@@ -0,0 +1,37 @@
+# QUnit README
+This example demonstrates how to use aXe with the QUnit unit testing framework.
+The unit test is in `test/a11y.js`, and has two test cases: One that shows the
+expected results from HTML with no errors, and one that shows the expected
+result from HTML with a single error.
+## To configure the example
+- Node must be installed; please follow the directions at http://www.nodejs.org
+  to install it.
+- `npm install -g grunt-cli` to install the Grunt task runner (may need to be
+  run with `sudo` on Unix or as Administrator on Windows)
+- Move to the `doc/examples/qunit` directory
+- `npm install` to install dependencies
+## To run the example
+- Move to the `doc/examples/qunit` directory
+- `grunt qunit` to run QUnit
+You should see output indicating that the tests ran successfully, with zero
+failures.
+## To modify the example
+To run the example on your own HTML, such as widgets or controls, insert the
+HTML into the document, retrieve the root element of your widget (with e.g.,
+`document.getElementById()`), and pass that as the first argument into a call
+to `axe.run`.
+The third argument to the `axe.run` call should be the function to test
+the results. The example is simply looking at the count of violations, but much
+more detailed information is available if desired. The aXe documentation
+should be consulted for more details on customizing and
+analyzing calls to `axe.run`.

data/node_modules/axe-core/doc/examples/qunit/package.json ADDED Viewed

@@ -0,0 +1,21 @@
+{
+	"name": "axe-qunit-example",
+	"description": "aXe QUnit Example",
+	"version": "0.0.1",
+	"private": true,
+	"author": {
+		"name": "David Sturley",
+		"organization": "Deque Systems, Inc.",
+		"url": "http://deque.com/"
+	},
+	"dependencies": {},
+	"scripts": {
+		"test": "grunt qunit"
+	},
+	"devDependencies": {
+		"axe-core": "^3.1.1",
+		"grunt": "~1.0.2",
+		"grunt-contrib-qunit": "~3.1.0",
+		"qunitjs": "~2.4.1"
+	}
+}

data/node_modules/axe-core/doc/plugins.md ADDED Viewed

@@ -0,0 +1,123 @@
+# Plugins
+aXe implements a general purpose plugin system that takes advantage of the cross-domain iframe capabilities of aXe and allows for adding functionality that extends the aXe library outside of its core automated accessibility auditing realm.
+The plugin system was initially designed to support functionality like highlighting of elements but has also been utilized for a variety of tasks including implementing functionality that aids with manual accessibility auditing.
+## What is a plugin?
+Plugins can be viewed as a registry of tools. The plugins themselves are registered with aXe and then allow themselves for the registration of plugin instances.
+Lets walk through a plugin implementation as an example to illustrate how plugins and plugin instances work.
+### A simple "act" plugin
+The act plugin will simply perform an action of some sort inside every iframe on the page. An example of how such a plugin might be used is to implement an instance of this plugin that performs highlighting of all of the elements of a particular type on the page.
+Plugins currently support two functions, a "run" function and a "collect" function. Together these functions can be combined to implement complex behaviors on top of the aXe system.
+In order to create such a plugin, we need to implement the "run" function for the plugin, and the command that registers and executes the "run" function within each iframe on the page that contains aXe. Lets look at what a noop implementation of this run function would look like:
+#### Basic plugin
+```js
+axe.registerPlugin({
+	id: 'doStuff',
+	run: function(id, action, options, callback) {
+		var frames;
+		var q = axe.utils.queue();
+		var that = this;
+		frames = axe.utils.toArray(document.querySelectorAll('iframe, frame'));
+		frames.forEach(function(frame) {
+			q.defer(function(done) {
+				axe.utils.sendCommandToFrame(
+					frame,
+					{
+						options: options,
+						command: 'run-doStuff',
+						parameter: id,
+						action: action
+					},
+					function() {
+						done();
+					}
+				);
+			});
+		});
+		if (!options.context.length) {
+			q.defer(function(done) {
+				that._registry[id][action].call(
+					that._registry[id],
+					document,
+					options,
+					done
+				);
+			});
+		}
+		q.then(callback);
+	},
+	commands: [
+		{
+			id: 'run-doStuff',
+			callback: function(data, callback) {
+				return axe.plugins.doStuff.run(
+					data.parameter,
+					data.action,
+					data.options,
+					callback
+				);
+			}
+		}
+	]
+});
+```
+Looking at the code, you will see the following things:
+1. The plugin contains an id. This id is then used to access the plugin and its implementations.
+2. The plugin is registered with aXe (in each iframe) using the `axe.registerPlugin()` function.
+3. The plugin registers the "run" function and the "commands" with the aXe system. This allows plugin implementations to be registered with the plugin, and to be executed. It also registers handlers for each of the commands within each of the iframes, so that the plugin can coordinate with itself across the iframe boundaries.
+When the caller wants to call a plugin instance, it does so by calling the plugin's "run" function in the top level document and passing the id of the plugin instance it would like to call, which plugin instance action it would like to call, the options and a callback function.
+The plugin takes this information and sends the same instructions to its implementation in each iframe by communicating to its own command(s) using the aXe utility function `axe.utils.sendCommandToFrame()`.
+The plugin waits for the commands in the iframes to complete and then executes its instances' action function within the current document.
+In the above implementation, the aXe promise utility `axe.utils.queue()` is used to coordinate the asynchronous handling of communication accross iframes.
+The command handler callback runs the plugin's run function within each iframe. This essentially operates like a recursive call to the run function for the plugin within each iframe.
+Once all the iframes' run functions have been executed, the callback is called. This essentially operates as a recursive "return" up the iframe heirarchy until at the top document, the actual callback function is executed. This can be leveraged to pass data back up the iframe hierarchy back to the caller (but this is a more advanced topic).
+#### Basic plugin instance
+Lets implement a basic plugin instance to see how this works. This instance will implement a "highlight" function (to place a basic frame around the bounding box of an element on each iframe on a page)
+```js
+var highlight = {
+	id: 'highlight',
+	highlighter: new Highlighter(),
+	run: function(contextNode, options, done) {
+		var that = this;
+		Array.prototype.slice
+			.call(contextNode.querySelectorAll(options.selector))
+			.forEach(function(node) {
+				that.highlighter.highlight(node, options);
+			});
+		done();
+	},
+	cleanup: function(done) {
+		this.highlighter.clear();
+		done();
+	}
+};
+axe.plugins.doStuff.add(highlight);
+```
+Above you can see the implementation of a `doStuff` "highlight" instance (the actual highlighting code is not included so as to simplify the example and is left as an exercise for the reader). Plugin instances have an id (which is used to address them), a cleanup function and any number of private or action members. The doStuff `add()` function is called to register this instance with the plugin (notice that we did not have to implement this add function, aXe did that for us). In this case, the action is called "run", so after registration, this instance can be called by calling `axe.plugins.doStuff.run('highlight', 'run', options, callback);` in the top-level iframe on the page.
+The cleanup functions for all plugin instances are called when the `axe.cleanup()` function is called. Note that this cleanup function will automatically call all the cleanup functions for all the plugin instances in all iframes on the page.