axe-core 4.1.2-canary.ec00dc7 → 4.1.2

package/typings/axe-core/axe-core-tests.ts

@@ -5,164 +5,164 @@ var $fixture: any = {};
 var options = { iframes: false, selectors: false, elementRef: false };
 
 axe.run(context, {}, (error: Error, results: axe.AxeResults) => {
-  if (error) {
-    console.log(error);
-  }
-  console.log(results.passes.length);
-  console.log(results.incomplete.length);
-  console.log(results.inapplicable.length);
-  console.log(results.violations.length);
-  console.log(results.violations[0].nodes[0].failureSummary);
+	if (error) {
+		console.log(error);
+	}
+	console.log(results.passes.length);
+	console.log(results.incomplete.length);
+	console.log(results.inapplicable.length);
+	console.log(results.violations.length);
+	console.log(results.violations[0].nodes[0].failureSummary);
 });
 axe.run().then(function(done: any) {
-  done();
+	done();
 });
 // additional configuration options
 axe.run(context, options, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results.passes.length);
+	console.log(error || results.passes.length);
 });
 // axe.run include/exclude
 axe.run(
-  { include: [['#id1'], ['#id2']] },
-  {},
-  (error: Error, results: axe.AxeResults) => {
-    console.log(error || results);
-  }
+	{ include: [['#id1'], ['#id2']] },
+	{},
+	(error: Error, results: axe.AxeResults) => {
+		console.log(error || results);
+	}
 );
 axe.run(
-  { exclude: [$fixture[0]] },
-  {},
-  (error: Error, results: axe.AxeResults) => {
-    console.log(error || results);
-  }
+	{ exclude: [$fixture[0]] },
+	{},
+	(error: Error, results: axe.AxeResults) => {
+		console.log(error || results);
+	}
 );
 // additional configuration options
 axe.run(context, options, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results.passes.length);
+	console.log(error || results.passes.length);
 });
 var tagConfigRunOnly: axe.RunOnly = {
-  type: 'tag',
-  values: ['wcag2a']
+	type: 'tag',
+	values: ['wcag2a']
 };
 var tagConfig = {
-  runOnly: tagConfigRunOnly
+	runOnly: tagConfigRunOnly
 };
 axe.run(context, tagConfig, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results);
+	console.log(error || results);
 });
 axe.run(
-  context,
-  {
-    runOnly: {
-      type: 'tags',
-      values: ['wcag2a', 'wcag2aa']
-    } as axe.RunOnly
-  },
-  (error: Error, results: axe.AxeResults) => {
-    console.log(error || results);
-  }
+	context,
+	{
+		runOnly: {
+			type: 'tags',
+			values: ['wcag2a', 'wcag2aa']
+		} as axe.RunOnly
+	},
+	(error: Error, results: axe.AxeResults) => {
+		console.log(error || results);
+	}
 );
 axe.run(
-  context,
-  {
-    runOnly: ['wcag2a', 'wcag2aa']
-  },
-  (error: Error, results: axe.AxeResults) => {
-    console.log(error || results);
-  }
+	context,
+	{
+		runOnly: ['wcag2a', 'wcag2aa']
+	},
+	(error: Error, results: axe.AxeResults) => {
+		console.log(error || results);
+	}
 );
 axe.run(
-  context,
-  {
-    runOnly: ['color-contrast', 'heading-order']
-  },
-  (error: Error, results: axe.AxeResults) => {
-    console.log(error || results);
-  }
+	context,
+	{
+		runOnly: ['color-contrast', 'heading-order']
+	},
+	(error: Error, results: axe.AxeResults) => {
+		console.log(error || results);
+	}
 );
 
 var someRulesConfig = {
-  rules: {
-    'color-contrast': { enabled: false },
-    'heading-order': { enabled: true }
-  }
+	rules: {
+		'color-contrast': { enabled: false },
+		'heading-order': { enabled: true }
+	}
 };
 axe.run(context, someRulesConfig, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results);
+	console.log(error || results);
 });
 
 // just context
 axe.run(context).then(function(done: any) {
-  done();
+	done();
 });
 // just options
 axe.run(options).then(function(done: any) {
-  done();
+	done();
 });
 // just callback
 axe.run((error: Error, results: axe.AxeResults) => {
-  console.log(error || results);
+	console.log(error || results);
 });
 // context and callback
 axe.run(context, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results);
+	console.log(error || results);
 });
 // options and callback
 axe.run(options, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results);
+	console.log(error || results);
 });
 // context and options
 axe.run(context, options).then(function(done: any) {
-  done();
+	done();
 });
 // context, options, and callback
 axe.run(context, options, (error: Error, results: axe.AxeResults) => {
-  console.log(error || results);
+	console.log(error || results);
 });
 
 // axe.configure
 var spec: axe.Spec = {
-  branding: {
-    brand: 'foo',
-    application: 'bar'
-  },
-  reporter: 'v1',
-  checks: [
-    {
-      id: 'custom-check',
-      evaluate: function() {
-        return true;
-      }
-    }
-  ],
-  standards: {
-    ariaRoles: {
-      'custom-role': {
-        type: 'widget',
-        requiredAttrs: ['aria-label']
-      }
-    },
-    ariaAttrs: {
-      'custom-attr': {
-        type: 'boolean'
-      }
-    },
-    htmlElms: {
-      'custom-elm': {
-        contentTypes: ['flow'],
-        allowedRoles: false
-      }
-    },
-    cssColors: {
-      customColor: [0, 1, 2, 3]
-    }
-  },
-  rules: [
-    {
-      id: 'custom-rule',
-      any: ['custom-check']
-    }
-  ]
+	branding: {
+		brand: 'foo',
+		application: 'bar'
+	},
+	reporter: 'v1',
+	checks: [
+		{
+			id: 'custom-check',
+			evaluate: function() {
+				return true;
+			}
+		}
+	],
+	standards: {
+		ariaRoles: {
+			'custom-role': {
+				type: 'widget',
+				requiredAttrs: ['aria-label']
+			}
+		},
+		ariaAttrs: {
+			'custom-attr': {
+				type: 'boolean'
+			}
+		},
+		htmlElms: {
+			'custom-elm': {
+				contentTypes: ['flow'],
+				allowedRoles: false
+			}
+		},
+		cssColors: {
+			customColor: [0, 1, 2, 3]
+		}
+	},
+	rules: [
+		{
+			id: 'custom-rule',
+			any: ['custom-check']
+		}
+	]
 };
 axe.configure(spec);
 
@@ -176,58 +176,58 @@ typeof axe.getRules() === 'object';
 
 const rules = axe.getRules();
 rules.forEach(rule => {
-  rule.ruleId.substr(1234);
+	rule.ruleId.substr(1234);
 });
 
 // Plugins
 var pluginSrc: axe.AxePlugin = {
-  id: 'doStuff',
-  run: (data: any, callback: Function) => {
-    callback();
-  },
-  commands: [
-    {
-      id: 'run-doStuff',
-      callback: (data: any, callback: Function) => {
-        axe.plugins['doStuff'].run(data, callback);
-      }
-    }
-  ]
+	id: 'doStuff',
+	run: (data: any, callback: Function) => {
+		callback();
+	},
+	commands: [
+		{
+			id: 'run-doStuff',
+			callback: (data: any, callback: Function) => {
+				axe.plugins['doStuff'].run(data, callback);
+			}
+		}
+	]
 };
 axe.registerPlugin(pluginSrc);
 axe.cleanup();
 
 axe.configure({
-  locale: {
-    checks: {
-      foo: {
-        fail: 'failure',
-        pass: 'success',
-        incomplete: {
-          foo: 'nar'
-        }
-      }
-    }
-  }
+	locale: {
+		checks: {
+			foo: {
+				fail: 'failure',
+				pass: 'success',
+				incomplete: {
+					foo: 'nar'
+				}
+			}
+		}
+	}
 });
 
 axe.configure({
-  locale: {
-    lang: 'foo',
-    rules: {
-      foo: {
-        description: 'desc',
-        help: 'help'
-      }
-    },
-    checks: {
-      foo: {
-        pass: 'pass',
-        fail: 'fail',
-        incomplete: {
-          foo: 'bar'
-        }
-      }
-    }
-  }
+	locale: {
+		lang: 'foo',
+		rules: {
+			foo: {
+				description: 'desc',
+				help: 'help'
+			}
+		},
+		checks: {
+			foo: {
+				pass: 'pass',
+				fail: 'fail',
+				incomplete: {
+					foo: 'bar'
+				}
+			}
+		}
+	}
 });

package/.eslintrc.js

@@ -1,111 +0,0 @@
-module.exports = {
-  extends: ['prettier'],
-  parserOptions: {
-    ecmaVersion: 9
-  },
-  env: {
-    node: true,
-    es6: true
-  },
-  globals: {
-    axe: true
-  },
-  rules: {
-    'no-bitwise': 2,
-    camelcase: 2,
-    curly: 2,
-    eqeqeq: 2,
-    'guard-for-in': 2,
-    'wrap-iife': [2, 'any'],
-    'no-use-before-define': [
-      2,
-      {
-        functions: false
-      }
-    ],
-    'new-cap': 2,
-    'no-caller': 2,
-    'no-empty': 2,
-    'no-new': 2,
-    'no-plusplus': 0,
-    'no-undef': 2,
-    'no-unused-vars': 2,
-    strict: 0,
-    'max-params': [2, 6],
-    'max-depth': [2, 5],
-    'max-len': 0,
-    semi: 0,
-    'no-cond-assign': 0,
-    'no-debugger': 2,
-    'no-eq-null': 0,
-    'no-eval': 2,
-    'no-unused-expressions': 0,
-    'block-scoped-var': 0,
-    'no-iterator': 0,
-    'linebreak-style': 0,
-    'no-loop-func': 0,
-    'no-multi-str': 0,
-    'no-proto': 0,
-    'no-script-url': 0,
-    'dot-notation': 2,
-    'no-new-func': 0,
-    'no-new-wrappers': 0,
-    'no-restricted-syntax': [
-      'error',
-      {
-        selector: 'MemberExpression[property.name=tagName]',
-        message: "Don't use node.tagName, use node.nodeName instead."
-      },
-      {
-        // node.attributes can be clobbered so is unsafe to use
-        // @see https://github.com/dequelabs/axe-core/pull/1432
-        selector:
-          'MemberExpression[object.name=node][property.name=attributes]',
-        message:
-          "Don't use node.attributes, use node.hasAttributes() or axe.utils.getNodeAttributes(node) instead."
-      }
-    ]
-  },
-  overrides: [
-    {
-      files: ['lib/**/*.js'],
-      parserOptions: {
-        sourceType: 'module'
-      },
-      env: {
-        browser: true,
-        es6: true
-      },
-      globals: {
-        window: true,
-        document: true
-      },
-      rules: {
-        'func-names': [2, 'as-needed'],
-        'prefer-const': 2
-      }
-    },
-    {
-      files: ['test/**/*.js'],
-      parserOptions: {
-        ecmaVersion: 5
-      },
-      env: {
-        browser: true,
-        es6: false,
-        mocha: true
-      },
-      globals: {
-        assert: true,
-        helpers: true,
-        checks: true
-      },
-      plugins: ['mocha-no-only'],
-      rules: {
-        'new-cap': 0,
-        'no-use-before-define': 0,
-        'mocha-no-only/mocha-no-only': ['error']
-      }
-    }
-  ]
-};

package/lib/checks/aria/aria-prohibited-attr-evaluate.js

@@ -1,67 +0,0 @@
-import { getRole } from '../../commons/aria';
-import { sanitize, subtreeText } from '../../commons/text';
-import standards from '../../standards';
-
-/**
- * Check that an element does not use any prohibited ARIA attributes.
- *
- * Prohibited attributes are taken from the `ariaAttrs` standards object from the attributes `prohibitedAttrs` property.
- *
- * ##### Data:
- * <table class="props">
- *   <thead>
- *     <tr>
- *       <th>Type</th>
- *       <th>Description</th>
- *     </tr>
- *   </thead>
- *   <tbody>
- *     <tr>
- *       <td><code>String[]</code></td>
- *       <td>List of all prohibited attributes</td>
- *     </tr>
- *   </tbody>
- * </table>
- *
- * @memberof checks
- * @return {Boolean} True if the element uses any prohibited ARIA attributes. False otherwise.
- */
-function ariaProhibitedAttrEvaluate(node, options, virtualNode) {
-  const prohibited = [];
-
-  const role = getRole(virtualNode);
-  const attrs = virtualNode.attrNames;
-  const prohibitedAttrs = role
-    ? standards.ariaRoles[role].prohibitedAttrs
-    : ['aria-label', 'aria-labelledby'];
-
-  if (!prohibitedAttrs) {
-    return false;
-  }
-
-  for (let i = 0; i < attrs.length; i++) {
-    const attrName = attrs[i];
-    const attrValue = sanitize(virtualNode.attr(attrName));
-    if (prohibitedAttrs.includes(attrName) && attrValue !== '') {
-      prohibited.push(attrName);
-    }
-  }
-
-  if (prohibited.length) {
-    this.data(prohibited);
-
-    // aria-label and aria-labelledy are not allowed on elements
-    // without roles, but if the element has text content then
-    // we will return undefined as a screen reader will read
-    // the text content
-    if (!role && sanitize(subtreeText(virtualNode)) !== '') {
-      return undefined;
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-export default ariaProhibitedAttrEvaluate;

package/lib/checks/aria/aria-prohibited-attr.json

@@ -1,12 +0,0 @@
-{
-  "id": "aria-prohibited-attr",
-  "evaluate": "aria-prohibited-attr-evaluate",
-  "metadata": {
-    "impact": "critical",
-    "messages": {
-      "pass": "ARIA attribute is allowed",
-      "fail": "ARIA attribute cannot be used: ${data.values}",
-      "incomplete": "ARIA attribute is not well supported on the element and the text content will be used instead: ${data.values}"
-    }
-  }
-}

package/lib/checks/keyboard/frame-focusable-content.json

@@ -1,12 +0,0 @@
-{
-  "id": "frame-focusable-content",
-  "evaluate": "no-focusable-content-evaluate",
-  "metadata": {
-    "impact": "serious",
-    "messages": {
-      "pass": "Element does not have focusable descendants",
-      "fail": "Element has focusable descendants",
-      "incomplete": "Could not determine if element has descendants"
-    }
-  }
-}

package/lib/checks/keyboard/no-focusable-content-evaluate.js

@@ -1,35 +0,0 @@
-import isFocusable from '../../commons/dom/is-focusable';
-
-function focusableDescendants(vNode) {
-  if (isFocusable(vNode)) {
-    return true;
-  }
-
-  if (!vNode.children) {
-    if (vNode.props.nodeType === 1) {
-      throw new Error('Cannot determine children');
-    }
-
-    return false;
-  }
-
-  return vNode.children.some(child => {
-    return focusableDescendants(child);
-  });
-}
-
-function noFocusbleContentEvaluate(node, options, virtualNode) {
-  if (!virtualNode.children) {
-    return undefined;
-  }
-
-  try {
-    return !virtualNode.children.some(child => {
-      return focusableDescendants(child);
-    });
-  } catch (e) {
-    return undefined;
-  }
-}
-
-export default noFocusbleContentEvaluate;

package/lib/checks/keyboard/no-focusable-content.json

@@ -1,12 +0,0 @@
-{
-  "id": "no-focusable-content",
-  "evaluate": "no-focusable-content-evaluate",
-  "metadata": {
-    "impact": "serious",
-    "messages": {
-      "pass": "Element does not have focusable descendants",
-      "fail": "Element has focusable descendants",
-      "incomplete": "Could not determine if element has descendants"
-    }
-  }
-}

package/lib/core/public/setup.js

@@ -1,20 +0,0 @@
-import { getFlattenedTree, getSelectorData } from '../utils';
-
-/**
- * Setup axe-core so axe.common functions can work properly.
- * @param {Node} [node=document.documentElement] optional node. NOTE: passing in anything other than body or the documentElement may result in incomplete results.
- */
-function setup(node) {
-  if (axe._tree) {
-    throw new Error(
-      'Axe is already setup. Call `axe.teardown()` before calling `axe.setup` again.'
-    );
-  }
-
-  axe._tree = getFlattenedTree(node);
-  axe._selectorData = getSelectorData(axe._tree);
-
-  return axe._tree[0];
-}
-
-export default setup;

package/lib/core/public/teardown.js

@@ -1,21 +0,0 @@
-import cache from '../base/cache';
-
-/**
- * Clean up axe-core tree and caches. `axe.run` will call this function at the end of the run so there's no need to call it yourself afterwards.
- */
-function teardown() {
-  if (cache.get('globalDocumentSet')) {
-    document = null;
-  }
-  if (cache.get('globalWindowSet')) {
-    window = null;
-  }
-
-  axe._memoizedFns.forEach(fn => fn.clear());
-  cache.clear();
-  axe._tree = undefined;
-  axe._selectorData = undefined;
-  axe._selectCache = undefined;
-}
-
-export default teardown;