@arcaauth/eslint-plugin-jsx-a11y 6.10.2

package/lib/rules/anchor-is-valid.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _safeRegexTest = _interopRequireDefault(require("safe-regex-test"));
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Performs validity check on anchor hrefs. Warns when anchors are used as buttons.
+ * @author Almero Steyn
+ * 
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var allAspects = ['noHref', 'invalidHref', 'preferButton'];
+var preferButtonErrorMessage = 'Anchor used as a button. Anchors are primarily expected to navigate. Use the button element instead. Learn more: https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/HEAD/docs/rules/anchor-is-valid.md';
+var noHrefErrorMessage = 'The href attribute is required for an anchor to be keyboard accessible. Provide a valid, navigable address as the href value. If you cannot provide an href, but still need the element to resemble a link, use a button and change it with appropriate styles. Learn more: https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/HEAD/docs/rules/anchor-is-valid.md';
+var invalidHrefErrorMessage = 'The href attribute requires a valid value to be accessible. Provide a valid, navigable address as the href value. If you cannot provide a valid href, but still need the element to resemble a link, use a button and change it with appropriate styles. Learn more: https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/HEAD/docs/rules/anchor-is-valid.md';
+var schema = (0, _schemas.generateObjSchema)({
+  components: _schemas.arraySchema,
+  specialLink: _schemas.arraySchema,
+  aspects: (0, _schemas.enumArraySchema)(allAspects, 1)
+});
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-is-valid.md',
+      description: 'Enforce all anchors are valid, navigable elements.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    var testJShref = (0, _safeRegexTest["default"])(/^\W*?javascript:/);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var attributes = node.attributes;
+        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;
+        }
+
+        // Set up the rule aspects to check.
+        var aspects = options.aspects || allAspects;
+
+        // Create active aspect flag object. Failing checks will only report
+        // if the related flag is set to true.
+        var activeAspects = {};
+        allAspects.forEach(function (aspect) {
+          activeAspects[aspect] = aspects.indexOf(aspect) !== -1;
+        });
+        var propOptions = options.specialLink || [];
+        var propsToValidate = ['href'].concat(propOptions);
+        var values = propsToValidate.map(function (prop) {
+          return (0, _jsxAstUtils.getPropValue)((0, _jsxAstUtils.getProp)(node.attributes, prop));
+        });
+        // Checks if any actual or custom href prop is provided.
+        var hasAnyHref = values.some(function (value) {
+          return value != null;
+        });
+        // Need to check for spread operator as props can be spread onto the element
+        // leading to an incorrect validation error.
+        var hasSpreadOperator = attributes.some(function (prop) {
+          return prop.type === 'JSXSpreadAttribute';
+        });
+        var onClick = (0, _jsxAstUtils.getProp)(attributes, 'onClick');
+
+        // When there is no href at all, specific scenarios apply:
+        if (!hasAnyHref) {
+          // If no spread operator is found and no onClick event is present
+          // it is a link without href.
+          if (!hasSpreadOperator && activeAspects.noHref && (!onClick || onClick && !activeAspects.preferButton)) {
+            context.report({
+              node,
+              message: noHrefErrorMessage
+            });
+          }
+          // If no spread operator is found but an onClick is preset it should be a button.
+          if (!hasSpreadOperator && onClick && activeAspects.preferButton) {
+            context.report({
+              node,
+              message: preferButtonErrorMessage
+            });
+          }
+          return;
+        }
+
+        // Hrefs have been found, now check for validity.
+        var invalidHrefValues = values.filter(function (value) {
+          return value != null && typeof value === 'string' && (!value.length || value === '#' || testJShref(value));
+        });
+        if (invalidHrefValues.length !== 0) {
+          // If an onClick is found it should be a button, otherwise it is an invalid link.
+          if (onClick && activeAspects.preferButton) {
+            context.report({
+              node,
+              message: preferButtonErrorMessage
+            });
+          } else if (activeAspects.invalidHref) {
+            context.report({
+              node,
+              message: invalidHrefErrorMessage
+            });
+          }
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/aria-activedescendant-has-tabindex.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _getTabIndex = _interopRequireDefault(require("../util/getTabIndex"));
+var _isInteractiveElement = _interopRequireDefault(require("../util/isInteractiveElement"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce elements with aria-activedescendant are tabbable.
+ * @author Jesse Beach <@jessebeach>
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'An element that manages focus with `aria-activedescendant` must have a tabindex';
+var schema = (0, _schemas.generateObjSchema)();
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-activedescendant-has-tabindex.md',
+      description: 'Enforce elements with aria-activedescendant are tabbable.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var attributes = node.attributes;
+        if ((0, _jsxAstUtils.getProp)(attributes, 'aria-activedescendant') === undefined) {
+          return;
+        }
+        var type = elementType(node);
+        // Do not test higher level JSX components, as we do not know what
+        // low-level DOM element this maps to.
+        if (!_ariaQuery.dom.has(type)) {
+          return;
+        }
+        var tabIndex = (0, _getTabIndex["default"])((0, _jsxAstUtils.getProp)(attributes, 'tabIndex'));
+
+        // If this is an interactive element and the tabindex attribute is not specified,
+        // or the tabIndex property was not mutated, then the tabIndex
+        // property will be undefined.
+        if ((0, _isInteractiveElement["default"])(type, attributes) && tabIndex === undefined) {
+          return;
+        }
+        if (tabIndex >= -1) {
+          return;
+        }
+        context.report({
+          node,
+          message: errorMessage
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/aria-props.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+var _getSuggestion = _interopRequireDefault(require("../util/getSuggestion"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce all aria-* properties are valid.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var ariaAttributes = _ariaQuery.aria.keys();
+var errorMessage = function errorMessage(name) {
+  var suggestions = (0, _getSuggestion["default"])(name, ariaAttributes);
+  var message = "".concat(name, ": This attribute is an invalid ARIA attribute.");
+  if (suggestions.length > 0) {
+    return "".concat(message, " Did you mean to use ").concat(suggestions, "?");
+  }
+  return message;
+};
+var schema = (0, _schemas.generateObjSchema)();
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-props.md',
+      description: 'Enforce all `aria-*` props are valid.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    return {
+      JSXAttribute: function JSXAttribute(attribute) {
+        var name = (0, _jsxAstUtils.propName)(attribute);
+
+        // `aria` needs to be prefix of property.
+        if (name.indexOf('aria-') !== 0) {
+          return;
+        }
+        var isValid = _ariaQuery.aria.has(name);
+        if (isValid === false) {
+          context.report({
+            node: attribute,
+            message: errorMessage(name)
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/aria-proptypes.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+/**
+ * @fileoverview Enforce ARIA state and property values are valid.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = function errorMessage(name, type, permittedValues) {
+  switch (type) {
+    case 'tristate':
+      return "The value for ".concat(name, " must be a boolean or the string \"mixed\".");
+    case 'token':
+      return "The value for ".concat(name, " must be a single token from the following: ").concat(permittedValues, ".");
+    case 'tokenlist':
+      return "The value for ".concat(name, " must be a list of one or more tokens from the following: ").concat(permittedValues, ".");
+    case 'idlist':
+      return "The value for ".concat(name, " must be a list of strings that represent DOM element IDs (idlist)");
+    case 'id':
+      return "The value for ".concat(name, " must be a string that represents a DOM element ID");
+    case 'boolean':
+    case 'string':
+    case 'integer':
+    case 'number':
+    default:
+      return "The value for ".concat(name, " must be a ").concat(type, ".");
+  }
+};
+var _validityCheck = function validityCheck(value, expectedType, permittedValues) {
+  switch (expectedType) {
+    case 'boolean':
+      return typeof value === 'boolean';
+    case 'string':
+    case 'id':
+      return typeof value === 'string';
+    case 'tristate':
+      return typeof value === 'boolean' || value === 'mixed';
+    case 'integer':
+    case 'number':
+      // Booleans resolve to 0/1 values so hard check that it's not first.
+      // eslint-disable-next-line no-restricted-globals
+      return typeof value !== 'boolean' && isNaN(Number(value)) === false;
+    case 'token':
+      return permittedValues.indexOf(typeof value === 'string' ? value.toLowerCase() : value) > -1;
+    case 'idlist':
+      return typeof value === 'string' && value.split(' ').every(function (token) {
+        return _validityCheck(token, 'id', []);
+      });
+    case 'tokenlist':
+      return typeof value === 'string' && value.split(' ').every(function (token) {
+        return permittedValues.indexOf(token.toLowerCase()) > -1;
+      });
+    default:
+      return false;
+  }
+};
+var schema = (0, _schemas.generateObjSchema)();
+var _default = exports["default"] = {
+  validityCheck: _validityCheck,
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-proptypes.md',
+      description: 'Enforce ARIA state and property values are valid.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    return {
+      JSXAttribute: function JSXAttribute(attribute) {
+        var name = (0, _jsxAstUtils.propName)(attribute);
+        var normalizedName = name.toLowerCase();
+
+        // Not a valid aria-* state or property.
+        if (normalizedName.indexOf('aria-') !== 0 || _ariaQuery.aria.get(normalizedName) === undefined) {
+          return;
+        }
+
+        // Ignore the attribute if its value is null or undefined.
+        if ((0, _jsxAstUtils.getPropValue)(attribute) == null) return;
+        var value = (0, _jsxAstUtils.getLiteralPropValue)(attribute);
+
+        // Ignore the attribute if its value is not a literal.
+        if (value === null) {
+          return;
+        }
+
+        // These are the attributes of the property/state to check against.
+        var attributes = _ariaQuery.aria.get(normalizedName);
+        var permittedType = attributes.type;
+        var allowUndefined = attributes.allowUndefined || false;
+        var permittedValues = attributes.values || [];
+        var isValid = _validityCheck(value, permittedType, permittedValues) || allowUndefined && value === undefined;
+        if (isValid) {
+          return;
+        }
+        context.report({
+          node: attribute,
+          message: errorMessage(name, permittedType, permittedValues)
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/aria-role.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _schemas = require("../util/schemas");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce aria role attribute is valid.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'Elements with ARIA roles must use a valid, non-abstract ARIA role.';
+var schema = (0, _schemas.generateObjSchema)({
+  allowedInvalidRoles: {
+    items: {
+      type: 'string'
+    },
+    type: 'array',
+    uniqueItems: true
+  },
+  ignoreNonDOM: {
+    type: 'boolean',
+    "default": false
+  }
+});
+var validRoles = new Set(_ariaQuery.roles.keys().filter(function (role) {
+  return _ariaQuery.roles.get(role)["abstract"] === false;
+}));
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-role.md',
+      description: 'Enforce that elements with ARIA roles must use a valid, non-abstract ARIA role.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var options = context.options[0] || {};
+    var ignoreNonDOM = !!options.ignoreNonDOM;
+    var allowedInvalidRoles = new Set(options.allowedInvalidRoles || []);
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXAttribute: function JSXAttribute(attribute) {
+        // If ignoreNonDOM and the parent isn't DOM, don't run rule.
+        if (ignoreNonDOM) {
+          var type = elementType(attribute.parent);
+          if (!_ariaQuery.dom.get(type)) {
+            return;
+          }
+        }
+
+        // Get prop name
+        var name = (0, _jsxAstUtils.propName)(attribute).toUpperCase();
+        if (name !== 'ROLE') {
+          return;
+        }
+        var value = (0, _jsxAstUtils.getLiteralPropValue)(attribute);
+
+        // If value is undefined, then the role attribute will be dropped in the DOM.
+        // If value is null, then getLiteralAttributeValue is telling us that the
+        // value isn't in the form of a literal.
+        if (value === undefined || value === null) {
+          return;
+        }
+        var values = String(value).split(' ');
+        var isValid = values.every(function (val) {
+          return allowedInvalidRoles.has(val) || validRoles.has(val);
+        });
+        if (isValid === true) {
+          return;
+        }
+        context.report({
+          node: attribute,
+          message: errorMessage
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/aria-unsupported-elements.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce that elements that do not support ARIA roles,
+ *  states and properties do not have those attributes.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = function errorMessage(invalidProp) {
+  return "This element does not support ARIA roles, states and properties. Try removing the prop '".concat(invalidProp, "'.");
+};
+var invalidAttributes = new Set(_ariaQuery.aria.keys().concat('role'));
+var schema = (0, _schemas.generateObjSchema)();
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-unsupported-elements.md',
+      description: 'Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var nodeType = elementType(node);
+        var nodeAttrs = _ariaQuery.dom.get(nodeType) || {};
+        var _nodeAttrs$reserved = nodeAttrs.reserved,
+          isReservedNodeType = _nodeAttrs$reserved === void 0 ? false : _nodeAttrs$reserved;
+
+        // If it's not reserved, then it can have aria-* roles, states, and properties
+        if (isReservedNodeType === false) {
+          return;
+        }
+        node.attributes.forEach(function (prop) {
+          if (prop.type === 'JSXSpreadAttribute') {
+            return;
+          }
+          var name = (0, _jsxAstUtils.propName)(prop).toLowerCase();
+          if (invalidAttributes.has(name)) {
+            context.report({
+              node,
+              message: errorMessage(name)
+            });
+          }
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/autocomplete-valid.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _axeCore = require("axe-core");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Ensure autocomplete attribute is correct.
+ * @author Wilco Fiers
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var schema = (0, _schemas.generateObjSchema)({
+  inputComponents: _schemas.arraySchema
+});
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/autocomplete-valid.md',
+      description: 'Enforce that autocomplete attributes are used correctly.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var options = context.options[0] || {};
+        var _options$inputCompone = options.inputComponents,
+          inputComponents = _options$inputCompone === void 0 ? [] : _options$inputCompone;
+        var inputTypes = ['input'].concat(inputComponents);
+        var elType = elementType(node);
+        var autocomplete = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(node.attributes, 'autocomplete'));
+        if (typeof autocomplete !== 'string' || !inputTypes.includes(elType)) {
+          return;
+        }
+        var type = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(node.attributes, 'type'));
+        var _runVirtualRule = (0, _axeCore.runVirtualRule)('autocomplete-valid', {
+            nodeName: 'input',
+            attributes: {
+              autocomplete,
+              // Which autocomplete is valid depends on the input type
+              type: type === null ? undefined : type
+            }
+          }),
+          violations = _runVirtualRule.violations;
+        if (violations.length === 0) {
+          return;
+        }
+        // Since we only test one rule, with one node, return the message from first (and only) instance of each
+        context.report({
+          node,
+          message: violations[0].nodes[0].all[0].message
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/click-events-have-key-events.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _isHiddenFromScreenReader = _interopRequireDefault(require("../util/isHiddenFromScreenReader"));
+var _isInteractiveElement = _interopRequireDefault(require("../util/isInteractiveElement"));
+var _isPresentationRole = _interopRequireDefault(require("../util/isPresentationRole"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce a clickable non-interactive element has at least 1 keyboard event listener.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'Visible, non-interactive elements with click handlers must have at least one keyboard listener.';
+var schema = (0, _schemas.generateObjSchema)();
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/click-events-have-key-events.md',
+      description: 'Enforce a clickable non-interactive element has at least one keyboard event listener.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var props = node.attributes;
+        if ((0, _jsxAstUtils.getProp)(props, 'onclick') === undefined) {
+          return;
+        }
+        var type = elementType(node);
+        var requiredProps = ['onkeydown', 'onkeyup', 'onkeypress'];
+        if (!_ariaQuery.dom.has(type)) {
+          // Do not test higher level JSX components, as we do not know what
+          // low-level DOM element this maps to.
+          return;
+        }
+        if ((0, _isHiddenFromScreenReader["default"])(type, props) || (0, _isPresentationRole["default"])(type, props)) {
+          return;
+        }
+        if ((0, _isInteractiveElement["default"])(type, props)) {
+          return;
+        }
+        if ((0, _jsxAstUtils.hasAnyProp)(props, requiredProps)) {
+          return;
+        }
+
+        // Visible, non-interactive elements with click handlers require one keyboard event listener.
+        context.report({
+          node,
+          message: errorMessage
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;