or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration.mdcore-testing.mdindex.mdplugins-frames.mdrules-reporting.mdutilities.md
tile.json

tessl/npm-axe-core

Accessibility engine for automated Web UI testing

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/axe-core@4.10.x

To install, run

npx @tessl/cli install tessl/npm-axe-core@4.10.0

index.mddocs/

Axe-Core

Axe-core is an accessibility testing engine for websites and other HTML-based user interfaces. It's fast, secure, lightweight, and designed to seamlessly integrate with any existing test environment to automate accessibility testing alongside regular functional testing. The library can automatically find an average of 57% of WCAG issues while flagging elements that require manual review as "incomplete".

Package Information

  • Package Name: axe-core
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install axe-core

Core Imports

// Browser environment
import axe from 'axe-core';
// Or access via global
// <script src="node_modules/axe-core/axe.min.js"></script>
// window.axe is now available

For Node.js:

const axe = require('axe-core');

TypeScript:

import * as axe from 'axe-core';

Basic Usage

// Run accessibility tests on the current page
axe.run()
  .then(results => {
    if (results.violations.length) {
      console.log('Accessibility violations found:', results.violations);
    } else {
      console.log('No accessibility violations found');
    }
  })
  .catch(err => {
    console.error('Error running axe:', err);
  });

// Run tests on specific elements
axe.run('#main-content')
  .then(results => {
    console.log('Results for main content:', results);
  });

// Run with specific options
axe.run(document, {
  runOnly: {
    type: 'tag',
    values: ['wcag2a', 'wcag2aa']
  }
}).then(results => {
  console.log('WCAG AA results:', results);
});

Architecture

Axe-core is built around several key components:

  • Testing Engine: Core accessibility rule evaluation system with WCAG 2.0, 2.1, and 2.2 support
  • Rule System: Modular rules and checks that can be enabled, disabled, or customized
  • Commons Library: Utilities for DOM manipulation, ARIA handling, color contrast, and text processing
  • Reporter System: Pluggable result formatting with built-in reporters (v1, v2, raw, etc.)
  • Frame Communication: Cross-frame testing support for complex applications
  • Plugin Architecture: Extensible system for custom functionality

Capabilities

Core Testing

Primary accessibility testing functions for running comprehensive or targeted accessibility audits.

function run(context?: ElementContext): Promise<AxeResults>;
function run(options: RunOptions): Promise<AxeResults>;
function run(context: ElementContext, options: RunOptions): Promise<AxeResults>;
function run(callback: RunCallback): void;
function run(context: ElementContext, callback: RunCallback): void;
function run(options: RunOptions, callback: RunCallback): void;
function run(context: ElementContext, options: RunOptions, callback: RunCallback): void;

function runPartial(context: ElementContext, options: RunOptions): Promise<PartialResult>;
function finishRun(partialResults: PartialResults, options: RunOptions): Promise<AxeResults>;

Core Testing

Configuration and Setup

Configuration management, initialization, and cleanup functions for customizing axe-core behavior.

function configure(spec: Spec): void;
function setup(node?: Element | Document): VirtualNode;
function teardown(): void;
function reset(): void;

Configuration

Rules and Reporting

Rule management and result reporting functionality for filtering, customizing, and formatting accessibility results.

function getRules(tags?: string[]): RuleMetadata[];
function runVirtualRule(ruleId: string, node: VirtualNode, options?: any): RawResult;

function hasReporter(reporterName: string): boolean;
function getReporter<T>(reporterName: string): AxeReporter<T>;
function addReporter<T>(reporterName: string, reporter: AxeReporter<T>, isDefault?: boolean): void;

Rules and Reporting

Utilities

Comprehensive utility functions for DOM manipulation, ARIA processing, color analysis, and text handling.

// Commons utilities
interface Commons {
  aria: Aria;
  color: ColorUtils;
  dom: DomUtils;
  forms: FormsUtils;
  math: MathUtils;
  matches: MatchesFunction;
  standards: StandardsUtils;
  table: TableUtils;
  text: TextUtils;
}

// Core utilities  
interface Utils {
  getFrameContexts(context?: ElementContext, options?: RunOptions): FrameContext[];
  shadowSelect(selector: CrossTreeSelector): Element | null;
  shadowSelectAll(selector: CrossTreeSelector): Element[];
  getStandards(): Required<Standards>;
  DqElement: DqElementConstructor;
  uuid(options?: UuidOptions): string;
}

Utilities

Plugins and Frames

Plugin system and frame communication for extending functionality and testing across iframe boundaries.

function registerPlugin(plugin: AxePlugin): void;
function cleanup(): void;
function frameMessenger(frameMessenger: FrameMessenger): void;

Plugins and Frames

Core Types

interface AxeResults {
  toolOptions: RunOptions;
  passes: Result[];
  violations: Result[];
  incomplete: Result[];
  inapplicable: Result[];
  testEngine: TestEngine;
  testRunner: TestRunner;
  testEnvironment: TestEnvironment;
  url: string;
  timestamp: string;
}

interface Result {
  description: string;
  help: string;
  helpUrl: string;
  id: string;
  impact?: 'minor' | 'moderate' | 'serious' | 'critical' | null;
  tags: string[];
  nodes: NodeResult[];
}

interface NodeResult {
  html: string;
  impact?: 'minor' | 'moderate' | 'serious' | 'critical' | null;
  target: string[];
  xpath?: string[];
  ancestry?: string[];
  any: CheckResult[];
  all: CheckResult[];
  none: CheckResult[];
  failureSummary?: string;
  element?: HTMLElement;
}

interface CheckResult {
  id: string;
  impact: string;
  message: string;
  data: any;
  relatedNodes?: RelatedNode[];
}

interface RunOptions {
  runOnly?: RunOnly | string[] | string;
  rules?: RuleObject;
  reporter?: 'v1' | 'v2' | 'raw' | 'rawEnv' | 'no-passes' | string;
  resultTypes?: ('inapplicable' | 'passes' | 'incomplete' | 'violations')[];
  selectors?: boolean;
  ancestry?: boolean;
  xpath?: boolean;
  absolutePaths?: boolean;
  iframes?: boolean;
  elementRef?: boolean;
  frameWaitTime?: number;
  preload?: boolean | PreloadOptions;
  performanceTimer?: boolean;
  pingWaitTime?: number;
}

interface RunOnly {
  type: 'rule' | 'rules' | 'tag' | 'tags';
  values: string[];
}

type ElementContext = string | Element | NodeList | Selector[] | ContextObject;

interface ContextObject {
  include?: ElementContext;
  exclude?: ElementContext;
}