eslint-plugin-jsx-a11y

v6.4.1

Static AST checker for accessibility rules on JSX elements.

NPM

README

GitHub

Website

MIT

Latest version published 6 months ago

    npm install eslint-plugin-jsx-a11y

We couldn't find any similar packages Browse all packages

Package Health Score

91 / 100

Popularity
Key ecosystem project
Maintenance
Healthy
Security
No known security issues
Community
Sustainable

Make sure the open source you're using is safe to use

Secure my Project

Popularity

Key ecosystem project

Weekly Downloads (5,470,628)

Dependents: 1
GitHub Stars: 2.35K
Forks: 479
Contributors: 100

The npm package eslint-plugin-jsx-a11y receives a total of 5,470,628 downloads a week. As such, we scored eslint-plugin-jsx-a11y popularity level to be Key ecosystem project.

Based on project statistics from the GitHub repository for the npm package eslint-plugin-jsx-a11y, we found that it has been starred 2,349 times, and that 1 other projects in the ecosystem are dependent on it.

Downloads are calculated as moving averages for a period of the last 12 months, excluding weekends and known missing data points.

Security

No known security issues

Security and license risk for significant versions

All Versions

Direct Vulnerabilities

3.0.2

4.0.0

5.1.1

6.3.1

6.4.1

Indirect Vulnerabilities

3.0.2

4.0.0

5.1.1

6.3.1

6.4.1

License Risks

3.0.2

4.0.0

5.1.1

6.3.1

6.4.1

All security vulnerabilities belong to production dependencies of direct and indirect packages.

License

MIT

Security Policy

We found a way for you to contribute to the project! Looks like eslint-plugin-jsx-a11y is missing a security policy.

You can connect your project's repository to Snyk to stay up to date on security alerts and receive automatic fix pull requests.

    # Install the Snyk CLI and test your project
npm i snyk -g && snyk test eslint-plugin-jsx-a11y

Keep your project free of vulnerabilities with Snyk

Maintenance

Healthy

Commit Frequency

Open Issues: 66
Open PR: 2
Last Release: 6 months ago
Last Commit: 2 days ago

Further analysis of the maintenance status of eslint-plugin-jsx-a11y based on released npm versions cadence, the repository activity, and other data points determined that its maintenance is Healthy.

We found that eslint-plugin-jsx-a11y demonstrates a positive version release cadence with at least one new version released in the past 12 months.

As a healthy sign for on-going project maintenance, we found that the GitHub repository had at least 1 pull request or issue interacted with by the community.

Community

Sustainable

Readme.md: Yes
Contributing.md: No
Code of Conduct: No
Contributors: 100
Funding: Yes

With more than 10 contributors for the eslint-plugin-jsx-a11y repository, this is possibly a sign for a growing and inviting community.

We found a way for you to contribute to the project! Looks like eslint-plugin-jsx-a11y is missing a Code of Conduct.

Embed Package Health Score Badge

Package

Node.js Compatibility: >=4.0

Age: 5 years
Dependencies: 11 Direct
Versions: 75
Install Size: 613 kB
Dist-tags: 2
# of Files: 217
Maintainers: 4
TS Typings: No

eslint-plugin-jsx-a11y has more than a single and default latest tag published for the npm package. This means, there may be other tags available for this package, such as next to indicate future releases, or stable to indicate stable releases.

Get professional support for eslint-plugin-jsx-a11y on Tidelift

eslint-plugin-jsx-a11y

Static AST checker for accessibility rules on JSX elements.

Read this in other languages.

Mexican Spanish🇲🇽

Why?

Ryan Florence built out this awesome runtime-analysis tool called react-a11y. It is super useful. However, since you're probably already using linting in your project, this plugin comes for free and closer to the actual development process. Pairing this plugin with an editor lint plugin, you can bake accessibility standards into your application in real-time.

Note: This project does not replace react-a11y, but can and should be used in conjunction with it. Static analysis tools cannot determine values of variables that are being placed in props before runtime, so linting will not fail if that value is undefined and/or does not pass the lint rule.

Installation

If you are installing this plugin via eslint-config-airbnb, please follow these instructions.

You'll first need to install ESLint:

# npm
npm install eslint --save-dev

# yarn
yarn add eslint --dev

Next, install eslint-plugin-jsx-a11y:

# npm
npm install eslint-plugin-jsx-a11y --save-dev

# yarn
yarn add eslint-plugin-jsx-a11y --dev

Note: If you installed ESLint globally (using the -g flag in npm, or the global prefix in yarn) then you must also install eslint-plugin-jsx-a11y globally.

Usage

Add jsx-a11y to the plugins section of your .eslintrc configuration file. You can omit the eslint-plugin- prefix:

{
  "plugins": [
    "jsx-a11y"
  ]
}

Then configure the rules you want to use under the rules section.

{
  "rules": {
    "jsx-a11y/rule-name": 2
  }
}

You can also enable all the recommended or strict rules at once. Add plugin:jsx-a11y/recommended or plugin:jsx-a11y/strict in extends:

{
  "extends": [
    "plugin:jsx-a11y/recommended"
  ]
}

Supported Rules

accessible-emoji: Enforce emojis are wrapped in <span> and provide screenreader access.
alt-text: Enforce all elements that require alternative text have meaningful information to relay back to end user.
anchor-has-content: Enforce all anchors to contain accessible content.
anchor-is-valid: Enforce all anchors are valid, navigable elements.
aria-activedescendant-has-tabindex: Enforce elements with aria-activedescendant are tabbable.
aria-props: Enforce all aria-* props are valid.
aria-proptypes: Enforce ARIA state and property values are valid.
aria-role: Enforce that elements with ARIA roles must use a valid, non-abstract ARIA role.
aria-unsupported-elements: Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.
autocomplete-valid: Enforce that autocomplete attributes are used correctly.
click-events-have-key-events: Enforce a clickable non-interactive element has at least one keyboard event listener.
heading-has-content: Enforce heading (h1, h2, etc) elements contain accessible content.
html-has-lang: Enforce <html> element has lang prop.
iframe-has-title: Enforce iframe elements have a title attribute.
img-redundant-alt: Enforce <img> alt prop does not contain the word "image", "picture", or "photo".
interactive-supports-focus: Enforce that elements with interactive handlers like onClick must be focusable.
label-has-associated-control: Enforce that a label tag has a text label and an associated control.
lang: Enforce lang attribute has a valid value.
media-has-caption: Enforces that <audio> and <video> elements must have a <track> for captions.
mouse-events-have-key-events: Enforce that onMouseOver/onMouseOut are accompanied by onFocus/onBlur for keyboard-only users.
no-access-key: Enforce that the accessKey prop is not used on any element to avoid complications with keyboard commands used by a screenreader.
no-autofocus: Enforce autoFocus prop is not used.
no-distracting-elements: Enforce distracting elements are not used.
no-interactive-element-to-noninteractive-role: Interactive elements should not be assigned non-interactive roles.
no-noninteractive-element-interactions: Non-interactive elements should not be assigned mouse or keyboard event listeners.
no-noninteractive-element-to-interactive-role: Non-interactive elements should not be assigned interactive roles.
no-noninteractive-tabindex: tabIndex should only be declared on interactive elements.
no-onchange: Enforce usage of onBlur over onChange on select menus for accessibility.
no-redundant-roles: Enforce explicit role property is not the same as implicit/default role property on element.
no-static-element-interactions: Enforce that non-interactive, visible elements (such as <div>) that have click handlers use the role attribute.
role-has-required-aria-props: Enforce that elements with ARIA roles must have all required attributes for that role.
role-supports-aria-props: Enforce that elements with explicit or implicit roles defined contain only aria-* properties supported by that role.
scope: Enforce scope prop is only used on <th> elements.
tabindex-no-positive: Enforce tabIndex value is not greater than zero.

Difference between 'recommended' and 'strict' mode

Rule	Recommended	Strict
accessible-emoji	error	error
alt-text	error	error
anchor-has-content	error	error
anchor-is-valid	error	error
aria-activedescendant-has-tabindex	error	error
aria-props	error	error
aria-proptypes	error	error
aria-role	error	error
aria-unsupported-elements	error	error
autocomplete-valid	error	error
click-events-have-key-events	error	error
heading-has-content	error	error
html-has-lang	error	error
iframe-has-title	error	error
img-redundant-alt	error	error
interactive-supports-focus	error	error
label-has-associated-control	error	error
media-has-caption	error	error
mouse-events-have-key-events	error	error
no-access-key	error	error
no-autofocus	error	error
no-distracting-elements	error	error
no-interactive-element-to-noninteractive-role	error, with options	error
no-noninteractive-element-interactions	error, with options	error
no-noninteractive-element-to-interactive-role	error, with options	error
no-noninteractive-tabindex	error, with options	error
no-onchange	error	error
no-redundant-roles	error	error
no-static-element-interactions	error, with options	error
role-has-required-aria-props	error	error
role-supports-aria-props	error	error
scope	error, with options	error
tabindex-no-positive	error	error

The following rules have extra options when in recommended mode:

no-interactive-element-to-noninteractive-role

'jsx-a11y/no-interactive-element-to-noninteractive-role': [
  'error',
  {
    tr: ['none', 'presentation'],
  },
]

no-noninteractive-element-interactions

'jsx-a11y/no-noninteractive-element-interactions': [
  'error',
  {
    handlers: [
      'onClick',
      'onMouseDown',
      'onMouseUp',
      'onKeyPress',
      'onKeyDown',
      'onKeyUp',
    ],
  },
]

no-noninteractive-element-to-interactive-role

'jsx-a11y/no-noninteractive-element-to-interactive-role': [
  'error',
  {
    ul: [
      'listbox',
      'menu',
      'menubar',
      'radiogroup',
      'tablist',
      'tree',
      'treegrid',
    ],
    ol: [
      'listbox',
      'menu',
      'menubar',
      'radiogroup',
      'tablist',
      'tree',
      'treegrid',
    ],
    li: ['menuitem', 'option', 'row', 'tab', 'treeitem'],
    table: ['grid'],
    td: ['gridcell'],
  },
]

no-noninteractive-tabindex

'jsx-a11y/no-noninteractive-tabindex': [
  'error',
  {
    tags: [],
    roles: ['tabpanel'],
  },
]

no-static-element-interactions

'jsx-a11y/no-noninteractive-element-interactions': [
  'error',
  {
    handlers: [
      'onClick',
      'onMouseDown',
      'onMouseUp',
      'onKeyPress',
      'onKeyDown',
      'onKeyUp',
    ],
  },
]

Creating a new rule

If you are developing new rules for this project, you can use the create-rule script to scaffold the new files.

$ ./scripts/create-rule.js my-new-rule

Some background on WAI-ARIA, the AX Tree and Browsers

Accessibility API

An operating system will provide an accessibility API that maps application state and content onto input/output controllers such as a screen reader, braille device, keyboard, etc.

These APIs were developed as computer interfaces shifted from buffers (which are text-based and inherently quite accessible) to graphical user interfaces (GUIs). The first attempts to make GUIs accessible involved raster image parsing to recognize characters, words, etc. This information was stored in a parallel buffer and made accessible to assistive technology (AT) devices.

As GUIs became more complex, the raster parsing approach became untenable. Accessibility APIs were developed to replace them. Check out NSAccessibility (AXAPI) for an example. See Core Accessibility API Mappings 1.1 for more details.

Browsers

Browsers support an Accessibility API on a per operating system basis. For instance, Firefox implements the MSAA accessibility API on Windows, but does not implement the AXAPI on OSX.

The Accessibility (AX) Tree & DOM

From the W3 Core Accessibility API Mappings 1.1

The accessibility tree and the DOM tree are parallel structures. Roughly speaking the accessibility tree is a subset of the DOM tree. It includes the user interface objects of the user agent and the objects of the document. Accessible objects are created in the accessibility tree for every DOM element that should be exposed to assistive technology, either because it may fire an accessibility event or because it has a property, relationship or feature which needs to be exposed. Generally, if something can be trimmed out it will be, for reasons of performance and simplicity. For example, a <span> with just a style change and no semantics may not get its own accessible object, but the style change will be exposed by other means.

Browser vendors are beginning to expose the AX Tree through inspection tools. Chrome has an experiment available to enable their inspection tool.

You can also see a text-based version of the AX Tree in Chrome in the stable release version.

Viewing the AX Tree in Chrome

Navigate to chrome://accessibility/ in Chrome.
Toggle the accessibility off link for any tab that you want to inspect.
A link labeled show accessibility tree will appear; click this link.
Balk at the wall of text that gets displayed, but then regain your conviction.
Use the browser's find command to locate strings and values in the wall of text.

Pulling it all together

A browser constructs an AX Tree as a subset of the DOM. ARIA heavily informs the properties of this AX Tree. This AX Tree is exposed to the system level Accessibility API which mediates assistive technology agents.

We model ARIA in the aria-query project. We model AXObjects (that comprise the AX Tree) in the axobject-query project. The goal of the WAI-ARIA specification is to be a complete declarative interface to the AXObject model. The in-draft 1.2 version is moving towards this goal. But until then, we must consider the semantics constructs afforded by ARIA as well as those afforded by the AXObject model (AXAPI) in order to determine how HTML can be used to express user interface affordances to assistive technology users.

License

eslint-plugin-jsx-a11y is licensed under the MIT License.