@arcaauth/eslint-plugin-jsx-a11y 6.10.2

package/docs/rules/tabindex-no-positive.md

@@ -0,0 +1,32 @@
+# jsx-a11y/tabindex-no-positive
+
+💼 This rule is enabled in the following configs: ☑️ `recommended`, 🔒 `strict`.
+
+<!-- end auto-generated rule header -->
+
+Avoid positive `tabIndex` property values to synchronize the flow of the page with keyboard tab order.
+
+## Rule details
+
+This rule takes no arguments.
+
+### Succeed
+```jsx
+<span tabIndex="0">foo</span>
+<span tabIndex="-1">bar</span>
+<span tabIndex={0}>baz</span>
+```
+
+### Fail
+```jsx
+<span tabIndex="5">foo</span>
+<span tabIndex="3">bar</span>
+<span tabIndex="1">baz</span>
+<span tabIndex="2">never really sure what goes after baz</span>
+```
+
+## Accessibility guidelines
+- [WCAG 2.4.3](https://www.w3.org/WAI/WCAG21/Understanding/focus-order)
+
+### Resources
+- [Chrome Audit Rules, AX_FOCUS_03](https://github.com/GoogleChrome/accessibility-developer-tools/wiki/Audit-Rules#ax_focus_03)

package/lib/configs/flat-config-base.js

@@ -0,0 +1,11 @@
+"use strict";
+
+module.exports = {
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true
+      }
+    }
+  }
+};

package/lib/configs/legacy-config-base.js

@@ -0,0 +1,9 @@
+"use strict";
+
+module.exports = {
+  parserOptions: {
+    ecmaFeatures: {
+      jsx: true
+    }
+  }
+};

package/lib/index.js

@@ -0,0 +1,209 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/* eslint-disable global-require */
+var flatConfigBase = require('./configs/flat-config-base');
+var legacyConfigBase = require('./configs/legacy-config-base');
+var _require = require('../package.json'),
+  name = _require.name,
+  version = _require.version;
+var allRules = {
+  'accessible-emoji': require('./rules/accessible-emoji'),
+  'alt-text': require('./rules/alt-text'),
+  'anchor-ambiguous-text': require('./rules/anchor-ambiguous-text'),
+  'anchor-has-content': require('./rules/anchor-has-content'),
+  'anchor-is-valid': require('./rules/anchor-is-valid'),
+  'aria-activedescendant-has-tabindex': require('./rules/aria-activedescendant-has-tabindex'),
+  'aria-props': require('./rules/aria-props'),
+  'aria-proptypes': require('./rules/aria-proptypes'),
+  'aria-role': require('./rules/aria-role'),
+  'aria-unsupported-elements': require('./rules/aria-unsupported-elements'),
+  'autocomplete-valid': require('./rules/autocomplete-valid'),
+  'click-events-have-key-events': require('./rules/click-events-have-key-events'),
+  'control-has-associated-label': require('./rules/control-has-associated-label'),
+  'heading-has-content': require('./rules/heading-has-content'),
+  'html-has-lang': require('./rules/html-has-lang'),
+  'iframe-has-title': require('./rules/iframe-has-title'),
+  'img-redundant-alt': require('./rules/img-redundant-alt'),
+  'interactive-supports-focus': require('./rules/interactive-supports-focus'),
+  'label-has-associated-control': require('./rules/label-has-associated-control'),
+  'label-has-for': require('./rules/label-has-for'),
+  lang: require('./rules/lang'),
+  'media-has-caption': require('./rules/media-has-caption'),
+  'mouse-events-have-key-events': require('./rules/mouse-events-have-key-events'),
+  'no-access-key': require('./rules/no-access-key'),
+  'no-aria-hidden-on-focusable': require('./rules/no-aria-hidden-on-focusable'),
+  'no-autofocus': require('./rules/no-autofocus'),
+  'no-distracting-elements': require('./rules/no-distracting-elements'),
+  'no-interactive-element-to-noninteractive-role': require('./rules/no-interactive-element-to-noninteractive-role'),
+  'no-noninteractive-element-interactions': require('./rules/no-noninteractive-element-interactions'),
+  'no-noninteractive-element-to-interactive-role': require('./rules/no-noninteractive-element-to-interactive-role'),
+  'no-noninteractive-tabindex': require('./rules/no-noninteractive-tabindex'),
+  'no-onchange': require('./rules/no-onchange'),
+  'no-redundant-roles': require('./rules/no-redundant-roles'),
+  'no-static-element-interactions': require('./rules/no-static-element-interactions'),
+  'prefer-tag-over-role': require('./rules/prefer-tag-over-role'),
+  'role-has-required-aria-props': require('./rules/role-has-required-aria-props'),
+  'role-supports-aria-props': require('./rules/role-supports-aria-props'),
+  scope: require('./rules/scope'),
+  'tabindex-no-positive': require('./rules/tabindex-no-positive')
+};
+var recommendedRules = {
+  'jsx-a11y/alt-text': 'error',
+  'jsx-a11y/anchor-ambiguous-text': 'off',
+  // TODO: error
+  'jsx-a11y/anchor-has-content': 'error',
+  'jsx-a11y/anchor-is-valid': 'error',
+  'jsx-a11y/aria-activedescendant-has-tabindex': 'error',
+  'jsx-a11y/aria-props': 'error',
+  'jsx-a11y/aria-proptypes': 'error',
+  'jsx-a11y/aria-role': 'error',
+  'jsx-a11y/aria-unsupported-elements': 'error',
+  'jsx-a11y/autocomplete-valid': 'error',
+  'jsx-a11y/click-events-have-key-events': 'error',
+  'jsx-a11y/control-has-associated-label': ['off', {
+    ignoreElements: ['audio', 'canvas', 'embed', 'input', 'textarea', 'tr', 'video'],
+    ignoreRoles: ['grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'row', 'tablist', 'toolbar', 'tree', 'treegrid'],
+    includeRoles: ['alert', 'dialog']
+  }],
+  'jsx-a11y/heading-has-content': 'error',
+  'jsx-a11y/html-has-lang': 'error',
+  'jsx-a11y/iframe-has-title': 'error',
+  'jsx-a11y/img-redundant-alt': 'error',
+  'jsx-a11y/interactive-supports-focus': ['error', {
+    tabbable: ['button', 'checkbox', 'link', 'searchbox', 'spinbutton', 'switch', 'textbox']
+  }],
+  'jsx-a11y/label-has-associated-control': 'error',
+  'jsx-a11y/label-has-for': 'off',
+  'jsx-a11y/media-has-caption': 'error',
+  'jsx-a11y/mouse-events-have-key-events': 'error',
+  'jsx-a11y/no-access-key': 'error',
+  'jsx-a11y/no-autofocus': 'error',
+  'jsx-a11y/no-distracting-elements': 'error',
+  'jsx-a11y/no-interactive-element-to-noninteractive-role': ['error', {
+    tr: ['none', 'presentation'],
+    canvas: ['img']
+  }],
+  'jsx-a11y/no-noninteractive-element-interactions': ['error', {
+    handlers: ['onClick', 'onError', 'onLoad', 'onMouseDown', 'onMouseUp', 'onKeyPress', 'onKeyDown', 'onKeyUp'],
+    alert: ['onKeyUp', 'onKeyDown', 'onKeyPress'],
+    body: ['onError', 'onLoad'],
+    dialog: ['onKeyUp', 'onKeyDown', 'onKeyPress'],
+    iframe: ['onError', 'onLoad'],
+    img: ['onError', 'onLoad']
+  }],
+  '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', 'menuitemradio', 'menuitemcheckbox', 'option', 'row', 'tab', 'treeitem'],
+    table: ['grid'],
+    td: ['gridcell'],
+    fieldset: ['radiogroup', 'presentation']
+  }],
+  'jsx-a11y/no-noninteractive-tabindex': ['error', {
+    tags: [],
+    roles: ['tabpanel'],
+    allowExpressionValues: true
+  }],
+  'jsx-a11y/no-redundant-roles': 'error',
+  'jsx-a11y/no-static-element-interactions': ['error', {
+    allowExpressionValues: true,
+    handlers: ['onClick', 'onMouseDown', 'onMouseUp', 'onKeyPress', 'onKeyDown', 'onKeyUp']
+  }],
+  'jsx-a11y/role-has-required-aria-props': 'error',
+  'jsx-a11y/role-supports-aria-props': 'error',
+  'jsx-a11y/scope': 'error',
+  'jsx-a11y/tabindex-no-positive': 'error'
+};
+var strictRules = {
+  'jsx-a11y/alt-text': 'error',
+  'jsx-a11y/anchor-has-content': 'error',
+  'jsx-a11y/anchor-is-valid': 'error',
+  'jsx-a11y/aria-activedescendant-has-tabindex': 'error',
+  'jsx-a11y/aria-props': 'error',
+  'jsx-a11y/aria-proptypes': 'error',
+  'jsx-a11y/aria-role': 'error',
+  'jsx-a11y/aria-unsupported-elements': 'error',
+  'jsx-a11y/autocomplete-valid': 'error',
+  'jsx-a11y/click-events-have-key-events': 'error',
+  'jsx-a11y/control-has-associated-label': ['off', {
+    ignoreElements: ['audio', 'canvas', 'embed', 'input', 'textarea', 'tr', 'video'],
+    ignoreRoles: ['grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'row', 'tablist', 'toolbar', 'tree', 'treegrid'],
+    includeRoles: ['alert', 'dialog']
+  }],
+  'jsx-a11y/heading-has-content': 'error',
+  'jsx-a11y/html-has-lang': 'error',
+  'jsx-a11y/iframe-has-title': 'error',
+  'jsx-a11y/img-redundant-alt': 'error',
+  'jsx-a11y/interactive-supports-focus': ['error', {
+    tabbable: ['button', 'checkbox', 'link', 'progressbar', 'searchbox', 'slider', 'spinbutton', 'switch', 'textbox']
+  }],
+  'jsx-a11y/label-has-for': 'off',
+  'jsx-a11y/label-has-associated-control': 'error',
+  'jsx-a11y/media-has-caption': 'error',
+  'jsx-a11y/mouse-events-have-key-events': 'error',
+  'jsx-a11y/no-access-key': 'error',
+  'jsx-a11y/no-autofocus': 'error',
+  'jsx-a11y/no-distracting-elements': 'error',
+  'jsx-a11y/no-interactive-element-to-noninteractive-role': 'error',
+  'jsx-a11y/no-noninteractive-element-interactions': ['error', {
+    body: ['onError', 'onLoad'],
+    iframe: ['onError', 'onLoad'],
+    img: ['onError', 'onLoad']
+  }],
+  'jsx-a11y/no-noninteractive-element-to-interactive-role': 'error',
+  'jsx-a11y/no-noninteractive-tabindex': 'error',
+  'jsx-a11y/no-redundant-roles': 'error',
+  'jsx-a11y/no-static-element-interactions': 'error',
+  'jsx-a11y/role-has-required-aria-props': 'error',
+  'jsx-a11y/role-supports-aria-props': 'error',
+  'jsx-a11y/scope': 'error',
+  'jsx-a11y/tabindex-no-positive': 'error'
+};
+
+/** Base plugin object */
+var jsxA11y = {
+  meta: {
+    name,
+    version
+  },
+  rules: _objectSpread({}, allRules)
+};
+
+/**
+ * Given a ruleset and optionally a flat config name, generate a config.
+ * @param {object} rules - ruleset for this config
+ * @param {string} flatConfigName - name for the config if flat
+ * @returns Config for this set of rules.
+ */
+var createConfig = function createConfig(rules, flatConfigName) {
+  return _objectSpread(_objectSpread({}, flatConfigName ? _objectSpread(_objectSpread({}, flatConfigBase), {}, {
+    name: "jsx-a11y/".concat(flatConfigName),
+    plugins: {
+      'jsx-a11y': jsxA11y
+    }
+  }) : _objectSpread(_objectSpread({}, legacyConfigBase), {}, {
+    plugins: ['jsx-a11y']
+  })), {}, {
+    rules: _objectSpread({}, rules)
+  });
+};
+
+// Create configs for the plugin object
+var configs = {
+  recommended: createConfig(recommendedRules),
+  strict: createConfig(strictRules)
+};
+var flatConfigs = {
+  recommended: createConfig(recommendedRules, 'recommended'),
+  strict: createConfig(strictRules, 'strict')
+};
+module.exports = _objectSpread(_objectSpread({}, jsxA11y), {}, {
+  configs,
+  flatConfigs
+});

package/lib/rules/accessible-emoji.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _emojiRegex = _interopRequireDefault(require("emoji-regex"));
+var _jsxAstUtils = require("jsx-ast-utils");
+var _safeRegexTest = _interopRequireDefault(require("safe-regex-test"));
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _isHiddenFromScreenReader = _interopRequireDefault(require("../util/isHiddenFromScreenReader"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce emojis are wrapped in <span> and provide screen reader access.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'Emojis should be wrapped in <span>, have role="img", and have an accessible description with aria-label or aria-labelledby.';
+var schema = (0, _schemas.generateObjSchema)();
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      description: 'Enforce emojis are wrapped in `<span>` and provide screen reader access.',
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/accessible-emoji.md'
+    },
+    deprecated: true,
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    var testEmoji = (0, _safeRegexTest["default"])((0, _emojiRegex["default"])());
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var literalChildValue = node.parent.children.find(function (child) {
+          return child.type === 'Literal' || child.type === 'JSXText';
+        });
+        if (literalChildValue && testEmoji(literalChildValue.value)) {
+          var elementIsHidden = (0, _isHiddenFromScreenReader["default"])(elementType(node), node.attributes);
+          if (elementIsHidden) {
+            return; // emoji is decorative
+          }
+          var rolePropValue = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(node.attributes, 'role'));
+          var ariaLabelProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-label');
+          var arialLabelledByProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-labelledby');
+          var hasLabel = ariaLabelProp !== undefined || arialLabelledByProp !== undefined;
+          var isSpan = elementType(node) === 'span';
+          if (hasLabel === false || rolePropValue !== 'img' || isSpan === false) {
+            context.report({
+              node,
+              message: errorMessage
+            });
+          }
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/alt-text.js

@@ -0,0 +1,218 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _arrayPrototype = _interopRequireDefault(require("array.prototype.flatmap"));
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _hasAccessibleChild = _interopRequireDefault(require("../util/hasAccessibleChild"));
+var _isPresentationRole = _interopRequireDefault(require("../util/isPresentationRole"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce all elements that require alternative text have it.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var DEFAULT_ELEMENTS = ['img', 'object', 'area', 'input[type="image"]'];
+var schema = (0, _schemas.generateObjSchema)({
+  elements: _schemas.arraySchema,
+  img: _schemas.arraySchema,
+  object: _schemas.arraySchema,
+  area: _schemas.arraySchema,
+  'input[type="image"]': _schemas.arraySchema
+});
+var ariaLabelHasValue = function ariaLabelHasValue(prop) {
+  var value = (0, _jsxAstUtils.getPropValue)(prop);
+  if (value === undefined) {
+    return false;
+  }
+  if (typeof value === 'string' && value.length === 0) {
+    return false;
+  }
+  return true;
+};
+var ruleByElement = {
+  img(context, node, nodeType) {
+    var altProp = (0, _jsxAstUtils.getProp)(node.attributes, 'alt');
+
+    // Missing alt prop error.
+    if (altProp === undefined) {
+      if ((0, _isPresentationRole["default"])(nodeType, node.attributes)) {
+        context.report({
+          node,
+          message: 'Prefer alt="" over a presentational role. First rule of aria is to not use aria if it can be achieved via native HTML.'
+        });
+        return;
+      }
+      // Check for `aria-label` to provide text alternative
+      // Don't create an error if the attribute is used correctly. But if it
+      // isn't, suggest that the developer use `alt` instead.
+      var ariaLabelProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-label');
+      if (ariaLabelProp !== undefined) {
+        if (!ariaLabelHasValue(ariaLabelProp)) {
+          context.report({
+            node,
+            message: 'The aria-label attribute must have a value. The alt attribute is preferred over aria-label for images.'
+          });
+        }
+        return;
+      }
+      // Check for `aria-labelledby` to provide text alternative
+      // Don't create an error if the attribute is used correctly. But if it
+      // isn't, suggest that the developer use `alt` instead.
+      var ariaLabelledbyProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-labelledby');
+      if (ariaLabelledbyProp !== undefined) {
+        if (!ariaLabelHasValue(ariaLabelledbyProp)) {
+          context.report({
+            node,
+            message: 'The aria-labelledby attribute must have a value. The alt attribute is preferred over aria-labelledby for images.'
+          });
+        }
+        return;
+      }
+      context.report({
+        node,
+        message: "".concat(nodeType, " elements must have an alt prop, either with meaningful text, or an empty string for decorative images.")
+      });
+      return;
+    }
+
+    // Check if alt prop is undefined.
+    var altValue = (0, _jsxAstUtils.getPropValue)(altProp);
+    var isNullValued = altProp.value === null; // <img alt />
+
+    if (altValue && !isNullValued || altValue === '') {
+      return;
+    }
+
+    // Undefined alt prop error.
+    context.report({
+      node,
+      message: "Invalid alt value for ".concat(nodeType, ". Use alt=\"\" for presentational images.")
+    });
+  },
+  object(context, node, unusedNodeType, elementType) {
+    var ariaLabelProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-label');
+    var arialLabelledByProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-labelledby');
+    var hasLabel = ariaLabelHasValue(ariaLabelProp) || ariaLabelHasValue(arialLabelledByProp);
+    var titleProp = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(node.attributes, 'title'));
+    var hasTitleAttr = !!titleProp;
+    if (hasLabel || hasTitleAttr || (0, _hasAccessibleChild["default"])(node.parent, elementType)) {
+      return;
+    }
+    context.report({
+      node,
+      message: 'Embedded <object> elements must have alternative text by providing inner text, aria-label or aria-labelledby props.'
+    });
+  },
+  area(context, node) {
+    var ariaLabelProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-label');
+    var arialLabelledByProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-labelledby');
+    var hasLabel = ariaLabelHasValue(ariaLabelProp) || ariaLabelHasValue(arialLabelledByProp);
+    if (hasLabel) {
+      return;
+    }
+    var altProp = (0, _jsxAstUtils.getProp)(node.attributes, 'alt');
+    if (altProp === undefined) {
+      context.report({
+        node,
+        message: 'Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.'
+      });
+      return;
+    }
+    var altValue = (0, _jsxAstUtils.getPropValue)(altProp);
+    var isNullValued = altProp.value === null; // <area alt />
+
+    if (altValue && !isNullValued || altValue === '') {
+      return;
+    }
+    context.report({
+      node,
+      message: 'Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.'
+    });
+  },
+  'input[type="image"]': function inputImage(context, node, nodeType) {
+    // Only test input[type="image"]
+    if (nodeType === 'input') {
+      var typePropValue = (0, _jsxAstUtils.getPropValue)((0, _jsxAstUtils.getProp)(node.attributes, 'type'));
+      if (typePropValue !== 'image') {
+        return;
+      }
+    }
+    var ariaLabelProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-label');
+    var arialLabelledByProp = (0, _jsxAstUtils.getProp)(node.attributes, 'aria-labelledby');
+    var hasLabel = ariaLabelHasValue(ariaLabelProp) || ariaLabelHasValue(arialLabelledByProp);
+    if (hasLabel) {
+      return;
+    }
+    var altProp = (0, _jsxAstUtils.getProp)(node.attributes, 'alt');
+    if (altProp === undefined) {
+      context.report({
+        node,
+        message: '<input> elements with type="image" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.'
+      });
+      return;
+    }
+    var altValue = (0, _jsxAstUtils.getPropValue)(altProp);
+    var isNullValued = altProp.value === null; // <area alt />
+
+    if (altValue && !isNullValued || altValue === '') {
+      return;
+    }
+    context.report({
+      node,
+      message: '<input> elements with type="image" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.'
+    });
+  }
+};
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/alt-text.md',
+      description: 'Enforce all elements that require alternative text have meaningful information to relay back to end user.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var options = context.options[0] || {};
+    // Elements to validate for alt text.
+    var elementOptions = options.elements || DEFAULT_ELEMENTS;
+    // Get custom components for just the elements that will be tested.
+    var customComponents = (0, _arrayPrototype["default"])(elementOptions, function (element) {
+      return options[element];
+    });
+    var typesToValidate = new Set([].concat(customComponents, elementOptions).map(function (type) {
+      return type === 'input[type="image"]' ? 'input' : type;
+    }));
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement(node) {
+        var nodeType = elementType(node);
+        if (!typesToValidate.has(nodeType)) {
+          return;
+        }
+        var DOMElement = nodeType;
+        if (DOMElement === 'input') {
+          DOMElement = 'input[type="image"]';
+        }
+
+        // Map nodeType to the DOM element if we are running this on a custom component.
+        if (elementOptions.indexOf(DOMElement) === -1) {
+          DOMElement = elementOptions.find(function (element) {
+            var customComponentsForElement = options[element] || [];
+            return customComponentsForElement.indexOf(nodeType) > -1;
+          });
+        }
+        ruleByElement[DOMElement](context, node, nodeType, elementType);
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/anchor-ambiguous-text.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _schemas = require("../util/schemas");
+var _getAccessibleChildText = _interopRequireDefault(require("../util/getAccessibleChildText"));
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce anchor text to not exactly match 'click here', 'here', 'link', 'learn more', and user-specified words.
+ * @author Matt Wang
+ * 
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var DEFAULT_AMBIGUOUS_WORDS = ['click here', 'here', 'link', 'a link', 'learn more'];
+var schema = (0, _schemas.generateObjSchema)({
+  words: _schemas.arraySchema
+});
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-ambiguous-text.md',
+      description: 'Enforce `<a>` text to not exactly match "click here", "here", "link", or "a link".'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    var typesToValidate = ['a'];
+    var options = context.options[0] || {};
+    var _options$words = options.words,
+      words = _options$words === void 0 ? DEFAULT_AMBIGUOUS_WORDS : _options$words;
+    var ambiguousWords = new Set(words);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var nodeType = elementType(node);
+
+        // Only check anchor elements and custom types.
+        if (typesToValidate.indexOf(nodeType) === -1) {
+          return;
+        }
+        var nodeText = (0, _getAccessibleChildText["default"])(node.parent, elementType);
+        if (!ambiguousWords.has(nodeText)) {
+          // check the value
+          return;
+        }
+        context.report({
+          node,
+          message: 'Ambiguous text within anchor. Screen reader users rely on link text for context; the words "{{wordsList}}" are ambiguous and do not provide enough context.',
+          data: {
+            wordsList: words.join('", "')
+          }
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/anchor-has-content.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _schemas = require("../util/schemas");
+var _hasAccessibleChild = _interopRequireDefault(require("../util/hasAccessibleChild"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce anchor elements to contain accessible content.
+ * @author Lisa Ring & Niklas Holmberg
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'Anchors must have content and the content must be accessible by a screen reader.';
+var schema = (0, _schemas.generateObjSchema)({
+  components: _schemas.arraySchema
+});
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-has-content.md',
+      description: 'Enforce all anchors to contain accessible content.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var options = context.options[0] || {};
+        var componentOptions = options.components || [];
+        var typeCheck = ['a'].concat(componentOptions);
+        var nodeType = elementType(node);
+
+        // Only check anchor elements and custom types.
+        if (typeCheck.indexOf(nodeType) === -1) {
+          return;
+        }
+        if ((0, _hasAccessibleChild["default"])(node.parent, elementType)) {
+          return;
+        }
+        if ((0, _jsxAstUtils.hasAnyProp)(node.attributes, ['title', 'aria-label'])) {
+          return;
+        }
+        context.report({
+          node,
+          message: errorMessage
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;