fix(template-no-autofocus-attribute): align value-aware check with HTML boolean semantics

Per HTML Living Standard on boolean attributes, the presence of `autofocus`
indicates TRUE regardless of value — `autofocus="false"` and
`autofocus="autofocus"` are equally truthy. jsx-a11y's `no-autofocus`
treats the literal string `"false"` as an opt-out (via `getPropValue`),
but that's a peer-plugin convention that diverges from HTML semantics;
vue-a11y and lit-a11y are presence-based, consistent with the spec.

Narrow opt-out to the only case that is spec-consistent:
- `autofocus={{false}}` in angle-bracket syntax — renders no attribute.
- `{{input autofocus=false}}` in mustache hash-pair syntax — no attribute.

Revert peer-parity opt-outs for `autofocus="false"`, `autofocus={{"false"}}`,
and `{{input autofocus="false"}}` — these are now flagged per HTML spec
semantics. Moved from valid → invalid in the test suite.

Dialog exemption unchanged — keeps MDN-backed behavior for autofocus on
and within <dialog>.

Follows the spec-first direction established in ember-cli#2717 (aria-hidden),
#19, #33.

Author: johanrd

lib/rules/template-no-autofocus-attribute.js

@@ -1,40 +1,25 @@
 /**
- * Returns true when the attribute value is statically known to be falsy
- * (i.e. the developer has written `autofocus="false"`, `autofocus={{false}}`,
- * or `autofocus={{"false"}}`). These forms are aligned with jsx-a11y's
- * `no-autofocus` rule, which reads the attribute value via `getPropValue` and
- * skips reporting when the value is falsy (e.g. `<div autoFocus={false} />`).
+ * `autofocus` is a boolean HTML attribute. Per the HTML spec, any presence
+ * (including `autofocus="false"`, `autofocus=""`, `autofocus="autofocus"`)
+ * means the element will auto-focus. Only the genuine absence of the
+ * attribute turns off auto-focus.
  *
- * Valueless attributes (`<input autofocus>`) are TRUTHY per the HTML spec
- * (boolean attribute present == "on") and must still be flagged.
+ * jsx-a11y's `no-autofocus` treats `autofocus={false}` / `autofocus="false"`
+ * as opt-outs — that is a peer-plugin convention that diverges from HTML
+ * boolean-attribute semantics. vue-a11y and lit-a11y are presence-based,
+ * consistent with the spec. We follow the spec.
+ *
+ * The only exception is a mustache boolean-literal `{{false}}` in element
+ * syntax — Glimmer authors writing `autofocus={{false}}` are expressing
+ * intent to omit the attribute conditionally. Treat that narrow literal
+ * case as opt-out (the rendered HTML will have no autofocus attr).
  */
-function isExplicitlyFalsy(value) {
-  if (!value) {
-    // No value property at all — treat as bare boolean attribute (truthy).
+function isMustacheBooleanFalse(value) {
+  if (value?.type !== 'GlimmerMustacheStatement') {
     return false;
   }
-
-  if (value.type === 'GlimmerTextNode') {
-    // `autofocus="false"` → chars === "false". Bare `autofocus` has chars === "".
-    return value.chars === 'false';
-  }
-
-  if (value.type === 'GlimmerMustacheStatement') {
-    const expr = value.path;
-    if (!expr) {
-      return false;
-    }
-    // `autofocus={{false}}` → BooleanLiteral(false).
-    if (expr.type === 'GlimmerBooleanLiteral' && expr.value === false) {
-      return true;
-    }
-    // `autofocus={{"false"}}` → StringLiteral("false").
-    if (expr.type === 'GlimmerStringLiteral' && expr.value === 'false') {
-      return true;
-    }
-  }
-
-  return false;
+  const expr = value.path;
+  return expr?.type === 'GlimmerBooleanLiteral' && expr.value === false;
 }
 
 /**
@@ -92,9 +77,10 @@ module.exports = {
           return;
         }
 
-        // jsx-a11y parity: `autofocus="false"` / `={{false}}` / `={{"false"}}`
-        // explicitly opt out and should not be flagged.
-        if (isExplicitlyFalsy(autofocusAttr.value)) {
+        // Mustache boolean-literal `autofocus={{false}}` renders no attribute
+        // at all — the only statically-known opt-out consistent with HTML
+        // boolean-attribute semantics.
+        if (isMustacheBooleanFalse(autofocusAttr.value)) {
           return;
         }
 
@@ -132,16 +118,14 @@ module.exports = {
           return;
         }
 
-        // Value-aware check for component/helper invocations such as
-        // `{{input autofocus=false}}` or `{{input autofocus="false"}}`.
+        // Mustache hash-pair `{{input autofocus=false}}` — boolean literal
+        // false at the hash-pair level is unambiguous and renders no attr.
+        // Note: `autofocus="false"` in mustache syntax IS still flagged — per
+        // HTML boolean-attribute semantics the string "false" is truthy; it
+        // is only jsx-a11y that carves that form out.
         const pairValue = autofocusPair.value;
-        if (pairValue) {
-          if (pairValue.type === 'GlimmerBooleanLiteral' && pairValue.value === false) {
-            return;
-          }
-          if (pairValue.type === 'GlimmerStringLiteral' && pairValue.value === 'false') {
-            return;
-          }
+        if (pairValue?.type === 'GlimmerBooleanLiteral' && pairValue.value === false) {
+          return;
         }
 
         context.report({

tests/lib/rules/template-no-autofocus-attribute.js

@@ -22,22 +22,15 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
     `<template>
       <button>Click me</button>
     </template>`,
-    // Value-aware: explicit falsy values opt out (jsx-a11y parity).
-    `<template>
-      <input autofocus="false" />
-    </template>`,
+    // Mustache boolean-literal forms render NO attribute when the literal
+    // is false — these are the statically-known opt-outs that align with
+    // HTML boolean-attribute semantics.
     `<template>
       <input autofocus={{false}} />
     </template>`,
-    `<template>
-      <input autofocus={{"false"}} />
-    </template>`,
     `<template>
       {{input autofocus=false}}
     </template>`,
-    `<template>
-      {{input autofocus="false"}}
-    </template>`,
     // Dialog exception (MDN): autofocus on <dialog> is recommended.
     `<template>
       <dialog autofocus></dialog>
@@ -232,5 +225,34 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         },
       ],
     },
+
+    // Per HTML boolean-attribute semantics, the string "false" / mustache
+    // string "false" / hash-pair string "false" are all TRUTHY. Only the
+    // mustache boolean-literal {{false}} renders no attribute.
+    {
+      code: `<template>
+        <input autofocus="false" />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [{ messageId: 'noAutofocus', type: 'GlimmerAttrNode' }],
+    },
+    {
+      code: `<template>
+        <input autofocus={{"false"}} />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [{ messageId: 'noAutofocus', type: 'GlimmerAttrNode' }],
+    },
+    {
+      code: `<template>
+        {{input autofocus="false"}}
+      </template>`,
+      output: null,
+      errors: [{ messageId: 'noAutofocus' }],
+    },
   ],
 });