feat: deprecate and replace dom.isVisible, utils.isHidden, and dom.isHiddenWithCss

lib/checks/aria/aria-allowed-role-evaluate.js

@@ -1,4 +1,4 @@
-import { isVisible } from '../../commons/dom';
+import { isVisibleForScreenreader } from '../../commons/dom';
 import { getElementUnallowedRoles } from '../../commons/aria';
 
 /**
@@ -29,7 +29,7 @@ function ariaAllowedRoleEvaluate(node, options = {}, virtualNode) {
   const unallowedRoles = getElementUnallowedRoles(virtualNode, allowImplicit);
   if (unallowedRoles.length) {
     this.data(unallowedRoles);
-    if (!isVisible(virtualNode, true)) {
+    if (!isVisibleForScreenreader(virtualNode)) {
       // flag hidden elements for review
       return undefined;
     }

lib/checks/aria/aria-errormessage-evaluate.js

@@ -1,7 +1,7 @@
 import standards from '../../standards';
 import { idrefs } from '../../commons/dom';
 import { tokenList } from '../../core/utils';
-import { isVisible } from '../../commons/dom';
+import { isVisibleForScreenreader } from '../../commons/dom';
 /**
  * Check if `aria-errormessage` references an element that also uses a technique to announce the message (aria-live, aria-describedby, etc.).
  *
@@ -55,7 +55,7 @@ function ariaErrormessageEvaluate(node, options, virtualNode) {
     }
 
     if (idref) {
-      if (!isVisible(idref, true)) {
+      if (!isVisibleForScreenreader(idref)) {
         this.data({
           messageKey: 'hidden',
           values: tokenList(attr)

lib/checks/color/color-contrast-evaluate.js

@@ -1,4 +1,4 @@
-import { isVisible } from '../../commons/dom';
+import { isVisibleOnScreen } from '../../commons/dom';
 import {
   visibleVirtual,
   hasUnicode,
@@ -29,7 +29,7 @@ export default function colorContrastEvaluate(node, options, virtualNode) {
     pseudoSizeThreshold
   } = options;
 
-  if (!isVisible(node, false)) {
+  if (!isVisibleOnScreen(node)) {
     this.data({ messageKey: 'hidden' });
     return true;
   }

lib/checks/generic/has-descendant-evaluate.js

@@ -1,5 +1,5 @@
 import { querySelectorAllFilter } from '../../core/utils';
-import { isVisible, isModalOpen } from '../../commons/dom';
+import { isVisibleForScreenreader, isModalOpen } from '../../commons/dom';
 
 function hasDescendant(node, options, virtualNode) {
   if (!options || !options.selector || typeof options.selector !== 'string') {
@@ -15,7 +15,7 @@ function hasDescendant(node, options, virtualNode) {
   const matchingElms = querySelectorAllFilter(
     virtualNode,
     options.selector,
-    vNode => isVisible(vNode.actualNode, true)
+    vNode => isVisibleForScreenreader(vNode)
   );
   this.relatedNodes(matchingElms.map(vNode => vNode.actualNode));
   return matchingElms.length > 0;

lib/checks/generic/page-no-duplicate-evaluate.js

@@ -1,6 +1,6 @@
 import cache from '../../core/base/cache';
 import { querySelectorAllFilter } from '../../core/utils';
-import { isVisible, findUpVirtual } from '../../commons/dom';
+import { isVisibleForScreenreader, findUpVirtual } from '../../commons/dom';
 
 function pageNoDuplicateEvaluate(node, options, virtualNode) {
   if (!options || !options.selector || typeof options.selector !== 'string') {
@@ -18,7 +18,7 @@ function pageNoDuplicateEvaluate(node, options, virtualNode) {
   cache.set(key, true);
 
   let elms = querySelectorAllFilter(axe._tree[0], options.selector, elm =>
-    isVisible(elm.actualNode, true)
+    isVisibleForScreenreader(elm)
   );
 
   // Filter elements that, within certain contexts, don't map their role.

lib/checks/keyboard/accesskeys-evaluate.js

@@ -1,7 +1,7 @@
-import { isVisible } from '../../commons/dom';
+import { isVisibleOnScreen } from '../../commons/dom';
 
 function accesskeysEvaluate(node) {
-  if (isVisible(node, false)) {
+  if (isVisibleOnScreen(node)) {
     this.data(node.getAttribute('accesskey'));
     this.relatedNodes([node]);
   }

lib/checks/label/explicit-evaluate.js

@@ -1,4 +1,4 @@
-import { getRootNode, isVisible } from '../../commons/dom';
+import { getRootNode, isVisibleOnScreen } from '../../commons/dom';
 import { accessibleText } from '../../commons/text';
 import { escapeSelector } from '../../core/utils';
 
@@ -16,7 +16,7 @@ function explicitEvaluate(node, options, virtualNode) {
       try {
         return labels.some(label => {
           // defer to hidden-explicit-label check for better messaging
-          if (!isVisible(label)) {
+          if (!isVisibleOnScreen(label)) {
             return true;
           } else {
             return !!accessibleText(label);

lib/checks/label/hidden-explicit-label-evaluate.js

@@ -1,4 +1,4 @@
-import { getRootNode, isVisible } from '../../commons/dom';
+import { getRootNode, isVisibleForScreenreader } from '../../commons/dom';
 import { accessibleTextVirtual } from '../../commons/text';
 import { escapeSelector } from '../../core/utils';
 
@@ -12,7 +12,7 @@ function hiddenExplicitLabelEvaluate(node, options, virtualNode) {
     const id = escapeSelector(node.getAttribute('id'));
     const label = root.querySelector(`label[for="${id}"]`);
 
-    if (label && !isVisible(label, true)) {
+    if (label && !isVisibleForScreenreader(label)) {
       let name;
       try {
         name = accessibleTextVirtual(virtualNode).trim();

lib/checks/label/multiple-label-evaluate.js

@@ -1,4 +1,4 @@
-import { getRootNode, isVisible, idrefs } from '../../commons/dom';
+import { getRootNode, isVisibleOnScreen, isVisibleForScreenreader, idrefs } from '../../commons/dom';
 import { escapeSelector } from '../../core/utils';
 
 function multipleLabelEvaluate(node) {
@@ -10,7 +10,7 @@ function multipleLabelEvaluate(node) {
 
   if (labels.length) {
     // filter out CSS hidden labels because they're fine
-    labels = labels.filter(label => isVisible(label));
+    labels = labels.filter(label => isVisibleOnScreen(label));
   }
 
   while (parent) {
@@ -27,7 +27,7 @@ function multipleLabelEvaluate(node) {
 
   // more than 1 CSS visible label
   if (labels.length > 1) {
-    const ATVisibleLabels = labels.filter(label => isVisible(label, true));
+    const ATVisibleLabels = labels.filter(label => isVisibleForScreenreader(label));
     // more than 1 AT visible label will fail IOS/Safari/VO even with aria-labelledby
     if (ATVisibleLabels.length > 1) {
       return undefined;

lib/checks/lists/only-dlitems-evaluate.js

@@ -1,4 +1,4 @@
-import { isVisible } from '../../commons/dom';
+import { isVisibleForScreenreader } from '../../commons/dom';
 import { getRole, getExplicitRole } from '../../commons/aria';
 
 function onlyDlitemsEvaluate(node, options, virtualNode) {
@@ -23,7 +23,7 @@ function onlyDlitemsEvaluate(node, options, virtualNode) {
     const { actualNode } = childNode;
     const tagName = actualNode.nodeName.toUpperCase();
 
-    if (actualNode.nodeType === 1 && isVisible(actualNode, true, false)) {
+    if (actualNode.nodeType === 1 && isVisibleForScreenreader(actualNode)) {
       const explicitRole = getExplicitRole(actualNode);
 
       if ((tagName !== 'DT' && tagName !== 'DD') || explicitRole) {

lib/checks/lists/only-listitems-evaluate.js

@@ -1,4 +1,4 @@
-import { isVisible } from '../../commons/dom';
+import { isVisibleForScreenreader } from '../../commons/dom';
 import { getRole } from '../../commons/aria';
 
 function onlyListitemsEvaluate(node, options, virtualNode) {
@@ -17,7 +17,7 @@ function onlyListitemsEvaluate(node, options, virtualNode) {
       return;
     }
 
-    if (actualNode.nodeType !== 1 || !isVisible(actualNode, true, false)) {
+    if (actualNode.nodeType !== 1 || !isVisibleForScreenreader(actualNode)) {
       return;
     }
 

lib/checks/navigation/heading-order-evaluate.js

@@ -1,6 +1,6 @@
 import cache from '../../core/base/cache';
 import { querySelectorAllFilter, getAncestry } from '../../core/utils';
-import { isVisible } from '../../commons/dom';
+import { isVisibleForScreenreader } from '../../commons/dom';
 import { getRole } from '../../commons/aria';
 
 function getLevel(vNode) {
@@ -55,7 +55,7 @@ function headingOrderEvaluate() {
   const selector = 'h1, h2, h3, h4, h5, h6, [role=heading], iframe, frame';
   // TODO: es-modules_tree
   const vNodes = querySelectorAllFilter(axe._tree[0], selector, vNode =>
-    isVisible(vNode.actualNode, true)
+    isVisibleForScreenreader(vNode.actualNode)
   );
 
   headingOrder = vNodes.map(vNode => {

lib/checks/navigation/region-evaluate.js

@@ -46,7 +46,7 @@ function findRegionlessElms(virtualNode, options) {
     ['iframe', 'frame'].includes(virtualNode.props.nodeName) ||
     (dom.isSkipLink(virtualNode.actualNode) &&
       dom.getElementByReference(virtualNode.actualNode, 'href')) ||
-    !dom.isVisible(node, true)
+    !dom.isVisibleForScreenreader(node)
   ) {
     // Mark each parent node as having region descendant
     let vNode = virtualNode;

lib/checks/navigation/skip-link-evaluate.js

@@ -1,9 +1,9 @@
-import { getElementByReference, isVisible } from '../../commons/dom';
+import { getElementByReference, isVisibleForScreenreader } from '../../commons/dom';
 
 function skipLinkEvaluate(node) {
   const target = getElementByReference(node, 'href');
   if (target) {
-    return isVisible(target, true) || undefined;
+    return isVisibleForScreenreader(target) || undefined;
   }
   return false;
 }

lib/checks/shared/is-on-screen-evaluate.js

@@ -1,8 +1,8 @@
-import { isVisible, isOffscreen } from '../../commons/dom';
+import { isVisibleOnScreen, isOffscreen } from '../../commons/dom';
 
 function isOnScreenEvaluate(node) {
   // From a visual perspective
-  return isVisible(node, false) && !isOffscreen(node);
+  return isVisibleOnScreen(node) && !isOffscreen(node);
 }
 
 export default isOnScreenEvaluate;

lib/commons/dom/focus-disabled.js

@@ -1,6 +1,6 @@
 import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-node';
 import { getNodeFromTree } from '../../core/utils';
-import isHiddenWithCSS from './is-hidden-with-css';
+import isHiddenForEveryone from './is-hidden-for-everyone';
 // Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/disabled 
 const allowedDisabledNodeNames = [
   'button', 
@@ -74,7 +74,7 @@ function focusDisabled(el) {
     if (!vNode.actualNode) {
       return false;
     }
-    return isHiddenWithCSS(vNode.actualNode);
+    return isHiddenForEveryone(vNode);
   }
 
   return false;

lib/commons/dom/get-rect-stack.js

@@ -1,4 +1,4 @@
-import isVisible from './is-visible';
+import isVisibleOnScreen from './is-visible-on-screen';
 import VirtualNode from '../../core/base/virtual-node/virtual-node';
 import { getNodeFromTree, getScroll, isShadowRoot } from '../../core/utils';
 
@@ -80,7 +80,7 @@ export function createGrid(
     // (we don't do this before so we can calculate stacking context
     // of parents with 0 width/height)
     const rect = vNode.boundingClientRect;
-    if (rect.width !== 0 && rect.height !== 0 && isVisible(node)) {
+    if (rect.width !== 0 && rect.height !== 0 && isVisibleOnScreen(node)) {
       addNodeToGrid(grid, vNode);
     }
 

lib/commons/dom/has-lang-text.js

@@ -1,6 +1,6 @@
 import { hasChildTextNodes } from './has-content-virtual';
 import isVisualContent from './is-visual-content';
-import isVisible from './is-visible';
+import isVisibleForScreenreader from './is-visible-for-screenreader';
 
 /**
  * Check that a node has text, or an accessible name which language is defined by the 
@@ -19,6 +19,6 @@ export default function hasLangText(virtualNode) {
   return virtualNode.children.some(child => (
     !child.attr('lang') && // non-empty lang
     hasLangText(child) && // has text
-    isVisible(child, true) // Not hidden for AT
+    isVisibleForScreenreader(child) // Not hidden for AT
   ));
 }

lib/commons/dom/index.js

@@ -23,6 +23,7 @@ export { default as insertedIntoFocusOrder } from './inserted-into-focus-order';
 export { default as isCurrentPageLink } from './is-current-page-link';
 export { default as isFocusable } from './is-focusable';
 export { default as isHiddenWithCSS } from './is-hidden-with-css';
+export { default as isHiddenForEveryone } from './is-hidden-for-everyone';
 export { default as isHTML5 } from './is-html5';
 export { default as isInTabOrder } from './is-in-tab-order';
 export { default as isInTextBlock } from './is-in-text-block';
@@ -33,6 +34,8 @@ export { default as isNode } from './is-node';
 export { default as isOffscreen } from './is-offscreen';
 export { default as isOpaque } from './is-opaque';
 export { default as isSkipLink } from './is-skip-link';
+export { default as isVisibleForScreenreader } from './is-visible-for-screenreader';
+export { default as isVisibleOnScreen } from './is-visible-on-screen';
 export { default as isVisible } from './is-visible';
 export { default as isVisualContent } from './is-visual-content';
 export { default as reduceToElementsBelowFloating } from './reduce-to-elements-below-floating';

lib/commons/dom/is-hidden-for-everyone.js

@@ -0,0 +1,67 @@
+import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-node';
+import { getNodeFromTree } from '../../core/utils';
+import memoize from '../../core/utils/memoize';
+import {
+  nativelyHidden,
+  displayHidden,
+  visibilityHidden
+} from './visibility-functions';
+
+/**
+ * Determine if an element is hidden from screenreaders and visual users
+ * @method isHiddenForEveryone
+ * @memberof axe.commons.dom
+ * @param {VirtualNode} vNode The Virtual Node
+ * @param {Boolean} [ancestors=true] If the ancestor tree should be used
+ * @param {Boolean} recursed
+ * @return {Boolean} The element's visibility state
+ */
+export default function isHiddenForEveryone(vNode, ancestors = true, recursed) {
+  vNode = vNode instanceof AbstractVirtualNode ? vNode : getNodeFromTree(vNode);
+
+  return ancestors
+    ? isHiddenAncestors(vNode, recursed)
+    : isHiddenSelf(vNode, recursed);
+}
+
+/**
+ * Check the element for visibility state
+ */
+const isHiddenSelf = memoize(function isHiddenSelfMemoized(vNode, recursed) {
+  if (nativelyHidden(vNode)) {
+    return true;
+  }
+
+  if (vNode.actualNode) {
+    const hiddenMethods = [displayHidden, visibilityHidden];
+
+    if (hiddenMethods.some(method => method(vNode, recursed))) {
+      return true;
+    }
+
+    // detached node
+    if (!vNode.actualNode.isConnected) {
+      return true;
+    }
+  }
+
+  return false;
+});
+
+/**
+ * Check the element and ancestors for visibility state
+ */
+const isHiddenAncestors = memoize(function isHiddenAncestorsMemoized(
+  vNode,
+  recursed
+) {
+  if (isHiddenSelf(vNode, recursed)) {
+    return true;
+  }
+
+  if (vNode.parent) {
+    return isHiddenAncestors(vNode.parent, true);
+  }
+
+  return false;
+});

lib/commons/dom/is-hidden-with-css.js

@@ -9,6 +9,7 @@ import { getNodeFromTree } from '../../core/utils';
  * @param {HTMLElement} el The HTML Element
  * @param {Boolean} descendentVisibilityValue (Optional) immediate descendant visibility value used for recursive computation
  * @return {Boolean} the element's hidden status
+ * @deprecated use isHiddenForEveryone
  */
 function isHiddenWithCSS(el, descendentVisibilityValue) {
   const vNode = getNodeFromTree(el);

lib/commons/dom/is-modal-open.js

@@ -1,4 +1,4 @@
-import isVisible from './is-visible';
+import isVisibleOnScreen from './is-visible-on-screen';
 import getViewportSize from './get-viewport-size';
 import cache from '../../core/base/cache';
 import { querySelectorAllFilter } from '../../core/utils';
@@ -42,7 +42,7 @@ function isModalOpen(options) {
     // TODO: es-module-_tree
     axe._tree[0],
     'dialog, [role=dialog], [aria-modal=true]',
-    vNode => isVisible(vNode.actualNode)
+    vNode => isVisibleOnScreen(vNode)
   );
 
   if (definiteModals.length) {

lib/commons/dom/is-offscreen.js

@@ -24,7 +24,13 @@ function noParentScrolled(element, offset) {
  * @param  {Element} element
  * @return {Boolean}
  */
-function isOffscreen(element) {
+function isOffscreen(element, recursed) {
+  if (recursed) {
+    return false;
+  }
+
+  element = element.actualNode ? element.actualNode : element
+
   let leftBoundary;
   const docElement = document.documentElement;
   const styl = window.getComputedStyle(element);