axe-core 4.2.4 → 4.3.0

package/lib/commons/matches/from-function.js

@@ -1,40 +0,0 @@
-import fromPrimative from './from-primative';
-
-/**
- * Check if the value from a function matches some condition
- *
- * Each key on the matcher object is passed to getValue, the returned value must match
- * with the value of that matcher
- *
- * Example:
- * ```js
- * matches.fromFunction(
- * 	 (attr => node.getAttribute(attr),
- * 	 {
- * 	   'aria-hidden': /^true|false$/i
- * 	 }
- * )
- * ```
- *
- * @private
- * @param {Function} getValue
- * @param {Object} matcher matcher
- * @returns {Boolean}
- */
-function fromFunction(getValue, matcher) {
-  const matcherType = typeof matcher;
-  if (
-    matcherType !== 'object' ||
-    Array.isArray(matcher) ||
-    matcher instanceof RegExp
-  ) {
-    throw new Error('Expect matcher to be an object');
-  }
-
-  // Check that the property has all the expected values
-  return Object.keys(matcher).every(propName => {
-    return fromPrimative(getValue(propName), matcher[propName]);
-  });
-}
-
-export default fromFunction;

package/lib/commons/matches/from-primative.js

@@ -1,44 +0,0 @@
-/**
- * Check if some value matches
- *
- * ```js
- * match.fromPrimative('foo', 'foo') // true, string is the same
- * match.fromPrimative('foo', ['foo', 'bar']) // true, string is included
- * match.fromPrimative('foo', /foo/) // true, string matches regex
- * match.fromPrimative('foo', str => str.toUpperCase() === 'FOO') // true, function return is truthy
- * match.fromPrimative('foo', '/foo/') // true, string matches regex string
- * ```
- *
- * @private
- * @param {String|Boolean|Array|Number|Null|Undefined} someString
- * @param {String|RegExp|Function|Array<String>|Null|Undefined} matcher
- * @returns {Boolean}
- */
-function fromPrimative(someString, matcher) {
-  const matcherType = typeof matcher;
-  if (Array.isArray(matcher) && typeof someString !== 'undefined') {
-    return matcher.includes(someString);
-  }
-
-  if (matcherType === 'function') {
-    return !!matcher(someString);
-  }
-
-  // RegExp.test(str) typecasts the str to a String value so doing
-  // `/.*/.test(null)` returns true as null is cast to "null"
-  if (someString !== null && someString !== undefined) {
-    if (matcher instanceof RegExp) {
-      return matcher.test(someString);
-    }
-
-    // matcher starts and ends with "/"
-    if (/^\/.*\/$/.test(matcher)) {
-      const pattern = matcher.substring(1, matcher.length - 1);
-      return new RegExp(pattern).test(someString);
-    }
-  }
-
-  return matcher === someString;
-}
-
-export default fromPrimative;

package/lib/commons/matches/implicit-role.js

@@ -1,24 +0,0 @@
-import fromPrimative from './from-primative';
-import getImplicitRole from '../aria/implicit-role';
-
-/**
- * Check if a virtual node matches an implicit role(s)
- *``
- * Note: matches.implicitRole(vNode, matcher) can be indirectly used through
- * matches(vNode, { implicitRole: matcher })
- *
- * Example:
- * ```js
- * matches.implicitRole(vNode, ['combobox', 'textbox']);
- * matches.implicitRole(vNode, 'combobox');
- * ```
- *
- * @param {VirtualNode} vNode
- * @param {Object} matcher
- * @returns {Boolean}
- */
-function implicitRole(vNode, matcher) {
-  return fromPrimative(getImplicitRole(vNode), matcher);
-}
-
-export default implicitRole;

package/lib/commons/matches/index.js

@@ -1,29 +0,0 @@
-/**
- * Namespace for matching utilities.
- * @namespace commons.matches
- * @memberof axe
- */
-import attributes from './attributes';
-import condition from './condition';
-import explicitRole from './explicit-role';
-import fromDefinition from './from-definition';
-import fromFunction from './from-function';
-import fromPrimative from './from-primative';
-import implicitRole from './implicit-role';
-import matches from './matches';
-import nodeName from './node-name';
-import properties from './properties';
-import semanticRole from './semantic-role';
-
-matches.attributes = attributes;
-matches.condition = condition;
-matches.explicitRole = explicitRole;
-matches.fromDefinition = fromDefinition;
-matches.fromFunction = fromFunction;
-matches.fromPrimative = fromPrimative;
-matches.implicitRole = implicitRole;
-matches.nodeName = nodeName;
-matches.properties = properties;
-matches.semanticRole = semanticRole;
-
-export default matches;

package/lib/commons/matches/matches.js

@@ -1,39 +0,0 @@
-import fromDefinition from './from-definition';
-
-/**
- * Check if a virtual node matches a definition
- *
- * Example:
- * ```js
- * // Match a single nodeName:
- * axe.commons.matches(vNode, 'div')
- *
- * // Match one of multiple nodeNames:
- * axe.commons.matches(vNode, ['ul', 'ol'])
- *
- * // Match a node with nodeName 'button' and with aria-hidden: true:
- * axe.commons.matches(vNode, {
- *   nodeName: 'button',
- *   attributes: { 'aria-hidden': 'true' }
- * })
- *
- * // Mixed input. Match button nodeName, input[type=button] and input[type=reset]
- * axe.commons.matches(vNode, ['button', {
- *  nodeName: 'input', // nodeName match isn't case sensitive
- *  properties: { type: ['button', 'reset'] }
- * }])
- * ```
- *
- * @deprecated HTMLElement is deprecated, use VirtualNode instead
- *
- * @namespace matches
- * @memberof axe.commons
- * @param {HTMLElement|VirtualNode} vNode virtual node to verify attributes against constraints
- * @param {Array<ElementDefinition>|String|Object|Function|Regex} definition
- * @return {Boolean} true/ false based on if vNode passes the constraints expected
- */
-function matches(vNode, definition) {
-  return fromDefinition(vNode, definition);
-}
-
-export default matches;

package/lib/commons/matches/node-name.js

@@ -1,29 +0,0 @@
-import fromPrimative from './from-primative';
-import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-node';
-import { getNodeFromTree } from '../../core/utils';
-
-/**
- * Check if the nodeName of a virtual node matches some value.
- *
- * Note: matches.nodeName(vNode, matcher) can be indirectly used through
- * matches(vNode, { nodeName: matcher })
- *
- * Example:
- * ```js
- * matches.nodeName(vNode, ['div', 'span'])
- * ```
- *
- * @deprecated HTMLElement is deprecated, use VirtualNode instead
- *
- * @param {HTMLElement|VirtualNode} vNode
- * @param {Object} Attribute matcher
- * @returns {Boolean}
- */
-function nodeName(vNode, matcher) {
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = getNodeFromTree(vNode);
-  }
-  return fromPrimative(vNode.props.nodeName, matcher);
-}
-
-export default nodeName;

package/lib/commons/matches/properties.js

@@ -1,32 +0,0 @@
-import fromFunction from './from-function';
-import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-node';
-import { getNodeFromTree } from '../../core/utils';
-
-/**
- * Check if a virtual node matches some attribute(s)
- *
- * Note: matches.properties(vNode, matcher) can be indirectly used through
- * matches(vNode, { properties: matcher })
- *
- * Example:
- * ```js
- * matches.properties(vNode, {
- *   type: 'text', // Simple string match
- *   value: value => value.trim() !== '', // None-empty value, using a function matcher
- * })
- * ```
- *
- * @deprecated HTMLElement is deprecated, use VirtualNode instead
- *
- * @param {HTMLElement|VirtualNode} vNode
- * @param {Object} matcher
- * @returns {Boolean}
- */
-function properties(vNode, matcher) {
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = getNodeFromTree(vNode);
-  }
-  return fromFunction(propName => vNode.props[propName], matcher);
-}
-
-export default properties;

package/lib/commons/matches/semantic-role.js

@@ -1,24 +0,0 @@
-import fromPrimative from './from-primative';
-import getRole from '../aria/get-role';
-
-/**
- * Check if a virtual node matches an semantic role(s)
- *``
- * Note: matches.semanticRole(vNode, matcher) can be indirectly used through
- * matches(vNode, { semanticRole: matcher })
- *
- * Example:
- * ```js
- * matches.semanticRole(vNode, ['combobox', 'textbox']);
- * matches.semanticRole(vNode, 'combobox');
- * ```
- *
- * @param {VirtualNode} vNode
- * @param {Object} matcher
- * @returns {Boolean}
- */
-function semanticRole(vNode, matcher) {
-  return fromPrimative(getRole(vNode), matcher);
-}
-
-export default semanticRole;

package/lib/commons/standards/get-aria-roles-by-type.js

@@ -1,14 +0,0 @@
-import standards from '../../standards';
-
-/**
- * Return a list of aria roles whose type matches the provided value.
- * @param {String} type The desired role type
- * @return {String[]} List of all roles matching the type
- */
-function getAriaRolesByType(type) {
-  return Object.keys(standards.ariaRoles).filter(roleName => {
-    return standards.ariaRoles[roleName].type === type;
-  });
-}
-
-export default getAriaRolesByType;

package/lib/commons/standards/get-aria-roles-supporting-name-from-content.js

@@ -1,22 +0,0 @@
-import cache from '../../core/base/cache';
-import standards from '../../standards';
-
-/**
- * Return a list of aria roles which are name from content.
- * @return {String[]} List of all roles with name from content
- */
-function getAriaRolesSupportingNameFromContent() {
-  if (cache.get('ariaRolesNameFromContent')) {
-    return cache.get('ariaRolesNameFromContent');
-  }
-
-  const contentRoles = Object.keys(standards.ariaRoles).filter(roleName => {
-    return standards.ariaRoles[roleName].nameFromContent;
-  });
-
-  cache.set('ariaRolesNameFromContent', contentRoles);
-
-  return contentRoles;
-}
-
-export default getAriaRolesSupportingNameFromContent;

package/lib/commons/standards/get-element-spec.js

@@ -1,54 +0,0 @@
-import standards from '../../standards';
-import matchesFn from '../../commons/matches';
-
-/**
- * Return the spec for an HTML element from the standards object. Since the spec is determined by the node and what attributes it has, a node is required.
- * @param {VirtualNode} vNode The VirtualNode to get the spec for.
- * @return {Object} The standard spec object
- */
-function getElementSpec(vNode) {
-  const standard = standards.htmlElms[vNode.props.nodeName];
-
-  // invalid element name (could be an svg or custom element name)
-  if (!standard) {
-    return {};
-  }
-
-  if (!standard.variant) {
-    return standard;
-  }
-
-  // start with the information at the top level
-  const { variant, ...spec } = standard;
-
-  // loop through all variants (excluding default) finding anything
-  // that matches
-  for (const variantName in variant) {
-    if (!variant.hasOwnProperty(variantName) || variantName === 'default') {
-      continue;
-    }
-
-    const { matches, ...props } = variant[variantName];
-    if (matchesFn(vNode, matches)) {
-      for (const propName in props) {
-        if (props.hasOwnProperty(propName)) {
-          spec[propName] = props[propName];
-        }
-      }
-    }
-  }
-
-  // apply defaults if properties were not found
-  for (const propName in variant.default) {
-    if (
-      variant.default.hasOwnProperty(propName) &&
-      typeof spec[propName] === 'undefined'
-    ) {
-      spec[propName] = variant.default[propName];
-    }
-  }
-
-  return spec;
-}
-
-export default getElementSpec;

package/lib/commons/standards/get-elements-by-content-type.js

@@ -1,30 +0,0 @@
-import standards from '../../standards';
-
-/**
- * Return a list of html elements whose content type matches the provided value. Note: this will not work for 'interactive' content types as those depend on the element.
- * @param {String} type The desired content type
- * @return {String[]} List of all elements matching the type
- */
-function getElementsByContentType(type) {
-  return Object.keys(standards.htmlElms).filter(nodeName => {
-    const elm = standards.htmlElms[nodeName];
-
-    if (elm.contentTypes) {
-      return elm.contentTypes.includes(type);
-    }
-
-    // some elements do not have content types
-    if (!elm.variant) {
-      return false;
-    }
-
-    if (elm.variant.default && elm.variant.default.contentTypes) {
-      return elm.variant.default.contentTypes.includes(type);
-    }
-
-    // content type depends on a virtual node
-    return false;
-  });
-}
-
-export default getElementsByContentType;

package/lib/commons/standards/get-global-aria-attrs.js

@@ -1,22 +0,0 @@
-import cache from '../../core/base/cache';
-import standards from '../../standards';
-
-/**
- * Return a list of global aria attributes.
- * @return {String[]} List of all global aria attributes
- */
-function getGlobalAriaAttrs() {
-  if (cache.get('globalAriaAttrs')) {
-    return cache.get('globalAriaAttrs');
-  }
-
-  const globalAttrs = Object.keys(standards.ariaAttrs).filter(attrName => {
-    return standards.ariaAttrs[attrName].global;
-  });
-
-  cache.set('globalAriaAttrs', globalAttrs);
-
-  return globalAttrs;
-}
-
-export default getGlobalAriaAttrs;

package/lib/commons/standards/implicit-html-roles.js

@@ -1,186 +0,0 @@
-// Source: https://www.w3.org/TR/html-aam-1.0/#element-mapping-table
-// Source: https://www.w3.org/TR/html-aria/
-import getElementsByContentType from './get-elements-by-content-type';
-import getGlobalAriaAttrs from './get-global-aria-attrs';
-import arialabelledbyText from '../aria/arialabelledby-text';
-import arialabelText from '../aria/arialabel-text';
-import idrefs from '../dom/idrefs';
-import isColumnHeader from '../table/is-column-header';
-import isRowHeader from '../table/is-row-header';
-import sanitize from '../text/sanitize';
-import isFocusable from '../dom/is-focusable';
-import { closest } from '../../core/utils';
-import getExplicitRole from '../aria/get-explicit-role';
-
-const sectioningElementSelector =
-  getElementsByContentType('sectioning')
-    .map(nodeName => `${nodeName}:not([role])`)
-    .join(', ') +
-  ' , main:not([role]), [role=article], [role=complementary], [role=main], [role=navigation], [role=region]';
-
-// sectioning elements only have an accessible name if the
-// aria-label, aria-labelledby, or title attribute has valid
-// content.
-// can't go through the normal accessible name computation
-// as it leads into an infinite loop of asking for the role
-// of the element while the implicit role needs the name.
-// Source: https://www.w3.org/TR/html-aam-1.0/#section-and-grouping-element-accessible-name-computation
-//
-// form elements also follow this same pattern although not
-// specifically called out in the spec like section elements
-// (per Scott O'Hara)
-// Source: https://web-a11y.slack.com/archives/C042TSFGN/p1590607895241100?thread_ts=1590602189.217800&cid=C042TSFGN
-function hasAccessibleName(vNode) {
-  // testing for when browsers give a <section> a region role:
-  // chrome - always a region role
-  // firefox - if non-empty aria-labelledby, aria-label, or title
-  // safari - if non-empty aria-lablledby or aria-label
-  //
-  // we will go with safaris implantation as it is the least common
-  // denominator
-  const ariaLabelledby = sanitize(arialabelledbyText(vNode));
-  const ariaLabel = sanitize(arialabelText(vNode));
-
-  return !!(ariaLabelledby || ariaLabel);
-}
-
-const implicitHtmlRoles = {
-  a: vNode => {
-    return vNode.hasAttr('href') ? 'link' : null;
-  },
-  area: vNode => {
-    return vNode.hasAttr('href') ? 'link' : null;
-  },
-  article: 'article',
-  aside: 'complementary',
-  body: 'document',
-  button: 'button',
-  datalist: 'listbox',
-  dd: 'definition',
-  dfn: 'term',
-  details: 'group',
-  dialog: 'dialog',
-  dt: 'term',
-  fieldset: 'group',
-  figure: 'figure',
-  footer: vNode => {
-    const sectioningElement = closest(vNode, sectioningElementSelector);
-
-    return !sectioningElement ? 'contentinfo' : null;
-  },
-  form: vNode => {
-    return hasAccessibleName(vNode) ? 'form' : null;
-  },
-  h1: 'heading',
-  h2: 'heading',
-  h3: 'heading',
-  h4: 'heading',
-  h5: 'heading',
-  h6: 'heading',
-  header: vNode => {
-    const sectioningElement = closest(vNode, sectioningElementSelector);
-
-    return !sectioningElement ? 'banner' : null;
-  },
-  hr: 'separator',
-  img: vNode => {
-    // an images role is considered implicitly presentation if the
-    // alt attribute is empty. But that shouldn't be the case if it
-    // has global aria attributes or is focusable, so we need to
-    // override the role back to `img`
-    // e.g. <img alt="" aria-label="foo"></img>
-    const emptyAlt = vNode.hasAttr('alt') && !vNode.attr('alt');
-    const hasGlobalAria = getGlobalAriaAttrs().find(attr =>
-      vNode.hasAttr(attr)
-    );
-
-    return emptyAlt && !hasGlobalAria && !isFocusable(vNode)
-      ? 'presentation'
-      : 'img';
-  },
-  input: vNode => {
-    // Source: https://www.w3.org/TR/html52/sec-forms.html#suggestions-source-element
-    let suggestionsSourceElement;
-    if (vNode.hasAttr('list')) {
-      const listElement = idrefs(vNode.actualNode, 'list').filter(
-        node => !!node
-      )[0];
-      suggestionsSourceElement =
-        listElement && listElement.nodeName.toLowerCase() === 'datalist';
-    }
-
-    switch (vNode.props.type) {
-      case 'checkbox':
-        return 'checkbox';
-      case 'number':
-        return 'spinbutton';
-      case 'radio':
-        return 'radio';
-      case 'range':
-        return 'slider';
-      case 'search':
-        return !suggestionsSourceElement ? 'searchbox' : 'combobox';
-
-      case 'button':
-      case 'image':
-      case 'reset':
-      case 'submit':
-        return 'button';
-
-      case 'text':
-      case 'tel':
-      case 'url':
-      case 'email':
-      case '':
-        return !suggestionsSourceElement ? 'textbox' : 'combobox';
-
-      default: 
-        return 'textbox';
-    }
-  },
-  // Note: if an li (or some other elms) do not have a required
-  // parent, Firefox ignores the implicit semantic role and treats
-  // it as a generic text.
-  li: 'listitem',
-  main: 'main',
-  math: 'math',
-  menu: 'list',
-  nav: 'navigation',
-  ol: 'list',
-  optgroup: 'group',
-  option: 'option',
-  output: 'status',
-  progress: 'progressbar',
-  section: vNode => {
-    return hasAccessibleName(vNode) ? 'region' : null;
-  },
-  select: vNode => {
-    return vNode.hasAttr('multiple') || parseInt(vNode.attr('size')) > 1
-      ? 'listbox'
-      : 'combobox';
-  },
-  summary: 'button',
-  table: 'table',
-  tbody: 'rowgroup',
-  td: vNode => {
-    const table = closest(vNode, 'table');
-    const role = getExplicitRole(table);
-
-    return ['grid', 'treegrid'].includes(role) ? 'gridcell' : 'cell';
-  },
-  textarea: 'textbox',
-  tfoot: 'rowgroup',
-  th: vNode => {
-    if (isColumnHeader(vNode.actualNode)) {
-      return 'columnheader';
-    }
-    if (isRowHeader(vNode.actualNode)) {
-      return 'rowheader';
-    }
-  },
-  thead: 'rowgroup',
-  tr: 'row',
-  ul: 'list'
-};
-
-export default implicitHtmlRoles;

package/lib/commons/standards/index.js

@@ -1,11 +0,0 @@
-/**
- * Namespace for standards-related utilities.
- * @namespace commons.standards
- * @memberof axe
- */
-export { default as getAriaRolesByType } from './get-aria-roles-by-type';
-export { default as getAriaRolesSupportingNameFromContent } from './get-aria-roles-supporting-name-from-content';
-export { default as getGlobalAriaAttrs } from './get-global-aria-attrs';
-export { default as getElementSpec } from './get-element-spec';
-export { default as getElementsByContentType } from './get-elements-by-content-type';
-export { default as implicitHtmlRoles } from './implicit-html-roles';

package/lib/commons/table/get-all-cells.js

@@ -1,28 +0,0 @@
-/**
- * Returns all cells contained in given HTMLTableElement
- * @method getAllCells
- * @memberof axe.commons.table
- * @instance
- * @param  {HTMLTableElement} tableElm Table Element to get cells from
- * @return {Array<HTMLTableCellElement>}
- */
-function getAllCells(tableElm) {
-  var rowIndex, cellIndex, rowLength, cellLength;
-  var cells = [];
-  for (
-    rowIndex = 0, rowLength = tableElm.rows.length;
-    rowIndex < rowLength;
-    rowIndex++
-  ) {
-    for (
-      cellIndex = 0, cellLength = tableElm.rows[rowIndex].cells.length;
-      cellIndex < cellLength;
-      cellIndex++
-    ) {
-      cells.push(tableElm.rows[rowIndex].cells[cellIndex]);
-    }
-  }
-  return cells;
-}
-
-export default getAllCells;

package/lib/commons/table/get-cell-position.js

@@ -1,32 +0,0 @@
-import toGrid from './to-grid';
-import findUp from '../dom/find-up';
-import { memoize } from '../../core/utils';
-
-/**
- * Get the x, y coordinates of a table cell; normalized for rowspan and colspan
- * @method getCellPosition
- * @memberof axe.commons.table
- * @instance
- * @param  {HTMLTableCellElement} cell The table cell of which to get the position
- * @return {Object} Object with `x` and `y` properties of the coordinates
- */
-function getCellPosition(cell, tableGrid) {
-  var rowIndex, index;
-  if (!tableGrid) {
-    tableGrid = toGrid(findUp(cell, 'table'));
-  }
-
-  for (rowIndex = 0; rowIndex < tableGrid.length; rowIndex++) {
-    if (tableGrid[rowIndex]) {
-      index = tableGrid[rowIndex].indexOf(cell);
-      if (index !== -1) {
-        return {
-          x: index,
-          y: rowIndex
-        };
-      }
-    }
-  }
-}
-
-export default memoize(getCellPosition);