@arcaauth/eslint-plugin-jsx-a11y 6.10.2

package/lib/rules/label-has-for.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+var _hasAccessibleChild = _interopRequireDefault(require("../util/hasAccessibleChild"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce label tags have htmlFor attribute.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var enumValues = ['nesting', 'id'];
+var schema = {
+  type: 'object',
+  properties: {
+    components: _schemas.arraySchema,
+    required: {
+      oneOf: [{
+        type: 'string',
+        "enum": enumValues
+      }, (0, _schemas.generateObjSchema)({
+        some: (0, _schemas.enumArraySchema)(enumValues)
+      }, ['some']), (0, _schemas.generateObjSchema)({
+        every: (0, _schemas.enumArraySchema)(enumValues)
+      }, ['every'])]
+    },
+    allowChildren: {
+      type: 'boolean'
+    }
+  }
+};
+// Breadth-first search, assuming that HTML for forms is shallow.
+function validateNesting(node) {
+  var queue = node.parent.children.slice();
+  var child;
+  var opener;
+  while (queue.length) {
+    child = queue.shift();
+    opener = child.openingElement;
+    if (child.type === 'JSXElement' && opener && (opener.name.name === 'input' || opener.name.name === 'textarea' || opener.name.name === 'select')) {
+      return true;
+    }
+    if (child.children) {
+      queue = queue.concat(child.children);
+    }
+  }
+  return false;
+}
+function validateID(_ref, context) {
+  var _settings$jsxA11y$at, _settings$jsxA11y, _settings$jsxA11y$att;
+  var attributes = _ref.attributes;
+  var settings = context.settings;
+  var htmlForAttributes = (_settings$jsxA11y$at = (_settings$jsxA11y = settings['jsx-a11y']) === null || _settings$jsxA11y === void 0 ? void 0 : (_settings$jsxA11y$att = _settings$jsxA11y.attributes) === null || _settings$jsxA11y$att === void 0 ? void 0 : _settings$jsxA11y$att["for"]) !== null && _settings$jsxA11y$at !== void 0 ? _settings$jsxA11y$at : ['htmlFor'];
+  for (var i = 0; i < htmlForAttributes.length; i += 1) {
+    var attribute = htmlForAttributes[i];
+    if ((0, _jsxAstUtils.hasProp)(attributes, attribute)) {
+      var htmlForAttr = (0, _jsxAstUtils.getProp)(attributes, attribute);
+      var htmlForValue = (0, _jsxAstUtils.getPropValue)(htmlForAttr);
+      return htmlForAttr !== false && !!htmlForValue;
+    }
+  }
+  return false;
+}
+function validate(node, required, allowChildren, elementType, context) {
+  if (allowChildren === true) {
+    return (0, _hasAccessibleChild["default"])(node.parent, elementType);
+  }
+  if (required === 'nesting') {
+    return validateNesting(node);
+  }
+  return validateID(node, context);
+}
+function getValidityStatus(node, required, allowChildren, elementType, context) {
+  if (Array.isArray(required.some)) {
+    var _isValid = required.some.some(function (rule) {
+      return validate(node, rule, allowChildren, elementType, context);
+    });
+    var _message = !_isValid ? "Form label must have ANY of the following types of associated control: ".concat(required.some.join(', ')) : null;
+    return {
+      isValid: _isValid,
+      message: _message
+    };
+  }
+  if (Array.isArray(required.every)) {
+    var _isValid2 = required.every.every(function (rule) {
+      return validate(node, rule, allowChildren, elementType, context);
+    });
+    var _message2 = !_isValid2 ? "Form label must have ALL of the following types of associated control: ".concat(required.every.join(', ')) : null;
+    return {
+      isValid: _isValid2,
+      message: _message2
+    };
+  }
+  var isValid = validate(node, required, allowChildren, elementType, context);
+  var message = !isValid ? "Form label must have the following type of associated control: ".concat(required) : null;
+  return {
+    isValid,
+    message
+  };
+}
+var _default = exports["default"] = {
+  meta: {
+    deprecated: true,
+    replacedBy: ['label-has-associated-control'],
+    docs: {
+      description: 'Enforce that `<label>` elements have the `htmlFor` prop.',
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/label-has-for.md'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement(node) {
+        var options = context.options[0] || {};
+        var componentOptions = options.components || [];
+        var typesToValidate = ['label'].concat(componentOptions);
+        var nodeType = elementType(node);
+
+        // Only check 'label' elements and custom types.
+        if (typesToValidate.indexOf(nodeType) === -1) {
+          return;
+        }
+        var required = options.required || {
+          every: ['nesting', 'id']
+        };
+        var allowChildren = options.allowChildren || false;
+        var _getValidityStatus = getValidityStatus(node, required, allowChildren, elementType, context),
+          isValid = _getValidityStatus.isValid,
+          message = _getValidityStatus.message;
+        if (!isValid) {
+          context.report({
+            node,
+            message
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/lang.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _languageTags = _interopRequireDefault(require("language-tags"));
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce lang attribute has a valid value.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'lang attribute must have a valid value.';
+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/lang.md',
+      description: 'Enforce lang attribute has a valid value.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXAttribute: function JSXAttribute(node) {
+        var name = (0, _jsxAstUtils.propName)(node);
+        if (name && name.toUpperCase() !== 'LANG') {
+          return;
+        }
+        var parent = node.parent;
+        var type = elementType(parent);
+        if (type && type !== 'html') {
+          return;
+        }
+        var value = (0, _jsxAstUtils.getLiteralPropValue)(node);
+
+        // Don't check identifiers
+        if (value === null) {
+          return;
+        }
+        if (value === undefined) {
+          context.report({
+            node,
+            message: errorMessage
+          });
+          return;
+        }
+        if (_languageTags["default"].check(value)) {
+          return;
+        }
+        context.report({
+          node,
+          message: errorMessage
+        });
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/media-has-caption.js

@@ -0,0 +1,96 @@
+"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"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview <audio> and <video> elements must have a <track> for captions.
+ * @author Ethan Cohen
+ * 
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'Media elements such as <audio> and <video> must have a <track> for captions.';
+var MEDIA_TYPES = ['audio', 'video'];
+var schema = (0, _schemas.generateObjSchema)({
+  audio: _schemas.arraySchema,
+  video: _schemas.arraySchema,
+  track: _schemas.arraySchema
+});
+var isMediaType = function isMediaType(context, type) {
+  var options = context.options[0] || {};
+  return MEDIA_TYPES.concat((0, _arrayPrototype["default"])(MEDIA_TYPES, function (mediaType) {
+    return options[mediaType];
+  })).some(function (typeToCheck) {
+    return typeToCheck === type;
+  });
+};
+var isTrackType = function isTrackType(context, type) {
+  var options = context.options[0] || {};
+  return ['track'].concat(options.track || []).some(function (typeToCheck) {
+    return typeToCheck === type;
+  });
+};
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/media-has-caption.md',
+      description: 'Enforces that `<audio>` and `<video>` elements must have a `<track>` for captions.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXElement: function JSXElement(node) {
+        var element = node.openingElement;
+        var type = elementType(element);
+        if (!isMediaType(context, type)) {
+          return;
+        }
+        var mutedProp = (0, _jsxAstUtils.getProp)(element.attributes, 'muted');
+        var mutedPropVal = (0, _jsxAstUtils.getLiteralPropValue)(mutedProp);
+        if (mutedPropVal === true) {
+          return;
+        }
+        // $FlowFixMe https://github.com/facebook/flow/issues/1414
+        var trackChildren = node.children.filter(function (child) {
+          if (child.type !== 'JSXElement') {
+            return false;
+          }
+
+          // $FlowFixMe https://github.com/facebook/flow/issues/1414
+          return isTrackType(context, elementType(child.openingElement));
+        });
+        if (trackChildren.length === 0) {
+          context.report({
+            node: element,
+            message: errorMessage
+          });
+          return;
+        }
+        var hasCaption = trackChildren.some(function (track) {
+          var kindProp = (0, _jsxAstUtils.getProp)(track.openingElement.attributes, 'kind');
+          var kindPropValue = (0, _jsxAstUtils.getLiteralPropValue)(kindProp) || '';
+          return kindPropValue.toLowerCase() === 'captions';
+        });
+        if (!hasCaption) {
+          context.report({
+            node: element,
+            message: errorMessage
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

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

@@ -0,0 +1,94 @@
+"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");
+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); } /**
+ * @fileoverview Enforce onmouseover/onmouseout are
+ *  accompanied by onfocus/onblur.
+ * @author Ethan Cohen
+ * 
+ */ // ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+var schema = (0, _schemas.generateObjSchema)({
+  hoverInHandlers: _objectSpread(_objectSpread({}, _schemas.arraySchema), {}, {
+    description: 'An array of events that need to be accompanied by `onFocus`'
+  }),
+  hoverOutHandlers: _objectSpread(_objectSpread({}, _schemas.arraySchema), {}, {
+    description: 'An array of events that need to be accompanied by `onBlur`'
+  })
+});
+
+// Use `onMouseOver` and `onMouseOut` by default if no config is
+// passed in for backwards compatibility
+var DEFAULT_HOVER_IN_HANDLERS = ['onMouseOver'];
+var DEFAULT_HOVER_OUT_HANDLERS = ['onMouseOut'];
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/mouse-events-have-key-events.md',
+      description: 'Enforce that `onMouseOver`/`onMouseOut` are accompanied by `onFocus`/`onBlur` for keyboard-only users.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var _options$0$hoverInHan, _options$, _options$0$hoverOutHa, _options$2;
+        var name = node.name.name;
+        if (!_ariaQuery.dom.get(name)) {
+          return;
+        }
+        var options = context.options;
+        var hoverInHandlers = (_options$0$hoverInHan = (_options$ = options[0]) === null || _options$ === void 0 ? void 0 : _options$.hoverInHandlers) !== null && _options$0$hoverInHan !== void 0 ? _options$0$hoverInHan : DEFAULT_HOVER_IN_HANDLERS;
+        var hoverOutHandlers = (_options$0$hoverOutHa = (_options$2 = options[0]) === null || _options$2 === void 0 ? void 0 : _options$2.hoverOutHandlers) !== null && _options$0$hoverOutHa !== void 0 ? _options$0$hoverOutHa : DEFAULT_HOVER_OUT_HANDLERS;
+        var attributes = node.attributes;
+
+        // Check hover in / onfocus pairing
+        var firstHoverInHandlerWithValue = hoverInHandlers.find(function (handler) {
+          var prop = (0, _jsxAstUtils.getProp)(attributes, handler);
+          var propValue = (0, _jsxAstUtils.getPropValue)(prop);
+          return propValue != null;
+        });
+        if (firstHoverInHandlerWithValue != null) {
+          var hasOnFocus = (0, _jsxAstUtils.getProp)(attributes, 'onFocus');
+          var onFocusValue = (0, _jsxAstUtils.getPropValue)(hasOnFocus);
+          if (hasOnFocus === false || onFocusValue === null || onFocusValue === undefined) {
+            context.report({
+              node: (0, _jsxAstUtils.getProp)(attributes, firstHoverInHandlerWithValue),
+              message: "".concat(firstHoverInHandlerWithValue, " must be accompanied by onFocus for accessibility.")
+            });
+          }
+        }
+
+        // Check hover out / onblur pairing
+        var firstHoverOutHandlerWithValue = hoverOutHandlers.find(function (handler) {
+          var prop = (0, _jsxAstUtils.getProp)(attributes, handler);
+          var propValue = (0, _jsxAstUtils.getPropValue)(prop);
+          return propValue != null;
+        });
+        if (firstHoverOutHandlerWithValue != null) {
+          var hasOnBlur = (0, _jsxAstUtils.getProp)(attributes, 'onBlur');
+          var onBlurValue = (0, _jsxAstUtils.getPropValue)(hasOnBlur);
+          if (hasOnBlur === false || onBlurValue === null || onBlurValue === undefined) {
+            context.report({
+              node: (0, _jsxAstUtils.getProp)(attributes, firstHoverOutHandlerWithValue),
+              message: "".concat(firstHoverOutHandlerWithValue, " must be accompanied by onBlur for accessibility.")
+            });
+          }
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/no-access-key.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _schemas = require("../util/schemas");
+/**
+ * @fileoverview Enforce no accesskey attribute on element.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'No access key attribute allowed. Inconsistencies between keyboard shortcuts and keyboard commands used by screen readers and keyboard-only users create a11y complications.';
+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/no-access-key.md',
+      description: 'Enforce that the `accessKey` prop is not used on any element to avoid complications with keyboard commands used by a screen reader.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var accessKey = (0, _jsxAstUtils.getProp)(node.attributes, 'accesskey');
+        var accessKeyValue = (0, _jsxAstUtils.getPropValue)(accessKey);
+        if (accessKey && accessKeyValue) {
+          context.report({
+            node,
+            message: errorMessage
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/no-aria-hidden-on-focusable.js

@@ -0,0 +1,47 @@
+"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 _isFocusable = _interopRequireDefault(require("../util/isFocusable"));
+var _schemas = require("../util/schemas");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce aria-hidden is not used on interactive elements or contain interactive elements.
+ * @author Kate Higa
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+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/no-aria-hidden-on-focusable.md',
+      description: 'Disallow `aria-hidden="true"` from being set on focusable elements.'
+    },
+    schema: [schema]
+  },
+  create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement(node) {
+        var attributes = node.attributes;
+        var type = elementType(node);
+        var isAriaHidden = (0, _jsxAstUtils.getPropValue)((0, _jsxAstUtils.getProp)(attributes, 'aria-hidden')) === true;
+        if (isAriaHidden && (0, _isFocusable["default"])(type, attributes)) {
+          context.report({
+            node,
+            message: 'aria-hidden="true" must not be set on focusable elements.'
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/no-autofocus.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _ariaQuery = require("aria-query");
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce autoFocus prop is not used.
+ * @author Ethan Cohen <@evcohen>
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = 'The autoFocus prop should not be used, as it can reduce usability and accessibility for users.';
+var schema = (0, _schemas.generateObjSchema)({
+  ignoreNonDOM: {
+    type: 'boolean',
+    "default": false
+  }
+});
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-autofocus.md',
+      description: 'Enforce autoFocus prop is not used.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXAttribute: function JSXAttribute(attribute) {
+        // Determine if ignoreNonDOM is set to true
+        // If true, then do not run rule.
+        var options = context.options[0] || {};
+        var ignoreNonDOM = !!options.ignoreNonDOM;
+        if (ignoreNonDOM) {
+          var type = elementType(attribute.parent);
+          if (!_ariaQuery.dom.get(type)) {
+            return;
+          }
+        }
+
+        // Don't normalize, since React only recognizes autoFocus on low-level DOM elements.
+        if ((0, _jsxAstUtils.propName)(attribute) === 'autoFocus') {
+          context.report({
+            node: attribute,
+            message: errorMessage
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;

package/lib/rules/no-distracting-elements.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _schemas = require("../util/schemas");
+var _getElementType = _interopRequireDefault(require("../util/getElementType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * @fileoverview Enforce distracting elements are not used.
+ * @author Ethan Cohen
+ */
+
+// ----------------------------------------------------------------------------
+// Rule Definition
+// ----------------------------------------------------------------------------
+
+var errorMessage = function errorMessage(element) {
+  return "Do not use <".concat(element, "> elements as they can create visual accessibility issues and are deprecated.");
+};
+var DEFAULT_ELEMENTS = ['marquee', 'blink'];
+var schema = (0, _schemas.generateObjSchema)({
+  elements: (0, _schemas.enumArraySchema)(DEFAULT_ELEMENTS)
+});
+var _default = exports["default"] = {
+  meta: {
+    docs: {
+      url: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-distracting-elements.md',
+      description: 'Enforce distracting elements are not used.'
+    },
+    schema: [schema]
+  },
+  create: function create(context) {
+    var elementType = (0, _getElementType["default"])(context);
+    return {
+      JSXOpeningElement: function JSXOpeningElement(node) {
+        var options = context.options[0] || {};
+        var elementOptions = options.elements || DEFAULT_ELEMENTS;
+        var type = elementType(node);
+        var distractingElement = elementOptions.find(function (element) {
+          return type === element;
+        });
+        if (distractingElement) {
+          context.report({
+            node,
+            message: errorMessage(distractingElement)
+          });
+        }
+      }
+    };
+  }
+};
+module.exports = exports.default;