AXE-3625: Emit bulk-review visualHelperData for axe-core rules

Add reviewPayload.visualHelperData emits for aria-valid-attr-value,
aria-hidden-focus, identical-links-same-purpose and duplicate-id-aria
(dedicated evaluate/after), plus their unit specs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rajathmr2000

lib/checks/aria/aria-valid-attr-value-evaluate.js

@@ -140,7 +140,11 @@ export default function ariaValidAttrValueEvaluate(node, options, virtualNode) {
   }
 
   if (needsReview) {
-    this.data({ messageKey, needsReview });
+    this.data({
+      messageKey,
+      needsReview,
+      reviewPayload: { visualHelperData: { ariaAttribute: needsReview } }
+    });
     return undefined;
   }
 

lib/checks/keyboard/focusable-disabled-evaluate.js

@@ -25,7 +25,7 @@ function focusableDisabledEvaluate(node, options, virtualNode) {
     return true;
   }
 
-  return relatedNodes.every(vNode => {
+  const verdict = relatedNodes.every(vNode => {
     const pointerEvents = vNode.getComputedStylePropertyValue('pointer-events');
     const width = parseInt(vNode.getComputedStylePropertyValue('width'));
     const height = parseInt(vNode.getComputedStylePropertyValue('height'));
@@ -37,6 +37,28 @@ function focusableDisabledEvaluate(node, options, virtualNode) {
   })
     ? undefined
     : false;
+
+  // a11y-rule-aria-hidden-focus: surface the focusable descendants for the
+  // bulk-review "Review Hidden Elements" visual helper. Reuse DqElement.selector
+  // (the same format-aware path relatedNodes uses) so the list and the overlay
+  // share identical selectors; no new computation. Wrapped so any failure to
+  // build the payload (e.g. an unexpected node) can never fail the check/scan.
+  try {
+    this.data({
+      reviewPayload: {
+        visualHelperData: {
+          focusableChildren: relatedNodes
+            .map(vNode => vNode.actualNode)
+            .filter(Boolean)
+            .map(actualNode => new axe.utils.DqElement(actualNode).selector)
+        }
+      }
+    });
+  } catch {
+    // best-effort emit — preserve the scan result
+  }
+
+  return verdict;
 }
 
 export default focusableDisabledEvaluate;

lib/checks/keyboard/focusable-not-tabbable-evaluate.js

@@ -25,7 +25,7 @@ function focusableNotTabbableEvaluate(node, options, virtualNode) {
     return true;
   }
 
-  return relatedNodes.every(vNode => {
+  const verdict = relatedNodes.every(vNode => {
     const pointerEvents = vNode.getComputedStylePropertyValue('pointer-events');
     const width = parseInt(vNode.getComputedStylePropertyValue('width'));
     const height = parseInt(vNode.getComputedStylePropertyValue('height'));
@@ -37,6 +37,28 @@ function focusableNotTabbableEvaluate(node, options, virtualNode) {
   })
     ? undefined
     : false;
+
+  // a11y-rule-aria-hidden-focus: surface the focusable descendants for the
+  // bulk-review "Review Hidden Elements" visual helper. Reuse DqElement.selector
+  // (the same format-aware path relatedNodes uses) so the list and the overlay
+  // share identical selectors; no new computation. Wrapped so any failure to
+  // build the payload (e.g. an unexpected node) can never fail the check/scan.
+  try {
+    this.data({
+      reviewPayload: {
+        visualHelperData: {
+          focusableChildren: relatedNodes
+            .map(vNode => vNode.actualNode)
+            .filter(Boolean)
+            .map(actualNode => new axe.utils.DqElement(actualNode).selector)
+        }
+      }
+    });
+  } catch {
+    // best-effort emit — preserve the scan result
+  }
+
+  return verdict;
 }
 
 export default focusableNotTabbableEvaluate;

lib/checks/navigation/identical-links-same-purpose-after.js

@@ -84,6 +84,13 @@ function identicalLinksSamePurposeAfter(results) {
       currentResult.result = undefined;
     }
 
+    /**
+     * The node's own DqElement is stored at `relatedNodes[0]` by the evaluate
+     * fn; capture it before `relatedNodes` is rebuilt so the link group can
+     * include the primary link, not just its same-name siblings.
+     */
+    const currentNode = currentResult.relatedNodes[0];
+
     /**
      *  -> deduplicate results (for both `pass` or `incomplete`) and add `relatedNodes` if any
      */
@@ -92,6 +99,24 @@ function identicalLinksSamePurposeAfter(results) {
       ...sameNameResults.map(node => node.relatedNodes[0])
     );
 
+    if (sameNameResults.length) {
+      try {
+        const identicalLinks = [currentNode, ...currentResult.relatedNodes]
+          .filter(Boolean)
+          .map(dqElm => (dqElm ? dqElm.selector : undefined))
+          .filter(Boolean);
+        const linkText =
+          (currentResult.data && currentResult.data.accessibleText) || name;
+        if (currentResult.data) {
+          currentResult.data.reviewPayload = {
+            visualHelperData: { linkText, identicalLinks }
+          };
+        }
+      } catch {
+        // best-effort emit — preserve the reconciled results
+      }
+    }
+
     /**
      * Update `nodeMap` with `sameNameResults`
      */

lib/checks/navigation/identical-links-same-purpose-evaluate.js

@@ -24,6 +24,7 @@ function identicalLinksSamePurposeEvaluate(node, options, virtualNode) {
    */
   const afterData = {
     name,
+    accessibleText: text.sanitize(accText),
     urlProps: dom.urlPropsFromAttribute(node, 'href')
   };
   this.data(afterData);

lib/checks/parsing/duplicate-id-aria-after.js

@@ -0,0 +1,18 @@
+/**
+ * Mirrors `duplicate-id-after`, but dedupes by `r.data.id` since the aria
+ * evaluate stores its data as an object (`{ id, reviewPayload }`) rather than
+ * a bare id string.
+ */
+function duplicateIdAriaAfter(results) {
+  const uniqueIds = [];
+  return results.filter(r => {
+    const id = r.data && r.data.id;
+    if (uniqueIds.indexOf(id) === -1) {
+      uniqueIds.push(id);
+      return true;
+    }
+    return false;
+  });
+}
+
+export default duplicateIdAriaAfter;

lib/checks/parsing/duplicate-id-aria-evaluate.js

@@ -0,0 +1,55 @@
+import { getRootNode } from '../../commons/dom';
+import { escapeSelector } from '../../core/utils';
+
+/**
+ * Mirrors `duplicate-id-evaluate`, but additionally emits a `reviewPayload`
+ * for the bulk-review "Review Duplicate IDs" visual helper. Kept separate so
+ * the non-bulk-review `duplicate-id` / `duplicate-id-active` checks (which
+ * share `duplicate-id-evaluate`) are untouched.
+ */
+function duplicateIdAriaEvaluate(node) {
+  const id = node.getAttribute('id').trim();
+  // Since empty ID's are not meaningful and are ignored by Edge, we'll
+  // let those pass.
+  if (!id) {
+    return true;
+  }
+  const root = getRootNode(node);
+  const matchingNodes = Array.from(
+    root.querySelectorAll(`[id="${escapeSelector(id)}"]`)
+  ).filter(foundNode => foundNode !== node);
+
+  if (matchingNodes.length) {
+    this.relatedNodes(matchingNodes);
+  }
+
+  // Verdict is computed independently of the emit below.
+  const verdict = matchingNodes.length === 0;
+
+  // a11y-rule-duplicate-id-aria: surface the duplicate id and the other
+  // elements sharing it for the visual helper. Reuse `DqElement.selector`
+  // (the same path `relatedNodes` serializes with) so the list matches the
+  // reported nodes; no new lookup. Emit only when a duplicate exists, and
+  // wrapped so any failure to build the payload can never fail the check/scan
+  // (the `id` is always carried for the fail message).
+  const data = { id };
+  try {
+    if (matchingNodes.length) {
+      data.reviewPayload = {
+        visualHelperData: {
+          duplicateId: id,
+          elements: matchingNodes
+            .filter(Boolean)
+            .map(foundNode => new axe.utils.DqElement(foundNode).selector)
+        }
+      };
+    }
+  } catch {
+    // best-effort emit — preserve the scan result
+  }
+  this.data(data);
+
+  return verdict;
+}
+
+export default duplicateIdAriaEvaluate;

lib/checks/parsing/duplicate-id-aria.json

@@ -1,12 +1,12 @@
 {
   "id": "duplicate-id-aria",
-  "evaluate": "duplicate-id-evaluate",
-  "after": "duplicate-id-after",
+  "evaluate": "duplicate-id-aria-evaluate",
+  "after": "duplicate-id-aria-after",
   "metadata": {
     "impact": "critical",
     "messages": {
       "pass": "Document has no elements referenced with ARIA or labels that share the same id attribute",
-      "fail": "Document has multiple elements referenced with ARIA with the same id attribute: ${data}"
+      "fail": "Document has multiple elements referenced with ARIA with the same id attribute: ${data.id}"
     }
   }
 }

test/checks/aria/aria-valid-attr-value.js

@@ -0,0 +1,46 @@
+describe('aria-valid-attr-value', () => {
+  'use strict';
+
+  const checkContext = axe.testUtils.MockCheckContext();
+  const checkSetup = axe.testUtils.checkSetup;
+  const checkEvaluate = axe.testUtils.getCheckEvaluate('aria-valid-attr-value');
+
+  afterEach(() => {
+    checkContext.reset();
+  });
+
+  it('emits the flagged aria-current attribute in reviewPayload.visualHelperData', () => {
+    const params = checkSetup(
+      '<div id="target" aria-current="active">Contents</div>'
+    );
+    assert.isUndefined(checkEvaluate.apply(checkContext, params));
+    assert.equal(checkContext._data.messageKey, 'ariaCurrent');
+    assert.equal(checkContext._data.needsReview, 'aria-current="active"');
+    assert.deepEqual(checkContext._data.reviewPayload, {
+      visualHelperData: { ariaAttribute: 'aria-current="active"' }
+    });
+  });
+
+  it('emits the flagged aria-labelledby attribute in reviewPayload.visualHelperData', () => {
+    const params = checkSetup(
+      '<div id="target" aria-labelledby="missing-id">Contents</div>'
+    );
+    assert.isUndefined(checkEvaluate.apply(checkContext, params));
+    assert.equal(
+      checkContext._data.needsReview,
+      'aria-labelledby="missing-id"'
+    );
+    assert.deepEqual(checkContext._data.reviewPayload, {
+      visualHelperData: { ariaAttribute: 'aria-labelledby="missing-id"' }
+    });
+  });
+
+  it('does not add a reviewPayload on the invalid-value (violation) path', () => {
+    const params = checkSetup(
+      '<div id="target" role="checkbox" aria-checked="foo">Contents</div>'
+    );
+    assert.isFalse(checkEvaluate.apply(checkContext, params));
+    assert.isArray(checkContext._data);
+    assert.notProperty(checkContext._data, 'reviewPayload');
+  });
+});

test/checks/keyboard/focusable-disabled.js

@@ -218,4 +218,19 @@ describe('focusable-disabled', function () {
     );
     assert.isUndefined(check.evaluate.apply(checkContext, params));
   });
+
+  it('emits the focusable children selectors in reviewPayload.visualHelperData', () => {
+    var params = checkSetup(
+      '<fieldset id="target" aria-hidden="true"><input /></fieldset>'
+    );
+    assert.isFalse(check.evaluate.apply(checkContext, params));
+    var focusableChildren =
+      checkContext._data.reviewPayload.visualHelperData.focusableChildren;
+    assert.isArray(focusableChildren);
+    assert.lengthOf(focusableChildren, 1);
+    // each entry is a DqElement.selector array, identical to relatedNodes[].selector
+    assert.isArray(focusableChildren[0]);
+    assert.isString(focusableChildren[0][0]);
+    assert.match(focusableChildren[0][0], /input/);
+  });
 });