@herb-tools/linter 0.4.2 → 0.5.0

package/src/rules/erb-prefer-image-tag-helper.ts

@@ -0,0 +1,124 @@
+import { BaseRuleVisitor, getTagName, findAttributeByName, getAttributes } from "./rule-utils.js"
+
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeValueNode, ERBContentNode, LiteralNode, ParseResult } from "@herb-tools/core"
+
+class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkImgTag(node)
+    super.visitHTMLOpenTagNode(node)
+  }
+
+  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
+    this.checkImgTag(node)
+    super.visitHTMLSelfCloseTagNode(node)
+  }
+
+  private checkImgTag(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
+    const tagName = getTagName(node)
+
+    if (tagName !== "img") {
+      return
+    }
+
+    const attributes = getAttributes(node)
+    const srcAttribute = findAttributeByName(attributes, "src")
+
+    if (!srcAttribute) {
+      return
+    }
+
+    if (!srcAttribute.value) {
+      return
+    }
+
+    const valueNode = srcAttribute.value as HTMLAttributeValueNode
+    const hasERBContent = this.containsERBContent(valueNode)
+
+    if (hasERBContent) {
+      const suggestedExpression = this.buildSuggestedExpression(valueNode)
+
+      this.addOffense(
+        `Prefer \`image_tag\` helper over manual \`<img>\` with dynamic ERB expressions. Use \`<%= image_tag ${suggestedExpression}, alt: "..." %>\` instead.`,
+        srcAttribute.location,
+        "warning"
+      )
+    }
+  }
+
+  private containsERBContent(valueNode: HTMLAttributeValueNode): boolean {
+    if (!valueNode.children) return false
+
+    return valueNode.children.some(child => child.type === "AST_ERB_CONTENT_NODE")
+  }
+
+  private buildSuggestedExpression(valueNode: HTMLAttributeValueNode): string {
+    if (!valueNode.children) return "expression"
+
+    let hasText = false
+    let hasERB = false
+
+    for (const child of valueNode.children) {
+      if (child.type === "AST_ERB_CONTENT_NODE") {
+        hasERB = true
+      } else if (child.type === "AST_LITERAL_NODE") {
+        const literalNode = child as LiteralNode
+
+        if (literalNode.content && literalNode.content.trim()) {
+          hasText = true
+        }
+      }
+    }
+
+    if (hasText && hasERB) {
+      let result = '"'
+
+      for (const child of valueNode.children) {
+        if (child.type === "AST_ERB_CONTENT_NODE") {
+          const erbNode = child as ERBContentNode
+
+          result += `#{${(erbNode.content?.value || "").trim()}}`
+        } else if (child.type === "AST_LITERAL_NODE") {
+          const literalNode = child as LiteralNode
+
+          result += literalNode.content || ""
+        }
+      }
+
+      result += '"'
+
+      return result
+    }
+
+    if (hasERB && !hasText) {
+      const erbNodes = valueNode.children.filter(child => child.type === "AST_ERB_CONTENT_NODE") as ERBContentNode[]
+
+      if (erbNodes.length === 1) {
+        return (erbNodes[0].content?.value || "").trim()
+      } else if (erbNodes.length > 1) {
+        let result = '"'
+
+        for (const erbNode of erbNodes) {
+          result += `#{${(erbNode.content?.value || "").trim()}}`
+        }
+
+        result += '"'
+
+        return result
+      }
+    }
+
+    return "expression"
+  }
+}
+
+export class ERBPreferImageTagHelperRule extends ParserRule {
+  name = "erb-prefer-image-tag-helper"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBPreferImageTagHelperVisitor(this.name, context)
+    visitor.visit(result.value)
+    return visitor.offenses
+  }
+}

package/src/rules/erb-require-whitespace-inside-tags.ts

@@ -1,6 +1,7 @@
-import type { Node, Token } from "@herb-tools/core"
+import type { ParseResult, Token, Node } from "@herb-tools/core"
 import { isERBNode } from "@herb-tools/core";
-import type { LintOffense, Rule } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 
 class RequireWhitespaceInsideTags extends BaseRuleVisitor {
@@ -81,12 +82,12 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
   }
 }
 
-export class ERBRequireWhitespaceRule implements Rule {
+export class ERBRequireWhitespaceRule extends ParserRule {
   name = "erb-require-whitespace-inside-tags"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new RequireWhitespaceInsideTags(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new RequireWhitespaceInsideTags(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/erb-requires-trailing-newline.ts

@@ -0,0 +1,29 @@
+import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
+import { SourceRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+
+class ERBRequiresTrailingNewlineVisitor extends BaseSourceRuleVisitor {
+  protected visitSource(source: string): void {
+    if (source.length === 0) return
+    if (source.endsWith('\n')) return
+    if (!this.context.fileName) return
+
+    this.addOffense(
+      "File must end with trailing newline",
+      createEndOfFileLocation(source),
+      "error"
+    )
+  }
+}
+
+export class ERBRequiresTrailingNewlineRule extends SourceRule {
+  name = "erb-requires-trailing-newline"
+
+  check(source: string, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBRequiresTrailingNewlineVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-anchor-require-href.ts

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
-import { Rule, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class AnchorRechireHrefVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -26,13 +27,13 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLAnchorRequireHrefRule implements Rule {
+export class HTMLAnchorRequireHrefRule extends ParserRule {
   name = "html-anchor-require-href"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new AnchorRechireHrefVisitor(this.name)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AnchorRechireHrefVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/html-aria-attribute-must-be-valid.ts

@@ -2,13 +2,13 @@ import {
   ARIA_ATTRIBUTES,
   AttributeVisitorMixin,
 } from "./rule-utils.js";
-
-import type { LintOffense, Rule } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type {
   HTMLAttributeNode,
   HTMLOpenTagNode,
   HTMLSelfCloseTagNode,
-  Node,
+  ParseResult,
 } from "@herb-tools/core";
 
 class AriaAttributeMustBeValid extends AttributeVisitorMixin {
@@ -31,12 +31,12 @@ class AriaAttributeMustBeValid extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLAriaAttributeMustBeValid implements Rule {
+export class HTMLAriaAttributeMustBeValid extends ParserRule {
   name = "html-aria-attribute-must-be-valid";
 
-  check(node: Node): LintOffense[] {
-    const visitor = new AriaAttributeMustBeValid(this.name);
-    visitor.visit(node);
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaAttributeMustBeValid(this.name, context);
+    visitor.visit(result.value);
     return visitor.offenses;
   }
 }

package/src/rules/html-aria-level-must-be-valid.ts

@@ -0,0 +1,42 @@
+import { AttributeVisitorMixin } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
+
+class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
+  protected checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode, _parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
+    if (attributeName !== "aria-level") return
+    if (attributeValue !== null && attributeValue.includes("<%")) return
+
+    if (attributeValue === null || attributeValue === "") {
+      this.addOffense(
+        `The \`aria-level\` attribute must be an integer between 1 and 6, got an empty value.`,
+        attributeNode.location,
+      )
+
+      return
+    }
+
+    const number = parseInt(attributeValue)
+
+    if (isNaN(number) || number < 1 || number > 6 || attributeValue !== number.toString()) {
+      this.addOffense(
+        `The \`aria-level\` attribute must be an integer between 1 and 6, got \`${attributeValue}\`.`,
+        attributeNode.location,
+      )
+    }
+  }
+}
+
+export class HTMLAriaLevelMustBeValidRule extends ParserRule {
+  name = "html-aria-level-must-be-valid"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-aria-role-heading-requires-level.ts

@@ -1,7 +1,8 @@
 import { AttributeVisitorMixin, getAttributeName, getAttributes } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { Node, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
 
 class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
 
@@ -33,12 +34,12 @@ class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLAriaRoleHeadingRequiresLevelRule implements Rule {
+export class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
   name = "html-aria-role-heading-requires-level"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new AriaRoleHeadingRequiresLevel(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaRoleHeadingRequiresLevel(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-aria-role-must-be-valid.ts

@@ -1,7 +1,8 @@
 import { AttributeVisitorMixin, VALID_ARIA_ROLES } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { Node, HTMLAttributeNode } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class AriaRoleMustBeValid extends AttributeVisitorMixin {
   checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode,): void {
@@ -17,13 +18,13 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLAriaRoleMustBeValidRule implements Rule {
+export class HTMLAriaRoleMustBeValidRule extends ParserRule {
   name = "html-aria-role-must-be-valid"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new AriaRoleMustBeValid(this.name)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaRoleMustBeValid(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/html-attribute-double-quotes.ts

@@ -1,7 +1,8 @@
 import { AttributeVisitorMixin, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { Node, HTMLAttributeNode } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
@@ -17,12 +18,12 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLAttributeDoubleQuotesRule implements Rule {
+export class HTMLAttributeDoubleQuotesRule extends ParserRule {
   name = "html-attribute-double-quotes"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new AttributeDoubleQuotesVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-attribute-values-require-quotes.ts

@@ -1,7 +1,8 @@
 import { AttributeVisitorMixin } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLAttributeNode, HTMLAttributeValueNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLAttributeNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
 
 class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, _attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
@@ -19,12 +20,12 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLAttributeValuesRequireQuotesRule implements Rule {
+export class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
   name = "html-attribute-values-require-quotes"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new AttributeValuesRequireQuotesVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-boolean-attributes-no-value.ts

@@ -1,7 +1,8 @@
 import { AttributeVisitorMixin, isBooleanAttribute, hasAttributeValue } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLAttributeNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLAttributeNode, ParseResult } from "@herb-tools/core"
 
 class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, _attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
@@ -16,12 +17,12 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLBooleanAttributesNoValueRule implements Rule {
+export class HTMLBooleanAttributesNoValueRule extends ParserRule {
   name = "html-boolean-attributes-no-value"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new BooleanAttributesNoValueVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new BooleanAttributesNoValueVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-img-require-alt.ts

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class ImgRequireAltVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -31,12 +32,12 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLImgRequireAltRule implements Rule {
+export class HTMLImgRequireAltRule extends ParserRule {
   name = "html-img-require-alt"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new ImgRequireAltVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ImgRequireAltVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, isInlineElement, isBlockElement } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
   private inlineStack: string[] = []
@@ -18,7 +19,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
     return { isInline, isBlock, isUnknown }
   }
 
-  private addViolationMessage(tagName: string, isBlock: boolean, openTag: HTMLOpenTagNode): void {
+  private addOffenseMessage(tagName: string, isBlock: boolean, openTag: HTMLOpenTagNode): void {
     const parentInline = this.inlineStack[this.inlineStack.length - 1]
     const elementType = isBlock ? "Block-level" : "Unknown"
 
@@ -61,7 +62,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
     const { isInline, isBlock, isUnknown } = this.getElementType(tagName)
 
     if ((isBlock || isUnknown) && this.inlineStack.length > 0) {
-      this.addViolationMessage(tagName, isBlock, openTag)
+      this.addOffenseMessage(tagName, isBlock, openTag)
     }
 
     if (isInline) {
@@ -73,12 +74,12 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLNoBlockInsideInlineRule implements Rule {
+export class HTMLNoBlockInsideInlineRule extends ParserRule {
   name = "html-no-block-inside-inline"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new BlockInsideInlineVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new BlockInsideInlineVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, forEachAttribute } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeNameNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeNameNode, ParseResult } from "@herb-tools/core"
 
 class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -48,12 +49,12 @@ class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLNoDuplicateAttributesRule implements Rule {
+export class HTMLNoDuplicateAttributesRule extends ParserRule {
   name = "html-no-duplicate-attributes"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new NoDuplicateAttributesVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoDuplicateAttributesVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -1,7 +1,7 @@
 import { AttributeVisitorMixin } from "./rule-utils"
-
-import type { Node } from "@herb-tools/core"
-import type { LintOffense, Rule } from "../types"
+import { ParserRule } from "../types"
+import type { ParseResult, Node } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types"
 
 class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
   private documentIds: Set<string> = new Set<string>()
@@ -26,13 +26,13 @@ class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
   }
 }
 
-export class HTMLNoDuplicateIdsRule implements Rule {
+export class HTMLNoDuplicateIdsRule extends ParserRule {
   name = "html-no-duplicate-ids"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new NoDuplicateIdsVisitor(this.name)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoDuplicateIdsVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, getTagName, getAttributes, findAttributeByName, getAttributeValue, HEADING_TAGS } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, Node, LiteralNode, HTMLTextNode } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, ParseResult, LiteralNode, HTMLTextNode } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -174,12 +175,12 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLNoEmptyHeadingsRule implements Rule {
+export class HTMLNoEmptyHeadingsRule extends ParserRule {
   name = "html-no-empty-headings"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new NoEmptyHeadingsVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoEmptyHeadingsVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-no-nested-links.ts

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, getTagName } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class NestedLinkVisitor extends BaseRuleVisitor {
   private linkStack: HTMLOpenTagNode[] = []
@@ -54,12 +55,12 @@ class NestedLinkVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLNoNestedLinksRule implements Rule {
+export class HTMLNoNestedLinksRule extends ParserRule {
   name = "html-no-nested-links"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new NestedLinkVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NestedLinkVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-tag-name-lowercase.ts

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class TagNameLowercaseVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -54,12 +55,12 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
   }
 }
 
-export class HTMLTagNameLowercaseRule implements Rule {
+export class HTMLTagNameLowercaseRule extends ParserRule {
   name = "html-tag-name-lowercase"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new TagNameLowercaseVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new TagNameLowercaseVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/index.ts

@@ -1,6 +1,9 @@
 export * from "./erb-no-empty-tags.js"
 export * from "./erb-no-output-control-flow.js"
+export * from "./erb-prefer-image-tag-helper.js"
+export * from "./erb-requires-trailing-newline.js"
 export * from "./html-anchor-require-href.js"
+export * from "./html-aria-level-must-be-valid.js"
 export * from "./html-aria-role-heading-requires-level.js"
 export * from "./html-aria-role-must-be-valid.js"
 export * from "./html-attribute-double-quotes.js"