axe-core 4.2.4 → 4.3.0

package/lib/commons/text/is-icon-ligature.js

@@ -1,214 +0,0 @@
-import sanitize from './sanitize';
-import hasUnicode from './has-unicode';
-import cache from '../../core/base/cache';
-
-/**
- * Determines if a given text node is an icon ligature
- *
- * @method isIconLigature
- * @memberof axe.commons.text
- * @instance
- * @param {VirtualNode} textVNode The virtual text node
- * @param {Number} occuranceThreshold Number of times the font is encountered before auto-assigning the font as a ligature or not
- * @param {Number} differenceThreshold Percent of differences in pixel data or pixel width needed to determine if a font is a ligature font
- * @return {Boolean}
- */
-function isIconLigature(
-  textVNode,
-  differenceThreshold = 0.15,
-  occuranceThreshold = 3
-) {
-  /**
-   * Determine if the visible text is a ligature by comparing the
-   * first letters image data to the entire strings image data.
-   * If the two images are significantly different (typical set to 5%
-   * statistical significance, but we'll be using a slightly higher value
-   * of 15% to help keep the size of the canvas down) then we know the text
-   * has been replaced by a ligature.
-   *
-   * Example:
-   * If a text node was the string "File", looking at just the first
-   * letter "F" would produce the following image:
-   *
-   * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
-   * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
-   *
-   * But if the entire string "File" produced an image which had at least
-   * a 15% difference in pixels, we would know that the string was replaced
-   * by a ligature:
-   *
-   * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
-   * │ │█│█│█│█│█│█│█│█│█│█│ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │█│█│ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │█│█│█│█│█│█│ │█│ │█│ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │█│█│█│█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │█│█│█│█│█│█│ │ │ │ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │█│█│█│█│█│█│█│█│█│ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│█│█│█│█│█│█│█│█│█│█│█│█│ │
-   * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
-   */
-  const nodeValue = textVNode.actualNode.nodeValue.trim();
-
-  // text with unicode or non-bmp letters cannot be ligature icons
-  if (
-    !sanitize(nodeValue) ||
-    hasUnicode(nodeValue, { emoji: true, nonBmp: true })
-  ) {
-    return false;
-  }
-
-  if (!cache.get('canvasContext')) {
-    cache.set(
-      'canvasContext',
-      document.createElement('canvas').getContext('2d')
-    );
-  }
-  const canvasContext = cache.get('canvasContext');
-  const canvas = canvasContext.canvas;
-
-  // keep track of each font encountered and the number of times it shows up
-  // as a ligature.
-  if (!cache.get('fonts')) {
-    cache.set('fonts', {});
-  }
-  const fonts = cache.get('fonts');
-
-  const style = window.getComputedStyle(textVNode.parent.actualNode);
-  const fontFamily = style.getPropertyValue('font-family');
-
-  if (!fonts[fontFamily]) {
-    fonts[fontFamily] = {
-      occurances: 0,
-      numLigatures: 0
-    };
-  }
-  const font = fonts[fontFamily];
-
-  // improve the performance by only comparing the image data of a font
-  // a certain number of times
-  if (font.occurances >= occuranceThreshold) {
-    // if the font has always been a ligature assume it's a ligature font
-    if (font.numLigatures / font.occurances === 1) {
-      return true;
-    }
-    // inversely, if it's never been a ligature assume it's not a ligature font
-    else if (font.numLigatures === 0) {
-      return false;
-    }
-
-    // we could theoretically get into an odd middle ground scenario in which
-    // the font family is being used as normal text sometimes and as icons
-    // other times. in these cases we would need to always check the text
-    // to know if it's an icon or not
-  }
-  font.occurances++;
-
-  // 30px was chosen to account for common ligatures in normal fonts
-  // such as fi, ff, ffi. If a ligature would add a single column of
-  // pixels to a 30x30 grid, it would not meet the statistical significance
-  // threshold of 15% (30x30 = 900; 30/900 = 3.333%). this also allows for
-  // more than 1 column differences (60/900 = 6.666%) and things like
-  // extending the top of the f in the fi ligature.
-  let fontSize = 30;
-  let fontStyle = `${fontSize}px ${fontFamily}`;
-
-  // set the size of the canvas to the width of the first letter
-  canvasContext.font = fontStyle;
-  const firstChar = nodeValue.charAt(0);
-  let width = canvasContext.measureText(firstChar).width;
-
-  // ensure font meets the 30px width requirement (30px font-size doesn't
-  // necessarily mean its 30px wide when drawn)
-  if (width < 30) {
-    const diff = 30 / width;
-    width *= diff;
-    fontSize *= diff;
-    fontStyle = `${fontSize}px ${fontFamily}`;
-  }
-  canvas.width = width;
-  canvas.height = fontSize;
-
-  // changing the dimensions of a canvas resets all properties (include font)
-  // and clears it
-  canvasContext.font = fontStyle;
-  canvasContext.textAlign = 'left';
-  canvasContext.textBaseline = 'top';
-  canvasContext.fillText(firstChar, 0, 0);
-  const compareData = new Uint32Array(
-    canvasContext.getImageData(0, 0, width, fontSize).data.buffer
-  );
-
-  // if the font doesn't even have character data for a single char then
-  // it has to be an icon ligature (e.g. Material Icon)
-  if (!compareData.some(pixel => pixel)) {
-    font.numLigatures++;
-    return true;
-  }
-
-  canvasContext.clearRect(0, 0, width, fontSize);
-  canvasContext.fillText(nodeValue, 0, 0);
-  const compareWith = new Uint32Array(
-    canvasContext.getImageData(0, 0, width, fontSize).data.buffer
-  );
-
-  // calculate the number of differences between the first letter and the
-  // entire string, ignoring color differences
-  const differences = compareData.reduce((diff, pixel, i) => {
-    if (pixel === 0 && compareWith[i] === 0) {
-      return diff;
-    }
-    if (pixel !== 0 && compareWith[i] !== 0) {
-      return diff;
-    }
-    return ++diff;
-  }, 0);
-
-  // calculate the difference between the width of each character and the
-  // combined with of all characters
-  const expectedWidth = nodeValue.split('').reduce((width, char) => {
-    return width + canvasContext.measureText(char).width;
-  }, 0);
-  const actualWidth = canvasContext.measureText(nodeValue).width;
-
-  const pixelDifference = differences / compareData.length;
-  const sizeDifference = 1 - actualWidth / expectedWidth;
-
-  if (
-    pixelDifference >= differenceThreshold &&
-    sizeDifference >= differenceThreshold
-  ) {
-    font.numLigatures++;
-    return true;
-  }
-
-  return false;
-}
-
-export default isIconLigature;

package/lib/commons/text/is-valid-autocomplete.js

@@ -1,118 +0,0 @@
-export const autocomplete = {
-  stateTerms: ['on', 'off'],
-  standaloneTerms: [
-    'name',
-    'honorific-prefix',
-    'given-name',
-    'additional-name',
-    'family-name',
-    'honorific-suffix',
-    'nickname',
-    'username',
-    'new-password',
-    'current-password',
-    'organization-title',
-    'organization',
-    'street-address',
-    'address-line1',
-    'address-line2',
-    'address-line3',
-    'address-level4',
-    'address-level3',
-    'address-level2',
-    'address-level1',
-    'country',
-    'country-name',
-    'postal-code',
-    'cc-name',
-    'cc-given-name',
-    'cc-additional-name',
-    'cc-family-name',
-    'cc-number',
-    'cc-exp',
-    'cc-exp-month',
-    'cc-exp-year',
-    'cc-csc',
-    'cc-type',
-    'transaction-currency',
-    'transaction-amount',
-    'language',
-    'bday',
-    'bday-day',
-    'bday-month',
-    'bday-year',
-    'sex',
-    'url',
-    'photo',
-    'one-time-code'
-  ],
-  qualifiers: ['home', 'work', 'mobile', 'fax', 'pager'],
-  qualifiedTerms: [
-    'tel',
-    'tel-country-code',
-    'tel-national',
-    'tel-area-code',
-    'tel-local',
-    'tel-local-prefix',
-    'tel-local-suffix',
-    'tel-extension',
-    'email',
-    'impp'
-  ],
-  locations: ['billing', 'shipping']
-};
-
-function isValidAutocomplete(
-  autocompleteValue,
-  {
-    looseTyped = false,
-    stateTerms = [],
-    locations = [],
-    qualifiers = [],
-    standaloneTerms = [],
-    qualifiedTerms = []
-  } = {}
-) {
-  autocompleteValue = autocompleteValue.toLowerCase().trim();
-  stateTerms = stateTerms.concat(autocomplete.stateTerms);
-  if (stateTerms.includes(autocompleteValue) || autocompleteValue === '') {
-    return true;
-  }
-
-  qualifiers = qualifiers.concat(autocomplete.qualifiers);
-  locations = locations.concat(autocomplete.locations);
-  standaloneTerms = standaloneTerms.concat(autocomplete.standaloneTerms);
-  qualifiedTerms = qualifiedTerms.concat(autocomplete.qualifiedTerms);
-
-  const autocompleteTerms = autocompleteValue.split(/\s+/g);
-  if (!looseTyped) {
-    if (
-      autocompleteTerms[0].length > 8 &&
-      autocompleteTerms[0].substr(0, 8) === 'section-'
-    ) {
-      autocompleteTerms.shift();
-    }
-
-    if (locations.includes(autocompleteTerms[0])) {
-      autocompleteTerms.shift();
-    }
-
-    if (qualifiers.includes(autocompleteTerms[0])) {
-      autocompleteTerms.shift();
-      // only quantifiers allowed at this point
-      standaloneTerms = [];
-    }
-
-    if (autocompleteTerms.length !== 1) {
-      return false;
-    }
-  }
-
-  const purposeTerm = autocompleteTerms[autocompleteTerms.length - 1];
-  return (
-    standaloneTerms.includes(purposeTerm) ||
-    qualifiedTerms.includes(purposeTerm)
-  );
-}
-
-export default isValidAutocomplete;

package/lib/commons/text/label-text.js

@@ -1,70 +0,0 @@
-import accessibleTextVirtual from './accessible-text-virtual';
-import accessibleText from './accessible-text';
-import findElmsInContext from '../dom/find-elms-in-context';
-import { closest, nodeSorter } from '../../core/utils';
-
-/**
- * Return accessible text for an implicit and/or explicit HTML label element
- * @param {VirtualNode} element
- * @param {Object} context
- * @property {Bool} inControlContext
- * @property {Bool} inLabelledByContext
- * @return {String} Label text
- */
-function labelText(virtualNode, context = {}) {
-  const { alreadyProcessed } = accessibleTextVirtual;
-  if (
-    context.inControlContext ||
-    context.inLabelledByContext ||
-    alreadyProcessed(virtualNode, context)
-  ) {
-    return '';
-  }
-  if (!context.startNode) {
-    context.startNode = virtualNode;
-  }
-
-  const labelContext = { inControlContext: true, ...context };
-  const explicitLabels = getExplicitLabels(virtualNode);
-  const implicitLabel = closest(virtualNode, 'label');
-
-  let labels;
-  if (implicitLabel) {
-    labels = [...explicitLabels, implicitLabel.actualNode];
-    labels.sort(nodeSorter);
-  } else {
-    labels = explicitLabels;
-  }
-
-  return labels
-    .map(label => accessibleText(label, labelContext))
-    .filter(text => text !== '')
-    .join(' ');
-}
-
-/**
- * Find a non-ARIA label for an element
- * @private
- * @param {VirtualNode} element The VirtualNode instance whose label we are seeking
- * @return {HTMLElement} The label element, or null if none is found
- */
-function getExplicitLabels(virtualNode) {
-  if (!virtualNode.attr('id')) {
-    return [];
-  }
-
-  if (!virtualNode.actualNode) {
-    throw new TypeError(
-      'Cannot resolve explicit label reference for non-DOM nodes'
-    );
-  }
-
-  return findElmsInContext({
-    elm: 'label',
-    attr: 'for',
-    value: virtualNode.attr('id'),
-    context: virtualNode.actualNode
-  });
-}
-
-export default labelText;

package/lib/commons/text/label-virtual.js

@@ -1,50 +0,0 @@
-import ariaLabelVirtual from '../aria/label-virtual';
-import visible from './visible';
-import visibleVirtual from './visible-virtual';
-import getRootNode from '../dom/get-root-node';
-import { closest, escapeSelector } from '../../core/utils';
-
-/**
- * Gets the visible text of a label for a given input
- * @see http://www.w3.org/WAI/PF/aria/roles#namecalculation
- * @method labelVirtual
- * @memberof axe.commons.text
- * @instance
- * @param  {VirtualNode} node The virtual node mapping to the input to test
- * @return {Mixed} String of visible text, or `null` if no label is found
- */
-function labelVirtual(virtualNode) {
-  var ref, candidate, doc;
-
-  candidate = ariaLabelVirtual(virtualNode);
-  if (candidate) {
-    return candidate;
-  }
-
-  // explicit label
-  if (virtualNode.attr('id')) {
-    if (!virtualNode.actualNode) {
-      throw new TypeError(
-        'Cannot resolve explicit label reference for non-DOM nodes'
-      );
-    }
-
-    const id = escapeSelector(virtualNode.attr('id'));
-    doc = getRootNode(virtualNode.actualNode);
-    ref = doc.querySelector('label[for="' + id + '"]');
-    candidate = ref && visible(ref, true);
-    if (candidate) {
-      return candidate;
-    }
-  }
-
-  ref = closest(virtualNode, 'label');
-  candidate = ref && visibleVirtual(ref, true);
-  if (candidate) {
-    return candidate;
-  }
-
-  return null;
-}
-
-export default labelVirtual;

package/lib/commons/text/label.js

@@ -1,19 +0,0 @@
-import labelVirtual from './label-virtual';
-import { getNodeFromTree } from '../../core/utils';
-
-/**
- * Finds virtual node and calls labelVirtual()
- * IMPORTANT: This method requires the composed tree at axe._tree
- * @see axe.commons.text.virtualLabel
- * @method label
- * @memberof axe.commons.text
- * @instance
- * @param  {Element} node The virtual node mapping to the input to test
- * @return {Mixed} String of visible text, or `null` if no label is found
- */
-function label(node) {
-  node = getNodeFromTree(node);
-  return labelVirtual(node);
-}
-
-export default label;

package/lib/commons/text/native-element-type.js

@@ -1,101 +0,0 @@
-const nativeElementType = [
-  {
-    // 5.1 input type="text", input type="password", input type="search", input type="tel", input type="url" and textarea Element
-    matches: [
-      {
-        nodeName: 'textarea'
-      },
-      {
-        nodeName: 'input',
-        properties: {
-          type: ['text', 'password', 'search', 'tel', 'email', 'url']
-        }
-      }
-    ],
-    namingMethods: 'labelText'
-  },
-  {
-    // 5.2 input type="button", input type="submit" and input type="reset"
-    matches: {
-      nodeName: 'input',
-      properties: {
-        type: ['button', 'submit', 'reset']
-      }
-    },
-    namingMethods: ['valueText', 'titleText', 'buttonDefaultText']
-  },
-  {
-    // 5.3 input type="image"
-    matches: {
-      nodeName: 'input',
-      properties: {
-        type: 'image'
-      }
-    },
-    namingMethods: [
-      'altText',
-      'valueText',
-      'labelText',
-      'titleText',
-      'buttonDefaultText'
-    ]
-  },
-  {
-    // 5.4 button Element
-    matches: 'button',
-    namingMethods: 'subtreeText'
-  },
-  {
-    // 5.5 fieldset and legend Elements
-    matches: 'fieldset',
-    namingMethods: 'fieldsetLegendText'
-  },
-  {
-    // 5.6 output Element
-    matches: 'OUTPUT',
-    namingMethods: 'subtreeText'
-  },
-  {
-    // 5.7 Other Form Elements
-    matches: [
-      {
-        nodeName: 'select'
-      },
-      {
-        nodeName: 'input',
-        properties: {
-          // Regex: Everything other than these
-          type: /^(?!text|password|search|tel|email|url|button|submit|reset)/
-        }
-      }
-    ],
-    namingMethods: 'labelText'
-  },
-  {
-    // 5.8 summary Element
-    matches: 'summary',
-    namingMethods: 'subtreeText'
-  },
-  {
-    // 5.9 figure and figcaption Elements
-    matches: 'figure',
-    namingMethods: ['figureText', 'titleText']
-  },
-  {
-    // 5.10 img Element
-    matches: 'img',
-    namingMethods: 'altText'
-  },
-  {
-    // 5.11 table Element
-    matches: 'table',
-    namingMethods: ['tableCaptionText', 'tableSummaryText']
-  },
-  {
-    matches: ['hr', 'br'],
-    namingMethods: ['titleText', 'singleSpace']
-  }
-  // All else defaults to just title
-];
-
-export default nativeElementType;

package/lib/commons/text/native-text-alternative.js

@@ -1,46 +0,0 @@
-import getRole from '../aria/get-role';
-import getElementSpec from '../standards/get-element-spec';
-import nativeTextMethods from './native-text-methods';
-
-/**
- * Get the accessible text using native HTML methods only
- * @param {VirtualNode} element
- * @param {Object} context
- * @property {Bool} debug Enable logging for formControlValue
- * @return {String} Accessible text
- */
-function nativeTextAlternative(virtualNode, context = {}) {
-  const { actualNode } = virtualNode;
-  if (
-    virtualNode.props.nodeType !== 1 ||
-    ['presentation', 'none'].includes(getRole(virtualNode))
-  ) {
-    return '';
-  }
-
-  const textMethods = findTextMethods(virtualNode);
-  // Find the first step that returns a non-empty string
-  const accName = textMethods.reduce((accName, step) => {
-    return accName || step(virtualNode, context);
-  }, '');
-
-  if (context.debug) {
-    axe.log(accName || '{empty-value}', actualNode, context);
-  }
-  return accName;
-}
-
-/**
- * Get accessible text functions for a specific native HTML element
- * @private
- * @param {VirtualNode} element
- * @return {Function[]} Array of native accessible name computation methods
- */
-function findTextMethods(virtualNode) {
-  const elmSpec = getElementSpec(virtualNode);
-  const methods = elmSpec.namingMethods || [];
-
-  return methods.map(methodName => nativeTextMethods[methodName]);
-}
-
-export default nativeTextAlternative;