axe-core 4.2.4 → 4.3.0

package/lib/core/utils/get-friendly-uri-end.js

@@ -1,143 +0,0 @@
-/* eslint no-script-url:0 */
-/**
- * Check if a string contains mostly numbers
- */
-function isMostlyNumbers(str = '') {
-  return (
-    str.length !== 0 && (str.match(/[0-9]/g) || '').length >= str.length / 2
-  );
-}
-
-/**
- * Spit a string into an array with two pieces, at a given index
- * @param String	string to split
- * @param Number	index at which to split
- * @return Array
- */
-function splitString(str, splitIndex) {
-  return [str.substring(0, splitIndex), str.substring(splitIndex)];
-}
-
-function trimRight(str) {
-  return str.replace(/\s+$/, '');
-}
-
-/**
- * Take a relative or absolute URL and pull it into it's indivisual pieces
- *
- * @param url (string)
- * @return urlPieces
- *	 .protocol	The protocol used, e.g. 'https://'
- *	 .domain		Domain name including sub domains and TLD, e.g. 'docs.deque.com'
- *	 .port			The port number, e.g. ':8080'
- *	 .path			Path after the domain, e.g. '/home.html'
- *	 .query		 Query string, e.g. '?user=admin&password=pass'
- *	 .hash			Hash / internal reference, e.g. '#footer'
- */
-function uriParser(url) {
-  const original = url;
-  let protocol = '',
-    domain = '',
-    port = '',
-    path = '',
-    query = '',
-    hash = '';
-  if (url.includes('#')) {
-    [url, hash] = splitString(url, url.indexOf('#'));
-  }
-
-  if (url.includes('?')) {
-    [url, query] = splitString(url, url.indexOf('?'));
-  }
-
-  if (url.includes('://')) {
-    [protocol, url] = url.split('://');
-    [domain, url] = splitString(url, url.indexOf('/'));
-  } else if (url.substr(0, 2) === '//') {
-    url = url.substr(2);
-    [domain, url] = splitString(url, url.indexOf('/'));
-  }
-
-  if (domain.substr(0, 4) === 'www.') {
-    domain = domain.substr(4);
-  }
-
-  if (domain && domain.includes(':')) {
-    [domain, port] = splitString(domain, domain.indexOf(':'));
-  }
-
-  path = url; // Whatever is left, must be the path
-  return { original, protocol, domain, port, path, query, hash };
-}
-
-/**
- * Try to, at the end of the URI, find a string that a user can identify the URI by
- *
- * @param uri			 The URI to use
- * @param options
- *	 .currentDomain	The current domain name (optional)
- *	 .maxLength			Max length of the returned string (default: 25)
- * @return string	 A portion at the end of the uri, no longer than maxLength
- */
-function getFriendlyUriEnd(uri = '', options = {}) {
-  if (
-    // Skip certain URIs:
-    uri.length <= 1 || // very short
-    uri.substr(0, 5) === 'data:' || // data URIs are unreadable
-    uri.substr(0, 11) === 'javascript:' || // JS isn't a URL
-    uri.includes('?') // query strings aren't very readable either
-  ) {
-    return;
-  }
-
-  const { currentDomain, maxLength = 25 } = options;
-  const { path, domain, hash } = uriParser(uri);
-  // Split the path at the last / that has text after it
-  const pathEnd = path.substr(
-    path.substr(0, path.length - 2).lastIndexOf('/') + 1
-  );
-
-  if (hash) {
-    if (pathEnd && (pathEnd + hash).length <= maxLength) {
-      return trimRight(pathEnd + hash);
-    } else if (
-      pathEnd.length < 2 &&
-      hash.length > 2 &&
-      hash.length <= maxLength
-    ) {
-      return trimRight(hash);
-    } else {
-      return;
-    }
-  } else if (domain && domain.length < maxLength && path.length <= 1) {
-    // '' or '/'
-    return trimRight(domain + path);
-  }
-
-  // See if the domain should be returned
-  if (
-    path === '/' + pathEnd &&
-    domain &&
-    currentDomain &&
-    domain !== currentDomain &&
-    (domain + path).length <= maxLength
-  ) {
-    return trimRight(domain + path);
-  }
-
-  const lastDotIndex = pathEnd.lastIndexOf('.');
-  if (
-    // Exclude very short or very long string
-    (lastDotIndex === -1 || lastDotIndex > 1) &&
-    (lastDotIndex !== -1 || pathEnd.length > 2) &&
-    pathEnd.length <= maxLength &&
-    // Exclude index files
-    !pathEnd.match(/index(\.[a-zA-Z]{2-4})?/) &&
-    // Exclude files that are likely to be database IDs
-    !isMostlyNumbers(pathEnd)
-  ) {
-    return trimRight(pathEnd);
-  }
-}
-
-export default getFriendlyUriEnd;

package/lib/core/utils/get-node-attributes.js

@@ -1,22 +0,0 @@
-/**
- * Return the list of attributes of a node.
- * @method getNodeAttributes
- * @memberof axe.utils
- * @param {Element} node
- * @deprecated
- * @returns {NamedNodeMap}
- */
-function getNodeAttributes(node) {
-  // eslint-disable-next-line no-restricted-syntax
-  if (node.attributes instanceof window.NamedNodeMap) {
-    // eslint-disable-next-line no-restricted-syntax
-    return node.attributes;
-  }
-
-  // if the attributes property is not of type NamedNodeMap then the DOM
-  // has been clobbered. E.g. <form><input name="attributes"></form>.
-  // We can clone the node to isolate it and then return the attributes
-  return node.cloneNode(false).attributes;
-}
-
-export default getNodeAttributes;

package/lib/core/utils/get-node-from-tree.js

@@ -1,14 +0,0 @@
-import cache from '../base/cache';
-
-/**
- * Return a single node from the virtual dom tree
- *
- * @param {Object} vNode The flattened, virtual DOM tree
- * @param {Node}   node  The HTML DOM node
- */
-function getNodeFromTree(vNode, node) {
-  const el = node || vNode;
-  return cache.get('nodeMap') ? cache.get('nodeMap').get(el) : null;
-}
-
-export default getNodeFromTree;

package/lib/core/utils/get-root-node.js

@@ -1,17 +0,0 @@
-/**
- * Return the document or document fragment (shadow DOM)
- * @method getRootNode
- * @memberof axe.utils
- * @param {Element} node
- * @returns {DocumentFragment|Document}
- */
-function getRootNode(node) {
-  var doc = (node.getRootNode && node.getRootNode()) || document; // this is for backwards compatibility
-  if (doc === node) {
-    // disconnected node
-    doc = document;
-  }
-  return doc;
-}
-
-export default getRootNode;

package/lib/core/utils/get-rule.js

@@ -1,17 +0,0 @@
-/**
- * Get an axe rule by id.
- * @param {String} ruelId the rule id
- * @return {Rule}
- */
-function getRule(ruleId) {
-  // TODO: es-modules_audit
-  var rule = axe._audit.rules.find(rule => rule.id === ruleId);
-
-  if (!rule) {
-    throw new Error(`Cannot find rule by id: ${ruleId}`);
-  }
-
-  return rule;
-}
-
-export default getRule;

package/lib/core/utils/get-scroll-state.js

@@ -1,43 +0,0 @@
-import getScroll from './get-scroll';
-
-/**
- * Create an array scroll positions from descending elements
- */
-function getElmScrollRecursive(root) {
-  // Need to also get .childNodes since SVGs in IE don't have .children.
-  return Array.from(root.children || root.childNodes || []).reduce(
-    (scrolls, elm) => {
-      const scroll = getScroll(elm);
-      if (scroll) {
-        scrolls.push(scroll);
-      }
-      return scrolls.concat(getElmScrollRecursive(elm));
-    },
-    []
-  );
-}
-
-/**
- * Get the scroll position of all scrollable elements in a page
- * @deprecated
- */
-function getScrollState(win = window) {
-  const root = win.document.documentElement;
-  const windowScroll = [
-    win.pageXOffset !== undefined
-      ? {
-          elm: win,
-          top: win.pageYOffset,
-          left: win.pageXOffset
-        }
-      : {
-          elm: root,
-          top: root.scrollTop,
-          left: root.scrollLeft
-        }
-  ];
-
-  return windowScroll.concat(getElmScrollRecursive(document.body));
-}
-
-export default getScrollState;

package/lib/core/utils/get-scroll.js

@@ -1,41 +0,0 @@
-/**
- * Get the scroll position of given element
- * @method getScroll
- * @memberof axe.utils
- * @param {Element} node
- * @param {buffer} (Optional) allowed negligence in overflow
- * @returns {Object | undefined}
- */
-function getScroll(elm, buffer = 0) {
-  const overflowX = elm.scrollWidth > elm.clientWidth + buffer;
-  const overflowY = elm.scrollHeight > elm.clientHeight + buffer;
-
-  /**
-   * if there is neither `overflow-x` or `overflow-y`
-   * -> return
-   */
-  if (!(overflowX || overflowY)) {
-    return;
-  }
-
-  const style = window.getComputedStyle(elm);
-  const overflowXStyle = style.getPropertyValue('overflow-x');
-  const overflowYStyle = style.getPropertyValue('overflow-y');
-  const scrollableX =
-    overflowXStyle !== 'visible' && overflowXStyle !== 'hidden';
-  const scrollableY =
-    overflowYStyle !== 'visible' && overflowYStyle !== 'hidden';
-
-  /**
-   * check direction of `overflow` and `scrollable`
-   */
-  if ((overflowX && scrollableX) || (overflowY && scrollableY)) {
-    return {
-      elm,
-      top: elm.scrollTop,
-      left: elm.scrollLeft
-    };
-  }
-}
-
-export default getScroll;

package/lib/core/utils/get-selector.js

@@ -1,395 +0,0 @@
-import escapeSelector from './escape-selector';
-import getFriendlyUriEnd from './get-friendly-uri-end';
-import getNodeAttributes from './get-node-attributes';
-import matchesSelector from './element-matches';
-import isXHTML from './is-xhtml';
-import getShadowSelector from './get-shadow-selector';
-
-let xhtml;
-const ignoredAttributes = [
-  'class',
-  'style',
-  'id',
-  'selected',
-  'checked',
-  'disabled',
-  'tabindex',
-  'aria-checked',
-  'aria-selected',
-  'aria-invalid',
-  'aria-activedescendant',
-  'aria-busy',
-  'aria-disabled',
-  'aria-expanded',
-  'aria-grabbed',
-  'aria-pressed',
-  'aria-valuenow'
-];
-const MAXATTRIBUTELENGTH = 31;
-
-/**
- * get the attribute name and value as a string
- * @param {Element} node		The element that has the attribute
- * @param {Attribute} at		The attribute
- * @return {String}
- */
-function getAttributeNameValue(node, at) {
-  const name = at.name;
-  let atnv;
-
-  if (name.indexOf('href') !== -1 || name.indexOf('src') !== -1) {
-    const friendly = getFriendlyUriEnd(node.getAttribute(name));
-    if (friendly) {
-      const value = encodeURI(friendly);
-      if (value) {
-        atnv = escapeSelector(at.name) + '$="' + escapeSelector(value) + '"';
-      } else {
-        return;
-      }
-    } else {
-      atnv =
-        escapeSelector(at.name) +
-        '="' +
-        escapeSelector(node.getAttribute(name)) +
-        '"';
-    }
-  } else {
-    atnv = escapeSelector(name) + '="' + escapeSelector(at.value) + '"';
-  }
-  return atnv;
-}
-
-function countSort(a, b) {
-  return a.count < b.count ? -1 : a.count === b.count ? 0 : 1;
-}
-
-/**
- * Filter the attributes
- * @param {Attribute}		The potential attribute
- * @return {Boolean}		 Whether to include or exclude
- */
-function filterAttributes(at) {
-  return (
-    !ignoredAttributes.includes(at.name) &&
-    at.name.indexOf(':') === -1 &&
-    (!at.value || at.value.length < MAXATTRIBUTELENGTH)
-  );
-}
-
-/**
- * Calculate the statistics for the classes, attributes and tags on the page, using
- * the virtual DOM tree
- * @param {Object} domTree		The root node of the virtual DOM tree
- * @returns {Object}					The statistics consisting of three maps, one for classes,
- *														one for tags and one for attributes. The map values are
- *														the counts for how many elements with that feature exist
- */
-export function getSelectorData(domTree) {
-  /* eslint no-loop-func:0*/
-
-  // Initialize the return structure with the three maps
-  const data = {
-    classes: {},
-    tags: {},
-    attributes: {}
-  };
-
-  domTree = Array.isArray(domTree) ? domTree : [domTree];
-  let currentLevel = domTree.slice();
-  const stack = [];
-  while (currentLevel.length) {
-    const current = currentLevel.pop();
-    const node = current.actualNode;
-
-    if (!!node.querySelectorAll) {
-      // ignore #text nodes
-
-      // count the tag
-      const tag = node.nodeName;
-      if (data.tags[tag]) {
-        data.tags[tag]++;
-      } else {
-        data.tags[tag] = 1;
-      }
-
-      // count all the classes
-      if (node.classList) {
-        Array.from(node.classList).forEach(cl => {
-          const ind = escapeSelector(cl);
-          if (data.classes[ind]) {
-            data.classes[ind]++;
-          } else {
-            data.classes[ind] = 1;
-          }
-        });
-      }
-
-      // count all the filtered attributes
-      if (node.hasAttributes()) {
-        Array.from(getNodeAttributes(node))
-          .filter(filterAttributes)
-          .forEach(at => {
-            const atnv = getAttributeNameValue(node, at);
-            if (atnv) {
-              if (data.attributes[atnv]) {
-                data.attributes[atnv]++;
-              } else {
-                data.attributes[atnv] = 1;
-              }
-            }
-          });
-      }
-    }
-    if (current.children.length) {
-      // "recurse"
-      stack.push(currentLevel);
-      currentLevel = current.children.slice();
-    }
-    while (!currentLevel.length && stack.length) {
-      currentLevel = stack.pop();
-    }
-  }
-  return data;
-}
-
-/**
- * Given a node and the statistics on class frequency on the page,
- * return all its uncommon class data sorted in order of decreasing uniqueness
- * @param {Element} node			The node
- * @param {Object} classData	The map of classes to counts
- * @return {Array}						The sorted array of uncommon class data
- */
-function uncommonClasses(node, selectorData) {
-  // eslint no-loop-func:false
-  const retVal = [];
-  const classData = selectorData.classes;
-  const tagData = selectorData.tags;
-
-  if (node.classList) {
-    Array.from(node.classList).forEach(cl => {
-      const ind = escapeSelector(cl);
-      if (classData[ind] < tagData[node.nodeName]) {
-        retVal.push({
-          name: ind,
-          count: classData[ind],
-          species: 'class'
-        });
-      }
-    });
-  }
-  return retVal.sort(countSort);
-}
-
-/**
- * Given an element and a selector that finds that element (but possibly other sibling elements)
- * return the :nth-child(n) pseudo selector that uniquely finds the node within its siblings
- * @param {Element} elm			 The Element
- * @param {String} selector	 The selector
- * @return {String}					 The nth-child selector
- */
-function getNthChildString(elm, selector) {
-  const siblings =
-    (elm.parentNode && Array.from(elm.parentNode.children || '')) || [];
-  const hasMatchingSiblings = siblings.find(
-    sibling => sibling !== elm && matchesSelector(sibling, selector)
-  );
-  if (hasMatchingSiblings) {
-    const nthChild = 1 + siblings.indexOf(elm);
-    return ':nth-child(' + nthChild + ')';
-  } else {
-    return '';
-  }
-}
-
-/**
- * Get ID selector
- */
-function getElmId(elm) {
-  if (!elm.getAttribute('id')) {
-    return;
-  }
-  const doc = (elm.getRootNode && elm.getRootNode()) || document;
-  const id = '#' + escapeSelector(elm.getAttribute('id') || '');
-  if (
-    // Don't include youtube's uid values, they change	on reload
-    !id.match(/player_uid_/) &&
-    // Don't include IDs that occur more then once on the page
-    doc.querySelectorAll(id).length === 1
-  ) {
-    return id;
-  }
-}
-
-/**
- * Return the base CSS selector for a given element
- * @param	{HTMLElement} elm				 The element to get the selector for
- * @return {String|Array<String>}	Base CSS selector for the node
- */
-function getBaseSelector(elm) {
-  if (typeof xhtml === 'undefined') {
-    xhtml = isXHTML(document);
-  }
-  return escapeSelector(xhtml ? elm.localName : elm.nodeName.toLowerCase());
-}
-
-/**
- * Given a node and the statistics on attribute frequency on the page,
- * return all its uncommon attribute data sorted in order of decreasing uniqueness
- * @param {Element} node			The node
- * @param {Object} attData		The map of attributes to counts
- * @return {Array}						The sorted array of uncommon attribute data
- */
-function uncommonAttributes(node, selectorData) {
-  const retVal = [];
-  const attData = selectorData.attributes;
-  const tagData = selectorData.tags;
-
-  if (node.hasAttributes()) {
-    Array.from(getNodeAttributes(node))
-      .filter(filterAttributes)
-      .forEach(at => {
-        const atnv = getAttributeNameValue(node, at);
-
-        if (atnv && attData[atnv] < tagData[node.nodeName]) {
-          retVal.push({
-            name: atnv,
-            count: attData[atnv],
-            species: 'attribute'
-          });
-        }
-      });
-  }
-  return retVal.sort(countSort);
-}
-
-/**
- * generates a selector fragment for an element based on the statistics of the page in
- * which the element exists. This function takes into account the fact that selectors that
- * use classes and tags are much faster than universal selectors. It also tries to use a
- * unique class selector before a unique attribute selector (with the tag), followed by
- * a selector made up of the three least common features statistically. A feature will
- * also only be used if it is less common than the tag of the element itself.
- *
- * @param {Element} elm			The element for which to generate a selector
- * @param {Object} options	 Options for how to generate the selector
- * @param {RootNode} doc		 The root node of the document or document fragment
- * @returns {String}				 The selector
- */
-
-function getThreeLeastCommonFeatures(elm, selectorData) {
-  let selector = '';
-  let features;
-  const clss = uncommonClasses(elm, selectorData);
-  const atts = uncommonAttributes(elm, selectorData);
-
-  if (clss.length && clss[0].count === 1) {
-    // only use the unique class
-    features = [clss[0]];
-  } else if (atts.length && atts[0].count === 1) {
-    // only use the unique attribute value
-    features = [atts[0]];
-    // if no class, add the tag
-    selector = getBaseSelector(elm);
-  } else {
-    features = clss.concat(atts);
-    // sort by least common
-    features.sort(countSort);
-
-    // select three least common features
-    features = features.slice(0, 3);
-
-    // if no class, add the tag
-    if (
-      !features.some(feat => {
-        return feat.species === 'class';
-      })
-    ) {
-      // has no class
-      selector = getBaseSelector(elm);
-    } else {
-      // put the classes at the front of the selector
-      features.sort((a, b) => {
-        return a.species !== b.species && a.species === 'class'
-          ? -1
-          : a.species === b.species
-          ? 0
-          : 1;
-      });
-    }
-  }
-
-  // construct the return value
-  return (selector += features.reduce((val, feat) => {
-    /*eslint indent: 0*/
-    switch (feat.species) {
-      case 'class':
-        return val + '.' + feat.name;
-      case 'attribute':
-        return val + '[' + feat.name + ']';
-    }
-    return val; // should never happen
-  }, ''));
-}
-
-/**
- * generates a single selector for an element
- * @param {Element} elm			The element for which to generate a selector
- * @param {Object} options	 Options for how to generate the selector
- * @param {RootNode} doc		 The root node of the document or document fragment
- * @returns {String}				 The selector
- */
-
-function generateSelector(elm, options, doc) {
-  /*eslint no-loop-func:0*/
-  // TODO: es-modules_selectorData
-  if (!axe._selectorData) {
-    throw new Error('Expect axe._selectorData to be set up');
-  }
-  const { toRoot = false } = options;
-  let selector;
-  let similar;
-
-  /**
-   * Try to find a unique selector by filtering out all the clashing
-   * nodes by adding ancestor selectors iteratively.
-   * This loop is much faster than recursing and using querySelectorAll
-   */
-  do {
-    let features = getElmId(elm);
-    if (!features) {
-      features = getThreeLeastCommonFeatures(elm, axe._selectorData);
-      features += getNthChildString(elm, features);
-    }
-    if (selector) {
-      selector = features + ' > ' + selector;
-    } else {
-      selector = features;
-    }
-    if (!similar) {
-      similar = Array.from(doc.querySelectorAll(selector));
-    } else {
-      similar = similar.filter(item => {
-        return matchesSelector(item, selector);
-      });
-    }
-    elm = elm.parentElement;
-  } while ((similar.length > 1 || toRoot) && elm && elm.nodeType !== 11);
-
-  if (similar.length === 1) {
-    return selector;
-  } else if (selector.indexOf(' > ') !== -1) {
-    // For the odd case that document doesn't have a unique selector
-    return ':root' + selector.substring(selector.indexOf(' > '));
-  }
-  return ':root';
-}
-
-/**
- * Gets a unique CSS selector
- * @param {HTMLElement} node The element to get the selector for
- * @param {Object} optional options
- * @returns {String|Array<String>} Unique CSS selector for the node
- */
-export default function getSelector(elm, options) {
-  return getShadowSelector(generateSelector, elm, options);
-}