sync: interactive-roles to canonical (PR #27) for byte-identical merges

Author: johanrd

lib/utils/interactive-roles.js

@@ -0,0 +1,131 @@
+const { roles } = require('aria-query');
+
+// Interactive ARIA roles — concrete roles whose taxonomy descends from `widget`
+// in aria-query. This is the same derivation jsx-a11y uses (the canonical
+// peer-plugin behavior here):
+//   https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/src/util/isInteractiveRole.js
+//
+// Authority: aria-query widget taxonomy, one manual addition, one manual
+// exclusion. Both documented below.
+//
+// `toolbar` is added explicitly — it does not descend from `widget` per
+// aria-query's taxonomy (its superClass is structure-based), but supports
+// `aria-activedescendant` and is widget-like in practice per WAI-ARIA APG's
+// toolbar pattern. jsx-a11y adds it for the same reason.
+//
+// `tooltip` is intentionally NOT added. Per WAI-ARIA 1.2 §5.3.3 — Document
+// Structure Roles (https://www.w3.org/TR/wai-aria-1.2/#tooltip), tooltip is
+// a document-structure role, not a widget; the spec says "document structures
+// are not usually interactive." jsx-a11y agrees.
+//
+// `progressbar` IS included (it descends from widget → range per aria-query).
+// lit-a11y explicitly excludes it on the grounds that `progressbar.value` is
+// always readonly, so the role isn't operable by the user. This is a real
+// design disagreement; we side with aria-query's taxonomy (and jsx-a11y) to
+// keep the authority single-sourced. Authors wanting lit-a11y behavior can
+// layer a rule-level exclusion if needed.
+module.exports.INTERACTIVE_ROLES = buildInteractiveRoleSet();
+
+// Composite-widget child map — for each composite-widget parent role, the
+// set of child roles that are legitimately nested inside it per ARIA's
+// "Required Owned Elements" (aria-query's `requiredOwnedElements`). Closed
+// transitively over chains of composite widgets (e.g. `grid` owns `row`,
+// `row` owns `gridcell` / `columnheader` / `rowheader`, so `grid` transitively
+// allows all of them).
+//
+// This drives the nested-interactive exception so canonical composite-widget
+// patterns (`listbox > option`, `tablist > tab`, `tree > treeitem`,
+// `grid > row > gridcell`, `radiogroup > radio`, etc.) are not flagged.
+module.exports.COMPOSITE_WIDGET_CHILDREN = buildCompositeWidgetChildren();
+
+function buildInteractiveRoleSet() {
+  const result = new Set(['toolbar']);
+  for (const [role, def] of roles) {
+    if (def.abstract) {
+      continue;
+    }
+    const descendsFromWidget = (def.superClass || []).some((chain) => chain.includes('widget'));
+    if (descendsFromWidget) {
+      result.add(role);
+    }
+  }
+  return result;
+}
+
+function buildCompositeWidgetChildren() {
+  // Collect each role's own `requiredOwnedElements` first.
+  const own = new Map();
+  for (const [role, def] of roles) {
+    if (def.abstract) {
+      continue;
+    }
+    const owned = def.requiredOwnedElements;
+    if (!owned || owned.length === 0) {
+      continue;
+    }
+    const kids = new Set();
+    for (const chain of owned) {
+      for (const child of chain) {
+        kids.add(child);
+      }
+    }
+    own.set(role, kids);
+  }
+
+  // A role also legitimately owns whatever its ancestor roles in `superClass`
+  // own. This lets e.g. `treegrid` (superClass chains include `grid` and
+  // `tree`) inherit `row` from `grid` and `treeitem` from `tree`, matching
+  // the APG treegrid pattern.
+  const direct = new Map();
+  for (const [role, def] of roles) {
+    if (def.abstract) {
+      continue;
+    }
+    const merged = new Set(own.get(role) || []);
+    for (const chain of def.superClass || []) {
+      for (const ancestor of chain) {
+        const inherited = own.get(ancestor);
+        if (inherited) {
+          for (const child of inherited) {
+            merged.add(child);
+          }
+        }
+      }
+    }
+    if (merged.size > 0) {
+      direct.set(role, merged);
+    }
+  }
+
+  // Transitive closure: parent -> all roles reachable through owned-element chains.
+  const closed = new Map();
+  function expand(role, visited) {
+    if (closed.has(role)) {
+      return closed.get(role);
+    }
+    const out = new Set();
+    const kids = direct.get(role);
+    if (!kids) {
+      closed.set(role, out);
+      return out;
+    }
+    for (const child of kids) {
+      out.add(child);
+      if (!visited.has(child)) {
+        // Pass a fresh branch-specific visited set so sibling branches do not
+        // contaminate each other's traversal. A shared Set across branches
+        // makes memoized results order-dependent, because whether `child` is
+        // recursed into depends on which sibling ran first.
+        for (const grandchild of expand(child, new Set([...visited, child]))) {
+          out.add(grandchild);
+        }
+      }
+    }
+    closed.set(role, out);
+    return out;
+  }
+  for (const role of direct.keys()) {
+    expand(role, new Set([role]));
+  }
+  return closed;
+}