@herb-tools/linter 0.5.0 → 0.6.1

package/src/rules/rule-utils.ts

@@ -1,7 +1,15 @@
 import {
   Visitor,
   Position,
-  Location
+  Location,
+  getStaticAttributeName,
+  hasDynamicAttributeName as hasNodeDynamicAttributeName,
+  getCombinedAttributeName,
+  hasERBOutput,
+  getStaticContentFromNodes,
+  hasStaticContent,
+  isEffectivelyStatic,
+  getValidatableStaticContent
 } from "@herb-tools/core"
 
 import type {
@@ -10,14 +18,24 @@ import type {
   HTMLAttributeNode,
   HTMLAttributeValueNode,
   HTMLOpenTagNode,
-  HTMLSelfCloseTagNode,
   LiteralNode,
   LexResult,
-  Token
+  Token,
+  Node
 } from "@herb-tools/core"
-import type { LintOffense, LintSeverity, LintContext } from "../types.js"
+
+import { IdentityPrinter } from "@herb-tools/printer"
+
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
+import type * as Nodes from "@herb-tools/core"
+import type { LintOffense, LintSeverity, LintContext } from "../types.js"
+
+export enum ControlFlowType {
+  CONDITIONAL,
+  LOOP
+}
+
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
@@ -56,34 +74,215 @@ export abstract class BaseRuleVisitor extends Visitor {
 }
 
 /**
- * Gets attributes from either an HTMLOpenTagNode or HTMLSelfCloseTagNode
+ * Mixin that adds control flow tracking capabilities to rule visitors
+ * This allows rules to track state across different control flow structures
+ * like if/else branches, loops, etc.
+ *
+ * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
+ * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
+ */
+export abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+  protected isInControlFlow: boolean = false
+  protected currentControlFlowType: ControlFlowType | null = null
+
+  /**
+   * Handle visiting a control flow node with proper scope management
+   */
+  protected handleControlFlowNode(node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void {
+    const wasInControlFlow = this.isInControlFlow
+    const previousControlFlowType = this.currentControlFlowType
+
+    this.isInControlFlow = true
+    this.currentControlFlowType = controlFlowType
+
+    const stateToRestore = this.onEnterControlFlow(controlFlowType, wasInControlFlow)
+
+    visitChildren()
+
+    this.onExitControlFlow(controlFlowType, wasInControlFlow, stateToRestore)
+
+    this.isInControlFlow = wasInControlFlow
+    this.currentControlFlowType = previousControlFlowType
+  }
+
+  /**
+   * Handle visiting a branch node (like else, when) with proper scope management
+   */
+  protected startNewBranch(visitChildren: () => void): void {
+    const stateToRestore = this.onEnterBranch()
+
+    visitChildren()
+
+    this.onExitBranch(stateToRestore)
+  }
+
+  visitERBIfNode(node: Nodes.ERBIfNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBIfNode(node))
+  }
+
+  visitERBUnlessNode(node: Nodes.ERBUnlessNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBUnlessNode(node))
+  }
+
+  visitERBCaseNode(node: Nodes.ERBCaseNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBCaseNode(node))
+  }
+
+  visitERBCaseMatchNode(node: Nodes.ERBCaseMatchNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBCaseMatchNode(node))
+  }
+
+  visitERBWhileNode(node: Nodes.ERBWhileNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.LOOP, () => super.visitERBWhileNode(node))
+  }
+
+  visitERBForNode(node: Nodes.ERBForNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.LOOP, () => super.visitERBForNode(node))
+  }
+
+  visitERBUntilNode(node: Nodes.ERBUntilNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.LOOP, () => super.visitERBUntilNode(node))
+  }
+
+  visitERBBlockNode(node: Nodes.ERBBlockNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBBlockNode(node))
+  }
+
+  visitERBElseNode(node: Nodes.ERBElseNode): void {
+    this.startNewBranch(() => super.visitERBElseNode(node))
+  }
+
+  visitERBWhenNode(node: Nodes.ERBWhenNode): void {
+    this.startNewBranch(() => super.visitERBWhenNode(node))
+  }
+
+  protected abstract onEnterControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): TControlFlowState
+  protected abstract onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: TControlFlowState): void
+  protected abstract onEnterBranch(): TBranchState
+  protected abstract onExitBranch(stateToRestore: TBranchState): void
+}
+
+/**
+ * Gets attributes from an HTMLOpenTagNode
  */
-export function getAttributes(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): any[] {
-  return node.type === "AST_HTML_SELF_CLOSE_TAG_NODE"
-    ? (node as HTMLSelfCloseTagNode).attributes
-    : (node as HTMLOpenTagNode).children
+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: HTMLOpenTagNode | HTMLSelfCloseTagNode): string | null {
+export function getTagName(node: HTMLOpenTagNode): string | 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): string | null {
   if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
     const nameNode = attributeNode.name as HTMLAttributeNameNode
+    const staticName = getStaticAttributeName(nameNode)
 
-    return nameNode.name?.value.toLowerCase() || null
+    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
  */
@@ -130,9 +329,20 @@ export function hasAttributeValue(attributeNode: HTMLAttributeNode): boolean {
 /**
  * Gets the quote type used for an attribute value
  */
-export function getAttributeValueQuoteType(attributeNode: HTMLAttributeNode): "single" | "double" | "none" | null {
-  if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-    const valueNode = attributeNode.value as HTMLAttributeValueNode
+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"
     }
@@ -146,25 +356,35 @@ export function getAttributeValueQuoteType(attributeNode: HTMLAttributeNode): "s
 /**
  * Finds an attribute by name in a list of attributes
  */
-export function findAttributeByName(attributes: any[], attributeName: string): HTMLAttributeNode | null {
+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 | HTMLSelfCloseTagNode, attributeName: string): boolean {
+export function hasAttribute(node: HTMLOpenTagNode, attributeName: string): boolean {
+  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) !== null
+
+  return findAttributeByName(attributes, attributeName)
 }
 
 /**
@@ -184,6 +404,11 @@ export const HTML_BLOCK_ELEMENTS = new Set([
   "ol", "p", "pre", "section", "table", "tfoot", "ul", "video"
 ])
 
+export const HTML_VOID_ELEMENTS = new Set([
+  "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta",
+  "param", "source", "track", "wbr",
+])
+
 export const HTML_BOOLEAN_ATTRIBUTES = new Set([
   "autofocus", "autoplay", "checked", "controls", "defer", "disabled", "hidden",
   "loop", "multiple", "muted", "readonly", "required", "reversed", "selected",
@@ -254,6 +479,41 @@ export const VALID_ARIA_ROLES = new Set([
   "log", "marquee"
 ]);
 
+/**
+ * Parameter types for AttributeVisitorMixin methods
+ */
+export interface StaticAttributeStaticValueParams {
+  attributeName: string
+  attributeValue: string
+  attributeNode: HTMLAttributeNode
+  parentNode: HTMLOpenTagNode
+}
+
+export interface StaticAttributeDynamicValueParams {
+  attributeName: string
+  valueNodes: Node[]
+  attributeNode: HTMLAttributeNode
+  parentNode: HTMLOpenTagNode
+  combinedValue?: string | null
+}
+
+export interface DynamicAttributeStaticValueParams {
+  nameNodes: Node[]
+  attributeValue: string
+  attributeNode: HTMLAttributeNode
+  parentNode: HTMLOpenTagNode
+  combinedName?: string
+}
+
+export interface DynamicAttributeDynamicValueParams {
+  nameNodes: Node[]
+  valueNodes: Node[]
+  attributeNode: HTMLAttributeNode
+  parentNode: HTMLOpenTagNode
+  combinedName?: string
+  combinedValue?: string | null
+}
+
 export const ARIA_ATTRIBUTES =  new Set([
   'aria-activedescendant',
   'aria-atomic',
@@ -335,6 +595,13 @@ export function isBlockElement(tagName: string): boolean {
   return HTML_BLOCK_ELEMENTS.has(tagName.toLowerCase())
 }
 
+/**
+ * Checks if an element is a void element
+ */
+export function isVoidElement(tagName: string): boolean {
+  return HTML_VOID_ELEMENTS.has(tagName.toLowerCase())
+}
+
 /**
  * Checks if an attribute is a boolean attribute
  */
@@ -343,9 +610,14 @@ export function isBooleanAttribute(attributeName: string): boolean {
 }
 
 /**
- * Abstract base class for rules that need to check individual attributes on HTML tags
- * Eliminates duplication of visitHTMLOpenTagNode/visitHTMLSelfCloseTagNode patterns
- * and attribute iteration logic. Provides simplified interface with extracted attribute info.
+ * Attribute visitor that provides granular processing based on both
+ * attribute name type (static/dynamic) and value type (static/dynamic)
+ *
+ * This gives you 4 distinct methods to override:
+ * - checkStaticAttributeStaticValue()   - name="class" value="foo"
+ * - checkStaticAttributeDynamicValue()  - name="class" value="<%= css_class %>"
+ * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
+ * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
 export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
   constructor(ruleName: string, context?: Partial<LintContext>) {
@@ -357,28 +629,74 @@ export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
     super.visitHTMLOpenTagNode(node)
   }
 
-  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
-    this.checkAttributesOnNode(node)
-    super.visitHTMLSelfCloseTagNode(node)
-  }
-
-  private checkAttributesOnNode(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
+  private checkAttributesOnNode(node: HTMLOpenTagNode): void {
     forEachAttribute(node, (attributeNode) => {
-      const attributeName = getAttributeName(attributeNode)
-      const attributeValue = getAttributeValue(attributeNode)
-
-      if (attributeName) {
-        this.checkAttribute(attributeName, attributeValue, attributeNode, node)
+      const staticAttributeName = getAttributeName(attributeNode)
+      const isDynamicName = hasDynamicAttributeName(attributeNode)
+      const staticAttributeValue = getStaticAttributeValue(attributeNode)
+      const valueNodes = getAttributeValueNodes(attributeNode)
+      const hasOutputERB = hasERBOutput(valueNodes)
+      const isEffectivelyStaticValue = isEffectivelyStatic(valueNodes)
+
+      if (staticAttributeName && staticAttributeValue !== null) {
+        this.checkStaticAttributeStaticValue({
+          attributeName: staticAttributeName,
+          attributeValue: staticAttributeValue,
+          attributeNode,
+          parentNode: node
+        })
+      } else if (staticAttributeName && isEffectivelyStaticValue && !hasOutputERB) {
+        const validatableContent = getValidatableStaticContent(valueNodes) || ""
+
+        this.checkStaticAttributeStaticValue({ attributeName: staticAttributeName, attributeValue: validatableContent, attributeNode, parentNode: node })
+      } else if (staticAttributeName && hasOutputERB) {
+        const combinedValue = getAttributeValue(attributeNode)
+
+        this.checkStaticAttributeDynamicValue({ attributeName: staticAttributeName, valueNodes, attributeNode, parentNode: node, combinedValue })
+      } else if (isDynamicName && staticAttributeValue !== null) {
+        const nameNode = attributeNode.name as HTMLAttributeNameNode
+        const nameNodes = nameNode.children || []
+        const combinedName = getCombinedAttributeNameString(attributeNode)
+
+        this.checkDynamicAttributeStaticValue({ nameNodes, attributeValue: staticAttributeValue, attributeNode, parentNode: node, combinedName })
+      } else if (isDynamicName) {
+        const nameNode = attributeNode.name as HTMLAttributeNameNode
+        const nameNodes = nameNode.children || []
+        const combinedName = getCombinedAttributeNameString(attributeNode)
+        const combinedValue = getAttributeValue(attributeNode)
+
+        this.checkDynamicAttributeDynamicValue({ nameNodes, valueNodes, attributeNode, parentNode: node, combinedName, combinedValue })
       }
     })
   }
 
-  protected abstract checkAttribute(
-    attributeName: string,
-    attributeValue: string | null,
-    attributeNode: HTMLAttributeNode,
-    parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode
-  ): void
+  /**
+   * Static attribute name with static value: class="container"
+   */
+  protected checkStaticAttributeStaticValue(params: StaticAttributeStaticValueParams): void {
+    // Default implementation does nothing
+  }
+
+  /**
+   * Static attribute name with dynamic value: class="<%= css_class %>"
+   */
+  protected checkStaticAttributeDynamicValue(params: StaticAttributeDynamicValueParams): void {
+    // Default implementation does nothing
+  }
+
+  /**
+   * Dynamic attribute name with static value: data-<%= key %>="foo"
+   */
+  protected checkDynamicAttributeStaticValue(params: DynamicAttributeStaticValueParams): void {
+    // Default implementation does nothing
+  }
+
+  /**
+   * Dynamic attribute name with dynamic value: data-<%= key %>="<%= value %>"
+   */
+  protected checkDynamicAttributeDynamicValue(params: DynamicAttributeDynamicValueParams): void {
+    // Default implementation does nothing
+  }
 }
 
 /**
@@ -398,7 +716,7 @@ export function isAttributeValueQuoted(attributeNode: HTMLAttributeNode): boolea
  * Iterates over all attributes of a tag node, calling the callback for each attribute
  */
 export function forEachAttribute(
-  node: HTMLOpenTagNode | HTMLSelfCloseTagNode,
+  node: HTMLOpenTagNode,
   callback: (attributeNode: HTMLAttributeNode) => void
 ): void {
   const attributes = getAttributes(node)
@@ -490,7 +808,7 @@ export abstract class BaseSourceRuleVisitor {
    */
   protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
     return {
-      rule: this.ruleName as any, // Type assertion for compatibility
+      rule: this.ruleName,
       code: this.ruleName,
       source: "Herb Linter",
       message,

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

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE }
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
   private insideSVG = false
@@ -30,14 +30,8 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
     this.visitChildNodes(node)
   }
 
-  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
-    if (this.insideSVG) {
-      this.checkTagName(node)
-    }
-    this.visitChildNodes(node)
-  }
 
-  private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode | HTMLSelfCloseTagNode): void {
+  private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode): void {
     const tagName = node.tag_name?.value
 
     if (!tagName) return
@@ -52,7 +46,6 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
 
       if (node.type == "AST_HTML_OPEN_TAG_NODE") type = "Opening"
       if (node.type == "AST_HTML_CLOSE_TAG_NODE") type = "Closing"
-      if (node.type == "AST_HTML_SELF_CLOSE_TAG_NODE") type = "Self-closing"
 
       this.addOffense(
         `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,

package/src/types.ts

@@ -24,12 +24,30 @@ export abstract class ParserRule {
   static type = "parser" as const
   abstract name: string
   abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense[]
+  
+  /**
+   * Optional method to determine if this rule should run.
+   * If not implemented, rule is always enabled.
+   * @param result - The parse result to analyze
+   * @param context - Optional context for linting
+   * @returns true if rule should run, false to skip
+   */
+  isEnabled?(result: ParseResult, context?: Partial<LintContext>): boolean
 }
 
 export abstract class LexerRule {
   static type = "lexer" as const
   abstract name: string
   abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[]
+  
+  /**
+   * Optional method to determine if this rule should run.
+   * If not implemented, rule is always enabled.
+   * @param lexResult - The lex result to analyze
+   * @param context - Optional context for linting
+   * @returns true if rule should run, false to skip
+   */
+  isEnabled?(lexResult: LexResult, context?: Partial<LintContext>): boolean
 }
 
 export interface LexerRuleConstructor {
@@ -56,6 +74,15 @@ export abstract class SourceRule {
   static type = "source" as const
   abstract name: string
   abstract check(source: string, context?: Partial<LintContext>): LintOffense[]
+  
+  /**
+   * Optional method to determine if this rule should run.
+   * If not implemented, rule is always enabled.
+   * @param source - The source code to analyze
+   * @param context - Optional context for linting
+   * @returns true if rule should run, false to skip
+   */
+  isEnabled?(source: string, context?: Partial<LintContext>): boolean
 }
 
 export interface SourceRuleConstructor {