axe-core 4.2.4 → 4.3.0

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

@@ -1,31 +0,0 @@
-/**
- * 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
- */
-function getShadowSelector(generateSelector, elm, options = {}) {
-  if (!elm) {
-    return '';
-  }
-  let doc = (elm.getRootNode && elm.getRootNode()) || document;
-  // Not a DOCUMENT_FRAGMENT - shadow DOM
-  if (doc.nodeType !== 11) {
-    return generateSelector(elm, options, doc);
-  }
-
-  const stack = [];
-  while (doc.nodeType === 11) {
-    if (!doc.host) {
-      return '';
-    }
-    stack.unshift({ elm, doc });
-    elm = doc.host;
-    doc = elm.getRootNode();
-  }
-
-  stack.unshift({ elm, doc });
-  return stack.map(({ elm, doc }) => generateSelector(elm, options, doc));
-}
-
-export default getShadowSelector;

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

@@ -1,6 +0,0 @@
-import standards from '../../standards';
-import clone from './clone';
-
-export default function getStandards() {
-  return clone(standards);
-}

package/lib/core/utils/get-stylesheet-factory.js

@@ -1,53 +0,0 @@
-/**
- * Function which converts given text to `CSSStyleSheet`
- * - used in `CSSOM` computation.
- * - factory (closure) function, initialized with `document.implementation.createHTMLDocument()`, which uses DOM API for creating `style` elements.
- *
- * @method axe.utils.getStyleSheetFactory
- * @memberof axe.utils
- * @param {Object} dynamicDoc `document.implementation.createHTMLDocument()
- * @param {Object} options an object with properties to construct stylesheet
- * @property {String} options.data text content of the stylesheet
- * @property {Boolean} options.isCrossOrigin flag to notify if the resource was fetched from the network
- * @property {String} options.shadowId (Optional) shadowId if shadowDOM
- * @property {Object} options.root implementation document to create style elements
- * @property {String} options.priority a number indicating the loaded priority of CSS, to denote specificity of styles contained in the sheet.
- * @returns {Function}
- */
-function getStyleSheetFactory(dynamicDoc) {
-  if (!dynamicDoc) {
-    throw new Error(
-      'axe.utils.getStyleSheetFactory should be invoked with an argument'
-    );
-  }
-
-  return options => {
-    const {
-      data,
-      isCrossOrigin = false,
-      shadowId,
-      root,
-      priority,
-      isLink = false
-    } = options;
-    const style = dynamicDoc.createElement('style');
-    if (isLink) {
-      // as creating a stylesheet as link will need to be awaited
-      // till `onload`, it is wise to convert link href to @import statement
-      const text = dynamicDoc.createTextNode(`@import "${data.href}"`);
-      style.appendChild(text);
-    } else {
-      style.appendChild(dynamicDoc.createTextNode(data));
-    }
-    dynamicDoc.head.appendChild(style);
-    return {
-      sheet: style.sheet,
-      isCrossOrigin,
-      shadowId,
-      root,
-      priority
-    };
-  };
-}
-
-export default getStyleSheetFactory;

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

@@ -1,84 +0,0 @@
-import escapeSelector from './escape-selector';
-
-function getXPathArray(node, path) {
-  var sibling, count;
-  // Gets an XPath for an element which describes its hierarchical location.
-  if (!node) {
-    return [];
-  }
-  if (!path && node.nodeType === 9) {
-    // special case for when we are called and give the document itself as the starting node
-    path = [
-      {
-        str: 'html'
-      }
-    ];
-    return path;
-  }
-  path = path || [];
-  if (node.parentNode && node.parentNode !== node) {
-    path = getXPathArray(node.parentNode, path);
-  }
-
-  if (node.previousSibling) {
-    count = 1;
-    sibling = node.previousSibling;
-    do {
-      if (sibling.nodeType === 1 && sibling.nodeName === node.nodeName) {
-        count++;
-      }
-      sibling = sibling.previousSibling;
-    } while (sibling);
-    if (count === 1) {
-      count = null;
-    }
-  } else if (node.nextSibling) {
-    sibling = node.nextSibling;
-    do {
-      if (sibling.nodeType === 1 && sibling.nodeName === node.nodeName) {
-        count = 1;
-        sibling = null;
-      } else {
-        count = null;
-        sibling = sibling.previousSibling;
-      }
-    } while (sibling);
-  }
-
-  if (node.nodeType === 1) {
-    var element = {};
-    element.str = node.nodeName.toLowerCase();
-    // add the id and the count so we can construct robust versions of the xpath
-    var id = node.getAttribute && escapeSelector(node.getAttribute('id'));
-    if (id && node.ownerDocument.querySelectorAll('#' + id).length === 1) {
-      element.id = node.getAttribute('id');
-    }
-    if (count > 1) {
-      element.count = count;
-    }
-    path.push(element);
-  }
-  return path;
-}
-
-// Robust is intended to allow xpaths to be robust to changes in the HTML structure of the page
-// This means always use the id when present
-// Non robust means always use the count (i.e. the exact position of the element)
-// Ironically this is a bit of a misnomer because in very, very dynamic pages (e.g. where ids are generated on the fly)
-// the non-ribust Xpaths will work whereas the robust ones will not work
-function xpathToString(xpathArray) {
-  return xpathArray.reduce((str, elm) => {
-    if (elm.id) {
-      return `/${elm.str}[@id='${elm.id}']`;
-    } else {
-      return str + `/${elm.str}` + (elm.count > 0 ? `[${elm.count}]` : '');
-    }
-  }, '');
-}
-
-function getXpath(node) {
-  var xpathArray = getXPathArray(node);
-  return xpathToString(xpathArray);
-}
-
-export default getXpath;

package/lib/core/utils/index.js

@@ -1,90 +0,0 @@
-import { setDefaultFrameMessenger } from './frame-messenger';
-
-/**
- * Namespace for utility helper methods.
- * @namespace utils
- * @memberof axe
- */
-export { default as aggregate } from './aggregate';
-export { default as aggregateChecks } from './aggregate-checks';
-export { default as aggregateNodeResults } from './aggregate-node-results';
-export { default as aggregateResult } from './aggregate-result';
-export { default as areStylesSet } from './are-styles-set';
-export { default as assert } from './assert';
-export { default as checkHelper } from './check-helper';
-export { default as clone } from './clone';
-export { default as closest } from './closest';
-export { default as collectResultsFromFrames } from './collect-results-from-frames';
-export { default as contains } from './contains';
-export { default as cssParser } from './css-parser';
-export { default as deepMerge } from './deep-merge';
-export { default as DqElement } from './dq-element';
-export { default as matchesSelector } from './element-matches';
-export { default as escapeSelector } from './escape-selector';
-export { default as extendMetaData } from './extend-meta-data';
-export { default as finalizeRuleResult } from './finalize-result';
-export { default as findBy } from './find-by';
-export { default as getFlattenedTree } from './get-flattened-tree';
-export { default as getAllChecks } from './get-all-checks';
-export { default as getBaseLang } from './get-base-lang';
-export { default as getCheckMessage } from './get-check-message';
-export { default as getCheckOption } from './get-check-option';
-export { default as getFriendlyUriEnd } from './get-friendly-uri-end';
-export { default as getNodeAttributes } from './get-node-attributes';
-export { default as getNodeFromTree } from './get-node-from-tree';
-export { default as getRootNode } from './get-root-node';
-export { default as getRule } from './get-rule';
-export { default as getScrollState } from './get-scroll-state';
-export { default as getScroll } from './get-scroll';
-export { default as getShadowSelector } from './get-shadow-selector';
-export { default as getSelector, getSelectorData } from './get-selector';
-export { default as getStandards } from './get-standards';
-export { default as getStyleSheetFactory } from './get-stylesheet-factory';
-export { default as getXpath } from './get-xpath';
-export { default as getAncestry } from './get-ancestry';
-export { default as injectStyle } from './inject-style';
-export { default as isHidden } from './is-hidden';
-export { default as isHtmlElement } from './is-html-element';
-export { default as isNodeInContext } from './is-node-in-context';
-export { default as isShadowRoot } from './is-shadow-root';
-export { default as isXHTML } from './is-xhtml';
-export {
-  default as matches,
-  matchesExpression,
-  convertSelector
-} from './matches';
-export { default as memoize } from './memoize';
-export { default as mergeResults } from './merge-results';
-export { default as nodeSorter } from './node-sorter';
-export { default as parseCrossOriginStylesheet } from './parse-crossorigin-stylesheet';
-export { default as parseSameOriginStylesheet } from './parse-sameorigin-stylesheet';
-export { default as parseStylesheet } from './parse-stylesheet';
-export { default as performanceTimer } from './performance-timer';
-export { pollyfillElementsFromPoint } from './pollyfills';
-export { default as preloadCssom } from './preload-cssom';
-export { default as preloadMedia } from './preload-media';
-export { default as preload, shouldPreload, getPreloadConfig } from './preload';
-export { default as processMessage } from './process-message';
-export { default as publishMetaData } from './publish-metadata';
-export { default as querySelectorAllFilter } from './query-selector-all-filter';
-export { default as querySelectorAll } from './query-selector-all';
-export { default as queue } from './queue';
-export { default as respondable } from './respondable';
-export { default as ruleShouldRun } from './rule-should-run';
-export { default as filterHtmlAttrs } from './filter-html-attrs';
-export { default as select } from './select';
-export { default as sendCommandToFrame } from './send-command-to-frame';
-export { default as setScrollState } from './set-scroll-state';
-export { default as toArray } from './to-array';
-export { default as tokenList } from './token-list';
-export { default as uniqueArray } from './unique-array';
-export { default as uuid } from './uuid';
-export { default as validInputTypes } from './valid-input-type';
-export { default as isValidLang, validLangs } from './valid-langs';
-
-// Setting up this private/temp namespace for the tests (which cannot yet `import/export` things).
-// TODO: remove `_thisWillBeDeletedDoNotUse`
-axe._thisWillBeDeletedDoNotUse = axe._thisWillBeDeletedDoNotUse || {};
-axe._thisWillBeDeletedDoNotUse.utils = {
-  setDefaultFrameMessenger
-};

package/lib/core/utils/inject-style.js

@@ -1,33 +0,0 @@
-var styleSheet;
-function injectStyle(style) {
-  if (styleSheet && styleSheet.parentNode) {
-    // append the style to the existing sheet
-    if (styleSheet.styleSheet === undefined) {
-      // Not old IE
-      styleSheet.appendChild(document.createTextNode(style));
-    } else {
-      styleSheet.styleSheet.cssText += style;
-    }
-    return styleSheet;
-  }
-  if (!style) {
-    return;
-  }
-
-  var head = document.head || document.getElementsByTagName('head')[0];
-  styleSheet = document.createElement('style');
-  styleSheet.type = 'text/css';
-
-  if (styleSheet.styleSheet === undefined) {
-    // Not old IE
-    styleSheet.appendChild(document.createTextNode(style));
-  } else {
-    styleSheet.styleSheet.cssText = style;
-  }
-
-  head.appendChild(styleSheet);
-
-  return styleSheet;
-}
-
-export default injectStyle;

package/lib/core/utils/is-hidden.js

@@ -1,55 +0,0 @@
-import getNodeFromTree from './get-node-from-tree';
-
-/**
- * Determine whether an element is visible
- * @method isHidden
- * @memberof axe.utils
- * @param {HTMLElement} el The HTMLElement
- * @param {Boolean} recursed
- * @return {Boolean} The element's visibilty status
- */
-function isHidden(el, recursed) {
-  const node = getNodeFromTree(el);
-
-  // 9 === Node.DOCUMENT
-  if (el.nodeType === 9) {
-    return false;
-  }
-
-  // 11 === Node.DOCUMENT_FRAGMENT_NODE
-  if (el.nodeType === 11) {
-    el = el.host; // grab the host Node
-  }
-
-  if (node && node._isHidden !== null) {
-    return node._isHidden;
-  }
-
-  const style = window.getComputedStyle(el, null);
-
-  if (
-    !style ||
-    !el.parentNode ||
-    style.getPropertyValue('display') === 'none' ||
-    (!recursed &&
-      // visibility is only accurate on the first element
-      style.getPropertyValue('visibility') === 'hidden') ||
-    el.getAttribute('aria-hidden') === 'true'
-  ) {
-    return true;
-  }
-
-  const parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
-  const hidden = isHidden(parent, true);
-
-  // cache the results of the isHidden check on the parent tree
-  // so we don't have to look at the parent tree again for all its
-  // descendants
-  if (node) {
-    node._isHidden = hidden;
-  }
-
-  return hidden;
-}
-
-export default isHidden;

package/lib/core/utils/is-html-element.js

@@ -1,137 +0,0 @@
-const htmlTags = [
-  'a',
-  'abbr',
-  'address',
-  'area',
-  'article',
-  'aside',
-  'audio',
-  'b',
-  'base',
-  'bdi',
-  'bdo',
-  'blockquote',
-  'body',
-  'br',
-  'button',
-  'canvas',
-  'caption',
-  'cite',
-  'code',
-  'col',
-  'colgroup',
-  'data',
-  'datalist',
-  'dd',
-  'del',
-  'details',
-  'dfn',
-  'dialog',
-  'div',
-  'dl',
-  'dt',
-  'em',
-  'embed',
-  'fieldset',
-  'figcaption',
-  'figure',
-  'footer',
-  'form',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'head',
-  'header',
-  'hgroup',
-  'hr',
-  'html',
-  'i',
-  'iframe',
-  'img',
-  'input',
-  'ins',
-  'kbd',
-  'keygen',
-  'label',
-  'legend',
-  'li',
-  'link',
-  'main',
-  'map',
-  'mark',
-  'math',
-  'menu',
-  'menuitem',
-  'meta',
-  'meter',
-  'nav',
-  'noscript',
-  'object',
-  'ol',
-  'optgroup',
-  'option',
-  'output',
-  'p',
-  'param',
-  'picture',
-  'pre',
-  'progress',
-  'q',
-  'rb',
-  'rp',
-  'rt',
-  'rtc',
-  'ruby',
-  's',
-  'samp',
-  'script',
-  'section',
-  'select',
-  'slot',
-  'small',
-  'source',
-  'span',
-  'strong',
-  'style',
-  'sub',
-  'summary',
-  'sup',
-  'svg',
-  'table',
-  'tbody',
-  'td',
-  'template',
-  'textarea',
-  'tfoot',
-  'th',
-  'thead',
-  'time',
-  'title',
-  'tr',
-  'track',
-  'u',
-  'ul',
-  'var',
-  'video',
-  'wbr'
-];
-
-/**
- * Verifies that if a given html tag is valid
- * @method isHtmlElement
- * @memberof axe.utils
- * @param htmlTag htmlTag to check if valid
- * @return {Boolean} true/ false
- */
-function isHtmlElement(node) {
-  if (node.namespaceURI === 'http://www.w3.org/2000/svg') {
-    return false;
-  }
-
-  return htmlTags.includes(node.nodeName.toLowerCase());
-}
-
-export default isHtmlElement;

package/lib/core/utils/is-node-in-context.js

@@ -1,46 +0,0 @@
-import contains from './contains';
-
-/**
- * Get the deepest node in a given collection
- * @private
- * @param  {Array} collection Array of nodes to test
- * @return {Node}             The deepest node
- */
-function getDeepest(collection) {
-  return collection.sort((a, b) => {
-    if (contains(a, b)) {
-      return 1;
-    }
-    return -1;
-  })[0];
-}
-
-/**
- * Determines if a node is included or excluded in a given context
- * @private
- * @param  {Node}  node     The node to test
- * @param  {Object}  context "Resolved" context object, @see resolveContext
- * @return {Boolean}         [description]
- */
-function isNodeInContext(node, context) {
-  const include =
-    context.include &&
-    getDeepest(
-      context.include.filter(candidate => {
-        return contains(candidate, node);
-      })
-    );
-  const exclude =
-    context.exclude &&
-    getDeepest(
-      context.exclude.filter(candidate => {
-        return contains(candidate, node);
-      })
-    );
-  if ((!exclude && include) || (exclude && contains(exclude, include))) {
-    return true;
-  }
-  return false;
-}
-
-export default isNodeInContext;

package/lib/core/utils/is-shadow-root.js

@@ -1,40 +0,0 @@
-const possibleShadowRoots = [
-  'article',
-  'aside',
-  'blockquote',
-  'body',
-  'div',
-  'footer',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'header',
-  'main',
-  'nav',
-  'p',
-  'section',
-  'span'
-];
-/**
- * Test a node to see if it has a spec-conforming shadow root
- *
- * @param {Node}   node  The HTML DOM node
- * @return {Boolean}
- */
-function isShadowRoot(node) {
-  if (node.shadowRoot) {
-    const nodeName = node.nodeName.toLowerCase();
-    if (
-      possibleShadowRoots.includes(nodeName) ||
-      /^[a-z][a-z0-9_.-]*-[a-z0-9_.-]*$/.test(nodeName)
-    ) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export default isShadowRoot;

package/lib/core/utils/is-xhtml.js

@@ -1,15 +0,0 @@
-/**
- * Determines if a document node is XHTML
- * @method isXHTML
- * @memberof axe.utils
- * @param {Node} doc a document node
- * @return {Boolean}
- */
-function isXHTML(doc) {
-  if (!doc.createElement) {
-    return false;
-  }
-  return doc.createElement('A').localName === 'A';
-}
-
-export default isXHTML;