@herb-tools/linter 0.7.4 → 0.8.0

package/src/rules/erb-right-trim.ts

@@ -0,0 +1,67 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBNode, ParseResult } from "@herb-tools/core"
+
+interface ERBRightTrimAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+}
+
+class ERBRightTrimVisitor extends BaseRuleVisitor<ERBRightTrimAutofixContext> {
+  visitERBNode(node: ERBNode): void {
+    if (!node.tag_closing) return
+
+    const trimClosing = node.tag_closing.value
+
+    if (trimClosing !== "=%>") return
+
+    this.addOffense(
+      "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.",
+      node.tag_closing.location,
+      { node }
+    )
+  }
+}
+
+export class ERBRightTrimRule extends ParserRule<ERBRightTrimAutofixContext> {
+  static autocorrectable = true
+  name = "erb-right-trim"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRightTrimAutofixContext>[] {
+    const visitor = new ERBRightTrimVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<ERBRightTrimAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    if (!node.tag_closing) return null
+
+    const closing = node.tag_closing
+
+    if (closing.value === "=%>") {
+      closing.value = "-%>"
+      return result
+    }
+
+    if (closing.value === "-%>") {
+      closing.value = "%>"
+      return result
+    }
+
+    return null
+  }
+}

package/src/rules/herb-disable-comment-base.ts

@@ -0,0 +1,76 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ERBContentNode, Location } from "@herb-tools/core"
+
+import { parseHerbDisableContent } from "../herb-disable-comment-utils.js"
+
+import type { LintContext } from "../types.js"
+import type { HerbDisableComment, HerbDisableRuleName } from "../herb-disable-comment-utils.js"
+
+/**
+ * Base visitor class for herb:disable comment validation rules.
+ * Handles common patterns like checking ERB comments and parsing herb:disable content.
+ */
+export abstract class HerbDisableCommentBaseVisitor extends BaseRuleVisitor {
+  constructor(ruleName: string, context?: Partial<LintContext>) {
+    super(ruleName, context)
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    if (node.tag_opening?.value !== "<%#") return
+
+    const content = node.content?.value
+    if (!content) return
+
+    this.checkHerbDisableComment(node, content)
+  }
+
+  /**
+   * Override this method to implement rule-specific logic.
+   * This is called for every ERB comment node.
+   */
+  protected abstract checkHerbDisableComment(node: ERBContentNode, content: string): void
+
+  /**
+   * Helper to create a precise location for a specific rule name within the comment.
+   * Returns null if content location is not available.
+   */
+  protected createRuleNameLocation(node: ERBContentNode, ruleDetail: HerbDisableRuleName): Location | null {
+    const contentLocation = node.content?.location
+    if (!contentLocation) return null
+
+    const startLine = contentLocation.start.line
+    const startColumn = contentLocation.start.column + ruleDetail.offset
+
+    return Location.from(
+      startLine,
+      startColumn,
+      startLine,
+      startColumn + ruleDetail.length
+    )
+  }
+
+  /**
+   * Helper to add an offense with a fallback to node location if precise location unavailable.
+   */
+  protected addOffenseWithFallback(message: string, preciseLocation: Location | null, node: ERBContentNode): void {
+    this.addOffense(message, preciseLocation || node.location)
+  }
+}
+
+/**
+ * Base visitor for rules that need to process parsed herb:disable comments.
+ * Only calls the abstract method if the content successfully parses as a herb:disable comment.
+ */
+export abstract class HerbDisableCommentParsedVisitor extends HerbDisableCommentBaseVisitor {
+  protected checkHerbDisableComment(node: ERBContentNode, content: string): void {
+    const herbDisable = parseHerbDisableContent(content)
+    if (!herbDisable) return
+
+    this.checkParsedHerbDisable(node, content, herbDisable)
+  }
+
+  /**
+   * Override this method to implement rule-specific logic for parsed herb:disable comments.
+   */
+  protected abstract checkParsedHerbDisable(node: ERBContentNode, content: string, herbDisable: HerbDisableComment): void
+}

package/src/rules/herb-disable-comment-malformed.ts

@@ -0,0 +1,66 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentBaseVisitor } from "./herb-disable-comment-base.js"
+import { parseHerbDisableContent } from "../herb-disable-comment-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+
+class HerbDisableCommentMalformedVisitor extends HerbDisableCommentBaseVisitor {
+  protected checkHerbDisableComment(node: ERBContentNode, content: string): void {
+    const trimmed = content.trim()
+    const looksLikeHerbDisable = trimmed.startsWith("herb:disable")
+    if (!looksLikeHerbDisable) return
+
+    if (trimmed.length > "herb:disable".length) {
+      const charAfterPrefix = trimmed["herb:disable".length]
+
+      if (charAfterPrefix !== ' ' && charAfterPrefix !== '\t' && charAfterPrefix !== '\n') {
+        this.addOffense(
+          "`herb:disable` comment is missing a space after `herb:disable`. Add a space before the rule names.",
+          node.location,
+        )
+
+        return
+      }
+    }
+
+    const afterPrefix = trimmed.substring("herb:disable".length).trim()
+    if (afterPrefix.length === 0) return
+
+    const parsed = parseHerbDisableContent(content)
+    if (parsed !== null) return
+
+    let message = "`herb:disable` comment is malformed."
+
+    const rulesString = afterPrefix.trim()
+
+    if (rulesString.endsWith(',')) {
+      message = "`herb:disable` comment has a trailing comma. Remove the trailing comma."
+    } else if (rulesString.includes(',,') || rulesString.match(/,\s*,/)) {
+      message = "`herb:disable` comment has consecutive commas. Remove extra commas."
+    } else if (rulesString.startsWith(',')) {
+      message = "`herb:disable` comment starts with a comma. Remove the leading comma."
+    }
+
+    this.addOffense(message, node.location)
+  }
+}
+
+export class HerbDisableCommentMalformedRule extends ParserRule {
+  name = "herb-disable-comment-malformed"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentMalformedVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-missing-rules.ts

@@ -0,0 +1,41 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentBaseVisitor } from "./herb-disable-comment-base.js"
+
+import { parseHerbDisableContent } from "../herb-disable-comment-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+
+class HerbDisableCommentMissingRulesVisitor extends HerbDisableCommentBaseVisitor {
+  protected checkHerbDisableComment(node: ERBContentNode, content: string): void {
+    const herbDisable = parseHerbDisableContent(content)
+    if (herbDisable) return
+
+    const emptyFormat = /^\s*herb:disable\s*$/
+    if (!emptyFormat.test(content)) return
+
+    this.addOffense(
+      `\`herb:disable\` comment is missing rule names. Specify \`all\` or list specific rules to disable.`,
+      node.location,
+    )
+  }
+}
+
+export class HerbDisableCommentMissingRulesRule extends ParserRule {
+  name = "herb-disable-comment-missing-rules"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentMissingRulesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-no-duplicate-rules.ts

@@ -0,0 +1,46 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentNoDuplicateRulesVisitor extends HerbDisableCommentParsedVisitor {
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    const seenRules = new Map<string, number>()
+
+    herbDisable.ruleNameDetails.forEach((ruleDetail, index) => {
+      const firstIndex = seenRules.get(ruleDetail.name)
+
+      if (firstIndex !== undefined) {
+        const location = this.createRuleNameLocation(node, ruleDetail)
+        const message = `Duplicate rule \`${ruleDetail.name}\` in \`herb:disable\` comment. Remove the duplicate.`
+
+        this.addOffenseWithFallback(message, location, node)
+
+        return
+      }
+
+      seenRules.set(ruleDetail.name, index)
+    })
+  }
+}
+
+export class HerbDisableCommentNoDuplicateRulesRule extends ParserRule {
+  name = "herb-disable-comment-no-duplicate-rules"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentNoDuplicateRulesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-no-redundant-all.ts

@@ -0,0 +1,40 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentNoRedundantAllVisitor extends HerbDisableCommentParsedVisitor {
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    if (!herbDisable.ruleNames.includes("all")) return
+    if (herbDisable.ruleNames.length <= 1) return
+
+    const allDetail = herbDisable.ruleNameDetails.find(detail => detail.name === "all")
+    if (!allDetail) return
+
+    const location = this.createRuleNameLocation(node, allDetail)
+    const message = `Using \`all\` with specific rules is redundant. Use \`herb:disable all\` by itself or list only specific rules.`
+
+    this.addOffenseWithFallback(message, location, node)
+  }
+}
+
+export class HerbDisableCommentNoRedundantAllRule extends ParserRule {
+  name = "herb-disable-comment-no-redundant-all"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentNoRedundantAllVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-unnecessary.ts

@@ -0,0 +1,103 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentUnnecessaryVisitor extends HerbDisableCommentParsedVisitor {
+  private ignoredOffensesByLine: Map<number, Set<string>>
+  private validRuleNames: Set<string>
+
+  constructor(ruleName: string, ignoredOffensesByLine: Map<number, Set<string>>, validRuleNames: string[], context?: Partial<LintContext>) {
+    super(ruleName, context)
+
+    this.ignoredOffensesByLine = ignoredOffensesByLine
+    this.validRuleNames = new Set([...validRuleNames, "all"])
+  }
+
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    const line = node.location.start.line
+    const usedRuleNames = this.ignoredOffensesByLine.get(line) || new Set<string>()
+
+    if (herbDisable.ruleNames.includes("all")) {
+      if (herbDisable.ruleNames.length > 1) return
+      if (usedRuleNames.size > 0) return
+
+      this.addOffense(
+        `No offenses to disable on this line. Remove the \`herb:disable all\` comment.`,
+        node.location,
+      )
+
+      return
+    }
+
+    const unnecessaryRules = herbDisable.ruleNameDetails.filter(
+      detail => this.validRuleNames.has(detail.name) && !usedRuleNames.has(detail.name)
+    )
+
+    if (unnecessaryRules.length === 0) return
+
+    const validRuleCount = herbDisable.ruleNames.filter(name => this.validRuleNames.has(name)).length
+
+    if (unnecessaryRules.length === validRuleCount) {
+      if (unnecessaryRules.length === 1) {
+        const ruleName = unnecessaryRules[0].name
+
+        this.addOffense(
+          `No offenses from \`${ruleName}\` on this line. Remove the \`herb:disable\` comment.`,
+          node.location,
+        )
+
+        return
+      }
+
+      const unnecessaryRuleNames = unnecessaryRules.map(rule => `\`${rule.name}\``).join(", ")
+
+      this.addOffense(
+        `No offenses from rules ${unnecessaryRuleNames} on this line. Remove them from the \`herb:disable\` comment.`,
+        node.location,
+      )
+
+      return
+    }
+
+    for (const unnecessaryRule of unnecessaryRules) {
+      const location = this.createRuleNameLocation(node, unnecessaryRule)
+      const message = `No offenses from \`${unnecessaryRule.name}\` on this line. Remove it from the \`herb:disable\` comment.`
+
+      this.addOffenseWithFallback(message, location, node)
+    }
+  }
+}
+
+export class HerbDisableCommentUnnecessaryRule extends ParserRule {
+  name = "herb-disable-comment-unnecessary"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const validRuleNames = context?.validRuleNames
+    const ignoredOffensesByLine = context?.ignoredOffensesByLine
+
+    if (!validRuleNames) return []
+    if (validRuleNames.length === 0) return []
+    if (!ignoredOffensesByLine) return []
+
+    const visitor = new HerbDisableCommentUnnecessaryVisitor(
+      this.name,
+      ignoredOffensesByLine,
+      validRuleNames,
+      context
+    )
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-valid-rule-name.ts

@@ -0,0 +1,62 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import { didyoumean } from "@herb-tools/core"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentValidRuleNameVisitor extends HerbDisableCommentParsedVisitor {
+  private validRuleNames: Set<string> = new Set()
+  private validRuleNamesList: string[] = []
+
+  constructor(ruleName: string, validRuleNames: string[], context?: Partial<LintContext>) {
+    super(ruleName, context)
+
+    this.validRuleNames = new Set([...validRuleNames, "all"])
+    this.validRuleNamesList = Array.from(this.validRuleNames)
+  }
+
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    herbDisable.ruleNameDetails.forEach(ruleDetail => {
+      if (this.validRuleNames.has(ruleDetail.name)) return
+
+      const suggestion = didyoumean(ruleDetail.name, this.validRuleNamesList)
+      const message = suggestion
+        ? `Unknown rule \`${ruleDetail.name}\`. Did you mean \`${suggestion}\`?`
+        : `Unknown rule \`${ruleDetail.name}\`.`
+
+      const location = this.createRuleNameLocation(node, ruleDetail)
+      this.addOffenseWithFallback(message, location, node)
+    })
+  }
+}
+
+export class HerbDisableCommentValidRuleNameRule extends ParserRule {
+  name = "herb-disable-comment-valid-rule-name"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const validRuleNames = context?.validRuleNames
+
+    if (!validRuleNames) return []
+    if (validRuleNames.length === 0) return []
+
+    const visitor = new HerbDisableCommentValidRuleNameVisitor(
+      this.name,
+      validRuleNames,
+      context
+    )
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

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

@@ -1,7 +1,7 @@
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class AnchorRechireHrefVisitor extends BaseRuleVisitor {
@@ -21,7 +21,6 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Add an `href` attribute to `<a>` to ensure it is focusable and accessible.",
         node.tag_name!.location,
-        "error",
       )
     }
   }
@@ -30,7 +29,14 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
 export class HTMLAnchorRequireHrefRule extends ParserRule {
   name = "html-anchor-require-href"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new AnchorRechireHrefVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { ARIA_ATTRIBUTES, AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class AriaAttributeMustBeValid extends AttributeVisitorMixin {
@@ -20,7 +20,6 @@ class AriaAttributeMustBeValid extends AttributeVisitorMixin {
     this.addOffense(
       `The attribute \`${attributeName}\` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.`,
       attributeNode.location,
-      "error"
     )
   }
 }
@@ -28,7 +27,14 @@ class AriaAttributeMustBeValid extends AttributeVisitorMixin {
 export class HTMLAriaAttributeMustBeValid extends ParserRule {
   name = "html-aria-attribute-must-be-valid"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new AriaAttributeMustBeValid(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/html-aria-label-is-well-formatted.ts

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult } from "@herb-tools/core"
 
 class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
@@ -12,7 +12,6 @@ class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
       this.addOffense(
         "The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.",
         attributeNode.location,
-        "error"
       )
 
       return
@@ -22,7 +21,6 @@ class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
       this.addOffense(
         "The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.",
         attributeNode.location,
-        "error"
       )
 
       return
@@ -32,7 +30,6 @@ class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
       this.addOffense(
         "The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).",
         attributeNode.location,
-        "error"
       )
     }
   }
@@ -49,7 +46,14 @@ class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
 export class HTMLAriaLabelIsWellFormattedRule extends ParserRule {
   name = "html-aria-label-is-well-formatted"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new AriaLabelIsWellFormattedVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -2,7 +2,7 @@ import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
 import { getValidatableStaticContent, hasERBOutput, filterLiteralNodes, filterERBContentNodes, isERBOutputNode } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
@@ -65,7 +65,14 @@ class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
 export class HTMLAriaLevelMustBeValidRule extends ParserRule {
   name = "html-aria-level-must-be-valid"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, getAttributeName, getAttributes, StaticAttributeStaticValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult } from "@herb-tools/core"
 
 class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
@@ -15,7 +15,6 @@ class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
     this.addOffense(
       `Element with \`role="heading"\` must have an \`aria-level\` attribute.`,
       attributeNode.location,
-      "error"
     )
   }
 }
@@ -23,7 +22,14 @@ class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
 export class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
   name = "html-aria-role-heading-requires-level"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new AriaRoleHeadingRequiresLevel(this.name, context)
 
     visitor.visit(result.value)