@arcaauth/eslint-plugin-jsx-a11y 6.10.2

package/lib/util/isAbstractRole.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var abstractRoles = new Set(_ariaQuery.roles.keys().filter(function (role) {
+  return _ariaQuery.roles.get(role)["abstract"];
+}));
+var DOMElements = new Set(_ariaQuery.dom.keys());
+var isAbstractRole = function isAbstractRole(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!DOMElements.has(tagName)) {
+    return false;
+  }
+  var role = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role'));
+  return abstractRoles.has(role);
+};
+var _default = exports["default"] = isAbstractRole;
+module.exports = exports.default;

package/lib/util/isContentEditable.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isContentEditable;
+var _jsxAstUtils = require("jsx-ast-utils");
+function isContentEditable(tagName, attributes) {
+  var _prop$value;
+  var prop = (0, _jsxAstUtils.getProp)(attributes, 'contentEditable');
+  return (prop === null || prop === void 0 ? void 0 : (_prop$value = prop.value) === null || _prop$value === void 0 ? void 0 : _prop$value.raw) === '"true"';
+}
+module.exports = exports.default;

package/lib/util/isDOMElement.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+/**
+ * Returns boolean indicating whether the given element is a DOM element.
+ */
+var isDOMElement = function isDOMElement(tagName) {
+  return _ariaQuery.dom.has(tagName);
+};
+var _default = exports["default"] = isDOMElement;
+module.exports = exports.default;

package/lib/util/isDisabledElement.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var isDisabledElement = function isDisabledElement(attributes) {
+  var disabledAttr = (0, _jsxAstUtils.getProp)(attributes, 'disabled');
+  var disabledAttrValue = (0, _jsxAstUtils.getPropValue)(disabledAttr);
+  var isHTML5Disabled = disabledAttr && disabledAttrValue !== undefined;
+  if (isHTML5Disabled) {
+    return true;
+  }
+  var ariaDisabledAttr = (0, _jsxAstUtils.getProp)(attributes, 'aria-disabled');
+  var ariaDisabledAttrValue = (0, _jsxAstUtils.getLiteralPropValue)(ariaDisabledAttr);
+  if (ariaDisabledAttr && ariaDisabledAttrValue !== undefined && ariaDisabledAttrValue === true) {
+    return true;
+  }
+  return false;
+};
+var _default = exports["default"] = isDisabledElement;
+module.exports = exports.default;

package/lib/util/isFocusable.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _getTabIndex = _interopRequireDefault(require("./getTabIndex"));
+var _isInteractiveElement = _interopRequireDefault(require("./isInteractiveElement"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * Returns boolean indicating whether an element appears in tab focus.
+ * Identifies an element as focusable if it is an interactive element, or an element with a tabIndex greater than or equal to 0.
+ */
+function isFocusable(type, attributes) {
+  var tabIndex = (0, _getTabIndex["default"])((0, _jsxAstUtils.getProp)(attributes, 'tabIndex'));
+  if ((0, _isInteractiveElement["default"])(type, attributes)) {
+    return tabIndex === undefined || tabIndex >= 0;
+  }
+  return tabIndex >= 0;
+}
+var _default = exports["default"] = isFocusable;
+module.exports = exports.default;

package/lib/util/isHiddenFromScreenReader.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+/**
+ * Returns boolean indicating that the aria-hidden prop
+ * is present or the value is true. Will also return true if
+ * there is an input with type='hidden'.
+ *
+ * <div aria-hidden /> is equivalent to the DOM as <div aria-hidden=true />.
+ */
+var isHiddenFromScreenReader = function isHiddenFromScreenReader(type, attributes) {
+  if (type.toUpperCase() === 'INPUT') {
+    var hidden = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'type'));
+    if (hidden && hidden.toUpperCase() === 'HIDDEN') {
+      return true;
+    }
+  }
+  var ariaHidden = (0, _jsxAstUtils.getPropValue)((0, _jsxAstUtils.getProp)(attributes, 'aria-hidden'));
+  return ariaHidden === true;
+};
+var _default = exports["default"] = isHiddenFromScreenReader;
+module.exports = exports.default;

package/lib/util/isInteractiveElement.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _axobjectQuery = require("axobject-query");
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+var _arrayPrototype = _interopRequireDefault(require("array.prototype.flatmap"));
+var _attributesComparator = _interopRequireDefault(require("./attributesComparator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var roleKeys = _ariaQuery.roles.keys();
+var elementRoleEntries = _toConsumableArray(_ariaQuery.elementRoles);
+var nonInteractiveRoles = new Set(roleKeys.filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+  return !role["abstract"]
+  // 'toolbar' does not descend from widget, but it does support
+  // aria-activedescendant, thus in practice we treat it as a widget.
+  && name !== 'toolbar' && !role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}).concat(
+// The `progressbar` is descended from `widget`, but in practice, its
+// value is always `readonly`, so we treat it as a non-interactive role.
+'progressbar'));
+var interactiveRoles = new Set(roleKeys.filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+  return !role["abstract"]
+  // The `progressbar` is descended from `widget`, but in practice, its
+  // value is always `readonly`, so we treat it as a non-interactive role.
+  && name !== 'progressbar' && role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}).concat(
+// 'toolbar' does not descend from widget, but it does support
+// aria-activedescendant, thus in practice we treat it as a widget.
+'toolbar'));
+var interactiveElementRoleSchemas = (0, _arrayPrototype["default"])(elementRoleEntries, function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+    elementSchema = _ref2[0],
+    rolesArr = _ref2[1];
+  return rolesArr.some(function (role) {
+    return interactiveRoles.has(role);
+  }) ? [elementSchema] : [];
+});
+var nonInteractiveElementRoleSchemas = (0, _arrayPrototype["default"])(elementRoleEntries, function (_ref3) {
+  var _ref4 = _slicedToArray(_ref3, 2),
+    elementSchema = _ref4[0],
+    rolesArr = _ref4[1];
+  return rolesArr.every(function (role) {
+    return nonInteractiveRoles.has(role);
+  }) ? [elementSchema] : [];
+});
+var interactiveAXObjects = new Set(_axobjectQuery.AXObjects.keys().filter(function (name) {
+  return _axobjectQuery.AXObjects.get(name).type === 'widget';
+}));
+var interactiveElementAXObjectSchemas = (0, _arrayPrototype["default"])(_toConsumableArray(_axobjectQuery.elementAXObjects), function (_ref5) {
+  var _ref6 = _slicedToArray(_ref5, 2),
+    elementSchema = _ref6[0],
+    AXObjectsArr = _ref6[1];
+  return AXObjectsArr.every(function (role) {
+    return interactiveAXObjects.has(role);
+  }) ? [elementSchema] : [];
+});
+function checkIsInteractiveElement(tagName, attributes) {
+  function elementSchemaMatcher(elementSchema) {
+    return tagName === elementSchema.name && (0, _attributesComparator["default"])(elementSchema.attributes, attributes);
+  }
+
+  // Check in elementRoles for inherent interactive role associations for
+  // this element.
+  var isInherentInteractiveElement = interactiveElementRoleSchemas.some(elementSchemaMatcher);
+  if (isInherentInteractiveElement) {
+    return true;
+  }
+  // Check in elementRoles for inherent non-interactive role associations for
+  // this element.
+  var isInherentNonInteractiveElement = nonInteractiveElementRoleSchemas.some(elementSchemaMatcher);
+  if (isInherentNonInteractiveElement) {
+    return false;
+  }
+  // Check in elementAXObjects for AX Tree associations for this element.
+  var isInteractiveAXElement = interactiveElementAXObjectSchemas.some(elementSchemaMatcher);
+  if (isInteractiveAXElement) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Returns boolean indicating whether the given element is
+ * interactive on the DOM or not. Usually used when an element
+ * has a dynamic handler on it and we need to discern whether or not
+ * it's intention is to be interacted with on the DOM.
+ */
+var isInteractiveElement = function isInteractiveElement(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!_ariaQuery.dom.has(tagName)) {
+    return false;
+  }
+  return checkIsInteractiveElement(tagName, attributes);
+};
+var _default = exports["default"] = isInteractiveElement;
+module.exports = exports.default;

package/lib/util/isInteractiveRole.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+var _arrayPrototype = _interopRequireDefault(require("array.prototype.flatmap"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+var roles = _ariaQuery.roles.keys();
+var interactiveRoles = roles.filter(function (name) {
+  return !_ariaQuery.roles.get(name)["abstract"] && _ariaQuery.roles.get(name).superClass.some(function (klasses) {
+    return (0, _arrayIncludes["default"])(klasses, 'widget');
+  });
+});
+
+// 'toolbar' does not descend from widget, but it does support
+// aria-activedescendant, thus in practice we treat it as a widget.
+interactiveRoles.push('toolbar');
+/**
+ * Returns boolean indicating whether the given element has a role
+ * that is associated with an interactive component. Used when an element
+ * has a dynamic handler on it and we need to discern whether or not
+ * its intention is to be interacted with in the DOM.
+ *
+ * isInteractiveRole is a Logical Disjunction:
+ * https://en.wikipedia.org/wiki/Logical_disjunction
+ * The JSX element does not have a tagName or it has a tagName and a role
+ * attribute with a value in the set of non-interactive roles.
+ */
+var isInteractiveRole = function isInteractiveRole(tagName, attributes) {
+  var value = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role'));
+
+  // 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 false;
+  }
+  var isInteractive = false;
+  var normalizedValues = String(value).toLowerCase().split(' ');
+  var validRoles = (0, _arrayPrototype["default"])(normalizedValues, function (name) {
+    return (0, _arrayIncludes["default"])(roles, name) ? [name] : [];
+  });
+  if (validRoles.length > 0) {
+    // The first role value is a series takes precedence.
+    isInteractive = (0, _arrayIncludes["default"])(interactiveRoles, validRoles[0]);
+  }
+  return isInteractive;
+};
+var _default = exports["default"] = isInteractiveRole;
+module.exports = exports.default;

package/lib/util/isNonInteractiveElement.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _axobjectQuery = require("axobject-query");
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+var _arrayPrototype = _interopRequireDefault(require("array.prototype.flatmap"));
+var _attributesComparator = _interopRequireDefault(require("./attributesComparator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var roleKeys = _ariaQuery.roles.keys();
+var elementRoleEntries = _toConsumableArray(_ariaQuery.elementRoles);
+var nonInteractiveRoles = new Set(roleKeys.filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+  return !role["abstract"]
+  // 'toolbar' does not descend from widget, but it does support
+  // aria-activedescendant, thus in practice we treat it as a widget.
+  && name !== 'toolbar'
+  // This role is meant to have no semantic value.
+  // @see https://www.w3.org/TR/wai-aria-1.2/#generic
+  && name !== 'generic' && !role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}).concat(
+// The `progressbar` is descended from `widget`, but in practice, its
+// value is always `readonly`, so we treat it as a non-interactive role.
+'progressbar'));
+var interactiveRoles = new Set(roleKeys.filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+  return !role["abstract"]
+  // The `progressbar` is descended from `widget`, but in practice, its
+  // value is always `readonly`, so we treat it as a non-interactive role.
+  && name !== 'progressbar'
+  // This role is meant to have no semantic value.
+  // @see https://www.w3.org/TR/wai-aria-1.2/#generic
+  && name !== 'generic' && role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}).concat(
+// 'toolbar' does not descend from widget, but it does support
+// aria-activedescendant, thus in practice we treat it as a widget.
+'toolbar'));
+var interactiveElementRoleSchemas = (0, _arrayPrototype["default"])(elementRoleEntries, function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+    elementSchema = _ref2[0],
+    rolesArr = _ref2[1];
+  return rolesArr.some(function (role) {
+    return interactiveRoles.has(role);
+  }) ? [elementSchema] : [];
+});
+var nonInteractiveElementRoleSchemas = (0, _arrayPrototype["default"])(elementRoleEntries, function (_ref3) {
+  var _ref4 = _slicedToArray(_ref3, 2),
+    elementSchema = _ref4[0],
+    rolesArr = _ref4[1];
+  return rolesArr.every(function (role) {
+    return nonInteractiveRoles.has(role);
+  }) ? [elementSchema] : [];
+});
+var nonInteractiveAXObjects = new Set(_axobjectQuery.AXObjects.keys().filter(function (name) {
+  return (0, _arrayIncludes["default"])(['window', 'structure'], _axobjectQuery.AXObjects.get(name).type);
+}));
+var nonInteractiveElementAXObjectSchemas = (0, _arrayPrototype["default"])(_toConsumableArray(_axobjectQuery.elementAXObjects), function (_ref5) {
+  var _ref6 = _slicedToArray(_ref5, 2),
+    elementSchema = _ref6[0],
+    AXObjectsArr = _ref6[1];
+  return AXObjectsArr.every(function (role) {
+    return nonInteractiveAXObjects.has(role);
+  }) ? [elementSchema] : [];
+});
+function checkIsNonInteractiveElement(tagName, attributes) {
+  function elementSchemaMatcher(elementSchema) {
+    return tagName === elementSchema.name && tagName !== 'td' // TODO: investigate why this is needed
+    && (0, _attributesComparator["default"])(elementSchema.attributes, attributes);
+  }
+  // Check in elementRoles for inherent non-interactive role associations for
+  // this element.
+  var isInherentNonInteractiveElement = nonInteractiveElementRoleSchemas.some(elementSchemaMatcher);
+  if (isInherentNonInteractiveElement) {
+    return true;
+  }
+  // Check in elementRoles for inherent interactive role associations for
+  // this element.
+  var isInherentInteractiveElement = interactiveElementRoleSchemas.some(elementSchemaMatcher);
+  if (isInherentInteractiveElement) {
+    return false;
+  }
+  // Check in elementAXObjects for AX Tree associations for this element.
+  var isNonInteractiveAXElement = nonInteractiveElementAXObjectSchemas.some(elementSchemaMatcher);
+  if (isNonInteractiveAXElement) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Returns boolean indicating whether the given element is a non-interactive
+ * element. If the element has either a non-interactive role assigned or it
+ * is an element with an inherently non-interactive role, then this utility
+ * returns true. Elements that lack either an explicitly assigned role or
+ * an inherent role are not considered. For those, this utility returns false
+ * because a positive determination of interactiveness cannot be determined.
+ */
+var isNonInteractiveElement = function isNonInteractiveElement(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!_ariaQuery.dom.has(tagName)) {
+    return false;
+  }
+  // <header> elements do not technically have semantics, unless the
+  // element is a direct descendant of <body>, and this plugin cannot
+  // reliably test that.
+  // @see https://www.w3.org/TR/wai-aria-practices/examples/landmarks/banner.html
+  if (tagName === 'header') {
+    return false;
+  }
+  return checkIsNonInteractiveElement(tagName, attributes);
+};
+var _default = exports["default"] = isNonInteractiveElement;
+module.exports = exports.default;

package/lib/util/isNonInteractiveRole.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ariaQuery = require("aria-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+var _arrayPrototype = _interopRequireDefault(require("array.prototype.flatmap"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+var nonInteractiveRoles = _ariaQuery.roles.keys().filter(function (name) {
+  return !_ariaQuery.roles.get(name)["abstract"] && !_ariaQuery.roles.get(name).superClass.some(function (klasses) {
+    return (0, _arrayIncludes["default"])(klasses, 'widget');
+  });
+});
+
+/**
+ * Returns boolean indicating whether the given element has a role
+ * that is associated with a non-interactive component. Non-interactive roles
+ * include `listitem`, `article`, or `dialog`. These are roles that indicate
+ * for the most part containers.
+ *
+ * Elements with these roles should not respond or handle user interactions.
+ * For example, an `onClick` handler should not be assigned to an element with
+ * the role `listitem`. An element inside the `listitem`, like a button or a
+ * link, should handle the click.
+ *
+ * This utility returns true for elements that are assigned a non-interactive
+ * role. It will return false for elements that do not have a role. So whereas
+ * a `div` might be considered non-interactive, for the purpose of this utility,
+ * it is considered neither interactive nor non-interactive -- a determination
+ * cannot be made in this case and false is returned.
+ */
+
+var isNonInteractiveRole = function isNonInteractiveRole(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!_ariaQuery.dom.has(tagName)) {
+    return false;
+  }
+  var role = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role'));
+  var isNonInteractive = false;
+  var normalizedValues = String(role).toLowerCase().split(' ');
+  var validRoles = (0, _arrayPrototype["default"])(normalizedValues, function (name) {
+    return _ariaQuery.roles.has(name) ? [name] : [];
+  });
+  if (validRoles.length > 0) {
+    // The first role value is a series takes precedence.
+    isNonInteractive = (0, _arrayIncludes["default"])(nonInteractiveRoles, validRoles[0]);
+  }
+  return isNonInteractive;
+};
+var _default = exports["default"] = isNonInteractiveRole;
+module.exports = exports.default;

package/lib/util/isNonLiteralProperty.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+/**
+ * Returns boolean indicating whether the given element has been specified with
+ * an AST node with a non-literal type.
+ *
+ * Returns true if the elements has a role and its value is not of a type Literal.
+ * Otherwise returns false.
+ */
+var isNonLiteralProperty = function isNonLiteralProperty(attributes, propName) {
+  var prop = (0, _jsxAstUtils.getProp)(attributes, propName);
+  if (!prop) return false;
+  var propValue = prop.value;
+  if (!propValue) return false;
+  if (propValue.type === 'Literal') return false;
+  if (propValue.type === 'JSXExpressionContainer') {
+    var expression = propValue.expression;
+    if (expression.type === 'Identifier' && expression.name === 'undefined') return false;
+    if (expression.type === 'JSXText') return false;
+  }
+  return true;
+};
+var _default = exports["default"] = isNonLiteralProperty;
+module.exports = exports.default;

package/lib/util/isPresentationRole.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _jsxAstUtils = require("jsx-ast-utils");
+var presentationRoles = new Set(['presentation', 'none']);
+var isPresentationRole = function isPresentationRole(tagName, attributes) {
+  return presentationRoles.has((0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role')));
+};
+var _default = exports["default"] = isPresentationRole;
+module.exports = exports.default;

package/lib/util/isSemanticRoleElement.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _axobjectQuery = require("axobject-query");
+var _jsxAstUtils = require("jsx-ast-utils");
+var isSemanticRoleElement = function isSemanticRoleElement(elementType, attributes) {
+  var roleAttr = (0, _jsxAstUtils.getProp)(attributes, 'role');
+  var res = false;
+  var roleAttrValue = (0, _jsxAstUtils.getLiteralPropValue)(roleAttr);
+  _axobjectQuery.elementAXObjects.forEach(function (axObjects, concept) {
+    if (res) {
+      return;
+    }
+    if (concept.name === elementType && (concept.attributes || []).every(function (cAttr) {
+      return attributes.some(function (attr) {
+        if (!attr.type || attr.type !== 'JSXAttribute') {
+          return false;
+        }
+        var namesMatch = cAttr.name === (0, _jsxAstUtils.propName)(attr);
+        var valuesMatch;
+        if (cAttr.value !== undefined) {
+          valuesMatch = cAttr.value === (0, _jsxAstUtils.getLiteralPropValue)(attr);
+        }
+        if (!namesMatch) {
+          return false;
+        }
+        return namesMatch && valuesMatch !== undefined ? valuesMatch : true;
+      });
+    })) {
+      axObjects.forEach(function (name) {
+        if (res) {
+          return;
+        }
+        var roles = _axobjectQuery.AXObjectRoles.get(name);
+        if (roles) {
+          roles.forEach(function (role) {
+            if (res === true) {
+              return;
+            }
+            if (role.name === roleAttrValue) {
+              res = true;
+            }
+          });
+        }
+      });
+    }
+  });
+  return res;
+};
+var _default = exports["default"] = isSemanticRoleElement;
+module.exports = exports.default;

package/lib/util/mayContainChildComponent.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = mayContainChildComponent;
+var _jsxAstUtils = require("jsx-ast-utils");
+var _minimatch = _interopRequireDefault(require("minimatch"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+/**
+ * Returns true if it can positively determine that the element lacks an
+ * accessible label. If no determination is possible, it returns false. Treat
+ * false as an unknown value. The element might still have an accessible label,
+ * but this module cannot determine it positively.
+ *
+ * 
+ */
+
+function mayContainChildComponent(root, componentName) {
+  var maxDepth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var elementType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _jsxAstUtils.elementType;
+  function traverseChildren(node, depth) {
+    // Bail when maxDepth is exceeded.
+    if (depth > maxDepth) {
+      return false;
+    }
+    if (node.children) {
+      /* $FlowFixMe */
+      for (var i = 0; i < node.children.length; i += 1) {
+        /* $FlowFixMe */
+        var childNode = node.children[i];
+        // Assume an expression container renders a label. It is the best we can
+        // do in this case.
+        if (childNode.type === 'JSXExpressionContainer') {
+          return true;
+        }
+        // Check for components with the provided name.
+        if (childNode.type === 'JSXElement' && childNode.openingElement && (0, _minimatch["default"])(elementType(childNode.openingElement), componentName)) {
+          return true;
+        }
+        if (traverseChildren(childNode, depth + 1)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  return traverseChildren(root, 1);
+}
+module.exports = exports.default;