axe-core 4.2.4 → 4.3.0

package/lib/core/public/configure.js

@@ -1,134 +0,0 @@
-import { hasReporter } from './reporter';
-import { configureStandards } from '../../standards';
-import constants from '../constants';
-
-function configure(spec) {
-  var audit;
-
-  audit = axe._audit;
-  if (!audit) {
-    throw new Error('No audit configured');
-  }
-
-  if (spec.axeVersion || spec.ver) {
-    const specVersion = spec.axeVersion || spec.ver;
-    if (!/^\d+\.\d+\.\d+(-canary)?/.test(specVersion)) {
-      throw new Error(`Invalid configured version ${specVersion}`);
-    }
-
-    const [version, canary] = specVersion.split('-');
-    const [major, minor, patch] = version.split('.').map(Number);
-
-    const [axeVersion, axeCanary] = axe.version.split('-');
-    const [axeMajor, axeMinor, axePatch] = axeVersion.split('.').map(Number);
-
-    if (
-      major !== axeMajor ||
-      axeMinor < minor ||
-      (axeMinor === minor && axePatch < patch) ||
-      (major === axeMajor &&
-        minor === axeMinor &&
-        patch === axePatch &&
-        canary &&
-        canary !== axeCanary)
-    ) {
-      throw new Error(
-        `Configured version ${specVersion} is not compatible with current axe version ${axe.version}`
-      );
-    }
-  }
-
-  if (
-    spec.reporter &&
-    (typeof spec.reporter === 'function' || hasReporter(spec.reporter))
-  ) {
-    audit.reporter = spec.reporter;
-  }
-
-  if (spec.checks) {
-    if (!Array.isArray(spec.checks)) {
-      throw new TypeError('Checks property must be an array');
-    }
-
-    spec.checks.forEach(check => {
-      if (!check.id) {
-        throw new TypeError(
-          // eslint-disable-next-line max-len
-          `Configured check ${JSON.stringify(
-            check
-          )} is invalid. Checks must be an object with at least an id property`
-        );
-      }
-
-      audit.addCheck(check);
-    });
-  }
-
-  const modifiedRules = [];
-  if (spec.rules) {
-    if (!Array.isArray(spec.rules)) {
-      throw new TypeError('Rules property must be an array');
-    }
-
-    spec.rules.forEach(rule => {
-      if (!rule.id) {
-        throw new TypeError(
-          // eslint-disable-next-line max-len
-          `Configured rule ${JSON.stringify(
-            rule
-          )} is invalid. Rules must be an object with at least an id property`
-        );
-      }
-
-      modifiedRules.push(rule.id);
-      audit.addRule(rule);
-    });
-  }
-
-  if (spec.disableOtherRules) {
-    audit.rules.forEach(rule => {
-      if (modifiedRules.includes(rule.id) === false) {
-        rule.enabled = false;
-      }
-    });
-  }
-
-  if (typeof spec.branding !== 'undefined') {
-    audit.setBranding(spec.branding);
-  } else {
-    audit._constructHelpUrls();
-  }
-
-  if (spec.tagExclude) {
-    audit.tagExclude = spec.tagExclude;
-  }
-
-  // Support runtime localization
-  if (spec.locale) {
-    audit.applyLocale(spec.locale);
-  }
-
-  if (spec.standards) {
-    configureStandards(spec.standards);
-  }
-
-  if (spec.noHtml) {
-    audit.noHtml = true;
-  }
-
-  if (spec.allowedOrigins) {
-    if (!Array.isArray(spec.allowedOrigins)) {
-      throw new TypeError('Allowed origins property must be an array');
-    }
-
-    if (spec.allowedOrigins.includes('*')) {
-      throw new Error(
-        `"*" is not allowed. Use "${constants.allOrigins}" instead`
-      );
-    }
-
-    audit.setAllowedOrigins(spec.allowedOrigins);
-  }
-}
-
-export default configure;

package/lib/core/public/frame-messenger.js

@@ -1,5 +0,0 @@
-import { respondable } from '../utils';
-
-export default function frameMessenger(frameHandler) {
-  respondable.updateMessenger(frameHandler);
-}

package/lib/core/public/get-rules.js

@@ -1,29 +0,0 @@
-/**
- * Searches and returns rules that contain a tag in the list of tags.
- * @param  {Array}   tags  Optional array of tags
- * @return {Array}  Array of rules
- */
-function getRules(tags) {
-  tags = tags || [];
-  var matchingRules = !tags.length
-    ? axe._audit.rules
-    : axe._audit.rules.filter(item => {
-        return !!tags.filter(tag => {
-          return item.tags.indexOf(tag) !== -1;
-        }).length;
-      });
-
-  var ruleData = axe._audit.data.rules || {};
-  return matchingRules.map(matchingRule => {
-    var rd = ruleData[matchingRule.id] || {};
-    return {
-      ruleId: matchingRule.id,
-      description: rd.description,
-      help: rd.help,
-      helpUrl: rd.helpUrl,
-      tags: matchingRule.tags
-    };
-  });
-}
-
-export default getRules;

package/lib/core/public/load.js

@@ -1,65 +0,0 @@
-import Audit from '../base/audit';
-import cleanup from './cleanup';
-import runRules from './run-rules';
-import respondable from '../utils/respondable';
-
-function runCommand(data, keepalive, callback) {
-  var resolve = callback;
-  var reject = function reject(err) {
-    if (err instanceof Error === false) {
-      err = new Error(err);
-    }
-    callback(err);
-  };
-
-  var context = (data && data.context) || {};
-  if (context.hasOwnProperty('include') && !context.include.length) {
-    context.include = [document];
-  }
-  var options = (data && data.options) || {};
-
-  switch (data.command) {
-    case 'rules':
-      return runRules(
-        context,
-        options,
-        (results, cleanup) => {
-          resolve(results);
-          // Cleanup AFTER resolve so that selectors can be generated
-          cleanup();
-        },
-        reject
-      );
-    case 'cleanup-plugin':
-      return cleanup(resolve, reject);
-    default:
-      // go through the registered commands
-      if (
-        axe._audit &&
-        axe._audit.commands &&
-        axe._audit.commands[data.command]
-      ) {
-        return axe._audit.commands[data.command](data, callback);
-      }
-  }
-}
-
-if (window.top !== window) {
-  respondable.subscribe('axe.start', runCommand);
-  respondable.subscribe('axe.ping', (data, keepalive, respond) => {
-    respond({
-      axe: true
-    });
-  });
-}
-
-/**
- * Sets up Rules, Messages and default options for Checks, must be invoked before attempting analysis
- * @param  {Object} audit The "audit specification" object
- * @private
- */
-function load(audit) {
-  axe._audit = new Audit(audit);
-}
-
-export default load;

package/lib/core/public/plugins.js

@@ -1,39 +0,0 @@
-/*eslint no-use-before-define:0 */
-
-function Plugin(spec) {
-  this._run = spec.run;
-  this._collect = spec.collect;
-  this._registry = {};
-  spec.commands.forEach(command => {
-    axe._audit.registerCommand(command);
-  });
-}
-
-Plugin.prototype.run = function run() {
-  return this._run.apply(this, arguments);
-};
-
-Plugin.prototype.collect = function collect() {
-  return this._collect.apply(this, arguments);
-};
-
-Plugin.prototype.cleanup = function cleanup(done) {
-  var q = axe.utils.queue();
-  var that = this;
-  Object.keys(this._registry).forEach(key => {
-    q.defer(_done => {
-      that._registry[key].cleanup(_done);
-    });
-  });
-  q.then(done);
-};
-
-Plugin.prototype.add = function add(impl) {
-  this._registry[impl.id] = impl;
-};
-
-function registerPlugin(plugin) {
-  axe.plugins[plugin.id] = new Plugin(plugin);
-}
-
-export default registerPlugin;

package/lib/core/public/reporter.js

@@ -1,25 +0,0 @@
-const reporters = {};
-let defaultReporter;
-
-export function hasReporter(reporterName) {
-  return reporters.hasOwnProperty(reporterName);
-}
-
-export function getReporter(reporter) {
-  if (typeof reporter === 'string' && reporters[reporter]) {
-    return reporters[reporter];
-  }
-
-  if (typeof reporter === 'function') {
-    return reporter;
-  }
-
-  return defaultReporter;
-}
-
-export function addReporter(name, cb, isDefault) {
-  reporters[name] = cb;
-  if (isDefault) {
-    defaultReporter = cb;
-  }
-}

package/lib/core/public/reset.js

@@ -1,13 +0,0 @@
-import { resetStandards } from '../../standards';
-
-function reset() {
-  var audit = axe._audit;
-
-  if (!audit) {
-    throw new Error('No audit configured');
-  }
-  audit.resetRulesAndChecks();
-  resetStandards();
-}
-
-export default reset;

package/lib/core/public/run-rules.js

@@ -1,83 +0,0 @@
-import Context from '../base/context';
-import teardown from './teardown';
-import {
-  getSelectorData,
-  queue,
-  performanceTimer,
-  collectResultsFromFrames,
-  mergeResults,
-  publishMetaData,
-  finalizeRuleResult
-} from '../utils';
-import log from '../log';
-
-/**
- * Starts analysis on the current document and its subframes
- * @private
- * @param  {Object}   context  The `Context` specification object @see Context
- * @param  {Array}    options  Optional RuleOptions
- * @param  {Function} resolve  Called when done running rules, receives ([results : Object], teardown : Function)
- * @param  {Function} reject   Called when execution failed, receives (err : Error)
- */
-function runRules(context, options, resolve, reject) {
-  try {
-    context = new Context(context);
-    axe._tree = context.flatTree;
-    axe._selectorData = getSelectorData(context.flatTree);
-  } catch (e) {
-    teardown();
-    return reject(e);
-  }
-
-  var q = queue();
-  var audit = axe._audit;
-
-  if (options.performanceTimer) {
-    performanceTimer.auditStart();
-  }
-
-  if (context.frames.length && options.iframes !== false) {
-    q.defer((res, rej) => {
-      collectResultsFromFrames(context, options, 'rules', null, res, rej);
-    });
-  }
-  q.defer((res, rej) => {
-    audit.run(context, options, res, rej);
-  });
-  q.then(data => {
-    try {
-      if (options.performanceTimer) {
-        performanceTimer.auditEnd();
-      }
-
-      // Add wrapper object so that we may use the same "merge" function for results from inside and outside frames
-      var results = mergeResults(
-        data.map(results => {
-          return { results };
-        })
-      );
-
-      // after should only run once, so ensure we are in the top level window
-      if (context.initiator) {
-        results = audit.after(results, options);
-
-        results.forEach(publishMetaData);
-        results = results.map(finalizeRuleResult);
-      }
-      try {
-        resolve(results, teardown);
-      } catch (e) {
-        teardown();
-        log(e);
-      }
-    } catch (e) {
-      teardown();
-      reject(e);
-    }
-  }).catch(e => {
-    teardown();
-    reject(e);
-  });
-}
-
-export default runRules;

package/lib/core/public/run-virtual-rule.js

@@ -1,63 +0,0 @@
-import SerialVirtualNode from '../base/virtual-node/serial-virtual-node';
-import AbstractVirtualNode from '../base/virtual-node/abstract-virtual-node';
-import * as helpers from '../reporters/helpers';
-import {
-  publishMetaData,
-  finalizeRuleResult,
-  aggregateResult,
-  getRule
-} from '../utils';
-
-/**
- * Run a rule in a non-browser environment
- * @param {String} ruleId  Id of the rule
- * @param {VirtualNode} vNode  The virtual node to run the rule against
- * @param {Object} options  (optional) Set of options passed into rules or checks
- * @return {Object} axe results for the rule run
- */
-function runVirtualRule(ruleId, vNode, options = {}) {
-  // TODO: es-modules axe._audit
-  // TODO: es-modules axe._selectorData
-  options.reporter = options.reporter || axe._audit.reporter || 'v1';
-  axe._selectorData = {};
-
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = new SerialVirtualNode(vNode);
-  }
-
-  let rule = getRule(ruleId);
-
-  if (!rule) {
-    throw new Error('unknown rule `' + ruleId + '`');
-  }
-
-  // rule.prototype.gather calls axe.utils.isHidden which in turn calls
-  // window.getComputedStyle if the rule excludes hidden elements. we
-  // can avoid this call by forcing the rule to not exclude hidden
-  // elements
-  rule = Object.create(rule, { excludeHidden: { value: false } });
-
-  const context = {
-    initiator: true,
-    include: [vNode]
-  };
-
-  const rawResults = rule.runSync(context, options);
-  publishMetaData(rawResults);
-  finalizeRuleResult(rawResults);
-  const results = aggregateResult([rawResults]);
-
-  results.violations.forEach(result =>
-    result.nodes.forEach(nodeResult => {
-      nodeResult.failureSummary = helpers.failureSummary(nodeResult);
-    })
-  );
-
-  return {
-    ...helpers.getEnvironmentData(),
-    ...results,
-    toolOptions: options
-  };
-}
-
-export default runVirtualRule;

package/lib/core/public/run.js

@@ -1,186 +0,0 @@
-import { getReporter } from './reporter';
-import cache from '../base/cache';
-
-function isContext(potential) {
-  switch (true) {
-    case typeof potential === 'string':
-    case Array.isArray(potential):
-    case window.Node && potential instanceof window.Node:
-    case window.NodeList && potential instanceof window.NodeList:
-      return true;
-
-    case typeof potential !== 'object':
-      return false;
-
-    case potential.include !== undefined:
-    case potential.exclude !== undefined:
-    case typeof potential.length === 'number':
-      return true;
-
-    default:
-      return false;
-  }
-}
-
-var noop = function noop() {};
-
-/**
- * Normalize the optional params of axe.run()
- * @param  {object}   context
- * @param  {object}   options
- * @param  {Function} callback
- * @return {object}            With 3 keys: context, options, callback
- */
-function normalizeRunParams(context, options, callback) {
-  const typeErr = new TypeError('axe.run arguments are invalid');
-
-  // Determine the context
-  if (!isContext(context)) {
-    if (callback !== undefined) {
-      // Either context is invalid or there are too many params
-      throw typeErr;
-    }
-    // Set default and shift one over
-    callback = options;
-    options = context;
-    context = document;
-  }
-
-  // Determine the options
-  if (typeof options !== 'object') {
-    if (callback !== undefined) {
-      // Either options is invalid or there are too many params
-      throw typeErr;
-    }
-    // Set default and shift one over
-    callback = options;
-    options = {};
-  }
-
-  // Set the callback or noop;
-  if (typeof callback !== 'function' && callback !== undefined) {
-    throw typeErr;
-  }
-
-  return {
-    context: context,
-    options: options,
-    callback: callback || noop
-  };
-}
-
-/**
- * Runs a number of rules against the provided HTML page and returns the
- * resulting issue list
- *
- * @param  {Object}   context  (optional) Defines the scope of the analysis
- * @param  {Object}   options  (optional) Set of options passed into rules or checks
- * @param  {Function} callback (optional) The callback when axe is done, given 2 params:
- *                             - Error    If any errors occured, otherwise null
- *                             - Results  The results object / array, or undefined on error
- * @return {Promise}           Resolves with the axe results. Only available when natively supported
- */
-function run(context, options, callback) {
-  if (!axe._audit) {
-    throw new Error('No audit configured');
-  }
-
-  // if window or document are not defined and context was passed in
-  // we can use it to configure them
-  // NOTE: because our polyfills run first, the global window object
-  // always exists but may not have things we expect
-  const hasWindow = window && 'Node' in window && 'NodeList' in window;
-  const hasDoc = !!document;
-  if (!hasWindow || !hasDoc) {
-    if (!context || !context.ownerDocument) {
-      throw new Error(
-        'Required "window" or "document" globals not defined and cannot be deduced from the context. ' +
-          'Either set the globals before running or pass in a valid Element.'
-      );
-    }
-
-    if (!hasDoc) {
-      cache.set('globalDocumentSet', true);
-      document = context.ownerDocument;
-    }
-
-    if (!hasWindow) {
-      cache.set('globalWindowSet', true);
-      window = document.defaultView;
-    }
-  }
-
-  const args = normalizeRunParams(context, options, callback);
-  context = args.context;
-  options = args.options;
-  callback = args.callback;
-
-  // set defaults:
-  options.reporter = options.reporter || axe._audit.reporter || 'v1';
-
-  if (options.performanceTimer) {
-    axe.utils.performanceTimer.start();
-  }
-  let p;
-  let reject = noop;
-  let resolve = noop;
-
-  if (typeof Promise === 'function' && callback === noop) {
-    p = new Promise((_resolve, _reject) => {
-      reject = _reject;
-      resolve = _resolve;
-    });
-  }
-
-  if (axe._running) {
-    const err =
-      'Axe is already running. Use `await axe.run()` to wait ' +
-      'for the previous run to finish before starting a new run.';
-    callback(err);
-    reject(err);
-    return p;
-  }
-
-  axe._running = true;
-  axe._runRules(
-    context,
-    options,
-    (rawResults, cleanup) => {
-      const respond = results => {
-        axe._running = false;
-        cleanup();
-        try {
-          callback(null, results);
-        } catch (e) {
-          axe.log(e);
-        }
-        resolve(results);
-      };
-      if (options.performanceTimer) {
-        axe.utils.performanceTimer.end();
-      }
-
-      try {
-        const reporter = getReporter(options.reporter);
-        const results = reporter(rawResults, options, respond);
-        if (results !== undefined) {
-          respond(results);
-        }
-      } catch (err) {
-        axe._running = false;
-        cleanup();
-        callback(err);
-        reject(err);
-      }
-    },
-    err => {
-      axe._running = false;
-      callback(err);
-      reject(err);
-    }
-  );
-
-  return p;
-}
-
-export default run;

package/lib/core/public/setup.js

@@ -1,20 +0,0 @@
-import { getFlattenedTree, getSelectorData } from '../utils';
-
-/**
- * Setup axe-core so axe.common functions can work properly.
- * @param {Node} [node=document.documentElement] optional node. NOTE: passing in anything other than body or the documentElement may result in incomplete results.
- */
-function setup(node) {
-  if (axe._tree) {
-    throw new Error(
-      'Axe is already setup. Call `axe.teardown()` before calling `axe.setup` again.'
-    );
-  }
-
-  axe._tree = getFlattenedTree(node);
-  axe._selectorData = getSelectorData(axe._tree);
-
-  return axe._tree[0];
-}
-
-export default setup;

package/lib/core/public/teardown.js

@@ -1,21 +0,0 @@
-import cache from '../base/cache';
-
-/**
- * Clean up axe-core tree and caches. `axe.run` will call this function at the end of the run so there's no need to call it yourself afterwards.
- */
-function teardown() {
-  if (cache.get('globalDocumentSet')) {
-    document = null;
-  }
-  if (cache.get('globalWindowSet')) {
-    window = null;
-  }
-
-  axe._memoizedFns.forEach(fn => fn.clear());
-  cache.clear();
-  axe._tree = undefined;
-  axe._selectorData = undefined;
-  axe._selectCache = undefined;
-}
-
-export default teardown;