fix(template-no-aria-hidden-on-focusable): unwrap mustache literals via shared helper (Copilot review)

Extract a new `getStaticAttrValue` util that resolves literal-valued
mustaches (`{{"foo"}}`, `{{true}}`, `{{-1}}`) and single-part concat
statements (`"{{true}}"`) to their static string value. The rule now
normalises the aria-hidden value through this helper and compares the
resolved string to `'true'` (case-insensitive, whitespace-trimmed),
covering the quoted-mustache forms that the previous per-rule check
missed.

Also fix the docs' "explicit truthy values" list: the example
`aria-hidden="{{true}}"` (concat) was paired with a rule implementation
that only inspected text + mustache shapes — replaced with the genuinely
supported `aria-hidden={{"true"}}` mustache-string-literal form, and the
concat equivalents are now implemented.

Byte-identical carrier of lib/utils/static-attr-value.js across all PRs
that land it.

Author: johanrd

docs/rules/template-no-aria-hidden-on-focusable.md

@@ -14,7 +14,7 @@ The phrase "may receive focus" is interpreted to include focusable descendants:
 
 ## What counts as `aria-hidden="true"`
 
-Only explicit truthy values trigger the rule: `aria-hidden="true"`, `aria-hidden={{true}}`, `aria-hidden="{{true}}"`, and case-insensitive variants. Valueless `<div aria-hidden>` and `aria-hidden="false"` / `{{false}}` are NOT treated as hidden — the author's signal must be explicit. See the shared spec-divergence rationale in `template-no-invalid-interactive` for the broader reasoning on valueless `aria-hidden` handling across this plugin.
+Only explicit truthy values trigger the rule: `aria-hidden="true"`, `aria-hidden={{true}}`, `aria-hidden={{"true"}}`, and case-insensitive variants. Valueless `<div aria-hidden>` and `aria-hidden="false"` / `{{false}}` are NOT treated as hidden — the author's signal must be explicit. See the shared spec-divergence rationale in `template-no-invalid-interactive` for the broader reasoning on valueless `aria-hidden` handling across this plugin.
 
 ## Examples
 

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const { isNativeElement } = require('../utils/is-native-element');
+const { getStaticAttrValue } = require('../utils/static-attr-value');
 
 function findAttr(node, name) {
   return node.attributes?.find((a) => a.name === name);
@@ -17,25 +18,21 @@ function getTextAttrValue(node, name) {
 // Per WAI-ARIA 1.2 §6.6 + aria-hidden value table, a missing or empty-string
 // aria-hidden resolves to the default `undefined` — NOT `true`. So only an
 // explicit `"true"` (ASCII case-insensitive per HTML enumerated-attribute
-// rules) hides the element. Mustache boolean-literal `{{true}}` and
-// string-literal `{{"true"}}` also qualify.
+// rules) hides the element. Mustache boolean-literal `{{true}}`,
+// string-literal `{{"true"}}`, and the quoted-mustache concat equivalents
+// (`"{{true}}"` / `"{{"true"}}"`) also qualify — all unwrapped via the
+// shared `getStaticAttrValue` helper.
 function isAriaHiddenTrue(node) {
-  const value = findAttr(node, 'aria-hidden')?.value;
-  if (!value) {
+  const attr = findAttr(node, 'aria-hidden');
+  if (!attr) {
     return false;
   }
-  if (value.type === 'GlimmerTextNode') {
-    return value.chars.trim().toLowerCase() === 'true';
-  }
-  if (value.type === 'GlimmerMustacheStatement' && value.path) {
-    if (value.path.type === 'GlimmerBooleanLiteral') {
-      return value.path.value === true;
-    }
-    if (value.path.type === 'GlimmerStringLiteral') {
-      return value.path.value.trim().toLowerCase() === 'true';
-    }
+  const resolved = getStaticAttrValue(attr.value);
+  if (resolved === undefined) {
+    // Dynamic — can't prove truthy.
+    return false;
   }
-  return false;
+  return resolved.trim().toLowerCase() === 'true';
 }
 
 // Tags with an unconditional default focusable UI (sequentially focusable per

lib/utils/static-attr-value.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Return the statically-known string value of a Glimmer attribute value node,
+ * or `undefined` when the value is dynamic (cannot be resolved at lint time).
+ *
+ * Unwraps:
+ *   - GlimmerTextNode → chars
+ *   - GlimmerMustacheStatement with a literal path (boolean/string/number) → stringified value
+ *   - GlimmerConcatStatement whose parts are all statically resolvable → joined string
+ *
+ * A missing/undefined value (valueless attribute, e.g. `<input disabled>`)
+ * returns the empty string. Pass `attr.value` — not the attribute itself.
+ */
+function getStaticAttrValue(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  if (value.type === 'GlimmerTextNode') {
+    return value.chars;
+  }
+  if (value.type === 'GlimmerMustacheStatement') {
+    return extractLiteral(value.path);
+  }
+  if (value.type === 'GlimmerConcatStatement') {
+    const parts = value.parts || [];
+    let out = '';
+    for (const part of parts) {
+      if (part.type === 'GlimmerTextNode') {
+        out += part.chars;
+        continue;
+      }
+      if (part.type === 'GlimmerMustacheStatement') {
+        const literal = extractLiteral(part.path);
+        if (literal === undefined) {
+          return undefined;
+        }
+        out += literal;
+        continue;
+      }
+      return undefined;
+    }
+    return out;
+  }
+  return undefined;
+}
+
+function extractLiteral(path) {
+  if (!path) {
+    return undefined;
+  }
+  if (path.type === 'GlimmerBooleanLiteral') {
+    return path.value ? 'true' : 'false';
+  }
+  if (path.type === 'GlimmerStringLiteral') {
+    return path.value;
+  }
+  if (path.type === 'GlimmerNumberLiteral') {
+    return String(path.value);
+  }
+  return undefined;
+}
+
+module.exports = { getStaticAttrValue };

tests/lib/utils/static-attr-value-test.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { getStaticAttrValue } = require('../../../lib/utils/static-attr-value');
+
+describe('getStaticAttrValue', () => {
+  it('returns empty string for null/undefined (valueless attribute)', () => {
+    expect(getStaticAttrValue(null)).toBe('');
+    expect(getStaticAttrValue(undefined)).toBe('');
+  });
+
+  it('returns chars for GlimmerTextNode', () => {
+    expect(getStaticAttrValue({ type: 'GlimmerTextNode', chars: 'hello' })).toBe('hello');
+    expect(getStaticAttrValue({ type: 'GlimmerTextNode', chars: '' })).toBe('');
+  });
+
+  it('unwraps GlimmerMustacheStatement with BooleanLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerBooleanLiteral', value: true },
+      })
+    ).toBe('true');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerBooleanLiteral', value: false },
+      })
+    ).toBe('false');
+  });
+
+  it('unwraps GlimmerMustacheStatement with StringLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerStringLiteral', value: 'foo' },
+      })
+    ).toBe('foo');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerStringLiteral', value: '' },
+      })
+    ).toBe('');
+  });
+
+  it('unwraps GlimmerMustacheStatement with NumberLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerNumberLiteral', value: -1 },
+      })
+    ).toBe('-1');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerNumberLiteral', value: 0 },
+      })
+    ).toBe('0');
+  });
+
+  it('returns undefined for GlimmerMustacheStatement with a dynamic PathExpression', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerPathExpression', original: 'this.foo' },
+      })
+    ).toBeUndefined();
+  });
+
+  it('joins GlimmerConcatStatement with only static parts', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          { type: 'GlimmerTextNode', chars: 'prefix-' },
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerStringLiteral', value: 'mid' },
+          },
+          { type: 'GlimmerTextNode', chars: '-suffix' },
+        ],
+      })
+    ).toBe('prefix-mid-suffix');
+  });
+
+  it('joins concat with boolean and number literal parts', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerBooleanLiteral', value: true },
+          },
+        ],
+      })
+    ).toBe('true');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerNumberLiteral', value: -1 },
+          },
+        ],
+      })
+    ).toBe('-1');
+  });
+
+  it('returns undefined for GlimmerConcatStatement with a dynamic part', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          { type: 'GlimmerTextNode', chars: 'x-' },
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerPathExpression', original: 'this.foo' },
+          },
+        ],
+      })
+    ).toBeUndefined();
+  });
+
+  it('returns undefined for an unknown node type', () => {
+    expect(getStaticAttrValue({ type: 'GlimmerSubExpression' })).toBeUndefined();
+  });
+});