axe-core 4.2.4 → 4.3.0

package/lib/core/utils/query-selector-all-filter.js

@@ -1,104 +0,0 @@
-import { matchesExpression, convertSelector } from './matches';
-
-function createLocalVariables(vNodes, anyLevel, thisLevel, parentShadowId) {
-  const retVal = {
-    vNodes: vNodes.slice(),
-    anyLevel: anyLevel,
-    thisLevel: thisLevel,
-    parentShadowId: parentShadowId
-  };
-  retVal.vNodes.reverse();
-  return retVal;
-}
-
-function matchExpressions(domTree, expressions, filter) {
-  const stack = [];
-  const vNodes = Array.isArray(domTree) ? domTree : [domTree];
-  let currentLevel = createLocalVariables(
-    vNodes,
-    expressions,
-    [],
-    domTree[0].shadowId
-  );
-  const result = [];
-
-  while (currentLevel.vNodes.length) {
-    const vNode = currentLevel.vNodes.pop();
-    const childOnly = []; // we will add hierarchical '>' selectors here
-    const childAny = [];
-    const combined = currentLevel.anyLevel
-      .slice()
-      .concat(currentLevel.thisLevel);
-    let added = false;
-    // see if node matches
-    for (let i = 0; i < combined.length; i++) {
-      const exp = combined[i];
-      if (
-        (!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) &&
-        matchesExpression(vNode, exp[0])
-      ) {
-        if (exp.length === 1) {
-          if (!added && (!filter || filter(vNode))) {
-            result.push(vNode);
-            added = true;
-          }
-        } else {
-          const rest = exp.slice(1);
-          if ([' ', '>'].includes(rest[0].combinator) === false) {
-            throw new Error(
-              'axe.utils.querySelectorAll does not support the combinator: ' +
-                exp[1].combinator
-            );
-          }
-          if (rest[0].combinator === '>') {
-            // add the rest to the childOnly array
-            childOnly.push(rest);
-          } else {
-            // add the rest to the childAny array
-            childAny.push(rest);
-          }
-        }
-      }
-      if (
-        (!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) &&
-        currentLevel.anyLevel.includes(exp)
-      ) {
-        childAny.push(exp);
-      }
-    }
-
-    if (vNode.children && vNode.children.length) {
-      stack.push(currentLevel);
-      currentLevel = createLocalVariables(
-        vNode.children,
-        childAny,
-        childOnly,
-        vNode.shadowId
-      );
-    }
-    // check for "return"
-    while (!currentLevel.vNodes.length && stack.length) {
-      currentLevel = stack.pop();
-    }
-  }
-  return result;
-}
-
-/**
- * querySelectorAllFilter implements querySelectorAll on the virtual DOM with
- * ability to filter the returned nodes using an optional supplied filter function
- *
- * @method querySelectorAllFilter
- * @memberof axe.utils
- * @param {NodeList} domTree flattened tree collection to search
- * @param {String} selector String containing one or more CSS selectors separated by commas
- * @param {Function} filter function (optional)
- * @return {Array} Elements matched by any of the selectors and filtered by the filter function
- */
-function querySelectorAllFilter(domTree, selector, filter) {
-  domTree = Array.isArray(domTree) ? domTree : [domTree];
-  const expressions = convertSelector(selector);
-  return matchExpressions(domTree, expressions, filter);
-}
-
-export default querySelectorAllFilter;

package/lib/core/utils/query-selector-all.js

@@ -1,15 +0,0 @@
-import querySelectorAllFilter from './query-selector-all-filter';
-
-/**
- * querySelectorAll implementation that operates on the flattened tree (supports shadow DOM)
- * @method querySelectorAll
- * @memberof axe.utils
- * @param	{NodeList} domTree flattened tree collection to search
- * @param	{String} selector String containing one or more CSS selectors separated by commas
- * @return {NodeList} Elements matched by any of the selectors
- */
-export function querySelectorAll(domTree, selector) {
-  return querySelectorAllFilter(domTree, selector);
-}
-
-export default querySelectorAll;

package/lib/core/utils/queue.js

@@ -1,137 +0,0 @@
-import log from '../log';
-
-function noop() {}
-function funcGuard(f) {
-  if (typeof f !== 'function') {
-    throw new TypeError('Queue methods require functions as arguments');
-  }
-}
-
-/**
- * Create an asynchronous "queue", list of functions to be invoked in parallel, but not necessarily returned in order
- * @return {Queue} The newly generated "queue"
- */
-function queue() {
-  var tasks = [];
-  var started = 0;
-  var remaining = 0; // number of tasks not yet finished
-  var completeQueue = noop;
-  var complete = false;
-  var err;
-
-  // By default, wait until the next tick,
-  // if no catch was set, throw to console.
-  var defaultFail = e => {
-    err = e;
-    setTimeout(() => {
-      if (err !== undefined && err !== null) {
-        log('Uncaught error (of queue)', err);
-      }
-    }, 1);
-  };
-  var failed = defaultFail;
-
-  function createResolve(i) {
-    return r => {
-      tasks[i] = r;
-      remaining -= 1;
-      if (!remaining && completeQueue !== noop) {
-        complete = true;
-        completeQueue(tasks);
-      }
-    };
-  }
-
-  function abort(msg) {
-    // reset tasks
-    completeQueue = noop;
-
-    // notify catch
-    failed(msg);
-    // return unfinished work
-    return tasks;
-  }
-
-  function pop() {
-    var length = tasks.length;
-    for (; started < length; started++) {
-      var task = tasks[started];
-
-      try {
-        task.call(null, createResolve(started), abort);
-      } catch (e) {
-        abort(e);
-      }
-    }
-  }
-
-  var q = {
-    /**
-     * Defer a function that may or may not run asynchronously.
-     *
-     * First parameter should be the function to execute with subsequent
-     * parameters being passed as arguments to that function
-     */
-    defer(fn) {
-      if (typeof fn === 'object' && fn.then && fn.catch) {
-        var defer = fn;
-        fn = (resolve, reject) => {
-          defer.then(resolve).catch(reject);
-        };
-      }
-      funcGuard(fn);
-      if (err !== undefined) {
-        return;
-      } else if (complete) {
-        throw new Error('Queue already completed');
-      }
-
-      tasks.push(fn);
-      ++remaining;
-      pop();
-      return q;
-    },
-
-    /**
-     * The callback to execute once all "deferred" functions have completed.  Will only be invoked once.
-     * @param  {Function} f The callback, receives an array of the return/callbacked
-     * values of each of the "deferred" functions
-     */
-    then(fn) {
-      funcGuard(fn);
-      if (completeQueue !== noop) {
-        throw new Error('queue `then` already set');
-      }
-      if (!err) {
-        completeQueue = fn;
-        if (!remaining) {
-          complete = true;
-          completeQueue(tasks);
-        }
-      }
-      return q;
-    },
-
-    catch: function(fn) {
-      funcGuard(fn);
-      if (failed !== defaultFail) {
-        throw new Error('queue `catch` already set');
-      }
-      if (!err) {
-        failed = fn;
-      } else {
-        fn(err);
-        err = null;
-      }
-      return q;
-    },
-    /**
-     * Abort the "queue" and prevent `then` function from firing
-     * @param  {Function} fn The callback to execute; receives an array of the results which have completed
-     */
-    abort: abort
-  };
-  return q;
-}
-
-export default queue;

package/lib/core/utils/respondable.js

@@ -1,108 +0,0 @@
-import { v4 as createUuid } from './uuid';
-import assert from './assert';
-import { setDefaultFrameMessenger } from './frame-messenger';
-
-let closeHandler;
-let postMessage;
-
-const topicHandlers = {};
-
-/**
- * Post a message to a window who may or may not respond to it.
- * @param  {Window}   win      The window to post the message to
- * @param  {String}   topic    The topic of the message
- * @param  {Object}   message  The message content
- * @param  {Boolean}  keepalive Whether to allow multiple responses - default is false
- * @param  {Function} replyHandler The function to invoke when/if the message is responded to
- */
-export default function respondable(
-  win,
-  topic,
-  message,
-  keepalive,
-  replyHandler
-) {
-  const data = {
-    topic,
-    message,
-    channelId: `${createUuid()}:${createUuid()}`,
-    keepalive
-  };
-
-  return postMessage(win, data, replyHandler);
-}
-
-/**
- * Handle incoming window messages
- * @param  {Object} data
- * @param {Function} responder
- */
-function messageListener(data, responder) {
-  const { topic, message, keepalive } = data;
-  const topicHandler = topicHandlers[topic];
-  if (!topicHandler) {
-    return;
-  }
-
-  try {
-    topicHandler(message, keepalive, responder);
-  } catch (error) {
-    axe.log(error);
-    responder(error, keepalive);
-  }
-}
-
-/**
- * Update how respondable communicates with iframes.
- * @param {Function} frameHandler  Object with open, post, and close functions
- */
-respondable.updateMessenger = function updateMessenger({ open, post }) {
-  assert(typeof open === 'function', 'open callback must be a function');
-  assert(typeof post === 'function', 'post callback must be a function');
-
-  if (closeHandler) {
-    closeHandler();
-  }
-
-  var close = open(messageListener);
-
-  if (close) {
-    assert(
-      typeof close === 'function',
-      'open callback must return a cleanup function'
-    );
-    closeHandler = close;
-  } else {
-    closeHandler = null;
-  }
-
-  postMessage = post;
-};
-
-/**
- * Subscribe to messages sent via the `respondable` module.
- *
- * Axe._load uses this to listen for messages from other frames
- *
- * @param  {String}   topic    The topic to listen to
- * @param  {Function} topicHandler The function to invoke when a message is received
- */
-respondable.subscribe = function subscribe(topic, topicHandler) {
-  assert(
-    typeof topicHandler === 'function',
-    'Subscriber callback must be a function'
-  );
-  assert(!topicHandlers[topic], `Topic ${topic} is already registered to.`);
-
-  topicHandlers[topic] = topicHandler;
-};
-
-/**
- * checks if the current context is inside a frame
- * @return {Boolean}
- */
-respondable.isInFrame = function isInFrame(win = window) {
-  return !!win.frameElement;
-};
-
-setDefaultFrameMessenger(respondable);

package/lib/core/utils/rule-should-run.js

@@ -1,83 +0,0 @@
-/**
- * Check if a rule matches the value of runOnly type=tag
- * @private
- * @param  {object} rule
- * @param  {object}	runOnly Value of runOnly with type=tags
- * @return {bool}
- */
-function matchTags(rule, runOnly) {
-  var include, exclude, matching;
-  var defaultExclude =
-    // TODO: es-modules_audit
-    axe._audit && axe._audit.tagExclude ? axe._audit.tagExclude : [];
-
-  // normalize include/exclude
-  if (runOnly.hasOwnProperty('include') || runOnly.hasOwnProperty('exclude')) {
-    // Wrap include and exclude if it's not already an array
-    include = runOnly.include || [];
-    include = Array.isArray(include) ? include : [include];
-
-    exclude = runOnly.exclude || [];
-    exclude = Array.isArray(exclude) ? exclude : [exclude];
-    // add defaults, unless mentioned in include
-    exclude = exclude.concat(
-      defaultExclude.filter(tag => {
-        return include.indexOf(tag) === -1;
-      })
-    );
-
-    // Otherwise, only use the include value, ignore exclude
-  } else {
-    include = Array.isArray(runOnly) ? runOnly : [runOnly];
-    // exclude the defaults not included
-    exclude = defaultExclude.filter(tag => {
-      return include.indexOf(tag) === -1;
-    });
-  }
-
-  matching = include.some(tag => {
-    return rule.tags.indexOf(tag) !== -1;
-  });
-  if (matching || (include.length === 0 && rule.enabled !== false)) {
-    return exclude.every(tag => {
-      return rule.tags.indexOf(tag) === -1;
-    });
-  } else {
-    return false;
-  }
-}
-
-/**
- * Determines whether a rule should run
- * @param  {Rule}    rule     The rule to test
- * @param  {Context} context  The context of the Audit
- * @param  {Object}  options  Options object
- * @return {Boolean}
- */
-function ruleShouldRun(rule, context, options) {
-  var runOnly = options.runOnly || {};
-  var ruleOptions = (options.rules || {})[rule.id];
-
-  // Never run page level rules if the context is not on the page
-  if (rule.pageLevel && !context.page) {
-    return false;
-
-    // First, runOnly type rule overrides anything else
-  } else if (runOnly.type === 'rule') {
-    return runOnly.values.indexOf(rule.id) !== -1;
-
-    // Second, if options.rules[rule].enabled is set, it overrides all
-  } else if (ruleOptions && typeof ruleOptions.enabled === 'boolean') {
-    return ruleOptions.enabled;
-
-    // Third, if tags are set, look at those
-  } else if (runOnly.type === 'tag' && runOnly.values) {
-    return matchTags(rule, runOnly.values);
-
-    // If nothing is set, only check for default excludes
-  } else {
-    return matchTags(rule, []);
-  }
-}
-
-export default ruleShouldRun;

package/lib/core/utils/select.js

@@ -1,87 +0,0 @@
-import contains from './contains';
-import querySelectorAllFilter from './query-selector-all-filter';
-import isNodeInContext from './is-node-in-context';
-
-/**
- * Pushes unique nodes that are in context to an array
- * @private
- * @param  {Array} result  The array to push to
- * @param  {Array} nodes   The list of nodes to push
- * @param  {Object} context The "resolved" context object, @see resolveContext
- */
-function pushNode(result, nodes) {
-  let temp;
-
-  if (result.length === 0) {
-    return nodes;
-  }
-  if (result.length < nodes.length) {
-    // switch so the comparison is shortest
-    temp = result;
-    result = nodes;
-    nodes = temp;
-  }
-  for (let i = 0, l = nodes.length; i < l; i++) {
-    if (!result.includes(nodes[i])) {
-      result.push(nodes[i]);
-    }
-  }
-  return result;
-}
-
-/**
- * reduces the includes list to only the outermost includes
- * @param {Array} the array of include nodes
- * @return {Array} the modified array of nodes
- */
-function reduceIncludes(includes) {
-  return includes.reduce((res, el) => {
-    if (!res.length || !contains(res[res.length - 1], el)) {
-      res.push(el);
-    }
-    return res;
-  }, []);
-}
-
-/**
- * Selects elements which match `selector` that are included and excluded via the `Context` object
- * @param  {String} selector  CSS selector of the HTMLElements to select
- * @param  {Context} context  The "resolved" context object, @see Context
- * @return {Array}            Matching virtual DOM nodes sorted by DOM order
- */
-function select(selector, context) {
-  let result = [];
-  let candidate;
-  if (axe._selectCache) {
-    // if used outside of run, it will still work
-    for (let j = 0, l = axe._selectCache.length; j < l; j++) {
-      // First see whether the item exists in the cache
-      const item = axe._selectCache[j];
-      if (item.selector === selector) {
-        return item.result;
-      }
-    }
-  }
-  const curried = (context => {
-    return node => {
-      return isNodeInContext(node, context);
-    };
-  })(context);
-  const reducedIncludes = reduceIncludes(context.include);
-  for (let i = 0; i < reducedIncludes.length; i++) {
-    candidate = reducedIncludes[i];
-    result = pushNode(
-      result,
-      querySelectorAllFilter(candidate, selector, curried)
-    );
-  }
-  if (axe._selectCache) {
-    axe._selectCache.push({
-      selector: selector,
-      result: result
-    });
-  }
-  return result;
-}
-
-export default select;

package/lib/core/utils/send-command-to-frame.js

@@ -1,65 +0,0 @@
-import getSelector from './get-selector';
-import respondable from './respondable';
-import log from '../log';
-
-function err(message, node) {
-  var selector;
-  // TODO: es-modules_tree
-  if (axe._tree) {
-    selector = getSelector(node);
-  }
-  return new Error(message + ': ' + (selector || node));
-}
-
-/**
- * Sends a command to an instance of axe in the specified frame
- * @param  {Element}  node       The frame element to send the message to
- * @param  {Object}   parameters Parameters to pass to the frame
- * @param  {Function} callback   Function to call when results from the frame has returned
- */
-function sendCommandToFrame(node, parameters, resolve, reject) {
-  var win = node.contentWindow;
-  if (!win) {
-    log('Frame does not have a content window', node);
-    resolve(null);
-    return;
-  }
-
-  // give the frame .5s to respond to 'axe.ping', else log failed response
-  var timeout = setTimeout(() => {
-    // This double timeout is important for allowing iframes to respond
-    // DO NOT REMOVE
-    timeout = setTimeout(() => {
-      if (!parameters.debug) {
-        resolve(null);
-      } else {
-        reject(err('No response from frame', node));
-      }
-    }, 0);
-  }, parameters.options?.pingWaitTime ?? 500);
-
-  // send 'axe.ping' to the frame
-  respondable(win, 'axe.ping', null, undefined, () => {
-    clearTimeout(timeout);
-
-    // Give axe 60s (or user-supplied value) to respond to 'axe.start'
-    var frameWaitTime =
-      (parameters.options && parameters.options.frameWaitTime) || 60000;
-
-    timeout = setTimeout(function collectResultFramesTimeout() {
-      reject(err('Axe in frame timed out', node));
-    }, frameWaitTime);
-
-    // send 'axe.start' and send the callback if it responded
-    respondable(win, 'axe.start', parameters, undefined, data => {
-      clearTimeout(timeout);
-      if (data instanceof Error === false) {
-        resolve(data);
-      } else {
-        reject(data);
-      }
-    });
-  });
-}
-
-export default sendCommandToFrame;

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

@@ -1,21 +0,0 @@
-/**
- * set the scroll position of an element
- */
-function setScroll(elm, top, left) {
-  if (elm === window) {
-    return elm.scroll(left, top);
-  } else {
-    elm.scrollTop = top;
-    elm.scrollLeft = left;
-  }
-}
-
-/**
- * set the scroll position of all items in the scrollState array
- * @deprecated
- */
-export function setScrollState(scrollState) {
-  scrollState.forEach(({ elm, top, left }) => setScroll(elm, top, left));
-}
-
-export default setScrollState;

package/lib/core/utils/to-array.js

@@ -1,10 +0,0 @@
-/**
- * Converts array-like (numerical indicies and `length` property) structures to actual, real arrays
- * @param	{Mixed} thing Array-like thing to convert
- * @return {Array}
- */
-function toArray(thing) {
-  return Array.prototype.slice.call(thing);
-}
-
-export default toArray;

package/lib/core/utils/token-list.js

@@ -1,15 +0,0 @@
-/**
- * Converts space delimited token list to an Array
- * @method tokenList
- * @memberof axe.utils
- * @param  {String} str
- * @return {Array}
- */
-function tokenList(str) {
-  return (str || '')
-    .trim()
-    .replace(/\s{2,}/g, ' ')
-    .split(' ');
-}
-
-export default tokenList;

package/lib/core/utils/unique-array.js

@@ -1,13 +0,0 @@
-/**
- * Creates an array without duplicate values from 2 array inputs
- * @param {Array} arr1 First array
- * @param {Array} arr2 Second array
- * @return {Array}
- */
-function uniqueArray(arr1, arr2) {
-  return arr1.concat(arr2).filter((elem, pos, arr) => {
-    return arr.indexOf(elem) === pos;
-  });
-}
-
-export default uniqueArray;