@herb-tools/linter 0.8.10 → 0.9.1

package/src/rules/rule-utils.ts

@@ -1,24 +1,24 @@
 import {
   Visitor,
   Location,
-  getStaticAttributeName,
-  hasDynamicAttributeName as hasNodeDynamicAttributeName,
-  getCombinedAttributeName,
+  Position,
   hasERBOutput,
-  getStaticContentFromNodes,
-  hasStaticContent,
   isEffectivelyStatic,
-  getValidatableStaticContent
+  getValidatableStaticContent,
+  getAttributeName,
+  getStaticAttributeValue,
+  hasDynamicAttributeName,
+  getCombinedAttributeNameString,
+  getAttributeValueNodes,
+  getAttributeValue,
+  forEachAttribute,
 } from "@herb-tools/core"
 
 import type {
-  ERBContentNode,
   HTMLAttributeNameNode,
   HTMLAttributeNode,
-  HTMLAttributeValueNode,
   HTMLElementNode,
   HTMLOpenTagNode,
-  LiteralNode,
   LexResult,
   Token,
   Node
@@ -27,7 +27,8 @@ import type {
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
 import type * as Nodes from "@herb-tools/core"
-import type { UnboundLintOffense, LintContext, BaseAutofixContext } from "../types.js"
+import type { DiagnosticTag } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, LintSeverity, BaseAutofixContext } from "../types.js"
 
 export enum ControlFlowType {
   CONDITIONAL,
@@ -53,7 +54,7 @@ export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext
    * Helper method to create an unbound lint offense (without severity).
    * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext> {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -61,14 +62,16 @@ export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext
       message,
       location,
       autofixContext,
+      severity,
+      tags,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void {
-    this.offenses.push(this.createOffense(message, location, autofixContext))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags))
   }
 }
 
@@ -162,236 +165,6 @@ export abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAut
   protected abstract onExitBranch(stateToRestore: TBranchState): void
 }
 
-/**
- * Gets attributes from an HTMLOpenTagNode
- */
-export function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[] {
-  return node.children.filter(node => node.type === "AST_HTML_ATTRIBUTE_NODE") as HTMLAttributeNode[]
-}
-
-/**
- * Gets the tag name from an HTML tag node (lowercased)
- */
-export function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null {
-  if (!node) return null
-
-  return node.tag_name?.value.toLowerCase() || null
-}
-
-/**
- * Gets the attribute name from an HTMLAttributeNode (lowercased)
- * Returns null if the attribute name contains dynamic content (ERB)
- */
-export function getAttributeName(attributeNode: HTMLAttributeNode, lowercase = true): string | null {
-  if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
-    const nameNode = attributeNode.name as HTMLAttributeNameNode
-    const staticName = getStaticAttributeName(nameNode)
-
-    if (!lowercase) return staticName
-
-    return staticName ? staticName.toLowerCase() : null
-  }
-
-  return null
-}
-
-/**
- * Checks if an attribute has a dynamic (ERB-containing) name
- */
-export function hasDynamicAttributeName(attributeNode: HTMLAttributeNode): boolean {
-  if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
-    const nameNode = attributeNode.name as HTMLAttributeNameNode
-    return hasNodeDynamicAttributeName(nameNode)
-  }
-
-  return false
-}
-
-/**
- * Gets the combined string representation of an attribute name (for debugging)
- * This includes both static content and ERB syntax
- */
-export function getCombinedAttributeNameString(attributeNode: HTMLAttributeNode): string {
-  if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
-    const nameNode = attributeNode.name as HTMLAttributeNameNode
-
-    return getCombinedAttributeName(nameNode)
-  }
-
-  return ""
-}
-
-/**
- * Checks if an attribute value contains only static content (no ERB)
- */
-export function hasStaticAttributeValue(attributeNode: HTMLAttributeNode): boolean {
-  const valueNode = attributeNode.value as HTMLAttributeValueNode | null
-
-  if (!valueNode?.children) return false
-
-  return valueNode.children.every(child => child.type === "AST_LITERAL_NODE")
-}
-
-/**
- * Checks if an attribute value contains dynamic content (ERB)
- */
-export function hasDynamicAttributeValue(attributeNode: HTMLAttributeNode): boolean {
-  const valueNode = attributeNode.value as HTMLAttributeValueNode | null
-
-  if (!valueNode?.children) return false
-
-  return valueNode.children.some(child => child.type === "AST_ERB_CONTENT_NODE")
-}
-
-/**
- * Gets the static string value of an attribute (returns null if it contains ERB)
- */
-export function getStaticAttributeValue(attributeNode: HTMLAttributeNode): string | null {
-  if (!hasStaticAttributeValue(attributeNode)) return null
-
-  const valueNode = attributeNode.value as HTMLAttributeValueNode
-
-  const result = valueNode.children
-    ?.filter(child => child.type === "AST_LITERAL_NODE")
-    .map(child => (child as LiteralNode).content)
-    .join("") || ""
-
-  return result
-}
-
-/**
- * Gets the value nodes array for dynamic inspection
- */
-export function getAttributeValueNodes(attributeNode: HTMLAttributeNode): Node[] {
-  const valueNode = attributeNode.value as HTMLAttributeValueNode | null
-
-  return valueNode?.children || []
-}
-
-/**
- * Checks if an attribute value contains any static content (for validation purposes)
- */
-export function hasStaticAttributeValueContent(attributeNode: HTMLAttributeNode): boolean {
-  const valueNodes = getAttributeValueNodes(attributeNode)
-
-  return hasStaticContent(valueNodes)
-}
-
-/**
- * Gets the static content of an attribute value (all literal parts combined)
- * Returns the concatenated literal content, or null if no literal nodes exist
- */
-export function getStaticAttributeValueContent(attributeNode: HTMLAttributeNode): string | null {
-  const valueNodes = getAttributeValueNodes(attributeNode)
-
-  return getStaticContentFromNodes(valueNodes)
-}
-
-/**
- * Gets the attribute value content from an HTMLAttributeValueNode
- */
-export function getAttributeValue(attributeNode: HTMLAttributeNode): string | null {
-  const valueNode: HTMLAttributeValueNode | null = attributeNode.value as HTMLAttributeValueNode
-
-  if (valueNode === null) return null
-
-  if (valueNode.type !== "AST_HTML_ATTRIBUTE_VALUE_NODE" || !valueNode.children?.length) {
-    return null
-  }
-
-  let result = ""
-
-  for (const child of valueNode.children) {
-    switch (child.type) {
-      case "AST_ERB_CONTENT_NODE": {
-        const erbNode = child as ERBContentNode
-
-        if (erbNode.content) {
-          result += `${erbNode.tag_opening?.value}${erbNode.content.value}${erbNode.tag_closing?.value}`
-        }
-
-        break
-      }
-
-      case "AST_LITERAL_NODE": {
-        result += (child as LiteralNode).content
-        break
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Checks if an attribute has a value
- */
-export function hasAttributeValue(attributeNode: HTMLAttributeNode): boolean {
-  return attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE"
-}
-
-/**
- * Gets the quote type used for an attribute value
- */
-export function getAttributeValueQuoteType(nodeOrAttribute: HTMLAttributeNode | HTMLAttributeValueNode): "single" | "double" | "none" | null {
-  let valueNode: HTMLAttributeValueNode | undefined
-
-  if (nodeOrAttribute.type === "AST_HTML_ATTRIBUTE_NODE") {
-    const attributeNode = nodeOrAttribute as HTMLAttributeNode
-
-    if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-      valueNode = attributeNode.value as HTMLAttributeValueNode
-    }
-  } else if (nodeOrAttribute.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-    valueNode = nodeOrAttribute as HTMLAttributeValueNode
-  }
-
-  if (valueNode) {
-    if (valueNode.quoted && valueNode.open_quote) {
-      return valueNode.open_quote.value === '"' ? "double" : "single"
-    }
-
-    return "none"
-  }
-
-  return null
-}
-
-/**
- * Finds an attribute by name in a list of attributes
- */
-export function findAttributeByName(attributes: Node[], attributeName: string): HTMLAttributeNode | null {
-  for (const child of attributes) {
-    if (child.type === "AST_HTML_ATTRIBUTE_NODE") {
-      const attributeNode = child as HTMLAttributeNode
-      const name = getAttributeName(attributeNode)
-
-      if (name === attributeName.toLowerCase()) {
-        return attributeNode
-      }
-    }
-  }
-
-  return null
-}
-
-/**
- * Checks if a tag has a specific attribute
- */
-export function hasAttribute(node: HTMLOpenTagNode | null | undefined, attributeName: string): boolean {
-  if (!node) return false
-
-  return getAttribute(node, attributeName) !== null
-}
-
-/**
- * Checks if a tag has a specific attribute
- */
-export function getAttribute(node: HTMLOpenTagNode, attributeName: string): HTMLAttributeNode | null {
-  const attributes = getAttributes(node)
-
-  return findAttributeByName(attributes, attributeName)
-}
 
 /**
  * Common HTML element categorization
@@ -485,6 +258,26 @@ export const VALID_ARIA_ROLES = new Set([
   "log", "marquee"
 ]);
 
+/**
+ * Abstract ARIA roles used to support the WAI-ARIA Roles Model.
+ * Authors MUST NOT use abstract roles in content.
+ * @see https://www.w3.org/TR/wai-aria-1.0/roles#abstract_roles
+ */
+export const ABSTRACT_ARIA_ROLES = new Set([
+  "command",
+  "composite",
+  "input",
+  "landmark",
+  "range",
+  "roletype",
+  "section",
+  "sectionhead",
+  "select",
+  "structure",
+  "widget",
+  "window"
+]);
+
 /**
  * Parameter types for AttributeVisitorMixin methods
  */
@@ -638,7 +431,7 @@ export abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixC
   private checkAttributesOnNode(node: HTMLOpenTagNode): void {
     forEachAttribute(node, (attributeNode) => {
       const staticAttributeName = getAttributeName(attributeNode)
-      const originalAttributeName = getAttributeName(attributeNode, false) || ""
+      const originalAttributeName = getAttributeName(attributeNode, false) || ""
       const isDynamicName = hasDynamicAttributeName(attributeNode)
       const staticAttributeValue = getStaticAttributeValue(attributeNode)
       const valueNodes = getAttributeValueNodes(attributeNode)
@@ -707,35 +500,6 @@ export abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixC
   }
 }
 
-/**
- * Checks if an attribute value is quoted
- */
-export function isAttributeValueQuoted(attributeNode: HTMLAttributeNode): boolean {
-  if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-    const valueNode = attributeNode.value as HTMLAttributeValueNode
-
-    return !!valueNode.quoted
-  }
-
-  return false
-}
-
-/**
- * Iterates over all attributes of a tag node, calling the callback for each attribute
- */
-export function forEachAttribute(
-  node: HTMLOpenTagNode,
-  callback: (attributeNode: HTMLAttributeNode) => void
-): void {
-  const attributes = getAttributes(node)
-
-  for (const child of attributes) {
-    if (child.type === "AST_HTML_ATTRIBUTE_NODE") {
-      callback(child as HTMLAttributeNode)
-    }
-  }
-}
-
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
@@ -753,7 +517,7 @@ export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixCo
    * Helper method to create an unbound lint offense (without severity).
    * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext> {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -761,14 +525,16 @@ export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixCo
       message,
       location,
       autofixContext,
+      severity,
+      tags,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void {
-    this.offenses.push(this.createOffense(message, location, autofixContext))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags))
   }
 
   /**
@@ -815,7 +581,7 @@ export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixC
    * Helper method to create an unbound lint offense (without severity).
    * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext> {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -823,14 +589,16 @@ export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixC
       message,
       location,
       autofixContext,
+      severity,
+      tags,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void {
-    this.offenses.push(this.createOffense(message, location, autofixContext))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags))
   }
 
   /**
@@ -1065,3 +833,122 @@ export function isHeadTag(tagName: string): boolean {
     (isHeadOnlyTag(tag) || isHeadAndBodyTag(tag))
   )
 }
+
+/**
+ * Converts a character offset in a source string to a Position (line, column).
+ * Lines are 1-based, columns are 0-based.
+ */
+export function positionFromOffset(source: string, offset: number): Position {
+  let line = 1
+  let column = 0
+  let currentOffset = 0
+
+  for (let i = 0; i < source.length && currentOffset < offset; i++) {
+    const char = source[i]
+    currentOffset++
+    if (char === "\n") {
+      line++
+      column = 0
+    } else {
+      column++
+    }
+  }
+
+  return new Position(line, column)
+}
+
+/**
+ * Creates a Location from a source string, a start offset, and a length.
+ */
+export function locationFromOffset(source: string, startOffset: number, length: number): Location {
+  const start = positionFromOffset(source, startOffset)
+  const end = positionFromOffset(source, startOffset + length)
+  return Location.from(start.line, start.column, end.line, end.column)
+}
+
+/**
+ * Checks if a position (line, column) is within a node's location range.
+ * @param node - The node to check
+ * @param line - Line number (1-based)
+ * @param column - Column number (0-based)
+ * @returns true if the position is within the node's location
+ */
+function isPositionInNode(node: Node, line: number, column: number): boolean {
+  if (!node.location) return false
+
+  const { start, end } = node.location
+
+  if (line < start.line) return false
+  if (line === start.line && column < start.column) return false
+
+  if (line > end.line) return false
+  if (line === end.line && column >= end.column) return false
+
+  return true
+}
+
+/**
+ * Finds a node in the AST that contains a specific position.
+ * Returns the deepest (most specific) node that matches the position and optional predicate.
+ *
+ * @param root - The root node to search from
+ * @param line - Line number (1-based)
+ * @param column - Column number (0-based)
+ * @param predicate - Optional predicate function to filter nodes
+ * @returns The matching node or null if not found
+ */
+export function findNodeAtPosition(root: Node, line: number, column: number, predicate?: (node: Node) => boolean): Node | null {
+  let bestMatch: Node | null = null
+  const visited = new Set<Node>()
+
+  function search(node: Node): void {
+    if (!node || visited.has(node)) return
+    visited.add(node)
+
+    if (isPositionInNode(node, line, column)) {
+      if (!predicate || predicate(node)) {
+        if (!bestMatch || isMoreSpecific(node, bestMatch)) {
+          bestMatch = node
+        }
+      }
+    }
+
+    const nodeAny = node as any
+
+    if (typeof nodeAny.compactChildNodes === 'function') {
+      for (const child of nodeAny.compactChildNodes()) {
+        search(child)
+      }
+    } else {
+      if (nodeAny.children && Array.isArray(nodeAny.children)) {
+        for (const child of nodeAny.children) {
+          if (child) search(child)
+        }
+      }
+
+      if (nodeAny.body && Array.isArray(nodeAny.body)) {
+        for (const child of nodeAny.body) {
+          if (child) search(child)
+        }
+      }
+    }
+  }
+
+  function isMoreSpecific(nodeA: Node, nodeB: Node): boolean {
+    if (!nodeA.location || !nodeB.location) return false
+
+    const aStart = nodeA.location.start
+    const aEnd = nodeA.location.end
+    const bStart = nodeB.location.start
+    const bEnd = nodeB.location.end
+
+    const startsAtOrAfter = aStart.line > bStart.line || (aStart.line === bStart.line && aStart.column >= bStart.column)
+    const endsAtOrBefore = aEnd.line < bEnd.line || (aEnd.line === bEnd.line && aEnd.column <= bEnd.column)
+
+    return startsAtOrAfter && endsAtOrBefore
+  }
+
+  search(root)
+
+  return bestMatch
+}

package/src/rules/svg-tag-name-capitalization.ts

@@ -1,5 +1,6 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE } from "./rule-utils.js"
+import { isHTMLOpenTagNode, isHTMLCloseTagNode } from "@herb-tools/core"
 
 import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, Mutable, FullRuleConfig } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core"
@@ -25,12 +26,12 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitali
     }
 
     if (this.insideSVG) {
-      if (node.open_tag) {
-        this.checkTagName(node.open_tag as HTMLOpenTagNode)
+      if (isHTMLOpenTagNode(node.open_tag)) {
+        this.checkTagName(node.open_tag)
       }
 
-      if (node.close_tag) {
-        this.checkTagName(node.close_tag as HTMLCloseTagNode)
+      if (node.close_tag && isHTMLCloseTagNode(node.close_tag)) {
+        this.checkTagName(node.close_tag)
       }
     }
 
@@ -40,7 +41,6 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitali
 
   private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode): void {
     const tagName = node.tag_name?.value
-
     if (!tagName) return
 
     if (SVG_CAMEL_CASE_ELEMENTS.has(tagName)) return
@@ -51,8 +51,8 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitali
     if (correctCamelCase && tagName !== correctCamelCase) {
       let type: string = node.type
 
-      if (node.type === "AST_HTML_OPEN_TAG_NODE") type = "Opening"
-      if (node.type === "AST_HTML_CLOSE_TAG_NODE") type = "Closing"
+      if (isHTMLOpenTagNode(node)) type = "Opening"
+      if (isHTMLCloseTagNode(node)) type = "Closing"
 
       this.addOffense(
         `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,
@@ -69,7 +69,7 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitali
 
 export class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitalizationAutofixContext> {
   static autocorrectable = true
-  name = "svg-tag-name-capitalization"
+  static ruleName = "svg-tag-name-capitalization"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -79,7 +79,7 @@ export class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitaliz
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<SVGTagNameCapitalizationAutofixContext>[] {
-    const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
+    const visitor = new SVGTagNameCapitalizationVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 
@@ -89,7 +89,7 @@ export class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitaliz
   autofix(offense: LintOffense<SVGTagNameCapitalizationAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
     if (!offense.autofixContext) return null
 
-    const { node: { tag_name }, correctCamelCase } = offense.autofixContext
+    const { node: { tag_name }, correctCamelCase } = offense.autofixContext
 
     if (!tag_name) return null
 

package/src/rules/turbo-permanent-require-id.ts

@@ -0,0 +1,49 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { getAttribute } from "@herb-tools/core"
+
+import { ParserRule } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
+
+class TurboPermanentRequireIdVisitor extends BaseRuleVisitor {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkTurboPermanent(node)
+    super.visitHTMLOpenTagNode(node)
+  }
+
+  private checkTurboPermanent(node: HTMLOpenTagNode): void {
+    const turboPermanentAttribute = getAttribute(node, "data-turbo-permanent")
+
+    if (!turboPermanentAttribute) {
+      return
+    }
+
+    const idAttribute = getAttribute(node, "id")
+
+    if (!idAttribute) {
+      this.addOffense(
+        "Elements with `data-turbo-permanent` must have an `id` attribute. Without an `id`, Turbo can't track the element across page changes and the permanent behavior won't work as expected.",
+        turboPermanentAttribute.location,
+      )
+    }
+  }
+}
+
+export class TurboPermanentRequireIdRule extends ParserRule {
+  static ruleName = "turbo-permanent-require-id"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new TurboPermanentRequireIdVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}