@herb-tools/linter 0.8.9 → 0.9.0

package/src/rules/html-input-require-autocomplete.ts

@@ -1,5 +1,5 @@
-import { getTagName } from "@herb-tools/core"
-import { BaseRuleVisitor, getAttribute, getAttributeValue, getStaticAttributeValueContent } from "./rule-utils.js"
+import { getTagLocalName, getStaticAttributeValue, getAttribute, getAttributeValue } from "@herb-tools/core"
+import { BaseRuleVisitor } from "./rule-utils.js"
 import { ParserRule } from "../types.js"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
@@ -30,10 +30,7 @@ class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
   private checkInputTag(node: HTMLOpenTagNode): void {
     if (!this.isInputTag(node) || this.hasAutocomplete(node)) return
 
-    const typeAttribute = getAttribute(node, "type");
-    if (!typeAttribute) return
-
-    const typeValue = getStaticAttributeValueContent(typeAttribute)
+    const typeValue = getStaticAttributeValue(node, "type")
     if (!typeValue) return
 
     if (!this.HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE.has(typeValue)) return
@@ -55,7 +52,7 @@ class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
   }
 
   private isInputTag(node: HTMLOpenTagNode) {
-    const tagName = getTagName(node);
+    const tagName = getTagLocalName(node);
 
     if (tagName === "input") {
       return true
@@ -66,17 +63,17 @@ class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
 }
 
 export class HTMLInputRequireAutocompleteRule extends ParserRule {
-  name = "html-input-require-autocomplete"
+  static ruleName = "html-input-require-autocomplete"
 
   get defaultConfig(): FullRuleConfig {
     return {
       enabled: true,
-      severity: "error"
+      severity: "warning"
     }
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new HTMLInputRequireAutocompleteVisitor(this.name, context)
+    const visitor = new HTMLInputRequireAutocompleteVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-navigation-has-label.ts

@@ -1,5 +1,6 @@
 import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, getTagName, hasAttribute, getAttributeValue, findAttributeByName, getAttributes } from "./rule-utils.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { hasAttribute, getAttributeValue, findAttributeByName, getAttributes, getTagLocalName } from "@herb-tools/core"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
@@ -11,7 +12,7 @@ class NavigationHasLabelVisitor extends BaseRuleVisitor {
   }
 
   private checkNavigationElement(node: HTMLOpenTagNode): void {
-    const tagName = getTagName(node)
+    const tagName = getTagLocalName(node)
     const isNavElement = tagName === "nav"
     const hasNavigationRole = this.hasRoleNavigation(node)
 
@@ -51,17 +52,17 @@ class NavigationHasLabelVisitor extends BaseRuleVisitor {
 }
 
 export class HTMLNavigationHasLabelRule extends ParserRule {
-  name = "html-navigation-has-label"
+  static ruleName = "html-navigation-has-label"
 
   get defaultConfig(): FullRuleConfig {
     return {
       enabled: false,
-      severity: "error"
+      severity: "warning"
     }
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new NavigationHasLabelVisitor(this.name, context)
+    const visitor = new NavigationHasLabelVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-no-abstract-roles.ts

@@ -0,0 +1,40 @@
+import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, ABSTRACT_ARIA_ROLES, StaticAttributeStaticValueParams } from "./rule-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult } from "@herb-tools/core"
+
+class NoAbstractRolesVisitor extends AttributeVisitorMixin {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
+    if (attributeName !== "role") return
+    if (!attributeValue) return
+
+    const normalizedValue = attributeValue.toLowerCase()
+
+    if (!ABSTRACT_ARIA_ROLES.has(normalizedValue)) return
+
+    this.addOffense(
+      `The \`role\` attribute must not use abstract ARIA role \`${attributeValue}\`. Abstract roles are not meant to be used directly.`,
+      attributeNode.location,
+    )
+  }
+}
+
+export class HTMLNoAbstractRolesRule extends ParserRule {
+  static ruleName = "html-no-abstract-roles"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new NoAbstractRolesVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-no-aria-hidden-on-body.ts

@@ -0,0 +1,58 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { hasAttribute, getAttributeValue, findAttributeByName, getAttributes, getTagLocalName } from "@herb-tools/core"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
+
+class NoAriaHiddenBodyVisitor extends BaseRuleVisitor {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkAriaHiddenOnBody(node)
+    super.visitHTMLOpenTagNode(node)
+  }
+
+  private checkAriaHiddenOnBody(node: HTMLOpenTagNode): void {
+    const tagName = getTagLocalName(node)
+
+    if (tagName !== "body") return
+
+    if (this.hasAriaHidden(node)) {
+      this.addOffense(
+        "The `aria-hidden` attribute should never be present on the `<body>` element, as it hides the entire document from assistive technology users.",
+        node.tag_name!.location,
+      )
+    }
+  }
+
+  private hasAriaHidden(node: HTMLOpenTagNode): boolean {
+    if (!hasAttribute(node, "aria-hidden")) return false
+
+    const attributes = getAttributes(node)
+    const ariaHiddenAttr = findAttributeByName(attributes, "aria-hidden")
+
+    if (!ariaHiddenAttr) return false
+
+    const value = getAttributeValue(ariaHiddenAttr)
+
+    return value === null || value === "" || value === "true"
+  }
+}
+
+export class HTMLNoAriaHiddenOnBodyRule extends ParserRule {
+  static ruleName = "html-no-aria-hidden-on-body"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new NoAriaHiddenBodyVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-no-aria-hidden-on-focusable.ts

@@ -1,5 +1,6 @@
 import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, getTagName, hasAttribute, getAttributeValue, findAttributeByName, getAttributes } from "./rule-utils.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { hasAttribute, getAttributeValue, findAttributeByName, getAttributes, getTagLocalName } from "@herb-tools/core"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
@@ -37,7 +38,7 @@ class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
   }
 
   private isFocusable(node: HTMLOpenTagNode): boolean {
-    const tagName = getTagName(node)
+    const tagName = getTagLocalName(node)
     if (!tagName) return false
 
     const tabIndexValue = this.getTabIndexValue(node)
@@ -77,17 +78,17 @@ class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
 }
 
 export class HTMLNoAriaHiddenOnFocusableRule extends ParserRule {
-  name = "html-no-aria-hidden-on-focusable"
+  static ruleName = "html-no-aria-hidden-on-focusable"
 
   get defaultConfig(): FullRuleConfig {
     return {
       enabled: true,
-      severity: "error"
+      severity: "warning"
     }
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new NoAriaHiddenOnFocusableVisitor(this.name, context)
+    const visitor = new NoAriaHiddenOnFocusableVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-no-block-inside-inline.ts

@@ -1,16 +1,13 @@
 import { BaseRuleVisitor, isInlineElement, isBlockElement } from "./rule-utils.js"
-
 import { ParserRule } from "../types.js"
+import { isHTMLOpenTagNode } from "@herb-tools/core"
+
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
   private inlineStack: string[] = []
 
-  private isValidHTMLOpenTag(node: HTMLElementNode): boolean {
-    return !!(node.open_tag && node.open_tag.type === "AST_HTML_OPEN_TAG_NODE")
-  }
-
   private getElementType(tagName: string): { isInline: boolean; isBlock: boolean; isUnknown: boolean } {
     const isInline = isInlineElement(tagName)
     const isBlock = isBlockElement(tagName)
@@ -43,25 +40,22 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
   }
 
   visitHTMLElementNode(node: HTMLElementNode): void {
-    if (!this.isValidHTMLOpenTag(node)) {
+    if (!isHTMLOpenTagNode(node.open_tag)) {
       super.visitHTMLElementNode(node)
-
       return
     }
 
-    const openTag = node.open_tag as HTMLOpenTagNode
-    const tagName = openTag.tag_name?.value.toLowerCase()
+    const tagName = node.open_tag.tag_name?.value.toLowerCase()
 
     if (!tagName) {
       super.visitHTMLElementNode(node)
-
       return
     }
 
     const { isInline, isBlock, isUnknown } = this.getElementType(tagName)
 
     if ((isBlock || isUnknown) && this.inlineStack.length > 0) {
-      this.addOffenseMessage(tagName, isBlock, openTag)
+      this.addOffenseMessage(tagName, isBlock, node.open_tag)
     }
 
     if (isInline) {
@@ -74,7 +68,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
 }
 
 export class HTMLNoBlockInsideInlineRule extends ParserRule {
-  name = "html-no-block-inside-inline"
+  static ruleName = "html-no-block-inside-inline"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -84,7 +78,7 @@ export class HTMLNoBlockInsideInlineRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new BlockInsideInlineVisitor(this.name, context)
+    const visitor = new BlockInsideInlineVisitor(this.ruleName, context)
     visitor.visit(result.value)
     return visitor.offenses
   }

package/src/rules/html-no-duplicate-attributes.ts

@@ -1,5 +1,6 @@
 import { ParserRule, BaseAutofixContext } from "../types.js"
-import { ControlFlowTrackingVisitor, ControlFlowType, getAttributeName } from "./rule-utils.js"
+import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils.js"
+import { getAttributeName } from "@herb-tools/core"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, HTMLAttributeNode, ParseResult, Location } from "@herb-tools/core"
@@ -162,7 +163,7 @@ class NoDuplicateAttributesVisitor extends ControlFlowTrackingVisitor<
 }
 
 export class HTMLNoDuplicateAttributesRule extends ParserRule {
-  name = "html-no-duplicate-attributes"
+  static ruleName = "html-no-duplicate-attributes"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -172,7 +173,7 @@ export class HTMLNoDuplicateAttributesRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new NoDuplicateAttributesVisitor(this.name, context)
+    const visitor = new NoDuplicateAttributesVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-no-duplicate-ids.ts

@@ -93,40 +93,41 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<BaseAutofixContex
     return getStaticAttributeName(attributeNode.name) === "id"
   }
 
-  private extractIdValue(attributeNode: HTMLAttributeNode): { identifier: string; shouldTrackDuplicates: boolean } | null {
+  private extractIdValue(attributeNode: HTMLAttributeNode): { identifier: string; shouldTrackDuplicates: boolean; isDynamic: boolean } | null {
     const valueNodes = attributeNode.value?.children || []
+    const isDynamic = hasERBOutput(valueNodes)
 
-    if (hasERBOutput(valueNodes) && this.isInControlFlow && this.currentControlFlowType === ControlFlowType.LOOP) {
+    if (isDynamic && this.isInControlFlow && this.currentControlFlowType === ControlFlowType.LOOP) {
       return null
     }
 
     const identifier = isEffectivelyStatic(valueNodes) ? getValidatableStaticContent(valueNodes) : OutputPrinter.print(valueNodes)
     if (!identifier) return null
 
-    return { identifier, shouldTrackDuplicates: true }
+    return { identifier, shouldTrackDuplicates: true, isDynamic }
   }
 
   private isWhitespaceOnlyId(identifier: string): boolean {
     return identifier !== '' && identifier.trim() === ''
   }
 
-  private processIdDuplicate(idValue: { identifier: string; shouldTrackDuplicates: boolean }, attributeNode: HTMLAttributeNode): void {
-    const { identifier, shouldTrackDuplicates } = idValue
+  private processIdDuplicate(idValue: { identifier: string; shouldTrackDuplicates: boolean; isDynamic: boolean }, attributeNode: HTMLAttributeNode): void {
+    const { identifier, shouldTrackDuplicates, isDynamic } = idValue
 
     if (!shouldTrackDuplicates) return
 
     if (this.isInControlFlow) {
-      this.handleControlFlowId(identifier, attributeNode)
+      this.handleControlFlowId(identifier, attributeNode, isDynamic)
     } else {
       this.handleGlobalId(identifier, attributeNode)
     }
   }
 
-  private handleControlFlowId(identifier: string, attributeNode: HTMLAttributeNode): void {
+  private handleControlFlowId(identifier: string, attributeNode: HTMLAttributeNode, isDynamic: boolean): void {
     if (this.currentControlFlowType === ControlFlowType.LOOP) {
       this.handleLoopId(identifier, attributeNode)
     } else {
-      this.handleConditionalId(identifier, attributeNode)
+      this.handleConditionalId(identifier, attributeNode, isDynamic)
     }
 
     this.currentBranchIds.add(identifier)
@@ -145,18 +146,20 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<BaseAutofixContex
     }
   }
 
-  private handleConditionalId(identifier: string, attributeNode: HTMLAttributeNode): void {
+  private handleConditionalId(identifier: string, attributeNode: HTMLAttributeNode, isDynamic: boolean): void {
     if (this.currentBranchIds.has(identifier)) {
       this.addSameBranchOffense(identifier, attributeNode.location)
       return
     }
 
-    if (this.documentIds.has(identifier)) {
+    if (!isDynamic && this.documentIds.has(identifier)) {
       this.addDuplicateIdOffense(identifier, attributeNode.location)
       return
     }
 
-    this.controlFlowIds.add(identifier)
+    if (!isDynamic) {
+      this.controlFlowIds.add(identifier)
+    }
   }
 
   private handleGlobalId(identifier: string, attributeNode: HTMLAttributeNode): void {
@@ -199,7 +202,7 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<BaseAutofixContex
 }
 
 export class HTMLNoDuplicateIdsRule extends ParserRule {
-  name = "html-no-duplicate-ids"
+  static ruleName = "html-no-duplicate-ids"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -209,7 +212,7 @@ export class HTMLNoDuplicateIdsRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new NoDuplicateIdsVisitor(this.name, context)
+    const visitor = new NoDuplicateIdsVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-no-duplicate-meta-names.ts

@@ -1,5 +1,5 @@
-import { isHTMLElementNode } from "@herb-tools/core"
-import { getTagName, getAttributeName, getAttributeValue, forEachAttribute } from "./rule-utils"
+import { isHTMLElementNode, isHTMLOpenTagNode, getAttributeName, getAttributeValue, forEachAttribute } from "@herb-tools/core"
+import { getTagLocalName } from "@herb-tools/core"
 
 import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
 import { ParserRule, BaseAutofixContext } from "../types"
@@ -30,7 +30,7 @@ class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor<BaseAut
   private controlFlowMetas: MetaTag[] = []
 
   visitHTMLElementNode(node: HTMLElementNode): void {
-    const tagName = getTagName(node)?.toLowerCase()
+    const tagName = getTagLocalName(node)
     if (!tagName) return
 
     if (tagName === "head") {
@@ -104,20 +104,21 @@ class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor<BaseAut
   }
 
   private extractAttributes(node: HTMLElementNode, metaTag: MetaTag): void {
-    if (isHTMLElementNode(node) && node.open_tag) {
-      forEachAttribute(node.open_tag as any, (attributeNode: HTMLAttributeNode) => {
-        const name = getAttributeName(attributeNode)
-        const value = getAttributeValue(attributeNode)?.trim()
-
-        if (name === "name" && value) {
-          metaTag.nameValue = value
-        } else if (name === "http-equiv" && value) {
-          metaTag.httpEquivValue = value
-        } else if (name === "media" && value) {
-          metaTag.mediaValue = value
-        }
-      })
-    }
+    if (!isHTMLElementNode(node)) return
+    if (!isHTMLOpenTagNode(node.open_tag)) return
+
+    forEachAttribute(node.open_tag, (attributeNode: HTMLAttributeNode) => {
+      const name = getAttributeName(attributeNode)
+      const value = getAttributeValue(attributeNode)?.trim()
+
+      if (name === "name" && value) {
+        metaTag.nameValue = value
+      } else if (name === "http-equiv" && value) {
+        metaTag.httpEquivValue = value
+      } else if (name === "media" && value) {
+        metaTag.mediaValue = value
+      }
+    })
   }
 
   private handleControlFlowMeta(metaTag: MetaTag): void {
@@ -182,7 +183,7 @@ class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor<BaseAut
 
 export class HTMLNoDuplicateMetaNamesRule extends ParserRule {
   static autocorrectable = false
-  name = "html-no-duplicate-meta-names"
+  static ruleName = "html-no-duplicate-meta-names"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -192,7 +193,7 @@ export class HTMLNoDuplicateMetaNamesRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.name, context)
+    const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-no-empty-attributes.ts

@@ -120,7 +120,7 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
 }
 
 export class HTMLNoEmptyAttributesRule extends ParserRule {
-  name = "html-no-empty-attributes"
+  static ruleName = "html-no-empty-attributes"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -130,7 +130,7 @@ export class HTMLNoEmptyAttributesRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new NoEmptyAttributesVisitor(this.name, context)
+    const visitor = new NoEmptyAttributesVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/html-no-empty-headings.ts

@@ -1,14 +1,15 @@
-import { BaseRuleVisitor, getTagName, getAttributes, findAttributeByName, getAttributeValue, HEADING_TAGS } from "./rule-utils.js"
-import { isHTMLOpenTagNode, isLiteralNode, isHTMLTextNode, isHTMLElementNode } from "@herb-tools/core"
-
 import { ParserRule } from "../types.js"
+import { BaseRuleVisitor, HEADING_TAGS } from "./rule-utils.js"
+import { getTagLocalName } from "@herb-tools/core"
+import { isLiteralNode, isHTMLTextNode, isHTMLElementNode, isERBOutputNode, isERBControlFlowNode, getStaticAttributeValue } from "@herb-tools/core"
 
+import type { Node } from "@herb-tools/core"
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
+import type { HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
-    const tagName = getTagName(node.open_tag)?.toLowerCase()
+    const tagName = getTagLocalName(node)
     if (tagName === "template") return
 
     this.checkHeadingElement(node)
@@ -16,14 +17,11 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   }
 
   private checkHeadingElement(node: HTMLElementNode): void {
-    if (!node.open_tag) return
-    if (!isHTMLOpenTagNode(node.open_tag)) return
-
-    const tagName = getTagName(node.open_tag)
+    const tagName = getTagLocalName(node)
     if (!tagName) return
 
     const isStandardHeading = HEADING_TAGS.has(tagName)
-    const isAriaHeading = this.hasHeadingRole(node.open_tag)
+    const isAriaHeading = this.hasHeadingRole(node)
 
     if (!isStandardHeading && !isAriaHeading) {
       return
@@ -46,90 +44,78 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       return true
     }
 
-    let hasAccessibleContent = false
+    return !this.hasAccessibleContent(node.body)
+  }
 
-    for (const child of node.body) {
-      if (isLiteralNode(child) || isHTMLTextNode(child)) {
+  private hasAccessibleContent(nodes: Node[]): boolean {
+    for (const child of nodes) {
+      if (isLiteralNode(child) || isHTMLTextNode(child)) {
         if (child.content.trim().length > 0) {
-          hasAccessibleContent = true
-          break
+          return true
         }
       } else if (isHTMLElementNode(child)) {
         if (this.isElementAccessible(child)) {
-          hasAccessibleContent = true
-          break
+          return true
+        }
+      } else if (isERBOutputNode(child)) {
+        return true
+      } else if (isERBControlFlowNode(child)) {
+        if (this.hasAccessibleContentInControlFlow(child)) {
+          return true
         }
-      } else {
-        hasAccessibleContent = true
-        break
       }
     }
 
-    return !hasAccessibleContent
+    return false
   }
 
-  private hasHeadingRole(node: HTMLOpenTagNode): boolean {
-    const attributes = getAttributes(node)
-    const roleAttribute = findAttributeByName(attributes, "role")
+  private hasAccessibleContentInControlFlow(node: Node): boolean {
+    const nodeWithStatements = node as { statements?: Node[], body?: Node[], subsequent?: Node }
 
-    if (!roleAttribute) {
-      return false
+    if (nodeWithStatements.statements && this.hasAccessibleContent(nodeWithStatements.statements)) {
+      return true
     }
 
-    const roleValue = getAttributeValue(roleAttribute)
-    return roleValue === "heading"
-  }
+    if (nodeWithStatements.body && this.hasAccessibleContent(nodeWithStatements.body)) {
+      return true
+    }
 
-  private isElementAccessible(node: HTMLElementNode): boolean {
-    if (!node.open_tag) return true
-    if (!isHTMLOpenTagNode(node.open_tag)) return true
+    if (nodeWithStatements.subsequent) {
+      return this.hasAccessibleContentInControlFlow(nodeWithStatements.subsequent)
+    }
 
-    const attributes = getAttributes(node.open_tag)
-    const ariaHiddenAttribute = findAttributeByName(attributes, "aria-hidden")
+    return false
+  }
 
-    if (ariaHiddenAttribute) {
-      const ariaHiddenValue = getAttributeValue(ariaHiddenAttribute)
+  private hasHeadingRole(node: HTMLElementNode): boolean {
+    return getStaticAttributeValue(node, "role") === "heading"
+  }
 
-      if (ariaHiddenValue === "true") {
-        return false
-      }
+  private isElementAccessible(node: HTMLElementNode): boolean {
+    if (getStaticAttributeValue(node, "aria-hidden") === "true") {
+      return false
     }
 
     if (!node.body || node.body.length === 0) {
       return false
     }
 
-    for (const child of node.body) {
-      if (isLiteralNode(child) || isHTMLTextNode(child)) {
-        if (child.content.trim().length > 0) {
-          return true
-        }
-      } else if (isHTMLElementNode(child)) {
-        if (this.isElementAccessible(child)) {
-          return true
-        }
-      } else {
-        // If there's any non-literal/non-text/non-element content (like ERB), consider it accessible
-        return true
-      }
-    }
-
-    return false
+    return this.hasAccessibleContent(node.body)
   }
 }
 
 export class HTMLNoEmptyHeadingsRule extends ParserRule {
-  name = "html-no-empty-headings"
+  static ruleName = "html-no-empty-headings"
 
   get defaultConfig(): FullRuleConfig {
     return {
       enabled: true,
-      severity: "error"
+      severity: "warning"
     }
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new NoEmptyHeadingsVisitor(this.name, context)
+    const visitor = new NoEmptyHeadingsVisitor(this.ruleName, context)
     visitor.visit(result.value)
     return visitor.offenses
   }