@herb-tools/linter 0.4.3 → 0.5.0

package/src/cli.ts

@@ -1,14 +1,41 @@
 import { glob } from "glob"
 import { Herb } from "@herb-tools/node-wasm"
-import { ArgumentParser } from "./cli/argument-parser.js"
+import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js"
 import { FileProcessor } from "./cli/file-processor.js"
-import { SimpleFormatter, DetailedFormatter } from "./cli/formatters/index.js"
-import { SummaryReporter } from "./cli/summary-reporter.js"
+import { OutputManager } from "./cli/output-manager.js"
 
 export class CLI {
   private argumentParser = new ArgumentParser()
   private fileProcessor = new FileProcessor()
-  private summaryReporter = new SummaryReporter()
+  private outputManager = new OutputManager()
+
+  private exitWithError(message: string, formatOption: FormatOption, exitCode: number = 1) {
+    this.outputManager.outputError(message, { 
+      formatOption, 
+      theme: 'auto', 
+      wrapLines: false, 
+      truncateLines: false, 
+      showTiming: false, 
+      startTime: 0, 
+      startDate: new Date() 
+    })
+    process.exit(exitCode)
+  }
+
+  private exitWithInfo(message: string, formatOption: FormatOption, exitCode: number = 0, timingData?: { startTime: number, startDate: Date, showTiming: boolean }) {
+    const outputOptions = {
+      formatOption,
+      theme: 'auto' as const,
+      wrapLines: false,
+      truncateLines: false,
+      showTiming: timingData?.showTiming ?? false,
+      startTime: timingData?.startTime ?? Date.now(),
+      startDate: timingData?.startDate ?? new Date()
+    }
+    
+    this.outputManager.outputInfo(message, outputOptions)
+    process.exit(exitCode)
+  }
 
   async run() {
     const startTime = Date.now()
@@ -16,45 +43,35 @@ export class CLI {
 
     const { pattern, formatOption, showTiming, theme, wrapLines, truncateLines } = this.argumentParser.parse(process.argv)
 
+    const outputOptions = {
+      formatOption,
+      theme,
+      wrapLines,
+      truncateLines,
+      showTiming,
+      startTime,
+      startDate
+    }
+
     try {
       await Herb.load()
 
       const files = await glob(pattern)
 
       if (files.length === 0) {
-        console.log(`No files found matching pattern: ${pattern}`)
-        process.exit(0)
+        this.exitWithInfo(`No files found matching pattern: ${pattern}`, formatOption, 0, { startTime, startDate, showTiming })
       }
 
-      const results = await this.fileProcessor.processFiles(files)
-      const { totalErrors, totalWarnings, filesWithIssues, ruleCount, allDiagnostics, ruleViolations } = results
-
-      const formatter = formatOption === 'simple'
-        ? new SimpleFormatter()
-        : new DetailedFormatter(theme, wrapLines, truncateLines)
-
-      await formatter.format(allDiagnostics, files.length === 1)
-
-      this.summaryReporter.displayMostViolatedRules(ruleViolations)
-      this.summaryReporter.displaySummary({
-        files,
-        totalErrors,
-        totalWarnings,
-        filesWithViolations: filesWithIssues,
-        ruleCount,
-        startTime,
-        startDate,
-        showTiming,
-        ruleViolations
-      })
-
-      if (totalErrors > 0) {
+      const results = await this.fileProcessor.processFiles(files, formatOption)
+      
+      await this.outputManager.outputResults({ ...results, files }, outputOptions)
+
+      if (results.totalErrors > 0) {
         process.exit(1)
       }
 
     } catch (error) {
-      console.error(`Error:`, error)
-      process.exit(1)
+      this.exitWithError(`Error: ${error}`, formatOption)
     }
   }
 }

package/src/default-rules.ts

@@ -20,6 +20,7 @@ import { HTMLNoDuplicateIdsRule } from "./rules/html-no-duplicate-ids.js"
 import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
 import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
 import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
+import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
 import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalization.js"
 
 export const defaultRules: RuleClass[] = [
@@ -43,5 +44,6 @@ export const defaultRules: RuleClass[] = [
   HTMLNoEmptyHeadingsRule,
   HTMLNoNestedLinksRule,
   HTMLTagNameLowercaseRule,
+  ParserNoErrorsRule,
   SVGTagNameCapitalizationRule,
 ]

package/src/linter.ts

@@ -66,7 +66,7 @@ export class Linter {
       } else if (this.isSourceRule(rule)) {
         ruleOffenses = (rule as SourceRule).check(source, context)
       } else {
-        ruleOffenses = (rule as ParserRule).check(parseResult.value, context)
+        ruleOffenses = (rule as ParserRule).check(parseResult, context)
       }
 
       this.offenses.push(...ruleOffenses)

package/src/rules/erb-no-empty-tags.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, ERBContentNode } from "@herb-tools/core"
+import type { ParseResult, ERBContentNode } from "@herb-tools/core"
 
 class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
   visitERBContentNode(node: ERBContentNode): void {
@@ -25,10 +25,10 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
 export class ERBNoEmptyTagsRule extends ParserRule {
   name = "erb-no-empty-tags"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBNoEmptyTagsVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/erb-no-output-control-flow.ts

@@ -1,6 +1,6 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { Node, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
+import type { ParseResult, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
 
@@ -53,10 +53,10 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
 export class ERBNoOutputControlFlowRule extends ParserRule {
   name = "erb-no-output-control-flow"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/erb-prefer-image-tag-helper.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName, findAttributeByName, getAttributes } from
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeValueNode, ERBContentNode, LiteralNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeValueNode, ERBContentNode, LiteralNode, ParseResult } from "@herb-tools/core"
 
 class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -116,9 +116,9 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
 export class ERBPreferImageTagHelperRule extends ParserRule {
   name = "erb-prefer-image-tag-helper"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBPreferImageTagHelperVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/erb-require-whitespace-inside-tags.ts

@@ -1,4 +1,4 @@
-import type { Node, Token } from "@herb-tools/core"
+import type { ParseResult, Token, Node } from "@herb-tools/core"
 import { isERBNode } from "@herb-tools/core";
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
@@ -85,9 +85,9 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
 export class ERBRequireWhitespaceRule extends ParserRule {
   name = "erb-require-whitespace-inside-tags"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new RequireWhitespaceInsideTags(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/erb-requires-trailing-newline.ts

@@ -21,7 +21,9 @@ export class ERBRequiresTrailingNewlineRule extends SourceRule {
 
   check(source: string, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBRequiresTrailingNewlineVisitor(this.name, context)
+
     visitor.visit(source)
+
     return visitor.offenses
   }
 }

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

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class AnchorRechireHrefVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -30,10 +30,10 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
 export class HTMLAnchorRequireHrefRule extends ParserRule {
   name = "html-anchor-require-href"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AnchorRechireHrefVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

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

@@ -8,7 +8,7 @@ import type {
   HTMLAttributeNode,
   HTMLOpenTagNode,
   HTMLSelfCloseTagNode,
-  Node,
+  ParseResult,
 } from "@herb-tools/core";
 
 class AriaAttributeMustBeValid extends AttributeVisitorMixin {
@@ -34,9 +34,9 @@ class AriaAttributeMustBeValid extends AttributeVisitorMixin {
 export class HTMLAriaAttributeMustBeValid extends ParserRule {
   name = "html-aria-attribute-must-be-valid";
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AriaAttributeMustBeValid(this.name, context);
-    visitor.visit(node);
+    visitor.visit(result.value);
     return visitor.offenses;
   }
 }

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

@@ -2,7 +2,7 @@ import { AttributeVisitorMixin } from "./rule-utils.js"
 import { ParserRule } from "../types.js"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
 
 class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode, _parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
@@ -32,10 +32,10 @@ class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
 export class HTMLAriaLevelMustBeValidRule extends ParserRule {
   name = "html-aria-level-must-be-valid"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

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

@@ -2,7 +2,7 @@ import { AttributeVisitorMixin, getAttributeName, getAttributes } from "./rule-u
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
 
 class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
 
@@ -37,9 +37,9 @@ class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
 export class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
   name = "html-aria-role-heading-requires-level"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AriaRoleHeadingRequiresLevel(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -2,7 +2,7 @@ import { AttributeVisitorMixin, VALID_ARIA_ROLES } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLAttributeNode } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class AriaRoleMustBeValid extends AttributeVisitorMixin {
   checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode,): void {
@@ -21,10 +21,10 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
 export class HTMLAriaRoleMustBeValidRule extends ParserRule {
   name = "html-aria-role-must-be-valid"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AriaRoleMustBeValid(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/html-attribute-double-quotes.ts

@@ -2,7 +2,7 @@ import { AttributeVisitorMixin, getAttributeValueQuoteType, hasAttributeValue }
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLAttributeNode } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
@@ -21,9 +21,9 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
 export class HTMLAttributeDoubleQuotesRule extends ParserRule {
   name = "html-attribute-double-quotes"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-attribute-values-require-quotes.ts

@@ -2,7 +2,7 @@ import { AttributeVisitorMixin } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLAttributeNode, HTMLAttributeValueNode, Node } from "@herb-tools/core"
+import type { HTMLAttributeNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
 
 class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, _attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
@@ -23,9 +23,9 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
 export class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
   name = "html-attribute-values-require-quotes"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-boolean-attributes-no-value.ts

@@ -2,7 +2,7 @@ import { AttributeVisitorMixin, isBooleanAttribute, hasAttributeValue } from "./
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLAttributeNode, Node } from "@herb-tools/core"
+import type { HTMLAttributeNode, ParseResult } from "@herb-tools/core"
 
 class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
   protected checkAttribute(attributeName: string, _attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
@@ -20,9 +20,9 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
 export class HTMLBooleanAttributesNoValueRule extends ParserRule {
   name = "html-boolean-attributes-no-value"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new BooleanAttributesNoValueVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-img-require-alt.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class ImgRequireAltVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -35,9 +35,9 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
 export class HTMLImgRequireAltRule extends ParserRule {
   name = "html-img-require-alt"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ImgRequireAltVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, isInlineElement, isBlockElement } from "./rule-utils.j
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
   private inlineStack: string[] = []
@@ -19,7 +19,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
     return { isInline, isBlock, isUnknown }
   }
 
-  private addViolationMessage(tagName: string, isBlock: boolean, openTag: HTMLOpenTagNode): void {
+  private addOffenseMessage(tagName: string, isBlock: boolean, openTag: HTMLOpenTagNode): void {
     const parentInline = this.inlineStack[this.inlineStack.length - 1]
     const elementType = isBlock ? "Block-level" : "Unknown"
 
@@ -62,7 +62,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
     const { isInline, isBlock, isUnknown } = this.getElementType(tagName)
 
     if ((isBlock || isUnknown) && this.inlineStack.length > 0) {
-      this.addViolationMessage(tagName, isBlock, openTag)
+      this.addOffenseMessage(tagName, isBlock, openTag)
     }
 
     if (isInline) {
@@ -77,9 +77,9 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
 export class HTMLNoBlockInsideInlineRule extends ParserRule {
   name = "html-no-block-inside-inline"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new BlockInsideInlineVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, forEachAttribute } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeNameNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeNameNode, ParseResult } from "@herb-tools/core"
 
 class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -52,9 +52,9 @@ class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
 export class HTMLNoDuplicateAttributesRule extends ParserRule {
   name = "html-no-duplicate-attributes"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new NoDuplicateAttributesVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -1,6 +1,6 @@
 import { AttributeVisitorMixin } from "./rule-utils"
 import { ParserRule } from "../types"
-import type { Node } from "@herb-tools/core"
+import type { ParseResult, Node } from "@herb-tools/core"
 import type { LintOffense, LintContext } from "../types"
 
 class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
@@ -29,10 +29,10 @@ class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
 export class HTMLNoDuplicateIdsRule extends ParserRule {
   name = "html-no-duplicate-ids"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new NoDuplicateIdsVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

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

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName, getAttributes, findAttributeByName, getAtt
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, Node, LiteralNode, HTMLTextNode } from "@herb-tools/core"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, ParseResult, LiteralNode, HTMLTextNode } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -178,9 +178,9 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
 export class HTMLNoEmptyHeadingsRule extends ParserRule {
   name = "html-no-empty-headings"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new NoEmptyHeadingsVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

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

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class NestedLinkVisitor extends BaseRuleVisitor {
   private linkStack: HTMLOpenTagNode[] = []
@@ -58,9 +58,9 @@ class NestedLinkVisitor extends BaseRuleVisitor {
 export class HTMLNoNestedLinksRule extends ParserRule {
   name = "html-no-nested-links"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new NestedLinkVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/html-tag-name-lowercase.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class TagNameLowercaseVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -58,9 +58,9 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
 export class HTMLTagNameLowercaseRule extends ParserRule {
   name = "html-tag-name-lowercase"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new TagNameLowercaseVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/parser-no-errors.ts

@@ -0,0 +1,25 @@
+import { ParserRule } from "../types.js"
+
+import type { LintOffense } from "../types.js"
+import type { ParseResult, HerbError } from "@herb-tools/core"
+
+export class ParserNoErrorsRule extends ParserRule {
+  name = "parser-no-errors"
+
+  check(result: ParseResult): LintOffense[] {
+    return result.recursiveErrors().map(error =>
+      this.herbErrorToLintOffense(error)
+    )
+  }
+
+  private herbErrorToLintOffense(error: HerbError): LintOffense {
+    return {
+      message: `${error.message} (\`${error.type}\`)`,
+      location: error.location,
+      severity: error.severity,
+      rule: this.name,
+      code: this.name,
+      source: "linter"
+    }
+  }
+}

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, Node } from "@herb-tools/core"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
   private insideSVG = false
@@ -66,9 +66,9 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
 export class SVGTagNameCapitalizationRule extends ParserRule {
   name = "svg-tag-name-capitalization"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/types.ts

@@ -1,7 +1,7 @@
-import { Node, Diagnostic, LexResult } from "@herb-tools/core"
+import { Diagnostic, LexResult, ParseResult } from "@herb-tools/core"
 import type { defaultRules } from "./default-rules.js"
 
-export type LintSeverity = "error" | "warning"
+export type LintSeverity = "error" | "warning" | "info" | "hint"
 
 /**
  * Automatically inferred union type of all available linter rule names.
@@ -23,7 +23,7 @@ export interface LintResult {
 export abstract class ParserRule {
   static type = "parser" as const
   abstract name: string
-  abstract check(node: Node, context?: Partial<LintContext>): LintOffense[]
+  abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense[]
 }
 
 export abstract class LexerRule {