@herb-tools/linter 0.7.4 → 0.8.0

package/dist/src/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAsBA,MAAM,OAAgB,UAAU;IAC9B,MAAM,CAAC,IAAI,GAAG,QAAiB,CAAA;;AAcjC,MAAM,OAAgB,SAAS;IAC7B,MAAM,CAAC,IAAI,GAAG,OAAgB,CAAA;;AA2BhC;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,QAAQ,EAAE,SAAS;CACX,CAAA;AAEV,MAAM,OAAgB,UAAU;IAC9B,MAAM,CAAC,IAAI,GAAG,QAAiB,CAAA"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAsEA;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAmB;IACjD,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,OAAO;IACjB,OAAO,EAAE,EAAE;CACZ,CAAA;AAED;;GAEG;AACH,MAAM,OAAgB,UAAU;IAC9B,MAAM,CAAC,IAAI,GAAG,QAAiB,CAAA;IAC/B,uEAAuE;IACvE,MAAM,CAAC,eAAe,GAAG,KAAK,CAAA;IAG9B,IAAI,aAAa;QACf,OAAO,mBAAmB,CAAA;IAC5B,CAAC;;AAuBH;;GAEG;AACH,MAAM,OAAgB,SAAS;IAC7B,MAAM,CAAC,IAAI,GAAG,OAAgB,CAAA;IAC9B,uEAAuE;IACvE,MAAM,CAAC,eAAe,GAAG,KAAK,CAAA;IAG9B,IAAI,aAAa;QACf,OAAO,mBAAmB,CAAA;IAC5B,CAAC;;AAuCH;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,QAAQ,EAAE,SAAS;IACnB,cAAc,EAAE,SAAS;IACzB,qBAAqB,EAAE,SAAS;IAChC,qBAAqB,EAAE,SAAS;CACxB,CAAA;AAEV,MAAM,OAAgB,UAAU;IAC9B,MAAM,CAAC,IAAI,GAAG,QAAiB,CAAA;IAC/B,uEAAuE;IACvE,MAAM,CAAC,eAAe,GAAG,KAAK,CAAA;IAG9B,IAAI,aAAa;QACf,OAAO,mBAAmB,CAAA;IAC5B,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/cli.ts","../src/default-rules.ts","../src/herb-lint.ts","../src/index.ts","../src/linter.ts","../src/types.ts","../src/cli/argument-parser.ts","../src/cli/file-processor.ts","../src/cli/index.ts","../src/cli/output-manager.ts","../src/cli/summary-reporter.ts","../src/cli/formatters/base-formatter.ts","../src/cli/formatters/detailed-formatter.ts","../src/cli/formatters/github-actions-formatter.ts","../src/cli/formatters/index.ts","../src/cli/formatters/json-formatter.ts","../src/cli/formatters/simple-formatter.ts","../src/rules/erb-no-empty-tags.ts","../src/rules/erb-no-output-control-flow.ts","../src/rules/erb-no-silent-tag-in-attribute-name.ts","../src/rules/erb-prefer-image-tag-helper.ts","../src/rules/erb-require-whitespace-inside-tags.ts","../src/rules/erb-requires-trailing-newline.ts","../src/rules/html-anchor-require-href.ts","../src/rules/html-aria-attribute-must-be-valid.ts","../src/rules/html-aria-label-is-well-formatted.ts","../src/rules/html-aria-level-must-be-valid.ts","../src/rules/html-aria-role-heading-requires-level.ts","../src/rules/html-aria-role-must-be-valid.ts","../src/rules/html-attribute-double-quotes.ts","../src/rules/html-attribute-equals-spacing.ts","../src/rules/html-attribute-values-require-quotes.ts","../src/rules/html-avoid-both-disabled-and-aria-disabled.ts","../src/rules/html-boolean-attributes-no-value.ts","../src/rules/html-iframe-has-title.ts","../src/rules/html-img-require-alt.ts","../src/rules/html-navigation-has-label.ts","../src/rules/html-no-aria-hidden-on-focusable.ts","../src/rules/html-no-block-inside-inline.ts","../src/rules/html-no-duplicate-attributes.ts","../src/rules/html-no-duplicate-ids.ts","../src/rules/html-no-empty-attributes.ts","../src/rules/html-no-empty-headings.ts","../src/rules/html-no-nested-links.ts","../src/rules/html-no-positive-tab-index.ts","../src/rules/html-no-self-closing.ts","../src/rules/html-no-title-attribute.ts","../src/rules/html-no-underscores-in-attribute-names.ts","../src/rules/html-tag-name-lowercase.ts","../src/rules/index.ts","../src/rules/parser-no-errors.ts","../src/rules/rule-utils.ts","../src/rules/svg-tag-name-capitalization.ts"],"version":"5.9.2"}
+{"root":["../src/cli.ts","../src/custom-rule-loader.ts","../src/herb-disable-comment-utils.ts","../src/herb-lint.ts","../src/index.ts","../src/linter.ts","../src/loader.ts","../src/rules.ts","../src/types.ts","../src/cli/argument-parser.ts","../src/cli/file-processor.ts","../src/cli/index.ts","../src/cli/output-manager.ts","../src/cli/summary-reporter.ts","../src/cli/formatters/base-formatter.ts","../src/cli/formatters/detailed-formatter.ts","../src/cli/formatters/github-actions-formatter.ts","../src/cli/formatters/index.ts","../src/cli/formatters/json-formatter.ts","../src/cli/formatters/simple-formatter.ts","../src/rules/erb-comment-syntax.ts","../src/rules/erb-no-case-node-children.ts","../src/rules/erb-no-empty-tags.ts","../src/rules/erb-no-extra-newline.ts","../src/rules/erb-no-extra-whitespace-inside-tags.ts","../src/rules/erb-no-output-control-flow.ts","../src/rules/erb-no-silent-tag-in-attribute-name.ts","../src/rules/erb-prefer-image-tag-helper.ts","../src/rules/erb-require-trailing-newline.ts","../src/rules/erb-require-whitespace-inside-tags.ts","../src/rules/erb-right-trim.ts","../src/rules/herb-disable-comment-base.ts","../src/rules/herb-disable-comment-malformed.ts","../src/rules/herb-disable-comment-missing-rules.ts","../src/rules/herb-disable-comment-no-duplicate-rules.ts","../src/rules/herb-disable-comment-no-redundant-all.ts","../src/rules/herb-disable-comment-unnecessary.ts","../src/rules/herb-disable-comment-valid-rule-name.ts","../src/rules/html-anchor-require-href.ts","../src/rules/html-aria-attribute-must-be-valid.ts","../src/rules/html-aria-label-is-well-formatted.ts","../src/rules/html-aria-level-must-be-valid.ts","../src/rules/html-aria-role-heading-requires-level.ts","../src/rules/html-aria-role-must-be-valid.ts","../src/rules/html-attribute-double-quotes.ts","../src/rules/html-attribute-equals-spacing.ts","../src/rules/html-attribute-values-require-quotes.ts","../src/rules/html-avoid-both-disabled-and-aria-disabled.ts","../src/rules/html-body-only-elements.ts","../src/rules/html-boolean-attributes-no-value.ts","../src/rules/html-head-only-elements.ts","../src/rules/html-iframe-has-title.ts","../src/rules/html-img-require-alt.ts","../src/rules/html-input-require-autocomplete.ts","../src/rules/html-navigation-has-label.ts","../src/rules/html-no-aria-hidden-on-focusable.ts","../src/rules/html-no-block-inside-inline.ts","../src/rules/html-no-duplicate-attributes.ts","../src/rules/html-no-duplicate-ids.ts","../src/rules/html-no-duplicate-meta-names.ts","../src/rules/html-no-empty-attributes.ts","../src/rules/html-no-empty-headings.ts","../src/rules/html-no-nested-links.ts","../src/rules/html-no-positive-tab-index.ts","../src/rules/html-no-self-closing.ts","../src/rules/html-no-space-in-tag.ts","../src/rules/html-no-title-attribute.ts","../src/rules/html-no-underscores-in-attribute-names.ts","../src/rules/html-tag-name-lowercase.ts","../src/rules/index.ts","../src/rules/parser-no-errors.ts","../src/rules/rule-utils.ts","../src/rules/svg-tag-name-capitalization.ts"],"version":"5.9.2"}

package/dist/types/cli/argument-parser.d.ts

@@ -1,16 +1,22 @@
 import type { ThemeInput } from "@herb-tools/highlighter";
 export type FormatOption = "simple" | "detailed" | "json";
 export interface ParsedArguments {
-    pattern: string;
+    patterns: string[];
+    configFile?: string;
     formatOption: FormatOption;
     showTiming: boolean;
     theme: ThemeInput;
     wrapLines: boolean;
     truncateLines: boolean;
     useGitHubActions: boolean;
+    fix: boolean;
+    ignoreDisableComments: boolean;
+    force: boolean;
+    init: boolean;
+    loadCustomRules: boolean;
 }
 export declare class ArgumentParser {
     private readonly usage;
     parse(argv: string[]): ParsedArguments;
-    private getFilePattern;
+    private getFilePatterns;
 }

package/dist/types/cli/file-processor.d.ts

@@ -1,18 +1,31 @@
+import { Config } from "@herb-tools/config";
 import type { Diagnostic } from "@herb-tools/core";
 import type { FormatOption } from "./argument-parser.js";
+import type { HerbConfigOptions } from "@herb-tools/config";
 export interface ProcessedFile {
     filename: string;
     offense: Diagnostic;
     content: string;
+    autocorrectable?: boolean;
 }
 export interface ProcessingContext {
     projectPath?: string;
     pattern?: string;
+    fix?: boolean;
+    ignoreDisableComments?: boolean;
+    linterConfig?: HerbConfigOptions['linter'];
+    config?: Config;
+    loadCustomRules?: boolean;
 }
 export interface ProcessingResult {
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
+    totalWouldBeIgnored?: number;
     filesWithOffenses: number;
+    filesFixed: number;
     ruleCount: number;
     allOffenses: ProcessedFile[];
     ruleOffenses: Map<string, {
@@ -23,5 +36,7 @@ export interface ProcessingResult {
 }
 export declare class FileProcessor {
     private linter;
+    private customRulesLoaded;
+    private isRuleAutocorrectable;
     processFiles(files: string[], formatOption?: FormatOption, context?: ProcessingContext): Promise<ProcessingResult>;
 }

package/dist/types/cli/formatters/json-formatter.d.ts

@@ -9,6 +9,9 @@ interface JSONSummary {
     filesWithOffenses: number;
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
     totalOffenses: number;
     ruleCount: number;
 }
@@ -28,6 +31,9 @@ interface JSONFormatOptions {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
     filesWithOffenses: number;
     ruleCount: number;
     startTime: number;

package/dist/types/cli/formatters/simple-formatter.d.ts

@@ -4,4 +4,5 @@ import type { ProcessedFile } from "../file-processor.js";
 export declare class SimpleFormatter extends BaseFormatter {
     format(allOffenses: ProcessedFile[]): Promise<void>;
     formatFile(filename: string, offenses: Diagnostic[]): void;
+    formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void;
 }

package/dist/types/cli/summary-reporter.d.ts

@@ -2,6 +2,10 @@ export interface SummaryData {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
+    totalInfo?: number;
+    totalHints?: number;
+    totalIgnored: number;
+    totalWouldBeIgnored?: number;
     filesWithOffenses: number;
     ruleCount: number;
     startTime: number;
@@ -11,6 +15,8 @@ export interface SummaryData {
         count: number;
         files: Set<string>;
     }>;
+    autofixableCount: number;
+    ignoreDisableComments?: boolean;
 }
 export declare class SummaryReporter {
     private pluralize;

package/dist/types/cli.d.ts

@@ -1,6 +1,8 @@
-import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js";
+import { Config } from "@herb-tools/config";
+import { ArgumentParser } from "./cli/argument-parser.js";
 import { FileProcessor } from "./cli/file-processor.js";
 import { OutputManager } from "./cli/output-manager.js";
+import type { FormatOption } from "./cli/argument-parser.js";
 export * from "./cli/index.js";
 export declare class CLI {
     protected argumentParser: ArgumentParser;
@@ -8,15 +10,18 @@ export declare class CLI {
     protected outputManager: OutputManager;
     protected projectPath: string;
     getProjectPath(): string;
-    protected findProjectRoot(startPath: string): string;
     protected exitWithError(message: string, formatOption: FormatOption, exitCode?: number): void;
     protected exitWithInfo(message: string, formatOption: FormatOption, exitCode?: number, timingData?: {
         startTime: number;
         startDate: Date;
         showTiming: boolean;
     }): void;
-    protected determineProjectPath(pattern: string | undefined): void;
-    protected adjustPattern(pattern: string | undefined): string;
+    protected determineProjectPath(patterns: string[]): void;
+    protected adjustPattern(pattern: string | undefined, configGlobPattern: string): string;
+    protected resolvePatternToFiles(pattern: string, config: Config, force: boolean): Promise<{
+        files: string[];
+        explicitFile: string | undefined;
+    }>;
     protected beforeProcess(): Promise<void>;
     protected afterProcess(_results: any, _outputOptions: any): Promise<void>;
     run(): Promise<void>;

package/dist/types/custom-rule-loader.d.ts

@@ -0,0 +1,62 @@
+import type { RuleClass } from "./types.js";
+export interface CustomRuleLoaderOptions {
+    /**
+     * Base directory to search for custom rules
+     * Defaults to current working directory
+     */
+    baseDir?: string;
+    /**
+     * Glob patterns to search for custom rule files
+     * Defaults to looking in common locations
+     */
+    patterns?: string[];
+    /**
+     * Whether to suppress errors when loading custom rules
+     * Defaults to false
+     */
+    silent?: boolean;
+}
+/**
+ * Loads custom linter rules from the user's project
+ */
+export declare class CustomRuleLoader {
+    private baseDir;
+    private patterns;
+    private silent;
+    constructor(options?: CustomRuleLoaderOptions);
+    /**
+     * Discovers custom rule files in the project
+     */
+    discoverRuleFiles(): Promise<string[]>;
+    /**
+     * Loads a single rule file
+     */
+    loadRuleFile(filePath: string): Promise<RuleClass[]>;
+    /**
+     * Type guard to check if an export is a valid rule class
+     */
+    private isValidRuleClass;
+    /**
+     * Loads all custom rules from the project
+     */
+    loadRules(): Promise<RuleClass[]>;
+    /**
+     * Loads all custom rules and returns detailed information about each rule
+     */
+    loadRulesWithInfo(): Promise<{
+        rules: RuleClass[];
+        ruleInfo: Array<{
+            name: string;
+            path: string;
+        }>;
+        duplicateWarnings: string[];
+    }>;
+    /**
+     * Static helper to check if custom rules exist in a project
+     */
+    static hasCustomRules(baseDir?: string): Promise<boolean>;
+    /**
+     * Static helper to load custom rules and merge with default rules
+     */
+    static loadAndMergeRules(defaultRules: RuleClass[], options?: CustomRuleLoaderOptions): Promise<RuleClass[]>;
+}

package/dist/types/herb-disable-comment-utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Utilities for parsing herb:disable comments
+ */
+/**
+ * Information about a single rule name in a herb:disable comment
+ */
+export interface HerbDisableRuleName {
+    /** The rule name */
+    name: string;
+    /** The starting offset of this rule name within the content/line */
+    offset: number;
+    /** The length of the rule name */
+    length: number;
+}
+/**
+ * Result of parsing a herb:disable comment
+ */
+export interface HerbDisableComment {
+    /** The full matched string */
+    match: string;
+    /** Array of rule names specified in the comment */
+    ruleNames: string[];
+    /** Array of rule name information with positions */
+    ruleNameDetails: HerbDisableRuleName[];
+    /** The original rules string (e.g., "rule1, rule2") */
+    rulesString: string;
+}
+/**
+ * Parse a herb:disable comment from ERB comment content.
+ * Use this when you have the content inside <%# ... %> (e.g., from ERBContentNode.content.value)
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableContent("herb:disable rule1, rule2")
+ * // { match: "herb:disable rule1, rule2", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export declare function parseHerbDisableContent(content: string): HerbDisableComment | null;
+/**
+ * Parse a herb:disable comment from a full source line.
+ * Use this when you have a complete line that may contain <%# herb:disable ... %>
+ *
+ * @param line - The source line that may contain a herb:disable comment
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableLine("<div>test</div> <%# herb:disable rule1, rule2 %>")
+ * // { match: "<%# herb:disable rule1, rule2 %>", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export declare function parseHerbDisableLine(line: string): HerbDisableComment | null;
+/**
+ * Check if an ERB comment content contains a herb:disable directive.
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns true if the content contains a herb:disable directive
+ */
+export declare function isHerbDisableContent(content: string): boolean;
+/**
+ * Check if a source line contains a herb:disable comment.
+ *
+ * @param line - The source line
+ * @returns true if the line contains a herb:disable comment
+ */
+export declare function isHerbDisableLine(line: string): boolean;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./linter.js";
 export * from "./rules/index.js";
 export * from "./types.js";
+export { rules } from "./rules.js";

package/dist/types/linter.d.ts

@@ -1,20 +1,89 @@
-import type { RuleClass, Rule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js";
+import type { RuleClass, Rule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js";
 import type { HerbBackend } from "@herb-tools/core";
+import type { RuleConfig, Config } from "@herb-tools/config";
+export interface LinterOptions {
+    /**
+     * Array of rule classes to use. If not provided, uses default rules.
+     */
+    rules?: RuleClass[];
+    /**
+     * Whether to load custom rules from the project.
+     * Defaults to false for backward compatibility.
+     */
+    loadCustomRules?: boolean;
+    /**
+     * Base directory to search for custom rules.
+     * Defaults to current working directory.
+     */
+    customRulesBaseDir?: string;
+    /**
+     * Custom glob patterns to search for rule files.
+     */
+    customRulesPatterns?: string[];
+    /**
+     * Whether to suppress custom rule loading errors.
+     * Defaults to false.
+     */
+    silentCustomRules?: boolean;
+}
 export declare class Linter {
     protected rules: RuleClass[];
+    protected allAvailableRules: RuleClass[];
     protected herb: HerbBackend;
     protected offenses: LintOffense[];
+    protected config?: Config;
+    /**
+     * Creates a new Linter instance with automatic rule filtering based on config.
+     *
+     * @param herb - The Herb backend instance for parsing and lexing
+     * @param config - Optional full Config instance for rule filtering, severity overrides, and path-based filtering
+     * @param customRules - Optional array of custom rules to include alongside built-in rules
+     * @returns A configured Linter instance
+     */
+    static from(herb: HerbBackend, config?: Config, customRules?: RuleClass[]): Linter;
     /**
      * Creates a new Linter instance.
+     *
+     * For most use cases, prefer `Linter.from()` which handles config-based filtering.
+     * Use this constructor directly when you need explicit control over rules.
+     *
      * @param herb - The Herb backend instance for parsing and lexing
      * @param rules - Array of rule classes (Parser/AST or Lexer) to use. If not provided, uses default rules.
+     * @param config - Optional full Config instance for severity overrides and path-based rule filtering
+     * @param allAvailableRules - Optional array of ALL available rules (including disabled) for herb:disable validation
+     */
+    constructor(herb: HerbBackend, rules?: RuleClass[], config?: Config, allAvailableRules?: RuleClass[]);
+    /**
+     * Filters rules based on default config and optional user config overrides.
+     *
+     * Priority:
+     * 1. User config override (if rule config exists in userRulesConfig)
+     * 2. Default config from rule's defaultConfig getter
+     *
+     * @param allRules - All available rule classes to filter from
+     * @param userRulesConfig - Optional user configuration for rules
+     * @returns Filtered array of rule classes that should be enabled
      */
-    constructor(herb: HerbBackend, rules?: RuleClass[]);
+    static filterRulesByConfig(allRules: RuleClass[], userRulesConfig?: Record<string, RuleConfig>): RuleClass[];
     /**
      * Returns the default set of rule classes used by the linter.
-     * @returns Array of rule classes
+     * These are the rules enabled when no custom rules are provided.
+     * Filters all available rules to only include those enabled by default.
+     * @returns Array of default rule classes
      */
     protected getDefaultRules(): RuleClass[];
+    /**
+     * Returns all available rule classes that can be referenced in herb:disable comments.
+     * This includes all rules that exist, regardless of whether they're currently enabled.
+     * Includes both built-in rules and any loaded custom rules.
+     * @returns Array of all available rule classes
+     */
+    protected getAvailableRules(): RuleClass[];
+    /**
+     * Meta-linting rules for herb:disable comments cannot be disabled
+     * This ensures that invalid herb:disable comments are always caught
+     */
+    protected get nonExcludableRules(): string[];
     getRuleCount(): number;
     /**
      * Type guard to check if a rule is a LexerRule
@@ -24,10 +93,37 @@ export declare class Linter {
      * Type guard to check if a rule is a SourceRule
      */
     protected isSourceRule(rule: Rule): rule is SourceRule;
+    /**
+     * Execute a single rule and return its unbound offenses.
+     * Handles rule type checking (Lexer/Parser/Source) and isEnabled checks.
+     */
+    private executeRule;
+    private filterOffenses;
     /**
      * Lint source code using Parser/AST, Lexer, and Source rules.
      * @param source - The source code to lint
      * @param context - Optional context for linting (e.g., fileName for distinguishing files vs snippets)
      */
     lint(source: string, context?: Partial<LintContext>): LintResult;
+    /**
+     * Bind severity to unbound offenses based on rule's defaultConfig and user config overrides.
+     *
+     * Priority:
+     * 1. User config severity override (if specified in config)
+     * 2. Rule's default severity (from defaultConfig.severity)
+     *
+     * @param unboundOffenses - Array of offenses without severity
+     * @param ruleName - Name of the rule that produced the offenses
+     * @returns Array of offenses with severity bound
+     */
+    protected bindSeverity(unboundOffenses: UnboundLintOffense[], ruleName: string): LintOffense[];
+    /**
+     * Automatically fix offenses in the source code.
+     * Uses AST mutation for parser rules and token mutation for lexer rules.
+     * @param source - The source code to fix
+     * @param context - Optional context for linting (e.g., fileName)
+     * @param offensesToFix - Optional array of specific offenses to fix. If not provided, all fixable offenses will be fixed.
+     * @returns AutofixResult containing the corrected source and lists of fixed/unfixed offenses
+     */
+    autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[]): AutofixResult;
 }

package/dist/types/loader.d.ts

@@ -0,0 +1,20 @@
+export * from "./index.js";
+export { CustomRuleLoader } from "./custom-rule-loader.js";
+export type { CustomRuleLoaderOptions } from "./custom-rule-loader.js";
+import type { RuleClass } from "./types.js";
+/**
+ * Loads custom rules from the filesystem.
+ * Only available in Node.js environments.
+ */
+export declare function loadCustomRules(options?: {
+    baseDir?: string;
+    patterns?: string[];
+    silent?: boolean;
+}): Promise<{
+    rules: RuleClass[];
+    ruleInfo: Array<{
+        name: string;
+        path: string;
+    }>;
+    warnings: string[];
+}>;

package/dist/types/rules/erb-comment-syntax.d.ts

@@ -0,0 +1,14 @@
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult, ERBContentNode } from "@herb-tools/core";
+interface ERBCommentSyntaxAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBContentNode>;
+}
+export declare class ERBCommentSyntax extends ParserRule<ERBCommentSyntaxAutofixContext> {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBCommentSyntaxAutofixContext>[];
+    autofix(offense: LintOffense<ERBCommentSyntaxAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
+}
+export {};

package/dist/types/rules/erb-no-case-node-children.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class ERBNoCaseNodeChildrenRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/erb-no-empty-tags.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ERBNoEmptyTagsRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-no-extra-newline.d.ts

@@ -0,0 +1,14 @@
+import { SourceRule } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, FullRuleConfig } from "../types.js";
+interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
+    startOffset: number;
+    endOffset: number;
+}
+export declare class ERBNoExtraNewLineRule extends SourceRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(source: string, context?: Partial<LintContext>): UnboundLintOffense[];
+    autofix(offense: LintOffense<ERBNoExtraNewLineAutofixContext>, source: string, _context?: Partial<LintContext>): string | null;
+}
+export {};

package/dist/types/rules/erb-no-extra-whitespace-inside-tags.d.ts

@@ -0,0 +1,18 @@
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+interface ERBNoExtraWhitespaceAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBNode>;
+    openTag: Token;
+    closeTag: Token;
+    content: string;
+    fixType: "after-open" | "before-close" | "after-comment-equals";
+}
+export declare class ERBNoExtraWhitespaceRule extends ParserRule<ERBNoExtraWhitespaceAutofixContext> {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBNoExtraWhitespaceAutofixContext>[];
+    autofix(offense: LintOffense<ERBNoExtraWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
+}
+export {};

package/dist/types/rules/erb-no-output-control-flow.d.ts

@@ -1,7 +1,8 @@
 import type { ParseResult } from "@herb-tools/core";
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 export declare class ERBNoOutputControlFlowRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-no-silent-tag-in-attribute-name.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ERBNoSilentTagInAttributeNameRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-prefer-image-tag-helper.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ERBPreferImageTagHelperRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-require-trailing-newline.d.ts

@@ -0,0 +1,9 @@
+import { SourceRule } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+export declare class ERBRequireTrailingNewlineRule extends SourceRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(source: string, context?: Partial<LintContext>): UnboundLintOffense[];
+    autofix(_offense: LintOffense, source: string, _context?: Partial<LintContext>): string | null;
+}

package/dist/types/rules/erb-require-whitespace-inside-tags.d.ts

@@ -1,7 +1,18 @@
-import type { ParseResult } from "@herb-tools/core";
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-export declare class ERBRequireWhitespaceRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+interface ERBRequireWhitespaceAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBNode>;
+    openTag: Token;
+    closeTag: Token;
+    content: string;
+    fixType: "after-open" | "before-close" | "after-comment-equals";
+}
+export declare class ERBRequireWhitespaceRule extends ParserRule<ERBRequireWhitespaceAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRequireWhitespaceAutofixContext>[];
+    autofix(offense: LintOffense<ERBRequireWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/erb-right-trim.d.ts

@@ -0,0 +1,14 @@
+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>;
+}
+export declare class ERBRightTrimRule extends ParserRule<ERBRightTrimAutofixContext> {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRightTrimAutofixContext>[];
+    autofix(offense: LintOffense<ERBRightTrimAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
+}
+export {};