@herb-tools/linter 0.4.2 → 0.4.3

package/src/default-rules.ts

@@ -2,9 +2,12 @@ import type { RuleClass } from "./types.js"
 
 import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
+import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
+import { ERBRequiresTrailingNewlineRule } from "./rules/erb-requires-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
 import { HTMLAnchorRequireHrefRule } from "./rules/html-anchor-require-href.js"
 import { HTMLAriaAttributeMustBeValid } from "./rules/html-aria-attribute-must-be-valid.js"
+import { HTMLAriaLevelMustBeValidRule } from "./rules/html-aria-level-must-be-valid.js"
 import { HTMLAriaRoleHeadingRequiresLevelRule } from "./rules/html-aria-role-heading-requires-level.js"
 import { HTMLAriaRoleMustBeValidRule } from "./rules/html-aria-role-must-be-valid.js"
 import { HTMLAttributeDoubleQuotesRule } from "./rules/html-attribute-double-quotes.js"
@@ -22,9 +25,12 @@ import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalizatio
 export const defaultRules: RuleClass[] = [
   ERBNoEmptyTagsRule,
   ERBNoOutputControlFlowRule,
+  ERBPreferImageTagHelperRule,
+  ERBRequiresTrailingNewlineRule,
   ERBRequireWhitespaceRule,
   HTMLAnchorRequireHrefRule,
   HTMLAriaAttributeMustBeValid,
+  HTMLAriaLevelMustBeValidRule,
   HTMLAriaRoleHeadingRequiresLevelRule,
   HTMLAriaRoleMustBeValidRule,
   HTMLAttributeDoubleQuotesRule,

package/src/linter.ts

@@ -1,17 +1,20 @@
 import { defaultRules } from "./default-rules.js"
 
-import type { RuleClass, LintResult, LintOffense } from "./types.js"
-import type { DocumentNode } from "@herb-tools/core"
+import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js"
+import type { HerbBackend } from "@herb-tools/core"
 
 export class Linter {
   private rules: RuleClass[]
+  private herb: HerbBackend
   private offenses: LintOffense[]
 
   /**
    * Creates a new Linter instance.
-   * @param rules - Array of rule classes (not instances) to use. If not provided, uses default rules.
+   * @param herb - The Herb backend instance for parsing and lexing
+   * @param rules - Array of rule classes (Parser/AST or Lexer) to use. If not provided, uses default rules.
    */
-  constructor(rules?: RuleClass[]) {
+  constructor(herb: HerbBackend, rules?: RuleClass[]) {
+    this.herb = herb
     this.rules = rules !== undefined ? rules : this.getDefaultRules()
     this.offenses = []
   }
@@ -28,12 +31,43 @@ export class Linter {
     return this.rules.length
   }
 
-  lint(document: DocumentNode): LintResult {
+  /**
+   * Type guard to check if a rule is a LexerRule
+   */
+  private isLexerRule(rule: Rule): rule is LexerRule {
+    return (rule.constructor as any).type === "lexer"
+  }
+
+  /**
+   * Type guard to check if a rule is a SourceRule
+   */
+  private isSourceRule(rule: Rule): rule is SourceRule {
+    return (rule.constructor as any).type === "source"
+  }
+
+  /**
+   * Lint source code using Parser/AST, Lexer, and Source rules.
+   * @param source - The source code to lint
+   * @param context - Optional context for linting (e.g., fileName for distinguishing files vs snippets)
+   */
+  lint(source: string, context?: Partial<LintContext>): LintResult {
     this.offenses = []
 
-    for (const Rule of this.rules) {
-      const rule = new Rule()
-      const ruleOffenses = rule.check(document)
+    const parseResult = this.herb.parse(source)
+    const lexResult = this.herb.lex(source)
+
+    for (const RuleClass of this.rules) {
+      const rule = new RuleClass()
+
+      let ruleOffenses: LintOffense[]
+
+      if (this.isLexerRule(rule)) {
+        ruleOffenses = (rule as LexerRule).check(lexResult, context)
+      } else if (this.isSourceRule(rule)) {
+        ruleOffenses = (rule as SourceRule).check(source, context)
+      } else {
+        ruleOffenses = (rule as ParserRule).check(parseResult.value, context)
+      }
 
       this.offenses.push(...ruleOffenses)
     }

package/src/rules/erb-no-empty-tags.ts

@@ -1,6 +1,7 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { Node, ERBContentNode } from "@herb-tools/core"
 
 class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
@@ -21,11 +22,11 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
   }
 }
 
-export class ERBNoEmptyTagsRule implements Rule {
+export class ERBNoEmptyTagsRule extends ParserRule {
   name = "erb-no-empty-tags"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new ERBNoEmptyTagsVisitor(this.name)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoEmptyTagsVisitor(this.name, context)
 
     visitor.visit(node)
 

package/src/rules/erb-no-output-control-flow.ts

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
 import type { Node, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 
 class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
   visitERBIfNode(node: ERBIfNode): void {
@@ -49,10 +50,11 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
   }
 }
 
-export class ERBNoOutputControlFlowRule implements Rule {
+export class ERBNoOutputControlFlowRule extends ParserRule {
   name = "erb-no-output-control-flow"
-  check(node: Node): LintOffense[] {
-    const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name)
+
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context)
 
     visitor.visit(node)
 

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, Node } 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(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBPreferImageTagHelperVisitor(this.name, context)
+    visitor.visit(node)
+    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 { 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,11 +82,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new RequireWhitespaceInsideTags(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -0,0 +1,27 @@
+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,6 +1,7 @@
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
-import { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLOpenTagNode, Node } from "@herb-tools/core"
 
 class AnchorRechireHrefVisitor extends BaseRuleVisitor {
@@ -26,11 +27,11 @@ 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(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AnchorRechireHrefVisitor(this.name, context)
 
     visitor.visit(node)
 

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

@@ -2,8 +2,8 @@ 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,
@@ -31,11 +31,11 @@ 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);
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaAttributeMustBeValid(this.name, context);
     visitor.visit(node);
     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 { Node, 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(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context)
+
+    visitor.visit(node)
+
+    return visitor.offenses
+  }
+}

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

@@ -1,6 +1,7 @@
 import { AttributeVisitorMixin, getAttributeName, getAttributes } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { Node, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
 
 class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
@@ -33,11 +34,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaRoleHeadingRequiresLevel(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,6 +1,7 @@
 import { AttributeVisitorMixin, VALID_ARIA_ROLES } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { Node, HTMLAttributeNode } from "@herb-tools/core"
 
 class AriaRoleMustBeValid extends AttributeVisitorMixin {
@@ -17,11 +18,11 @@ 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(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaRoleMustBeValid(this.name, context)
 
     visitor.visit(node)
 

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

@@ -1,6 +1,7 @@
 import { AttributeVisitorMixin, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { Node, HTMLAttributeNode } from "@herb-tools/core"
 
 class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
@@ -17,11 +18,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,6 +1,7 @@
 import { AttributeVisitorMixin } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLAttributeNode, HTMLAttributeValueNode, Node } from "@herb-tools/core"
 
 class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
@@ -19,11 +20,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,6 +1,7 @@
 import { AttributeVisitorMixin, isBooleanAttribute, hasAttributeValue } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLAttributeNode, Node } from "@herb-tools/core"
 
 class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
@@ -16,11 +17,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new BooleanAttributesNoValueVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,6 +1,7 @@
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
 
 class ImgRequireAltVisitor extends BaseRuleVisitor {
@@ -31,11 +32,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ImgRequireAltVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,6 +1,7 @@
 import { BaseRuleVisitor, isInlineElement, isBlockElement } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLOpenTagNode, HTMLElementNode, Node } from "@herb-tools/core"
 
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
@@ -73,11 +74,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new BlockInsideInlineVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,6 +1,7 @@
 import { BaseRuleVisitor, forEachAttribute } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeNameNode, Node } from "@herb-tools/core"
 
 class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
@@ -48,11 +49,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoDuplicateAttributesVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }

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

@@ -1,7 +1,7 @@
 import { AttributeVisitorMixin } from "./rule-utils"
-
+import { ParserRule } from "../types"
 import type { Node } from "@herb-tools/core"
-import type { LintOffense, Rule } from "../types"
+import type { LintOffense, LintContext } from "../types"
 
 class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
   private documentIds: Set<string> = new Set<string>()
@@ -26,11 +26,11 @@ 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(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoDuplicateIdsVisitor(this.name, context)
 
     visitor.visit(node)
 

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

@@ -1,6 +1,7 @@
 import { BaseRuleVisitor, getTagName, getAttributes, findAttributeByName, getAttributeValue, HEADING_TAGS } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, Node, LiteralNode, HTMLTextNode } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
@@ -174,11 +175,11 @@ 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)
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoEmptyHeadingsVisitor(this.name, context)
     visitor.visit(node)
     return visitor.offenses
   }