@herb-tools/linter 0.7.4 → 0.8.0

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

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, hasAttribute, getAttributeValue, findAttributeByName, getAttributes } from "./rule-utils.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 NavigationHasLabelVisitor extends BaseRuleVisitor {
@@ -32,7 +32,6 @@ class NavigationHasLabelVisitor extends BaseRuleVisitor {
       this.addOffense(
         message,
         node.tag_name!.location,
-        "error"
       )
     }
   }
@@ -54,7 +53,14 @@ class NavigationHasLabelVisitor extends BaseRuleVisitor {
 export class HTMLNavigationHasLabelRule extends ParserRule {
   name = "html-navigation-has-label"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NavigationHasLabelVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, hasAttribute, getAttributeValue, findAttributeByName, getAttributes } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 const INTERACTIVE_ELEMENTS = new Set([
@@ -21,7 +21,6 @@ class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Elements that are focusable should not have \`aria-hidden="true"\` because it will cause confusion for assistive technology users.`,
         node.tag_name!.location,
-        "error"
       )
     }
   }
@@ -80,7 +79,14 @@ class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
 export class HTMLNoAriaHiddenOnFocusableRule extends ParserRule {
   name = "html-no-aria-hidden-on-focusable"
 
-  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 NoAriaHiddenOnFocusableVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,7 +1,7 @@
 import { BaseRuleVisitor, isInlineElement, isBlockElement } 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, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
@@ -26,7 +26,6 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
     this.addOffense(
       `${elementType} element \`<${tagName}>\` cannot be placed inside inline element \`<${parentInline}>\`.`,
       openTag.tag_name!.location,
-      "error"
     )
   }
 
@@ -77,7 +76,14 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
 export class HTMLNoBlockInsideInlineRule extends ParserRule {
   name = "html-no-block-inside-inline"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     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,7 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, HTMLAttributeNode, ParseResult } from "@herb-tools/core"
 
 class NoDuplicateAttributesVisitor extends AttributeVisitorMixin {
@@ -39,7 +39,6 @@ class NoDuplicateAttributesVisitor extends AttributeVisitorMixin {
           this.addOffense(
             `Duplicate attribute \`${attributeName}\` found on tag. Remove the duplicate occurrence.`,
             attributeNode.name!.location,
-            "error"
           )
         }
       }
@@ -50,7 +49,14 @@ class NoDuplicateAttributesVisitor extends AttributeVisitorMixin {
 export class HTMLNoDuplicateAttributesRule extends ParserRule {
   name = "html-no-duplicate-attributes"
 
-  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 NoDuplicateAttributesVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,4 +1,4 @@
-import { ParserRule } from "../types"
+import { ParserRule, BaseAutofixContext } from "../types"
 import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
 import { LiteralNode } from "@herb-tools/core"
 import { Printer, IdentityPrinter } from "@herb-tools/printer"
@@ -6,7 +6,7 @@ import { Printer, IdentityPrinter } from "@herb-tools/printer"
 import { hasERBOutput, getValidatableStaticContent, isEffectivelyStatic, isNode, getStaticAttributeName, isERBOutputNode } from "@herb-tools/core"
 
 import type { ParseResult, HTMLAttributeNode, ERBContentNode } from "@herb-tools/core"
-import type { LintOffense, LintContext } from "../types"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types"
 
 interface ControlFlowState {
   previousBranchIds: Set<string>
@@ -29,7 +29,7 @@ class OutputPrinter extends Printer {
   }
 }
 
-class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState, BranchState> {
+class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<BaseAutofixContext, ControlFlowState, BranchState> {
   private documentIds: Set<string> = new Set<string>()
   private currentBranchIds: Set<string> = new Set<string>()
   private controlFlowIds: Set<string> = new Set<string>()
@@ -180,7 +180,6 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState,
     this.addOffense(
       `Duplicate ID \`${identifier}\` found. IDs must be unique within a document.`,
       location,
-      "error"
     )
   }
 
@@ -188,7 +187,6 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState,
     this.addOffense(
       `Duplicate ID \`${identifier}\` found within the same loop iteration. IDs must be unique within the same loop iteration.`,
       location,
-      "error"
     )
   }
 
@@ -196,7 +194,6 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState,
     this.addOffense(
       `Duplicate ID \`${identifier}\` found within the same control flow branch. IDs must be unique within the same control flow branch.`,
       location,
-      "error"
     )
   }
 }
@@ -204,7 +201,14 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState,
 export class HTMLNoDuplicateIdsRule extends ParserRule {
   name = "html-no-duplicate-ids"
 
-  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 NoDuplicateIdsVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -0,0 +1,188 @@
+import { isHTMLElementNode } from "@herb-tools/core"
+import { getTagName, getAttributeName, getAttributeValue, forEachAttribute } from "./rule-utils"
+
+import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
+import { ParserRule, BaseAutofixContext } from "../types"
+
+import type { ParseResult, HTMLElementNode, HTMLAttributeNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types"
+
+interface MetaTag {
+  node: HTMLElementNode
+  nameValue?: string
+  httpEquivValue?: string
+}
+
+interface ControlFlowState {
+  previousBranchMetas: MetaTag[]
+  previousControlFlowMetas: MetaTag[]
+}
+
+interface BranchState {
+  previousBranchMetas: MetaTag[]
+}
+
+class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor<BaseAutofixContext, ControlFlowState, BranchState> {
+  private elementStack: string[] = []
+  private documentMetas: MetaTag[] = []
+  private currentBranchMetas: MetaTag[] = []
+  private controlFlowMetas: MetaTag[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node)?.toLowerCase()
+    if (!tagName) return
+
+    if (tagName === "head") {
+      this.documentMetas = []
+      this.currentBranchMetas = []
+      this.controlFlowMetas = []
+    } else if (tagName === "meta" && this.insideHead) {
+      this.collectAndCheckMetaTag(node)
+    }
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  protected onEnterControlFlow(_controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): ControlFlowState {
+    const stateToRestore: ControlFlowState = {
+      previousBranchMetas: this.currentBranchMetas,
+      previousControlFlowMetas: this.controlFlowMetas
+    }
+
+    this.currentBranchMetas = []
+
+    if (!wasAlreadyInControlFlow) {
+      this.controlFlowMetas = []
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: ControlFlowState): void {
+    if (controlFlowType === ControlFlowType.CONDITIONAL && !wasAlreadyInControlFlow) {
+      this.controlFlowMetas.forEach(meta => this.documentMetas.push(meta))
+    }
+
+    this.currentBranchMetas = stateToRestore.previousBranchMetas
+    this.controlFlowMetas = stateToRestore.previousControlFlowMetas
+  }
+
+  protected onEnterBranch(): BranchState {
+    const stateToRestore: BranchState = {
+      previousBranchMetas: this.currentBranchMetas
+    }
+
+    if (this.isInControlFlow) {
+      this.currentBranchMetas = []
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitBranch(_stateToRestore: BranchState): void {}
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+
+  private collectAndCheckMetaTag(node: HTMLElementNode): void {
+    const metaTag: MetaTag = { node }
+    this.extractAttributes(node, metaTag)
+
+    if (!metaTag.nameValue && !metaTag.httpEquivValue) return
+
+    if (this.isInControlFlow) {
+      this.handleControlFlowMeta(metaTag)
+    } else {
+      this.handleGlobalMeta(metaTag)
+    }
+
+    this.currentBranchMetas.push(metaTag)
+  }
+
+  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
+        }
+      })
+    }
+  }
+
+  private handleControlFlowMeta(metaTag: MetaTag): void {
+    if (this.currentControlFlowType === ControlFlowType.LOOP) {
+      this.checkAgainstMetaList(metaTag, this.currentBranchMetas, "within the same loop iteration")
+    } else {
+      this.checkAgainstMetaList(metaTag, this.currentBranchMetas, "within the same control flow branch")
+      this.checkAgainstMetaList(metaTag, this.documentMetas, "")
+
+      this.controlFlowMetas.push(metaTag)
+    }
+  }
+
+  private handleGlobalMeta(metaTag: MetaTag): void {
+    this.checkAgainstMetaList(metaTag, this.documentMetas, "")
+    this.documentMetas.push(metaTag)
+  }
+
+  private checkAgainstMetaList(metaTag: MetaTag, existingMetas: MetaTag[], context: string): void {
+    for (const existing of existingMetas) {
+      if (this.areMetaTagsDuplicate(metaTag, existing)) {
+        const attributeDescription = metaTag.nameValue
+          ? `\`name="${metaTag.nameValue}"\``
+          : `\`http-equiv="${metaTag.httpEquivValue}"\``
+
+        const attributeType = metaTag.nameValue ? "Meta names" : "`http-equiv` values"
+
+        const contextMsg = context ? ` ${context}` : ""
+
+        this.addOffense(
+          `Duplicate \`<meta>\` tag with ${attributeDescription}${contextMsg}. ${attributeType} should be unique within the \`<head>\` section.`,
+          metaTag.node.location,
+        )
+
+        return
+      }
+    }
+  }
+
+  private areMetaTagsDuplicate(meta1: MetaTag, meta2: MetaTag): boolean {
+    if (meta1.nameValue && meta2.nameValue) {
+      return meta1.nameValue.toLowerCase() === meta2.nameValue.toLowerCase()
+    }
+
+    if (meta1.httpEquivValue && meta2.httpEquivValue) {
+      return meta1.httpEquivValue.toLowerCase() === meta2.httpEquivValue.toLowerCase()
+    }
+
+    return false
+  }
+}
+
+export class HTMLNoDuplicateMetaNamesRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-no-duplicate-meta-names"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

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

@@ -1,11 +1,11 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, DynamicAttributeStaticValueParams } from "./rule-utils.js"
 import { IdentityPrinter } from "@herb-tools/printer"
+import { Visitor, isERBOutputNode } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, HTMLAttributeNode, ERBContentNode, LiteralNode, Node } from "@herb-tools/core"
 
-// Attributes that must not have empty values
 const RESTRICTED_ATTRIBUTES = new Set([
   'id',
   'class',
@@ -18,19 +18,15 @@ const RESTRICTED_ATTRIBUTES = new Set([
   'role'
 ])
 
-// Check if attribute name matches any restricted patterns
 function isRestrictedAttribute(attributeName: string): boolean {
-  // Check direct matches
   if (RESTRICTED_ATTRIBUTES.has(attributeName)) {
     return true
   }
 
-  // Check for data-* attributes
   if (attributeName.startsWith('data-')) {
     return true
   }
 
-  // Check for aria-* attributes
   if (attributeName.startsWith('aria-')) {
     return true
   }
@@ -42,6 +38,50 @@ function isDataAttribute(attributeName: string): boolean {
   return attributeName.startsWith('data-')
 }
 
+/**
+ * Visitor that checks if a node tree contains any output content.
+ * Output content includes:
+ * - Non-whitespace literal text (LiteralNode)
+ * - ERB output tags (<%= %>, <%== %>)
+ */
+class ContainsOutputContentVisitor extends Visitor {
+  public hasOutputContent: boolean = false
+
+  visitLiteralNode(node: LiteralNode): void {
+    if (this.hasOutputContent) return
+
+    if (node.content && node.content.trim() !== "") {
+      this.hasOutputContent = true
+
+      return
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    if (this.hasOutputContent) return
+
+    if (isERBOutputNode(node)) {
+      this.hasOutputContent = true
+
+      return
+    }
+
+    this.visitChildNodes(node)
+  }
+}
+
+
+function containsOutputContent(node: Node): boolean {
+  const visitor = new ContainsOutputContentVisitor()
+
+  visitor.visit(node)
+
+  return visitor.hasOutputContent
+}
+
+
 class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
     this.checkEmptyAttribute(attributeName, attributeValue, attributeNode)
@@ -56,6 +96,9 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
     if (!isRestrictedAttribute(attributeName)) return
     if (attributeValue.trim() !== "") return
 
+    if (!attributeNode?.value) return
+    if (containsOutputContent(attributeNode.value)) return
+
     const hasExplicitValue = attributeNode.value !== null
 
     if (isDataAttribute(attributeName)) {
@@ -63,7 +106,6 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
         this.addOffense(
           `Data attribute \`${attributeName}\` should not have an empty value. Either provide a meaningful value or use \`${attributeName}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`,
           attributeNode.location,
-          "warning"
         )
       }
 
@@ -73,7 +115,6 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` must not be empty. Either provide a meaningful value or remove the attribute entirely.`,
       attributeNode.location,
-      "warning"
     )
   }
 }
@@ -81,7 +122,14 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
 export class HTMLNoEmptyAttributesRule extends ParserRule {
   name = "html-no-empty-attributes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NoEmptyAttributesVisitor(this.name, context)
 
     visitor.visit(result.value)

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 { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, ParseResult, LiteralNode, HTMLTextNode } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
@@ -38,7 +39,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Heading element ${elementDescription} must not be empty. Provide accessible text content for screen readers and SEO.`,
         node.location,
-        "error"
       )
     }
   }
@@ -49,7 +49,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       return true
     }
 
-    // Check if all content is just whitespace or inaccessible
     let hasAccessibleContent = false
 
     for (const child of node.body) {
@@ -70,13 +69,11 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       } else if (child.type === "AST_HTML_ELEMENT_NODE") {
         const elementNode = child as HTMLElementNode
 
-        // Check if this element is accessible (not aria-hidden="true")
         if (this.isElementAccessible(elementNode)) {
           hasAccessibleContent = true
           break
         }
       } else {
-        // If there's any non-literal/non-text/non-element content (like ERB), consider it accessible
         hasAccessibleContent = true
         break
       }
@@ -98,7 +95,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   }
 
   private isElementAccessible(node: HTMLElementNode): boolean {
-    // Check if the element has aria-hidden="true"
     if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
       return true
     }
@@ -115,7 +111,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       }
     }
 
-    // Recursively check if the element has any accessible content
     if (!node.body || node.body.length === 0) {
       return false
     }
@@ -149,7 +144,14 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
 export class HTMLNoEmptyHeadingsRule extends ParserRule {
   name = "html-no-empty-headings"
 
-  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 NoEmptyHeadingsVisitor(this.name, context)
     visitor.visit(result.value)
     return visitor.offenses

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

@@ -1,7 +1,7 @@
 import { BaseRuleVisitor, getTagName } 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, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class NestedLinkVisitor extends BaseRuleVisitor {
@@ -12,7 +12,6 @@ class NestedLinkVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Nested `<a>` elements are not allowed. Links cannot contain other links.",
         openTag.tag_name!.location,
-        "error"
       )
 
       return true
@@ -58,7 +57,14 @@ class NestedLinkVisitor extends BaseRuleVisitor {
 export class HTMLNoNestedLinksRule extends ParserRule {
   name = "html-no-nested-links"
 
-  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 NestedLinkVisitor(this.name, context)
     visitor.visit(result.value)
     return visitor.offenses

package/src/rules/html-no-positive-tab-index.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 NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
@@ -14,7 +14,6 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
       this.addOffense(
         `Do not use positive \`tabindex\` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use \`tabindex="0"\` to make an element focusable or \`tabindex="-1"\` to remove it from the tab sequence.`,
         attributeNode.location,
-        "error"
       )
     }
   }
@@ -23,7 +22,14 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
 export class HTMLNoPositiveTabIndexRule extends ParserRule {
   name = "html-no-positive-tab-index"
 
-  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 NoPositiveTabIndexVisitor(this.name, context)
 
     visitor.visit(result.value)